[BUG] Realtime Audio Generation Playback is Broken!

[PlatinumLucario]

Requirements

• I have searched the existing issues to ensure this bug has not already been reported.
• I have provided a clear and concise description of the bug.
• I have provided detailed steps to reproduce the bug.
• I have included a minimal reproducible example (MRE) if applicable.
• I have provided error messages and stack traces if applicable.
• I have completed the environment information.

1. Describe the Bug

As I decided to use SoundFlow in the project I'm contributing to. But as I tried to use it and follow the documentation, there was nothing about how to implement QueueDataProvider or RawDataProvider.

So I tried asking here and here for help, haven't got a response so far about it.

So I started to wonder if this actually was a bug in SoundFlow or MiniAudio itself? It's really hard to know.

But seeing as it doesn't occur in PortAudio or NAudio, it really seems to be the case.

Okay, to explain, here's what happens: When playing back any interchanging audio buffer, it won't progress past the first few arrays, and sounds like a game crash on a N64 or GameCube. Despite the audio buffers changing within the MiniAudioEngine, it still can't playback the first few buffers. The audio stays like this until the engine is disposed.

I have tried a similar approach with RawDataProvider, but still causes the exact same issue.

I tried to provide a minimal example, however it only produces a small pop sound and nothing else. It's likely that it needs large audio generation mixing to properly show how the issue occurs in realtime.

As I already said, I have no idea if this is a SoundFlow issue or a MiniAudio issue.

Here's what I mean (Volume Warning!):

2025-09-09.17-28-58.mp4

2. Steps to Reproduce

1. Clone VG Music Studio new-gui-experimental branch, found here: https://github.com/PlatinumLucario/VGMusicStudio/tree/new-gui-experimental
2. Checkout new-gui-experimental branch, to make sure it's on the correct branch.
3. Add the SoundFlow NuGet to the project.
4. Replace Mixer.cs with this:

using PortAudio;
using System;
using System.Runtime.InteropServices;
using System.Linq;
using System.IO;
using Kermalis.EndianBinaryIO;
using Kermalis.VGMusicStudio.Core.Formats;
using Stream = PortAudio.Stream;
using NAudio.Wave;
using NAudio.CoreAudioApi;
using NAudio.CoreAudioApi.Interfaces;
using SoundFlow.Abstracts;
using SoundFlow.Backends.MiniAudio;
using SoundFlow.Components;
using SoundFlow.Enums;
using SoundFlow.Providers;
using SoundFlow.Structs;
using SoundFlow.Abstracts.Devices;
using SoundFlow.Interfaces;

namespace Kermalis.VGMusicStudio.Core;

public abstract class Mixer : IAudioSessionEventsHandler, IDisposable
{
    public readonly bool[] Mutes;

    #region MiniAudio Fields
    // MiniAudio Fields
    private AudioPlaybackDevice? _playbackDevice;
    internal SoundPlayer? MiniAudioPlayer;
    internal QueueDataProvider? DataProvider;
    #endregion

    #region PortAudio Fields
    // PortAudio Fields
    public Wave? WaveData;
    internal abstract int SamplesPerBuffer { get; }
    private float Vol = 1;

    public readonly object CountLock = new();

    protected Wave? _waveWriterPortAudio;

    public StreamParameters OParams;
    public StreamParameters DefaultOutputParams { get; private set; }

    public Stream? Stream;
    public bool IsDisposing = false;
    private bool _isDisposed = false;
    #endregion

    #region NAudio Fields
    // NAudio Fields
    public static event Action<float>? VolumeChanged;
    private WasapiOut? _out;
    private AudioSessionControl? _appVolume;

    private bool _shouldSendVolUpdateEvent = true;

    protected WaveFileWriter? _waveWriterNAudio;
    protected abstract WaveFormat? WaveFormat { get; }
    #endregion

    // Audio Backend
    public static AudioBackend PlaybackBackend { get; set; }

    public enum AudioBackend
    {
        PortAudio,
        MiniAudio,
        NAudio
    }

    protected Mixer()
    {
        Mutes = new bool[SongState.MAX_TRACKS];
        if (PlaybackBackend is AudioBackend.NAudio)
        {
            _out = null!;
            _appVolume = null!;
        }
    }

    public class MiniAudioBuffer : ISoundDataProvider, IDisposable
    {
        public int Position { get; set; }

        public int Length { get; }

        public bool CanSeek { get; }

        public SoundFlow.Enums.SampleFormat SampleFormat { get; }

        public int SampleRate { get; set; }

        public bool IsDisposed { get; private set; }

        public event EventHandler<EventArgs> EndOfStreamReached;
        public event EventHandler<PositionChangedEventArgs> PositionChanged;

        public void Dispose()
        {
            if (!IsDisposed)
            {
                GC.SuppressFinalize(this);
            }
        }

        public int ReadBytes(Span<float> buffer)
        {
            throw new NotImplementedException();
        }

        public void Seek(int offset)
        {
            throw new NotImplementedException();
        }
    }

