Need more information on how to implement RawDataProvider or QueueDataProvider

[PlatinumLucario]

Since MiniAudio is a completely new library to me and because I want to try and create an extra backend to a Sound Editor that I've been contributing to since years ago, so I tried implementing MiniAudio into VG Music Studio using the SoundFlow package (which are essentially bindings for MiniAudio). Since I'm used to using PortAudio and NAudio, I literally thought MiniAudio would work in the same way or similar.

But oh wow, I was wrong! lol

I ran into a huge problem: It can output sound, but sounds like one of those old game console crashes, because the buffer doesn't output any sound past the first few buffer arrays. I've tried this with QueueDataProvider and RawDataProvider, and both of them cause the same issue. And every other data provider I've tried expects the buffer to read a RIFF Wave or something, resulting in a decoding error upon reading the array I feed into it.

Here's Mixer.cs, part of the initialisation process:
Mixer.cs

Here's MP2K_Mixer.cs, the other part of the initialisation process and where the data gets fed into it:
MP2KMixer.cs

Then there's Player.cs, the part where the timer and ticks begin from:
Player.cs

Then there's MP2K_Player.cs, which uses the abstract overrides from the Player class to then lead into the mixer:
MP2KPlayer.cs

First, it begins with this (seen in MP2K_Mixer.cs):

	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;
				}
		}
	}

Then it enters into Init (seen in Mixer.cs):

    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;
                }
        }
    }

Then this runs within a timer thread (seen in Player.cs):

	private void TimerTick()
	{
		_deltaTimeElapsed = 0;
		_timer.Start();
		while (true)
		{
			var state = State;
			var playing = state == PlayerState.Playing;
			var recording = state == PlayerState.Recording;
			if (!playing && !recording)
			{
				break;
			}
			_deltaTimeElapsed += _timer.GetDeltaTime();
			while (_deltaTimeElapsed >= _timer.GetDeltaTick())
			{
				_deltaTimeElapsed -= _timer.GetDeltaTick();
				try
				{
					bool allDone = Tick(playing, recording);
					if (Info is not null)
					{
						UpdateSongState(Info);
					}
					if (allDone)
					{
						// TODO: lock state
						_timer.Stop(); // TODO: Don't need timer if recording
						SongEnded?.Invoke();
						return;
					}
				}
				catch (Exception ex)
				{
					ErrorDetails = ex;
				}
			}
		}
		_timer.Stop();
	}

Which then leads to Tick being called in MP2K_Player.cs:

	protected override bool Tick(bool playing, bool recording)
	{
		MP2KLoadedSong s = _loadedSong!;

		bool allDone = false;
		while (!allDone && TempoStack >= 150)
		{
			TempoStack -= 150;
			allDone = true;
			for (int i = 0; i < s.Tracks.Length; i++)
			{
				TickTrack(s, s.Tracks[i], ref allDone);
			}
			if (MMixer.IsFadeDone())
			{
				allDone = true;
			}
		}
		if (!allDone)
		{
			TempoStack += Tempo;
		}
		MMixer.Process(playing, recording);
		return allDone;
	}

Then leads to Process being called in MP2K_Mixer.cs:

	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];
						}
						if (DataProvider.SamplesAvailable < 1000000)
						{
							DataProvider.AddSamples(_floatBufferMiniAudio);
						}
						if (MiniAudioPlayer.State == SoundFlow.Enums.PlaybackState.Stopped && DataProvider.SamplesAvailable >= 1000000)
						{
							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;
					}
			}
		}
	}

Now, I'm aware that all this code works almost perfectly in PortAudio and NAudio, but as for MiniAudio? The audio gets stuck right at the very beginning. And I'm unsure as to why.

Is there something that I'm missing in the MiniAudio process that I need to do in order to make it work correctly with a buffer array that constantly keeps changing? I really need to know how I can understand how to properly implement it.

I can't see any documentation on how to correctly implement QueueDataProvider or RawDataProvider, so I'd really like to know what I'm missing in this that is needed for a QueueDataProvider or RawDataProvider to work correctly so that the sound will proceed correctly, and not sound like an old game console crash.

Thank you in advance!

[LSXPrime]

For some reason, GitHub Discussions have actually never notified me. However, the discussion was closed as solved in #86