Having a hard time getting a successful audio transcription

[sej69]

I'm using C#/Windows/.Net Maui (or Console app)

I've written a simple class to play with transcriptions.

I first recorded my voice into a .M4A file knowing I need to convert it to PCM.

The program loads the LLM and it appears that the processor is valid.

The TestMp3ToWhisper() loads the recording, converts it to PCM and attempts to pass it into the processor. But I don't get anything back from the processor but a blank res variable.

What am I missing?

I initialize the API and use the API using this:

`
public static class WhisperHandler
{
private static WhisperFactory? _factory;
private static WhisperProcessor? _processor;
private static string DBName = "ggml-large-v1.bin";
private static string dbPath = string.Empty;

    public static void WhisperHandlerStartup()
    {
        // check to see if llm exists
        dbPath = Path.Combine(FileSystem.AppDataDirectory, DBName);
        if (!File.Exists(dbPath))
        {
            Debug.WriteLine($"Model file {dbPath} does not exist. Downloading...");
            DownloadModel(DBName, GgmlType.LargeV1).GetAwaiter().GetResult();
        }
        else
        {
            Debug.WriteLine($"Model file {dbPath} already exists.");
        }
        try
        {
            int max_threads = Math.Min(8, Environment.ProcessorCount);
            _factory = WhisperFactory.FromPath(dbPath);
            _processor = _factory.CreateBuilder()
            .WithLanguage("auto")
            .WithThreads(max_threads)
            .Build();
        }
        catch (Exception ex)
        {
            Debug.WriteLine($"Error initializing WhisperHandler: {ex.Message}");
            throw;
        }
 }


    public static async Task<string> TestMp3ToWhisper()
    {
        string mp3FilePath = @"D:\TestDATA\recording.m4a"; 
        try
        {
            // Read all bytes from the MP3 file
            byte[] mp3Bytes = File.ReadAllBytes(mp3FilePath);

            // Create a MemoryStream from the byte array
            using (MemoryStream audioStream = new MemoryStream(mp3Bytes))
            {

                Console.WriteLine($"MP3 file loaded into MemoryStream. Length: {audioStream.Length} bytes.");

                // Example: You could reset the position to the beginning if needed for reading
                audioStream.Position = 0;

                var test = audioStream.Length;
                var floatSamples = ConvertPcm16ToFloat(audioStream);

                IAsyncEnumerable<Whisper.net.SegmentData> res = null;
                res = _processor.ProcessAsync(floatSamples);

                string returnResult = string.Empty;

                Debug.WriteLine("Starting transcription...");
                try
                {
                    await foreach (var result in res)
                    {
                        returnResult += result.Text;
                    }
                }
                catch (Exception ex)
                {
                    Debug.WriteLine($"Error during transcription: {ex.Message}");
                }

                Debug.WriteLine(returnResult.ToString());
                Debug.WriteLine("Processing complete.");

                return returnResult;
            }
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine($"Error: MP3 file not found at '{mp3FilePath}'");
            return null;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
            return null;
        }
    }

    /// <summary>
    /// Converts a PCM 16-bit mono MemoryStream to a float array normalized between -1.0 and 1.0.
    /// </summary>
    private static float[] ConvertPcm16ToFloat(Stream pcmStream)
    {
        pcmStream.Seek(0, SeekOrigin.Begin);
        using var br = new BinaryReader(pcmStream, System.Text.Encoding.Default, leaveOpen: true);
        var sampleCount = (int)(pcmStream.Length / 2);
        var floatSamples = new float[sampleCount];
        for (int i = 0; i < sampleCount; i++)
        {
            short sample = br.ReadInt16();
            floatSamples[i] = sample / 32768f;
        }
        return floatSamples;
    }
}

`