    protected void Init(Wave waveData = null!, PortAudio.SampleFormat sampleFormat = PortAudio.SampleFormat.Float32,
    int sampleRate = 48000, byte[] stream = null!,
    IWaveProvider waveProvider = null!)
    {
        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    // First, check if the instance contains something
                    if (WaveData == null)
                    {
                        _isDisposed = false;

                        Pa.Initialize();
                        WaveData = waveData;

                        // Try setting up an output device
                        OParams.Device = Pa.DefaultOutputDevice;
                        if (OParams.Device == Pa.NoDevice)
                        {
                            throw new Exception("No default audio output device is available.");
                        }

                        OParams.Channels = 2;
                        OParams.SampleFormat = sampleFormat;
                        OParams.SuggestedLatency = Pa.GetDeviceInfo(OParams.Device).defaultLowOutputLatency;
                        OParams.HostApiSpecificStreamInfo = IntPtr.Zero;

                        // Set it as the default
                        DefaultOutputParams = OParams;
                    }

                    Stream = new Stream(
                        null,
                        OParams,
                        WaveData!.SampleRate,
                        (uint)SamplesPerBuffer,
                        StreamFlags.NoFlag,
                        PortAudioPlayer.Play,
                        waveData
                    );

                    var hostApiInfo = Pa.GetHostApiInfo(Pa.DefaultHostApi);

                    Stream!.Start();
                    break;
                }
            case AudioBackend.MiniAudio:
                {
                    var engine = new MiniAudioEngine();
                    var format = new AudioFormat
                    {
                        SampleRate = sampleRate,
                        Channels = 2,
                        Format = SoundFlow.Enums.SampleFormat.F32
                    };
                    var defaultDevice = engine.PlaybackDevices.FirstOrDefault(x => x.IsDefault);
                    _playbackDevice = engine.InitializePlaybackDevice(defaultDevice, format);
                    DataProvider = new QueueDataProvider(format);
                    MiniAudioPlayer = new SoundPlayer(engine, format, DataProvider);
                    _playbackDevice.MasterMixer.AddComponent(MiniAudioPlayer);
                    _playbackDevice.Start();
                    MiniAudioPlayer.IsLooping = true;
                    break;
                }
            case AudioBackend.NAudio:
                {
                    _out = new WasapiOut();
                    _out.Init(waveProvider);
                    using (var en = new MMDeviceEnumerator())
                    {
                        SessionCollection sessions = en.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia).AudioSessionManager.Sessions;
                        int id = Environment.ProcessId;
                        for (int i = 0; i < sessions.Count; i++)
                        {
                            AudioSessionControl session = sessions[i];
                            if (session.GetProcessID == id)
                            {
                                _appVolume = session;
                                _appVolume.RegisterEventClient(this);
                                break;
                            }
                        }
                    }
                    _out.Play();
                    break;
                }
        }
    }

    internal void UpdateStream(Span<byte> stream, int sampleRate)
    {
        if (MiniAudioPlayer.State != SoundFlow.Enums.PlaybackState.Playing)
        {
            MiniAudioPlayer.Play();
        }
    }

    public float Volume
    {
        get => Vol;
        set => Vol = Math.Clamp(value, 0, 1);
    }

    public float GetVolume()
    {
        return Vol;
    }

    public void SetVolume(float volume)
    {
        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    Vol = Math.Clamp(volume, 0, 1);
                    break;
                }
            case AudioBackend.MiniAudio:
                {
                    _playbackDevice!.MasterMixer.Volume = volume;
                    break;
                }
            case AudioBackend.NAudio:
                {
                    _shouldSendVolUpdateEvent = false;
                    _appVolume!.SimpleAudioVolume.Volume = volume;
                    break;
                }
        }
    }

    #region NAudio Functions
    public void OnVolumeChanged(float volume, bool isMuted)
    {
        if (_shouldSendVolUpdateEvent)
        {
            VolumeChanged?.Invoke(volume);
        }
        _shouldSendVolUpdateEvent = true;
    }
    public void OnDisplayNameChanged(string displayName)
    {
        throw new NotImplementedException();
    }
    public void OnIconPathChanged(string iconPath)
    {
        throw new NotImplementedException();
    }
    public void OnChannelVolumeChanged(uint channelCount, IntPtr newVolumes, uint channelIndex)
    {
        throw new NotImplementedException();
    }
    public void OnGroupingParamChanged(ref Guid groupingId)
    {
        throw new NotImplementedException();
    }
    // Fires on @out.Play() and @out.Stop()
    public void OnStateChanged(AudioSessionState state)
    {
        if (state == AudioSessionState.AudioSessionStateActive)
        {
            OnVolumeChanged(_appVolume!.SimpleAudioVolume.Volume, _appVolume.SimpleAudioVolume.Mute);
        }
    }
    public void OnSessionDisconnected(AudioSessionDisconnectReason disconnectReason)
    {
        throw new NotImplementedException();
    }
    #endregion

    public void CreateWaveWriter(string fileName)
    {
        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    _waveWriterPortAudio = WaveData;
                    _waveWriterPortAudio!.CreateFileStream(fileName);
                    break;
                }
            case AudioBackend.NAudio:
                {
                    _waveWriterNAudio = new WaveFileWriter(fileName, WaveFormat);
                    break;
                }
        }
    }
    public void CloseWaveWriter()
    {
        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    _waveWriterPortAudio!.Dispose(true);
                    _waveWriterPortAudio = null;
                    break;
                }
            case AudioBackend.NAudio:
                {
                    _waveWriterNAudio!.Dispose();
                    _waveWriterNAudio = null;
                    break;
                }
        }
    }

    public virtual void Dispose()
    {
        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    if (_isDisposed || Stream is null)
                    {
                        return;
                    }

                    IsDisposing = true;
                    Stream!.Stop();

                    Stream!.Dispose();
                    break;
                }
            case AudioBackend.MiniAudio:
                {
                    if (MiniAudioPlayer is not null && _playbackDevice is not null)
                    {
                        MiniAudioPlayer.Stop();
                        _playbackDevice.Stop();
                        _playbackDevice.MasterMixer.RemoveComponent(MiniAudioPlayer);
                    }
                    break;
                }
            case AudioBackend.NAudio:
                {
                    if (_out is not null)
                    {
                        _out!.Stop();
                        _out.Dispose();
                        _appVolume!.Dispose();
                    }
                    break;
                }
        }
        GC.SuppressFinalize(this);

        _isDisposed = true;
    }

    public interface IAudio
    {
        Span<byte> ByteBuffer { get; }
        Span<short> Int16Buffer { get; }
        Span<int> Int32Buffer { get; }
        Span<long> Int64Buffer { get; }
        Span<Int128> Int128Buffer { get; }
        Span<Half> Float16Buffer { get; }
        Span<float> Float32Buffer { get; }
        Span<double> Float64Buffer { get; }
        Span<decimal> Float128Buffer { get; }
    }

    [StructLayout(LayoutKind.Explicit, Pack = 2)]
    public class Audio : IAudio
    {
        [FieldOffset(0)]
        public int NumberOfBytes;
        [FieldOffset(8)]
        public byte[]? ByteBuffer;
        [FieldOffset(8)]
        public short[]? Int16Buffer;
        [FieldOffset(8)]
        public int[]? Int32Buffer;
        [FieldOffset(8)]
        public long[]? Int64Buffer;
        [FieldOffset(8)]
        public Int128[]? Int128Buffer;
        [FieldOffset(8)]
        public Half[]? Float16Buffer;
        [FieldOffset(8)]
        public float[]? Float32Buffer;
        [FieldOffset(8)]
        public double[]? Float64Buffer;
        [FieldOffset(8)]
        public decimal[]? Float128Buffer;

        Span<byte> IAudio.ByteBuffer => ByteBuffer!;
        Span<short> IAudio.Int16Buffer => Int16Buffer!;
        Span<int> IAudio.Int32Buffer => Int32Buffer!;
        Span<long> IAudio.Int64Buffer => Int64Buffer!;
        Span<Int128> IAudio.Int128Buffer => Int128Buffer!;
        Span<Half> IAudio.Float16Buffer => Float16Buffer!;
        Span<float> IAudio.Float32Buffer => Float32Buffer!;
        Span<double> IAudio.Float64Buffer => Float64Buffer!;
        Span<decimal> IAudio.Float128Buffer => Float128Buffer!;

        public int ByteBufferCount
        {
            get
            {
                return NumberOfBytes;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("ByteBufferCount", value, 1);
            }
        }

        public int Int16BufferCount
        {
            get
            {
                return NumberOfBytes / 2;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Int16BufferCount", value, 2);
            }
        }

        public int Int32BufferCount
        {
            get
            {
                return NumberOfBytes / 4;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Int32BufferCount", value, 4);
            }
        }

        public int Int64BufferCount
        {
            get
            {
                return NumberOfBytes / 8;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Int64BufferCount", value, 8);
            }
        }

        public int Int128BufferCount
        {
            get
            {
                return NumberOfBytes / 16;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Int128BufferCount", value, 16);
            }
        }

        public int Float16BufferCount
        {
            get
            {
                return NumberOfBytes / 2;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Float16BufferCount", value, 2);
            }
        }

        public int Float32BufferCount
        {
            get
            {
                return NumberOfBytes / 4;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Float32BufferCount", value, 4);
            }
        }

        public int Float64BufferCount
        {
            get
            {
                return NumberOfBytes / 8;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Float64BufferCount", value, 8);
            }
        }

        public int Float128BufferCount
        {
            get
            {
                return NumberOfBytes / 16;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Float128BufferCount", value, 16);
            }
        }

        public Audio(int sizeToAllocateInBytes)
        {
            var sizeInBytes = sizeToAllocateInBytes;
            int aligned32Bits = sizeInBytes % 4;
            sizeToAllocateInBytes = (aligned32Bits == 0) ? sizeInBytes : (sizeInBytes + 4 - aligned32Bits);
            ByteBuffer = new byte[sizeToAllocateInBytes];
            NumberOfBytes = 0;
        }

        public static implicit operator byte[](Audio waveBuffer)
        {
            return waveBuffer.ByteBuffer!;
        }

        private int CheckValidityCount(string argName, int value, int sizeOfValue)
        {
            int num = value * sizeOfValue;
            if (num % 4 != 0)
            {
                throw new ArgumentOutOfRangeException(argName, $"{argName} cannot set a count ({num}) that is not 4 bytes aligned ");
            }

            if (value < 0 || value > ByteBuffer!.Length / sizeOfValue)
            {
                throw new ArgumentOutOfRangeException(argName, $"{argName} cannot set a count that exceeds max count of {ByteBuffer!.Length / sizeOfValue}.");
            }

            return num;
        }

        public void Clear()
        {
            Array.Clear(ByteBuffer!, 0, ByteBuffer!.Length);
        }

        public void Copy(Array destinationArray)
        {
            Array.Copy(ByteBuffer!, destinationArray, NumberOfBytes);
        }
    }
}

