StreamDataProvider.ReadBytes(buffer) returns zero array

[SonneKiwiBird]

Dear all,

First of all, thank you for this amazing library.
I just started using this library and I need to get a raw decoded MemoryStream object.
So, I tried this approach. The type of wavStream is MemoryStream.

StreamDataProvider streamDataProvider = new StreamDataProvider(File.OpenRead(inputFile.FullName));
BinaryWriter writer = new BinaryWriter(wavStream);
float[] floats = new float[streamDataProvider.Length];
Span<float> buffer = new Span<float>(floats);
streamDataProvider.Seek(0);
int nBytes = streamDataProvider.ReadBytes(buffer);
Console.WriteLine(nBytes);

foreach(float value in floats)
{
    writer.Write(value);
}

When I debugged this piece of code, I realized that the float[] floats is actually filled with zero values.

May I ask you what I'm missing here?

[LSXPrime]

Although I haven't attempted to use StreamDataProvider to read the entire audio data at once, as it was not intended for this purpose, I recommend using AssetDataProvider instead, as it is designed to decode the entire audio stream into memory upon initialization, allowing you to read raw frames from the whole audio file and then dispose of it, as shown in the code below:

    /// <summary>
    /// Reads an audio file from a stream and returns its PCM data as a float array.
    /// </summary>
    /// <param name="stream">The audio file stream.</param>
    /// <param name="targetSampleRate">Optional target sample rate to resample the audio to. If null, no resampling is performed.</param>
    /// <returns>The PCM audio data as a float array, or an empty array if reading fails.</returns>
    public float[] ReadAudioFile(Stream? stream)
    {
        if (_isDisposed || stream == null || stream.Length == 0)
            return [];

        try
        {
            using var dataProvider = new AssetDataProvider(stream, _audioEngine.SampleRate);

            var totalSamples = dataProvider.Length;
            if (totalSamples <= 0)
                return [];

            var audioData = new float[totalSamples];
            dataProvider.ReadBytes(audioData.AsSpan());

            return audioData;
        }
        catch (Exception ex)
        {
            // Handle any exceptions that might occur during file reading or decoding.
            Console.WriteLine($"Error reading audio file: {ex.Message}");
            return [];
        }
    }

I've just tested the code you provided and it's working as expected. The example below allows me to play the raw audio file without any issues with results

StreamDataProvider ReadBytes: 18085938, Floats Array Length: 18085938, Zeros: 4729
Raw float audio data written to: output.raw
DataProvider Length: 9042969

using SoundFlow.Abstracts;
using SoundFlow.Backends.MiniAudio;
using SoundFlow.Components;
using SoundFlow.Enums;
using SoundFlow.Providers;

namespace ConsoleApp6;

internal static class Program
{

    private static void Main()
    {
        // Specify the audio file path
        const string audioFilePath = @"D:\Music\Personal Collection\Nightcore - Shameless (By. Camila Cabello).mp3";
        const string outputWavFilePath = "output.raw";

        _ = new MiniAudioEngine(44100, Capability.Playback);

        // Write raw float audio data using StreamDataProvider
        WriteRawFloatAudioData(audioFilePath, outputWavFilePath);
        Console.WriteLine($"Raw float audio data written to: {outputWavFilePath}");
        
        // Play the audio file
        PlayRawAudio(File.OpenRead(outputWavFilePath));
    }
    
