SHA256
89 lines
3.3 KiB
C#
89 lines
3.3 KiB
C#
using System;
|
|
|
|
namespace ADOFAIRenderer.Util.Audio.Clip;
|
|
|
|
/// <summary>
|
|
/// <see cref="IPCMReader"/> that reproduces the game's output for mono MP3 files.
|
|
///
|
|
/// MP3Sharp (Assembly-CSharp-firstpass, MP3Sharp.Buffer16BitStereo) writes every frame in stereo layout and fills only the
|
|
/// channel 0 slot for mono streams, while MP3Stream.ChannelCount reports 1. The game creates a 1-channel clip from that data,
|
|
/// so a mono MP3 plays as [s0, 0, s1, 0, ...]: twice as long, at half speed and one octave lower
|
|
/// (confirmed in game with TestMaps/mp3_mono, 2026-10-13).
|
|
///
|
|
/// Output: 1 channel at the inner reader's sample rate. Frame 2k is inner frame k, frame 2k + 1 is 0.
|
|
/// <see cref="TotalFrames"/> = 2 * inner TotalFrames.
|
|
/// </summary>
|
|
internal sealed class MP3MonoLayoutReader : IPCMReader
|
|
{
|
|
private readonly IPCMReader _inner;
|
|
|
|
/// <summary>Reused buffer for inner frames, grown to the largest request.</summary>
|
|
private float[] _innerBuffer = Array.Empty<float>();
|
|
|
|
/// <param name="inner">Mono reader of the MP3 file with the game's MP3 timing (<see cref="FFmpegPCMReader.IsMP3"/>). Owned by this reader.</param>
|
|
public MP3MonoLayoutReader(IPCMReader inner)
|
|
{
|
|
if (inner.Channels != 1) throw new ArgumentException("Inner reader must be mono.", nameof(inner));
|
|
_inner = inner;
|
|
Position = inner.Position * 2;
|
|
}
|
|
|
|
/// <summary>Always 1.</summary>
|
|
public int Channels => 1;
|
|
|
|
/// <summary>The inner reader's sample rate (the game plays the doubled data at this rate).</summary>
|
|
public int SampleRate => _inner.SampleRate;
|
|
|
|
/// <summary>Twice the inner frame count.</summary>
|
|
public long TotalFrames => _inner.TotalFrames * 2;
|
|
|
|
/// <inheritdoc/>
|
|
public bool IsForwardOnly => _inner.IsForwardOnly;
|
|
|
|
/// <inheritdoc/>
|
|
public long Position { get; private set; }
|
|
|
|
/// <summary>Moves to <paramref name="frame"/>; the inner reader moves to the inner frame of the next even position.</summary>
|
|
public void Seek(long frame)
|
|
{
|
|
_inner.Seek((frame + 1) / 2);
|
|
Position = frame;
|
|
}
|
|
|
|
/// <inheritdoc/>
|
|
public int Read(float[] buffer, int frameCount)
|
|
{
|
|
var limit = (int)Math.Min(frameCount, TotalFrames - Position);
|
|
var written = 0;
|
|
while (written < limit)
|
|
{
|
|
// Odd position: the zero slot after an inner sample (also the first frame after a seek to an odd frame).
|
|
if ((Position & 1) == 1)
|
|
{
|
|
buffer[written++] = 0f;
|
|
Position++;
|
|
continue;
|
|
}
|
|
|
|
// Even position: read enough inner frames for the remaining output, then interleave each with a zero.
|
|
var want = (limit - written + 1) / 2;
|
|
if (_innerBuffer.Length < want) _innerBuffer = new float[want];
|
|
var got = _inner.Read(_innerBuffer, want);
|
|
if (got == 0) break;
|
|
|
|
for (var i = 0; i < got && written < limit; i++)
|
|
{
|
|
buffer[written++] = _innerBuffer[i];
|
|
Position++;
|
|
if (written >= limit) break;
|
|
buffer[written++] = 0f;
|
|
Position++;
|
|
}
|
|
}
|
|
return written;
|
|
}
|
|
|
|
/// <summary>Disposes the inner reader.</summary>
|
|
public void Dispose() => _inner.Dispose();
|
|
}
|