4. Replace MP2KMixer.cs with this:

using Kermalis.VGMusicStudio.Core.Formats;
using Kermalis.VGMusicStudio.Core.Util;
using NAudio.Wave;
using SoundFlow.Abstracts;
using SoundFlow.Backends.MiniAudio;
using SoundFlow.Components;
using SoundFlow.Enums;
using SoundFlow.Providers;
using SoundFlow.Structs;
using System;
using System.IO;
using System.Linq;

namespace Kermalis.VGMusicStudio.Core.GBA.MP2K;

public sealed class MP2KMixer : Mixer
{
	internal readonly int SampleRate;
	internal override int SamplesPerBuffer { get; }
	internal readonly float SampleRateReciprocal;
	private readonly float _samplesReciprocal;
	internal readonly float PCM8MasterVolume;
	private bool _isFading;
	private long _fadeMicroFramesLeft;
	private float _fadePos;
	private float _fadeStepPerMicroframe;

	internal readonly MP2KConfig Config;
	private readonly AudioBackend MP2KPlaybackBackend;

	#region MiniAudio Fields
	private readonly Wave? _bufferMiniAudio;
	private byte[]? _byteBufferMiniAudio;
	private float[]? _floatBufferMiniAudio;
	#endregion

	#region PortAudio Fields
	// PortAudio Fields
	private readonly Audio? _audioPortAudio;
	private readonly Wave? _bufferPortAudio;
	#endregion

	#region NAudio Fields
	// NAudio Fields
	private WaveBuffer? _audioNAudio;
	private BufferedWaveProvider? _bufferNAudio;

	protected override WaveFormat WaveFormat => _bufferNAudio!.WaveFormat;
	#endregion

	private readonly float[][] _trackBuffers;
	private readonly MP2KPCM8Channel[] _pcm8Channels;
	private readonly MP2KSquareChannel _sq1;
	private readonly MP2KSquareChannel _sq2;
	private readonly MP2KPCM4Channel _pcm4;
	private readonly MP2KNoiseChannel _noise;
	private readonly MP2KPSGChannel[] _psgChannels;

	internal MP2KMixer(MP2KConfig config)
	{
		Config = config;
		(SampleRate, SamplesPerBuffer) = MP2KUtils.FrequencyTable[config.SampleRate];
		SampleRateReciprocal = 1f / SampleRate;
		_samplesReciprocal = 1f / SamplesPerBuffer;
		PCM8MasterVolume = config.Volume / 15f;

		_pcm8Channels = new MP2KPCM8Channel[24];
		for (int i = 0; i < _pcm8Channels.Length; i++)
		{
			_pcm8Channels[i] = new MP2KPCM8Channel(this);
		}
		_psgChannels = [_sq1 = new MP2KSquareChannel(this), _sq2 = new MP2KSquareChannel(this), _pcm4 = new MP2KPCM4Channel(this), _noise = new MP2KNoiseChannel(this)];

		int amt = SamplesPerBuffer * 2;
		_trackBuffers = new float[0x10][];
		for (int i = 0; i < _trackBuffers.Length; i++)
		{
			_trackBuffers[i] = new float[amt];
		}
		MP2KPlaybackBackend = PlaybackBackend;
		switch (PlaybackBackend)
		{
			case AudioBackend.PortAudio:
				{
					_audioPortAudio = new Audio(amt * sizeof(float)) { Float32BufferCount = amt };
					_bufferPortAudio = new Wave()
					{
						DiscardOnBufferOverflow = true,
						BufferLength = SamplesPerBuffer * 64,
					};
					_bufferPortAudio.CreateIeeeFloatWave((uint)SampleRate, 2);

					Init(waveData: _bufferPortAudio);
					break;
				}
			case AudioBackend.MiniAudio:
				{
					int sizeInBytes = amt * sizeof(float);
					int aligned32Bits = sizeInBytes % 4;
					int sizeToAllocateInBytes = (aligned32Bits == 0) ? sizeInBytes : (sizeInBytes + 4 - aligned32Bits);
					// _bufferMiniAudio = new Wave()
					// {
					// 	DiscardOnBufferOverflow = true,
					// 	BufferLength = SamplesPerBuffer * 64,
					// };
					// _bufferMiniAudio.CreateIeeeFloatWave((uint)SampleRate, 2);
					_byteBufferMiniAudio = new byte[sizeToAllocateInBytes];
					_floatBufferMiniAudio = new float[amt];
					Init(sampleRate: SampleRate, stream: _byteBufferMiniAudio);
					break;
				}
			case AudioBackend.NAudio:
				{
					_audioNAudio = new WaveBuffer(amt * sizeof(float)) { FloatBufferCount = amt };
					_bufferNAudio = new BufferedWaveProvider(WaveFormat.CreateIeeeFloatWaveFormat(SampleRate, 2))
					{
						DiscardOnBufferOverflow = true,
						BufferLength = SamplesPerBuffer * 64,
					};
					Init(waveProvider: _bufferNAudio);
					break;
				}
		}
	}

	internal MP2KPCM8Channel? AllocPCM8Channel(MP2KTrack owner, ADSR env, NoteInfo note, byte vol, sbyte pan, int instPan, int pitch, bool bFixed, bool bCompressed, int sampleOffset)
	{
		MP2KPCM8Channel? nChn = null;
		IOrderedEnumerable<MP2KPCM8Channel> byOwner = _pcm8Channels.OrderByDescending(c => c.Owner is null ? 0xFF : c.Owner.Index);
		foreach (MP2KPCM8Channel i in byOwner) // Find free
		{
			if (i.State == EnvelopeState.Dead || i.Owner is null)
			{
				nChn = i;
				break;
			}
		}
		if (nChn is null) // Find releasing
		{
			foreach (MP2KPCM8Channel i in byOwner)
			{
				if (i.State == EnvelopeState.Releasing)
				{
					nChn = i;
					break;
				}
			}
		}
		if (nChn is null) // Find prioritized
		{
			foreach (MP2KPCM8Channel i in byOwner)
			{
				if (owner.Priority > i.Owner!.Priority)
				{
					nChn = i;
					break;
				}
			}
		}
		if (nChn is null) // None available
		{
			MP2KPCM8Channel lowest = byOwner.First(); // Kill lowest track's instrument if the track is lower than this one
			if (lowest.Owner!.Index >= owner.Index)
			{
				nChn = lowest;
			}
		}
		if (nChn is not null) // Could still be null from the above if
		{
			nChn.Init(owner, note, env, sampleOffset, vol, pan, instPan, pitch, bFixed, bCompressed);
		}
		return nChn;
	}
	internal MP2KPSGChannel? AllocPSGChannel(MP2KTrack owner, ADSR env, NoteInfo note, byte vol, sbyte pan, int instPan, int pitch, VoiceType type, object arg)
	{
		MP2KPSGChannel nChn;
		switch (type)
		{
			case VoiceType.Square1:
				{
					nChn = _sq1;
					if (nChn.State < EnvelopeState.Releasing && nChn.Owner!.Index < owner.Index)
					{
						return null;
					}
					_sq1.Init(owner, note, env, instPan, (SquarePattern)arg);
					break;
				}
			case VoiceType.Square2:
				{
					nChn = _sq2;
					if (nChn.State < EnvelopeState.Releasing && nChn.Owner!.Index < owner.Index)
					{
						return null;
					}
					_sq2.Init(owner, note, env, instPan, (SquarePattern)arg);
					break;
				}
			case VoiceType.PCM4:
				{
					nChn = _pcm4;
					if (nChn.State < EnvelopeState.Releasing && nChn.Owner!.Index < owner.Index)
					{
						return null;
					}
					_pcm4.Init(owner, note, env, instPan, (int)arg);
					break;
				}
			case VoiceType.Noise:
				{
					nChn = _noise;
					if (nChn.State < EnvelopeState.Releasing && nChn.Owner!.Index < owner.Index)
					{
						return null;
					}
					_noise.Init(owner, note, env, instPan, (NoisePattern)arg);
					break;
				}
			default: return null;
		}
		nChn.SetVolume(vol, pan);
		nChn.SetPitch(pitch);
		return nChn;
	}