    /// <summary>
    /// Reads an audio file using StreamDataProvider and writes the raw float audio data to a file.
    /// Assumes the input file can be processed by StreamDataProvider (e.g., raw PCM or a format StreamDataProvider understands).
    /// </summary>
    /// <param name="inputFilePath">The path to the input audio file.</param>
    /// <param name="outputFilePath">The path to the output raw float data file.</param>
    private static void WriteRawFloatAudioData(string inputFilePath, string outputFilePath)
    {
        if (!File.Exists(inputFilePath))
        {
            Console.WriteLine($"Input file not found: {inputFilePath}");
            return;
        }

        var inputFile = new FileInfo(inputFilePath);

        try
        {
            var streamDataProvider = new StreamDataProvider(File.OpenRead(inputFile.FullName));
            using var wavStream = File.Create(outputFilePath);
            using var writer = new BinaryWriter(wavStream);
            var floats = new float[streamDataProvider.Length];
            var buffer = new Span<float>(floats);
            streamDataProvider.Seek(0);
            var nBytes = streamDataProvider.ReadBytes(buffer);
            Console.WriteLine($"StreamDataProvider ReadBytes: {nBytes}, Floats Array Length: {floats.Length}, Zeros: {floats.Count(z => z == 0)}");

            foreach (var value in floats)
            {
                writer.Write(value);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error writing raw float audio data: {ex.Message}");
        }
    }

    /// <summary>
    /// Plays a raw float audio data stream using SoundPlayer.
    /// </summary>
    private static void PlayRawAudio(Stream stream)
    {
        var dataProvider = new RawDataProvider(stream, SampleFormat.F32, 2, 44100);
        Console.WriteLine($"DataProvider Length: {dataProvider.Length}");
        var player = new SoundPlayer(dataProvider);
        Mixer.Master.AddComponent(player);
        player.Play();
        Console.ReadLine();
        player.Stop();
    }
}

I'm unable to reproduce the issue, but I'll keep the discussion open in case you can provide an example. It's possible that the issue lies with your audio file, try using a different one to see if the problem persists. and if your issue is resolved, feel free to close it otherwise.

[SonneKiwiBird]

Thank you for your reply with examples.
Here's the entire code. I modified mine with yours a little bit.
I set the breakpoint at where BinaryWriter is initiated. I checked the content of float[] buffer.
The length is correct, but it is still filled with zero values. You can also check the screenshot below.

When I tested the most basic example "Basic Usage Example" from your front page, the library could play the same MP3 file properly.

internal static void SoundFlowToMemoryStream(FileInfo inputFile, MemoryStream wavStream)
{
    using var audioEngine = new MiniAudioEngine(44100, Capability.Playback);
    AssetDataProvider streamDataProvider = new AssetDataProvider(File.OpenRead(inputFile.FullName), audioEngine.SampleRate);
    float[] buffer = new float[streamDataProvider.Length];
    streamDataProvider.Seek(0);
    int nBytes = streamDataProvider.ReadBytes(buffer.AsSpan());

    Console.WriteLine(nBytes);

    BinaryWriter writer = new BinaryWriter(wavStream, Encoding.UTF8, true); // Break point here to check the content of float[] buffer
    foreach (float value in buffer)
    {
        writer.Write(value);
    }

    writer.Close();

    audioEngine.Dispose();
}

[LSXPrime]

After some experiments, it appears that using BinaryWriter to return a stream, regardless of whether it's a MemoryStream or FileStream, results in values being written as zeros. However, when writing to a FileStream and then opening it with File.OpenRead, the data is written correctly,
After further experiments, I found that BinaryWriter does not reset its position upon completion, resulting in the stream playing nothing. To resolve this, I added wavStream.Position = 0; before writer.Close();, and the sound played correctly using SoundFlowToMemoryStream. Regarding the zeros at the beginning of the file, I think this may be related to the decoder and does not affect playback. Instead of manually checking the buffer for zeros, replace Console.WriteLine(nBytes); with Console.WriteLine($"AssetDataProvider ReadBytes: {nBytes}, Floats Array Length: {buffer.Length}, Zeros: {buffer.Count(z => z == 0)}"); and you will get something similar to AssetDataProvider ReadBytes: 18085938, Floats Array Length: 18085938, Zeros: 4729

[SonneKiwiBird]

Thank you for your reply and the advice.
Yes, indeed, wavStream.Position = 0 solved my problem.
Now, I'm fully moving to SoundFlow from NAudio.

Thank you again!