	internal void BeginFadeIn()
	{
		_fadePos = 0f;
		_fadeMicroFramesLeft = (long)(GlobalConfig.Instance.PlaylistFadeOutMilliseconds / 1_000.0 * GBAUtils.AGB_FPS);
		_fadeStepPerMicroframe = 1f / _fadeMicroFramesLeft;
		_isFading = true;
	}
	internal void BeginFadeOut()
	{
		_fadePos = 1f;
		_fadeMicroFramesLeft = (long)(GlobalConfig.Instance.PlaylistFadeOutMilliseconds / 1_000.0 * GBAUtils.AGB_FPS);
		_fadeStepPerMicroframe = -1f / _fadeMicroFramesLeft;
		_isFading = true;
	}
	internal bool IsFading()
	{
		return _isFading;
	}
	internal bool IsFadeDone()
	{
		return _isFading && _fadeMicroFramesLeft == 0;
	}
	internal void ResetFade()
	{
		_isFading = false;
		_fadeMicroFramesLeft = 0;
	}

	internal void Process(bool output, bool recording)
	{
		for (int i = 0; i < _trackBuffers.Length; i++)
		{
			Span<float> buf = _trackBuffers[i];
			buf.Clear();
		}
		switch (MP2KPlaybackBackend)
		{
			case AudioBackend.PortAudio:
				{
					_audioPortAudio!.Clear();
					break;
				}
			case AudioBackend.NAudio:
				{
					_audioNAudio!.Clear();
					break;
				}
		}

		for (int i = 0; i < _pcm8Channels.Length; i++)
		{
			MP2KPCM8Channel c = _pcm8Channels[i];
			if (c.Owner is not null)
			{
				c.Process(_trackBuffers[c.Owner.Index]);
			}
		}

		for (int i = 0; i < _psgChannels.Length; i++)
		{
			MP2KPSGChannel c = _psgChannels[i];
			if (c.Owner is not null)
			{
				c.Process(_trackBuffers[c.Owner.Index]);
			}
		}

		float masterStep;
		float masterLevel;
		if (_isFading && _fadeMicroFramesLeft == 0)
		{
			masterStep = 0;
			masterLevel = 0;
		}
		else
		{
			float fromMaster = 1f;
			float toMaster = 1f;
			if (_fadeMicroFramesLeft > 0)
			{
				const float scale = 10f / 6f;
				fromMaster *= (_fadePos < 0f) ? 0f : MathF.Pow(_fadePos, scale);
				_fadePos += _fadeStepPerMicroframe;
				toMaster *= (_fadePos < 0f) ? 0f : MathF.Pow(_fadePos, scale);
				_fadeMicroFramesLeft--;
			}
			masterStep = (toMaster - fromMaster) * _samplesReciprocal;
			masterLevel = fromMaster;
		}
		for (int i = 0; i < _trackBuffers.Length; i++)
		{
			if (Mutes[i])
			{
				continue;
			}

			float level = masterLevel;
			Span<float> buf = _trackBuffers[i];
			for (int j = 0; j < SamplesPerBuffer; j++)
			{
				switch (MP2KPlaybackBackend)
				{
					case AudioBackend.PortAudio:
						{
							_audioPortAudio!.Float32Buffer![j * 2] += buf[j * 2] * level;
							_audioPortAudio.Float32Buffer[(j * 2) + 1] += buf[(j * 2) + 1] * level;
							break;
						}
					case AudioBackend.MiniAudio:
						{
							_floatBufferMiniAudio![j * 2] += buf[j * 2] * level;
							_floatBufferMiniAudio[(j * 2) + 1] += buf[(j * 2) + 1] * level;
							break;
						}
					case AudioBackend.NAudio:
						{
							_audioNAudio!.FloatBuffer![j * 2] += buf[j * 2] * level;
							_audioNAudio.FloatBuffer[(j * 2) + 1] += buf[(j * 2) + 1] * level;
							break;
						}
				}
				level += masterStep;
			}
		}
		if (output)
		{
			switch (MP2KPlaybackBackend)
			{
				case AudioBackend.PortAudio:
					{
						_bufferPortAudio!.AddSamples(_audioPortAudio!.ByteBuffer, 0, _audioPortAudio.ByteBufferCount);
						break;
					}
				case AudioBackend.MiniAudio:
					{
						for (int i = 0, b = 0; i < _floatBufferMiniAudio!.Length; i++)
						{
							// Span<byte> bytes = BitConverter.GetBytes(_floatBufferMiniAudio[i]);
							// _byteBufferMiniAudio![b++] = bytes[0];
							// _byteBufferMiniAudio[b++] = bytes[1];
							// _byteBufferMiniAudio[b++] = bytes[2];
							// _byteBufferMiniAudio[b++] = bytes[3];
						}
						DataProvider.AddSamples(_floatBufferMiniAudio);
						if (MiniAudioPlayer.State == SoundFlow.Enums.PlaybackState.Stopped)
						{
							MiniAudioPlayer.Play();
						}
						// _bufferMiniAudio.AddSamples(_byteBufferMiniAudio, 0, _byteBufferMiniAudio.Length);
						// UpdateStream(_byteBufferMiniAudio, SampleRate);
						break;
					}
				case AudioBackend.NAudio:
					{
						_bufferNAudio!.AddSamples(_audioNAudio!.ByteBuffer, 0, _audioNAudio.ByteBufferCount);
						break;
					}
			}
		}
		if (recording)
		{
			switch (MP2KPlaybackBackend)
			{
				case AudioBackend.PortAudio:
					{
						_waveWriterPortAudio!.Write(_audioPortAudio!.ByteBuffer, 0, _audioPortAudio.ByteBufferCount);
						break;
					}
				case AudioBackend.NAudio:
					{
						_waveWriterNAudio!.Write(_audioNAudio!.ByteBuffer, 0, _audioNAudio.ByteBufferCount);
						break;
					}
			}
		}
	}
}

5. Open Edit > Preferences and select MiniAudio and click the OK button.
6. Open any GBA game dump of Pokémon FireRed that you own.

3. Expected Behavior

The audio should playback clearly, in the same way as PortAudio and NAudio do.

4. Current Behavior

Playback buffer is stuck at the very beginning, despite the buffers being changed on every interval, it doesn't progress and sounds like a game crash on a N64 or GameCube.

5. Minimal Reproducible Example (MRE)

using System.Diagnostics;
using SoundFlow.Backends.MiniAudio;
using SoundFlow.Components;
using SoundFlow.Enums;
using SoundFlow.Providers;
using SoundFlow.Structs;

namespace SoundFlow_SineWaveTest;

internal static class Program
{
    public static float[] Sine = new float[200];

    private static void Main(string[] args)
    {
        for (int i = 0; i < 200; i++)
        {
            Sine[i] = (float)Math.Sin(((double)i / (double)200) * Math.PI * 2);
        }

        // 1. Initialize the engine context. It no longer starts a device directly.
        using var engine = new MiniAudioEngine();

        // 2. Define the audio format for playback.
        var format = new AudioFormat
        {
            SampleRate = 48000,
            Channels = 2,
            Format = SampleFormat.F32
        };

        // 3. Initialize a specific playback device. Passing `null` will use the system default too.
        // The `using` statement ensures the device is properly disposed.
        var defaultDevice = engine.PlaybackDevices.FirstOrDefault(x => x.IsDefault);
        using var playbackDevice = engine.InitializePlaybackDevice(defaultDevice, format);

        // 4. Create a SoundPlayer, passing the engine and format context.
        // Make sure you replace "path/to/your/audiofile.wav" with the actual path.
        using var dataProvider = new QueueDataProvider(format);
        var player = new SoundPlayer(engine, format, dataProvider);

        // 5. Add the player to the device's master mixer.
        playbackDevice.MasterMixer.AddComponent(player);

        // 6. Start the device to begin the audio stream.
        playbackDevice.Start();

        bool stopped = false;

        var stopwatch = new Stopwatch();
        stopwatch.Start();

        var thread = new Thread(Playback) { Name = "SineWave Tick" };
        thread.Start();

        // 7. Start the player.
        player.Play();

        Console.WriteLine($"Playing audio on '{playbackDevice.Info?.Name}'... Press any key to stop.");
        Console.Read();

        void Playback()
        {
            dataProvider.AddSamples(Sine);

            if (player.State is PlaybackState.Stopped && !stopped)
            {
                player.Play();
            }

            if (stopwatch.Elapsed.Seconds == 5)
            {
                for (int i = 0; i < 200; i++)
                {
                    Sine[i] = (float)Math.Sin(((double)i / (double)200) * Math.PI * 2) / 2;
                }
            }

            if (stopwatch.Elapsed.Seconds == 10)
            {
                for (int i = 0; i < 200; i++)
                {
                    Sine[i] = (float)Math.Sin(((double)i / (double)200) * Math.PI * 2) / 4;
                }
            }

            if (stopwatch.Elapsed.Seconds == 15)
            {
                playbackDevice.Stop();
            }
        }
    }
}

6. Error Messages and Stack Trace (if applicable)

SoundFlow Version

1.2.1

.NET Version

.NET 8.0

Operating System

Fedora 42

Architecture

x64

Audio Backend Used (if known)

ALSA (MiniAudio)

Specific Audio Hardware (if relevant)

No response

8. Affected Components/Modules (if known)

SoundPlayer, AudioPlaybackDevice, MiniAudioEngine, AudioFormat, QueueDataProvider, RawDataProvider

9. Impact

Incorrect audio output, playback buffers not changing

10. Possible Workaround (if known)

No response

11. Additional Context

This issue does not occur in NAudio (Windows) or PortAudio (Cross-Platform), as they properly output the buffer while playing.

[LSXPrime]

Sorry for the delay. I've been focused on an update and haven't been checking GitHub, and there are actually some issues in your implementation, the main problem is that the Process loop is pushing the entire audio buffer to the QueueDataProvider on every frame, including un-rendered data. The player also seems to be started repeatedly, whereas it only needs to be started once to begin pulling from the queue. Additionally, the AudioEngine isn't being disposed, which will lead to resource leaks.

Fixed Implementation, it's playing correctly now

// Mixer.cs

using PortAudio;
using System;
using System.IO;
using System.Runtime.InteropServices;
using Kermalis.VGMusicStudio.Core.Formats;
using Stream = PortAudio.Stream;
using NAudio.Wave;
using NAudio.CoreAudioApi;
using NAudio.CoreAudioApi.Interfaces;
using SoundFlow.Abstracts;
using SoundFlow.Abstracts.Devices;
using SoundFlow.Backends.MiniAudio;
using SoundFlow.Components;
using SoundFlow.Interfaces;
using SoundFlow.Providers;
using SfAudioFormat = SoundFlow.Structs.AudioFormat;
using SfEncodingFormat = SoundFlow.Enums.EncodingFormat;

namespace Kermalis.VGMusicStudio.Core;

public abstract class Mixer : IAudioSessionEventsHandler, IDisposable
{
    public readonly bool[] Mutes;

    #region MiniAudio Fields
    // MiniAudio Fields
    private AudioEngine? _soundFlowEngine;
    private AudioPlaybackDevice? _playbackDevice;
    internal SoundPlayer? MiniAudioPlayer;
    internal QueueDataProvider? DataProvider;
    private System.IO.Stream? _soundFlowFileStream;
    protected ISoundEncoder? _soundFlowEncoder;
    protected virtual SfAudioFormat? SoundFlowFormat { get; }
    #endregion

    #region PortAudio Fields
    // PortAudio Fields
    public Wave? WaveData;
    internal abstract int SamplesPerBuffer { get; }
    private float Vol = 1;

    public readonly object CountLock = new();

    protected Wave? _waveWriterPortAudio;

    public StreamParameters OParams;
    public StreamParameters DefaultOutputParams { get; private set; }

    public Stream? Stream;
    public bool IsDisposing = false;
    private bool _isDisposed = false;
    #endregion

    #region NAudio Fields
    // NAudio Fields
    public static event Action<float>? VolumeChanged;
    private WasapiOut? _out;
    private AudioSessionControl? _appVolume;

    private bool _shouldSendVolUpdateEvent = true;

    protected WaveFileWriter? _waveWriterNAudio;
    protected abstract WaveFormat? WaveFormat { get; }
    #endregion

    // Audio Backend
    public static AudioBackend PlaybackBackend { get; set; }

    public enum AudioBackend
    {
        PortAudio,
        MiniAudio,
        NAudio
    }

    protected Mixer()
    {
        Mutes = new bool[SongState.MAX_TRACKS];
        if (PlaybackBackend is AudioBackend.NAudio)
        {
            _out = null!;
            _appVolume = null!;
        }
    }

    protected void Init(Wave waveData = null!, PortAudio.SampleFormat sampleFormat = PortAudio.SampleFormat.Float32,
    int sampleRate = 48000,
    IWaveProvider waveProvider = null!)
    {
        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    // First, check if the instance contains something
                    if (WaveData == null)
                    {
                        _isDisposed = false;

                        Pa.Initialize();
                        WaveData = waveData;

                        // Try setting up an output device
                        OParams.Device = Pa.DefaultOutputDevice;
                        if (OParams.Device == Pa.NoDevice)
                        {
                            throw new Exception("No default audio output device is available.");
                        }

                        OParams.Channels = 2;
                        OParams.SampleFormat = sampleFormat;
                        OParams.SuggestedLatency = Pa.GetDeviceInfo(OParams.Device).defaultLowOutputLatency;
                        OParams.HostApiSpecificStreamInfo = IntPtr.Zero;

                        // Set it as the default
                        DefaultOutputParams = OParams;
                    }

                    Stream = new Stream(
                        null,
                        OParams,
                        WaveData!.SampleRate,
                        (uint)SamplesPerBuffer,
                        StreamFlags.NoFlag,
                        Player.PlayCallback,
                        waveData
                    );

                    var hostApiInfo = Pa.GetHostApiInfo(Pa.DefaultHostApi);

                    Stream!.Start();
                    break;
                }
            case AudioBackend.MiniAudio:
                {
                    _soundFlowEngine = new MiniAudioEngine();
                    var format = new SfAudioFormat
                    {
                        SampleRate = sampleRate,
                        Channels = 2,
                        Format = SoundFlow.Enums.SampleFormat.F32
                    };
                    // Let SoundFlow pick the default device by passing null
                    _playbackDevice = _soundFlowEngine.InitializePlaybackDevice(null, format);

                    // Provide a capacity to the queue to prevent unbounded memory growth
                    DataProvider = new QueueDataProvider(format, SamplesPerBuffer * 64, QueueFullBehavior.Block);
                    MiniAudioPlayer = new SoundPlayer(_soundFlowEngine, format, DataProvider);

                    _playbackDevice.MasterMixer.AddComponent(MiniAudioPlayer);
                    _playbackDevice.Start();
                    MiniAudioPlayer.Play(); // Start the player once; it will pull from the queue automatically
                    break;
                }
            case AudioBackend.NAudio:
                {
                    _out = new WasapiOut();
                    _out.Init(waveProvider);
                    using (var en = new MMDeviceEnumerator())
                    {
                        SessionCollection sessions = en.GetDefaultAudioEndpoint(DataFlow.Render, Role.Multimedia).AudioSessionManager.Sessions;
                        int id = Environment.ProcessId;
                        for (int i = 0; i < sessions.Count; i++)
                        {
                            AudioSessionControl session = sessions[i];
                            if (session.GetProcessID == id)
                            {
                                _appVolume = session;
                                _appVolume.RegisterEventClient(this);
                                break;
                            }
                        }
                    }
                    _out.Play();
                    break;
                }
        }
    }

    public float Volume
    {
        get => Vol;
        set => SetVolume(value);
    }

    public float GetVolume()
    {
        return Vol;
    }

    public void SetVolume(float volume)
    {
        Vol = Math.Clamp(volume, 0, 1);

        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                    Vol = Math.Clamp(volume, 0, 1);
                    break;
            case AudioBackend.MiniAudio:
                if (MiniAudioPlayer is not null)
                {
                    MiniAudioPlayer.Volume = Vol;
                }
                break;
            case AudioBackend.NAudio:
                _shouldSendVolUpdateEvent = false;
                if (_appVolume is not null)
                {
                    _appVolume.SimpleAudioVolume.Volume = Vol;
                }
                break;
        }
    }

    #region NAudio Functions
    public void OnVolumeChanged(float volume, bool isMuted)
    {
        if (_shouldSendVolUpdateEvent)
        {
            VolumeChanged?.Invoke(volume);
        }
        _shouldSendVolUpdateEvent = true;
    }
    public void OnDisplayNameChanged(string displayName)
    {
        throw new NotImplementedException();
    }
    public void OnIconPathChanged(string iconPath)
    {
        throw new NotImplementedException();
    }
    public void OnChannelVolumeChanged(uint channelCount, IntPtr newVolumes, uint channelIndex)
    {
        throw new NotImplementedException();
    }
    public void OnGroupingParamChanged(ref Guid groupingId)
    {
        throw new NotImplementedException();
    }
    // Fires on @out.Play() and @out.Stop()
    public void OnStateChanged(AudioSessionState state)
    {
        if (state == AudioSessionState.AudioSessionStateActive)
        {
            OnVolumeChanged(_appVolume!.SimpleAudioVolume.Volume, _appVolume.SimpleAudioVolume.Mute);
        }
    }
    public void OnSessionDisconnected(AudioSessionDisconnectReason disconnectReason)
    {
        throw new NotImplementedException();
    }
    #endregion

    public void CreateWaveWriter(string fileName)
    {
        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    _waveWriterPortAudio = WaveData;
                    _waveWriterPortAudio!.CreateFileStream(fileName);
                    break;
                }
            case AudioBackend.MiniAudio:
                {
                    if (_soundFlowEngine is null || SoundFlowFormat is null)
                    {
                        throw new InvalidOperationException("SoundFlow engine or format is not initialized for recording.");
                    }
                    _soundFlowFileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None);
                    _soundFlowEncoder = _soundFlowEngine.CreateEncoder(_soundFlowFileStream, SfEncodingFormat.Wav, SoundFlowFormat.Value);
                    break;
                }
            case AudioBackend.NAudio:
                {
                    _waveWriterNAudio = new WaveFileWriter(fileName, WaveFormat);
                    break;
                }
        }
    }
    public void CloseWaveWriter()
    {
        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    _waveWriterPortAudio!.Dispose(true);
                    _waveWriterPortAudio = null;
                    break;
                }
            case AudioBackend.MiniAudio:
                {
                    _soundFlowEncoder?.Dispose();
                    _soundFlowFileStream?.Dispose();
                    _soundFlowEncoder = null;
                    _soundFlowFileStream = null;
                    break;
                }
            case AudioBackend.NAudio:
                {
                    _waveWriterNAudio!.Dispose();
                    _waveWriterNAudio = null;
                    break;
                }
        }
    }

    public virtual void Dispose()
    {
        if (_isDisposed)
        {
            return;
        }

        switch (PlaybackBackend)
        {
            case AudioBackend.PortAudio:
                {
                    if (_isDisposed || Stream is null)
                    {
                        return;
                    }

                    IsDisposing = true;
                    Stream!.Stop();

                    Stream!.Dispose();
                    break;
                }
            case AudioBackend.MiniAudio:
                {
                    IsDisposing = true;
                    _playbackDevice?.Stop();
                    _playbackDevice?.Dispose();
                    _soundFlowEngine?.Dispose();
                    DataProvider?.Dispose();
                    break;
                }
            case AudioBackend.NAudio:
                {
                    if (_out is not null)
                    {
                        _out!.Stop();
                        _out.Dispose();
                        _appVolume!.Dispose();
                    }
                    break;
                }
        }
        GC.SuppressFinalize(this);

        _isDisposed = true;
    }

    public interface IAudio
    {
        Span<byte> ByteBuffer { get; }
        Span<short> Int16Buffer { get; }
        Span<int> Int32Buffer { get; }
        Span<long> Int64Buffer { get; }
        Span<Int128> Int128Buffer { get; }
        Span<Half> Float16Buffer { get; }
        Span<float> Float32Buffer { get; }
        Span<double> Float64Buffer { get; }
        Span<decimal> Float128Buffer { get; }
    }

    [StructLayout(LayoutKind.Explicit, Pack = 2)]
    public class Audio : IAudio
    {
        [FieldOffset(0)]
        public int NumberOfBytes;
        [FieldOffset(8)]
        public byte[]? ByteBuffer;
        [FieldOffset(8)]
        public short[]? Int16Buffer;
        [FieldOffset(8)]
        public int[]? Int32Buffer;
        [FieldOffset(8)]
        public long[]? Int64Buffer;
        [FieldOffset(8)]
        public Int128[]? Int128Buffer;
        [FieldOffset(8)]
        public Half[]? Float16Buffer;
        [FieldOffset(8)]
        public float[]? Float32Buffer;
        [FieldOffset(8)]
        public double[]? Float64Buffer;
        [FieldOffset(8)]
        public decimal[]? Float128Buffer;

        Span<byte> IAudio.ByteBuffer => ByteBuffer!;
        Span<short> IAudio.Int16Buffer => Int16Buffer!;
        Span<int> IAudio.Int32Buffer => Int32Buffer!;
        Span<long> IAudio.Int64Buffer => Int64Buffer!;
        Span<Int128> IAudio.Int128Buffer => Int128Buffer!;
        Span<Half> IAudio.Float16Buffer => Float16Buffer!;
        Span<float> IAudio.Float32Buffer => Float32Buffer!;
        Span<double> IAudio.Float64Buffer => Float64Buffer!;
        Span<decimal> IAudio.Float128Buffer => Float128Buffer!;

        public int ByteBufferCount
        {
            get
            {
                return NumberOfBytes;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("ByteBufferCount", value, 1);
            }
        }

        public int Int16BufferCount
        {
            get
            {
                return NumberOfBytes / 2;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Int16BufferCount", value, 2);
            }
        }

        public int Int32BufferCount
        {
            get
            {
                return NumberOfBytes / 4;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Int32BufferCount", value, 4);
            }
        }

        public int Int64BufferCount
        {
            get
            {
                return NumberOfBytes / 8;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Int64BufferCount", value, 8);
            }
        }

        public int Int128BufferCount
        {
            get
            {
                return NumberOfBytes / 16;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Int128BufferCount", value, 16);
            }
        }

        public int Float16BufferCount
        {
            get
            {
                return NumberOfBytes / 2;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Float16BufferCount", value, 2);
            }
        }

        public int Float32BufferCount
        {
            get
            {
                return NumberOfBytes / 4;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Float32BufferCount", value, 4);
            }
        }

        public int Float64BufferCount
        {
            get
            {
                return NumberOfBytes / 8;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Float64BufferCount", value, 8);
            }
        }

        public int Float128BufferCount
        {
            get
            {
                return NumberOfBytes / 16;
            }
            set
            {
                NumberOfBytes = CheckValidityCount("Float128BufferCount", value, 16);
            }
        }

        public Audio(int sizeToAllocateInBytes)
        {
            var sizeInBytes = sizeToAllocateInBytes;
            int aligned32Bits = sizeInBytes % 4;
            sizeToAllocateInBytes = (aligned32Bits == 0) ? sizeInBytes : (sizeInBytes + 4 - aligned32Bits);
            ByteBuffer = new byte[sizeToAllocateInBytes];
            NumberOfBytes = 0;
        }

        public static implicit operator byte[](Audio waveBuffer)
        {
            return waveBuffer.ByteBuffer!;
        }

        private int CheckValidityCount(string argName, int value, int sizeOfValue)
        {
            int num = value * sizeOfValue;
            if (num % 4 != 0)
            {
                throw new ArgumentOutOfRangeException(argName, $"{argName} cannot set a count ({num}) that is not 4 bytes aligned ");
            }

            if (value < 0 || value > ByteBuffer!.Length / sizeOfValue)
            {
                throw new ArgumentOutOfRangeException(argName, $"{argName} cannot set a count that exceeds max count of {ByteBuffer!.Length / sizeOfValue}.");
            }

            return num;
        }

        public void Clear()
        {
            Array.Clear(ByteBuffer!, 0, ByteBuffer!.Length);
        }

        public void Copy(Array destinationArray)
        {
            Array.Copy(ByteBuffer!, destinationArray, NumberOfBytes);
        }
    }
}

// MP2KMixer.cs

using Kermalis.VGMusicStudio.Core.Formats;
using Kermalis.VGMusicStudio.Core.Util;
using NAudio.Wave;
using System;
using System.Linq;
using SfAudioFormat = SoundFlow.Structs.AudioFormat;
using SfSampleFormat = SoundFlow.Enums.SampleFormat;

namespace Kermalis.VGMusicStudio.Core.GBA.MP2K;

public sealed class MP2KMixer : Mixer
{
	internal readonly int SampleRate;
	internal override int SamplesPerBuffer { get; }
	internal readonly float SampleRateReciprocal;
	private readonly float _samplesReciprocal;
	internal readonly float PCM8MasterVolume;
	private bool _isFading;
	private long _fadeMicroFramesLeft;
	private float _fadePos;
	private float _fadeStepPerMicroframe;

	internal readonly MP2KConfig Config;
	private readonly AudioBackend MP2KPlaybackBackend;

	#region MiniAudio Fields
	private readonly float[]? _audioSoundFlow;
	private readonly SfAudioFormat? _soundFlowFormat;
	protected override SfAudioFormat? SoundFlowFormat => _soundFlowFormat;
	#endregion

	#region PortAudio Fields
	// PortAudio Fields
	private readonly Audio? _audioPortAudio;
	private readonly Wave? _bufferPortAudio;
	#endregion

	#region NAudio Fields
	// NAudio Fields
	private WaveBuffer? _audioNAudio;
	private BufferedWaveProvider? _bufferNAudio;

	protected override WaveFormat WaveFormat => _bufferNAudio!.WaveFormat;
	#endregion

	private readonly float[][] _trackBuffers;
	private readonly MP2KPCM8Channel[] _pcm8Channels;
	private readonly MP2KSquareChannel _sq1;
	private readonly MP2KSquareChannel _sq2;
	private readonly MP2KPCM4Channel _pcm4;
	private readonly MP2KNoiseChannel _noise;
	private readonly MP2KPSGChannel[] _psgChannels;

	internal MP2KMixer(MP2KConfig config)
	{
		Config = config;
		(SampleRate, SamplesPerBuffer) = MP2KUtils.FrequencyTable[config.SampleRate];
		SampleRateReciprocal = 1f / SampleRate;
		_samplesReciprocal = 1f / SamplesPerBuffer;
		PCM8MasterVolume = config.Volume / 15f;

		_pcm8Channels = new MP2KPCM8Channel[24];
		for (int i = 0; i < _pcm8Channels.Length; i++)
		{
			_pcm8Channels[i] = new MP2KPCM8Channel(this);
		}
		_psgChannels = [_sq1 = new MP2KSquareChannel(this), _sq2 = new MP2KSquareChannel(this), _pcm4 = new MP2KPCM4Channel(this), _noise = new MP2KNoiseChannel(this)];

		int amt = SamplesPerBuffer * 2;
		_trackBuffers = new float[0x10][];
		for (int i = 0; i < _trackBuffers.Length; i++)
		{
			_trackBuffers[i] = new float[amt];
		}
		MP2KPlaybackBackend = PlaybackBackend;
		switch (PlaybackBackend)
		{
			case AudioBackend.PortAudio:
				{
					_audioPortAudio = new Audio(amt * sizeof(float)) { Float32BufferCount = amt };
					_bufferPortAudio = new Wave()
					{
						DiscardOnBufferOverflow = true,
						BufferLength = SamplesPerBuffer * 64,
					};
					_bufferPortAudio.CreateIeeeFloatWave((uint)SampleRate, 2);

					Init(waveData: _bufferPortAudio);
					break;
				}
			case AudioBackend.MiniAudio:
				{
					_audioSoundFlow = new float[amt];
					_soundFlowFormat = new SfAudioFormat
					{
						Channels = 2,
						SampleRate = SampleRate,
						Format = SfSampleFormat.F32
					};
					Init(sampleRate: SampleRate);
					break;
				}
			case AudioBackend.NAudio:
				{
					_audioNAudio = new WaveBuffer(amt * sizeof(float)) { FloatBufferCount = amt };
					_bufferNAudio = new BufferedWaveProvider(WaveFormat.CreateIeeeFloatWaveFormat(SampleRate, 2))
					{
						DiscardOnBufferOverflow = true,
						BufferLength = SamplesPerBuffer * 64,
					};
					Init(waveProvider: _bufferNAudio);
					break;
				}
		}
	}

	internal MP2KPCM8Channel? AllocPCM8Channel(MP2KTrack owner, ADSR env, NoteInfo note, byte vol, sbyte pan, int instPan, int pitch, bool bFixed, bool bCompressed, int sampleOffset)
	{
		MP2KPCM8Channel? nChn = null;
		IOrderedEnumerable<MP2KPCM8Channel> byOwner = _pcm8Channels.OrderByDescending(c => c.Owner is null ? 0xFF : c.Owner.Index);
		foreach (MP2KPCM8Channel i in byOwner) // Find free
		{
			if (i.State == EnvelopeState.Dead || i.Owner is null)
			{
				nChn = i;
				break;
			}
		}
		if (nChn is null) // Find releasing
		{
			foreach (MP2KPCM8Channel i in byOwner)
			{
				if (i.State == EnvelopeState.Releasing)
				{
					nChn = i;
					break;
				}
			}
		}
		if (nChn is null) // Find prioritized
		{
			foreach (MP2KPCM8Channel i in byOwner)
			{
				if (owner.Priority > i.Owner!.Priority)
				{
					nChn = i;
					break;
				}
			}
		}
		if (nChn is null) // None available
		{
			MP2KPCM8Channel lowest = byOwner.First(); // Kill lowest track's instrument if the track is lower than this one
			if (lowest.Owner!.Index >= owner.Index)
			{
				nChn = lowest;
			}
		}
		if (nChn is not null) // Could still be null from the above if
		{
			nChn.Init(owner, note, env, sampleOffset, vol, pan, instPan, pitch, bFixed, bCompressed);
		}
		return nChn;
	}
	internal MP2KPSGChannel? AllocPSGChannel(MP2KTrack owner, ADSR env, NoteInfo note, byte vol, sbyte pan, int instPan, int pitch, VoiceType type, object arg)
	{
		MP2KPSGChannel nChn;
		switch (type)
		{
			case VoiceType.Square1:
				{
					nChn = _sq1;
					if (nChn.State < EnvelopeState.Releasing && nChn.Owner!.Index < owner.Index)
					{
						return null;
					}
					_sq1.Init(owner, note, env, instPan, (SquarePattern)arg);
					break;
				}
			case VoiceType.Square2:
				{
					nChn = _sq2;
					if (nChn.State < EnvelopeState.Releasing && nChn.Owner!.Index < owner.Index)
					{
						return null;
					}
					_sq2.Init(owner, note, env, instPan, (SquarePattern)arg);
					break;
				}
			case VoiceType.PCM4:
				{
					nChn = _pcm4;
					if (nChn.State < EnvelopeState.Releasing && nChn.Owner!.Index < owner.Index)
					{
						return null;
					}
					_pcm4.Init(owner, note, env, instPan, (int)arg);
					break;
				}
			case VoiceType.Noise:
				{
					nChn = _noise;
					if (nChn.State < EnvelopeState.Releasing && nChn.Owner!.Index < owner.Index)
					{
						return null;
					}
					_noise.Init(owner, note, env, instPan, (NoisePattern)arg);
					break;
				}
			default: return null;
		}
		nChn.SetVolume(vol, pan);
		nChn.SetPitch(pitch);
		return nChn;
	}

	internal void BeginFadeIn()
	{
		_fadePos = 0f;
		_fadeMicroFramesLeft = (long)(GlobalConfig.Instance.PlaylistFadeOutMilliseconds / 1_000.0 * GBAUtils.AGB_FPS);
		_fadeStepPerMicroframe = 1f / _fadeMicroFramesLeft;
		_isFading = true;
	}
	internal void BeginFadeOut()
	{
		_fadePos = 1f;
		_fadeMicroFramesLeft = (long)(GlobalConfig.Instance.PlaylistFadeOutMilliseconds / 1_000.0 * GBAUtils.AGB_FPS);
		_fadeStepPerMicroframe = -1f / _fadeMicroFramesLeft;
		_isFading = true;
	}
	internal bool IsFading()
	{
		return _isFading;
	}
	internal bool IsFadeDone()
	{
		return _isFading && _fadeMicroFramesLeft == 0;
	}
	internal void ResetFade()
	{
		_isFading = false;
		_fadeMicroFramesLeft = 0;
	}

	internal void Process(bool output, bool recording)
	{
		for (int i = 0; i < _trackBuffers.Length; i++)
		{
			Span<float> buf = _trackBuffers[i];
			buf.Clear();
		}
		switch (MP2KPlaybackBackend)
		{
			case AudioBackend.PortAudio:
				{
					_audioPortAudio!.Clear();
					break;
				}
			case AudioBackend.MiniAudio:
				{
					Array.Clear(_audioSoundFlow!);
					break;
				}
			case AudioBackend.NAudio:
				{
					_audioNAudio!.Clear();
					break;
				}
		}

		for (int i = 0; i < _pcm8Channels.Length; i++)
		{
			MP2KPCM8Channel c = _pcm8Channels[i];
			if (c.Owner is not null)
			{
				c.Process(_trackBuffers[c.Owner.Index]);
			}
		}

		for (int i = 0; i < _psgChannels.Length; i++)
		{
			MP2KPSGChannel c = _psgChannels[i];
			if (c.Owner is not null)
			{
				c.Process(_trackBuffers[c.Owner.Index]);
			}
		}

		float masterStep;
		float masterLevel;
		if (_isFading && _fadeMicroFramesLeft == 0)
		{
			masterStep = 0;
			masterLevel = 0;
		}
		else
		{
			float fromMaster = 1f;
			float toMaster = 1f;
			if (_fadeMicroFramesLeft > 0)
			{
				const float scale = 10f / 6f;
				fromMaster *= (_fadePos < 0f) ? 0f : MathF.Pow(_fadePos, scale);
				_fadePos += _fadeStepPerMicroframe;
				toMaster *= (_fadePos < 0f) ? 0f : MathF.Pow(_fadePos, scale);
				_fadeMicroFramesLeft--;
			}
			masterStep = (toMaster - fromMaster) * _samplesReciprocal;
			masterLevel = fromMaster;
		}
		for (int i = 0; i < _trackBuffers.Length; i++)
		{
			if (Mutes[i])
			{
				continue;
			}

			float level = masterLevel;
			Span<float> buf = _trackBuffers[i];
			for (int j = 0; j < SamplesPerBuffer; j++)
			{
				switch (MP2KPlaybackBackend)
				{
					case AudioBackend.PortAudio:
						{
							_audioPortAudio!.Float32Buffer![j * 2] += buf[j * 2] * level;
							_audioPortAudio.Float32Buffer[(j * 2) + 1] += buf[(j * 2) + 1] * level;
							break;
						}
					case AudioBackend.MiniAudio:
						{
							_audioSoundFlow![j * 2] += buf[j * 2] * level;
							_audioSoundFlow[(j * 2) + 1] += buf[(j * 2) + 1] * level;
							break;
						}
					case AudioBackend.NAudio:
						{
							_audioNAudio!.FloatBuffer![j * 2] += buf[j * 2] * level;
							_audioNAudio.FloatBuffer[(j * 2) + 1] += buf[(j * 2) + 1] * level;
							break;
						}
				}
				level += masterStep;
			}
		}
		if (output)
		{
			switch (MP2KPlaybackBackend)
			{
				case AudioBackend.PortAudio:
					{
						_bufferPortAudio!.AddSamples(_audioPortAudio!.ByteBuffer, 0, _audioPortAudio.ByteBufferCount);
						break;
					}
				case AudioBackend.MiniAudio:
					{
						DataProvider?.AddSamples(_audioSoundFlow.AsSpan(0, SamplesPerBuffer * 2));
						break;
					}
				case AudioBackend.NAudio:
					{
						_bufferNAudio!.AddSamples(_audioNAudio!.ByteBuffer, 0, _audioNAudio.ByteBufferCount);
						break;
					}
			}
		}
		if (recording)
		{
			switch (MP2KPlaybackBackend)
			{
				case AudioBackend.PortAudio:
					{
						_waveWriterPortAudio!.Write(_audioPortAudio!.ByteBuffer, 0, _audioPortAudio.ByteBufferCount);
						break;
					}
				case AudioBackend.MiniAudio:
					{
						_soundFlowEncoder?.Encode(_audioSoundFlow.AsSpan(0, SamplesPerBuffer * 2));
						break;
					}
				case AudioBackend.NAudio:
					{
						_waveWriterNAudio!.Write(_audioNAudio!.ByteBuffer, 0, _audioNAudio.ByteBufferCount);
						break;
					}
			}
		}
	}
}

If you have any further questions, don't hesitate to ask here, or feel free to close the issue.

[PlatinumLucario]

@LSXPrime Thank you so much for showing me how to properly use QueueDataProvider, it really means a lot!

It works just as it does with PortAudio (and the deprecated NAudio), and it doesn't have the same minor issue that the PortAudio backend currently has in the project I'm contributing to.

Now I understand that I need to specify the buffer length as well as QueueFullBehavior.Block in order for it to correctly playback the buffers and proceed.

I've implemented the changes, and can be seen in this commit and this commit into the VG Music Studio new-gui-experimental branch.

If I have any more questions, I'll definitely ask about them in a separate issue.