public override int Read(byte[] buffer, int offset, int count)
{
// adjust count so it is in floats instead of bytes
count /= sizeof(float);
// make sure we don't have an odd count
count -= count % m_reader.Channels;
// get the buffer, creating a new one if none exists or the existing one is too small
var cb = _conversionBuffer ?? (_conversionBuffer = new float[count]);
if (cb.Length < count)
{
cb = (_conversionBuffer = new float[count]);
}
// let ReadSamples(float[], int, int) do the actual reading; adjust count back to bytes
int cnt = m_reader.ReadSamples(cb, 0, count) * sizeof(float);
// move the data back to the request buffer
Buffer.BlockCopy(cb, 0, buffer, offset, cnt);
// done!
return(cnt);
}
private SoundEffect LoadSound(Stream stream, int length, string extension)
{
switch (extension)
{
case ".wav":
if (!stream.CanSeek)
{
stream = new MemoryStream(stream.ReadBytes(length));
}
return(SoundEffect.FromStream(stream));
case ".mp3":
using (var mp3Stream = new MP3Stream(stream))
using (var ms = new MemoryStream()) {
mp3Stream.CopyTo(ms);
return(new SoundEffect(ms.ToArray(), mp3Stream.Frequency, (AudioChannels)mp3Stream.ChannelCount));
}
case ".ogg":
using (var reader = new VorbisReader(stream, true)) {
var buffer = new byte[reader.TotalSamples * 2 * reader.Channels];
var floatBuf = new float[buffer.Length / 2];
reader.ReadSamples(floatBuf, 0, floatBuf.Length);
MusicStreamingOGG.Convert(floatBuf, buffer);
return(new SoundEffect(buffer, reader.SampleRate, (AudioChannels)reader.Channels));
}
}
throw new ResourceLoadException("Unknown sound extension " + extension);
}
public override AudioClip Load(Identifier name, Uri uri)
{
using var reader = new VorbisReader(uri.LocalPath)
{
ClipSamples = true
};
var channels = reader.Channels;
var format = channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16;
var sampleRate = reader.SampleRate;
// TODO use stream-able clip for large sounds
var totalTime = reader.TotalTime;
var buffer = new float[channels * sampleRate * (int)System.Math.Ceiling(totalTime.TotalSeconds)];
var count = 0;
int read;
do
{
read = reader.ReadSamples(buffer, count, buffer.Length - count);
count += read;
} while (read > 0);
var audioClip = new AudioClip(format, sampleRate);
var data = Convert(buffer);
audioClip.SetData(data);
return(audioClip);
}
/// <summary>
/// Extract the bufferdata from an ogg-file.
/// </summary>
/// <param name="file">The file to load the data from.</param>
/// <returns>A SoundBufferData object containing the data from the specified file.</returns>
public static SoundBufferData FromOgg(Stream file)
{
var buffers = new List <short[]>();
ALFormat format;
int sampleRate;
using (var vorbis = new VorbisReader(file, true))
{
// Save format and samplerate for playback
format = vorbis.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16;
sampleRate = vorbis.SampleRate;
var buffer = new float[16384];
int count;
while ((count = vorbis.ReadSamples(buffer, 0, buffer.Length)) > 0)
{
// Sample value range is -0.99999994f to 0.99999994f
// Samples are interleaved (chan0, chan1, chan0, chan1, etc.)
// Use the OggStreamer method to cast to the right format
var castBuffer = new short[count];
SoundBufferData.CastBuffer(buffer, castBuffer, count);
buffers.Add(castBuffer);
}
}
return(new SoundBufferData(buffers, format, sampleRate));
}
private static void LoadOgg(VorbisReader vorbis, out byte[] data, out ALFormat format, out uint sampleRate, out TimeSpan len)
{
sampleRate = (uint)vorbis.SampleRate;
format = vorbis.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16;
len = vorbis.TotalTime;
float[] buffer = new float[vorbis.SampleRate / 10 * vorbis.Channels];
List <byte> bytes = new List <byte>((int)(vorbis.SampleRate * vorbis.Channels * 2 * len.TotalSeconds));
int count = 0;
while ((count = vorbis.ReadSamples(buffer, 0, buffer.Length)) > 0)
{
for (int i = 0; i < count; i++)
{
int temp = (int)(short.MaxValue * buffer[i]);
if (temp > short.MaxValue)
{
temp = short.MaxValue;
}
else if (temp < short.MinValue)
{
temp = short.MinValue;
}
short tempBytes = (short)temp;
byte byte1 = (byte)((tempBytes >> 8) & 0x00FF);
byte byte2 = (byte)((tempBytes >> 0) & 0x00FF);
// Little endian
bytes.Add(byte2);
bytes.Add(byte1);
}
}
// TODO: Add better implementation so that there's no need for array copying
data = bytes.ToArray();
}
public static SoundStats <float> LoadNVorbisData(string fileName)
{
var result = new SoundStats <float>();
var reader = new VorbisReader(fileName);
result.SampleRate = reader.SampleRate;
result.TotalSeconds = (float)reader.TotalTime.TotalSeconds;
result.Channels = reader.Channels;
var dataResult = new List <float>();
float[] buffer = new float[reader.Channels * reader.SampleRate]; // 200ms
while (reader.ReadSamples(buffer, 0, buffer.Length) > 0)
{
dataResult.AddRange(buffer);
}
switch (reader.Channels)
{
case 1:
result.Format = AudioFormat.Mono32Float;
break;
case 2:
result.Format = AudioFormat.StereoFloat32;
break;
}
result.BufferData = dataResult.ToArray();
return(result);
}
internal unsafe AudioClip(IResource resource)
{
Al.GenBuffer(out Buffer);
using var reader = new VorbisReader(resource.OpenStream());
var channels = reader.Channels;
var sampleRate = reader.SampleRate;
var seconds = reader.TotalTime.TotalSeconds;
var samples = (int)Math.Ceiling(seconds * sampleRate * channels);
var floats = new Span <float>(new float[samples]);
if (reader.ReadSamples(floats) <= 0)
{
throw new Exception("Failed to read OGG stream.");
}
var shorts = new Span <short>(new short[samples]); // 16 bit
for (var i = 0; i < floats.Length; i++)
shorts[i] = (short)(short.MaxValue * floats[i]);
fixed(void *p = &shorts.GetPinnableReference())
{
Al.BufferData(Buffer, channels == 2 ? Al.FormatStereo16 : Al.FormatMono16, p, shorts.Length * sizeof(short), sampleRate);
}
}
// This is used to load audio files that supported by NVorbis like ogg
public static AudioClip LoadOggAudioFile(string path)
{
float[] audioData = null;
int channels = 0;
int sampleRate = 0; try
{
using (VorbisReader reader = new VorbisReader(path))
{
//Note: Same here
if (reader.TotalSamples * reader.Channels > 0x7FFFFFFFL)
{
return(null);
}
float[] data = new float[reader.TotalSamples * reader.Channels];
reader.ReadSamples(data, 0, (int)(reader.TotalSamples * reader.Channels));
channels = reader.Channels;
sampleRate = reader.SampleRate;
audioData = data;
}
}
catch
{
return(null);
}
if (audioData == null)
{
return(null);
}
AudioDataHost dataHost = new AudioDataHost(audioData, channels);
AudioClip clip = AudioClip.Create(path, audioData.Length / channels, channels, sampleRate, true, dataHost.PCMReaderCallback, dataHost.PCMSetPositionCallback);
return(clip);
}
public ConvertOGG()
{
DirectoryInfo dInfo = new DirectoryInfo(@"C:\Games\Thief2\FMs\DCE_v1\snd\ogg");
FileInfo[] oggFiles = dInfo.GetFiles("*.ogg", SearchOption.TopDirectoryOnly);
for (int i = 0; i < oggFiles.Length; i++)
{
//to do - figure out how to do this.
VorbisReader vR = new VorbisReader(oggFiles[i].FullName);
long samples = vR.TotalSamples;
float[] f = new float[samples];
vR.ReadSamples(f, 0, f.Length);
byte[] sndByte = new byte[f.Length];
for (int j = 0; j < f.Length; j++)
{
float fl = f[j];
sndByte[j] = (byte)fl;
}
WaveFormat wFormat = new WaveFormat();
string wName = oggFiles[i].FullName.Replace(oggFiles[i].Extension, ".wav");
WaveFileWriter writer = new WaveFileWriter(wName, wFormat);
writer.Write(sndByte, 0, sndByte.Length);
}
}
public void OnAudioFilterRead(float[] data, int ch)
{
if (isReady)
{
int num = vorbisReader.ReadSamples(data, 0, data.Length);
if (num != data.Length && vorbisReader.DecodedPosition >= vorbisReader.TotalSamples && isLoop)
{
vorbisReader.DecodedPosition = loopPoint;
num += vorbisReader.ReadSamples(data, num, data.Length - num);
}
for (int i = 0; i < num; i++)
{
data[i] = data[i] * volume * subVolume * chvolume[i % 2];
}
}
}
static void PlayOGG(string filename)
{
var buffers = Initialize(out IntPtr device, out ContextHandle context, out int source);
var vorbis = new VorbisReader(string.Format(AudioFilesPathFormat, filename));
var stream = new MemoryStream();
var samples = new float[vorbis.Channels * vorbis.SampleRate];
var samplesRead = 0;
while ((samplesRead = vorbis.ReadSamples(samples, 0, samples.Length)) > 0)
{
var readBuffer = new byte[samplesRead * 4];
Buffer.BlockCopy(samples, 0, readBuffer, 0, readBuffer.Length);
stream.Write(readBuffer, 0, readBuffer.Length);
}
stream.Position = 0;
PlayAndDispose(stream, buffers, source, vorbis.SampleRate);
vorbis.Dispose();
vorbis = null;
Dispose(ref device, ref context);
}
private void FillBuffers(int buffers = 3, int samples = 44100)
{
float[] sampleBuffer = null;
while (mInstance.PendingBufferCount < buffers && mReader != null)
{
if (sampleBuffer == null)
{
sampleBuffer = new float[samples];
}
var read = mReader.ReadSamples(sampleBuffer, 0, sampleBuffer.Length);
if (read == 0)
{
mReader.DecodedPosition = 0;
continue;
}
var dataBuffer = new byte[read << 1];
for (var sampleIndex = 0; sampleIndex < read; ++sampleIndex)
{
var sample = (short)MathHelper.Clamp(sampleBuffer[sampleIndex] * 32767f, short.MinValue, short.MaxValue);
var sampleData = BitConverter.GetBytes(sample);
for (var sampleByteIndex = 0; sampleByteIndex < sampleData.Length; ++sampleByteIndex)
{
dataBuffer[(sampleIndex << 1) + sampleByteIndex] = sampleData[sampleByteIndex];
}
}
mInstance.SubmitBuffer(dataBuffer, 0, read << 1);
}
}
public byte[] ReadSamples(int samples)
{
var bytes = Array.Empty <byte>();
var offset = 0;
while (samples > 0)
{
var sampleCount = Math.Min(samples, _buffer.Length);
var read = _reader.ReadSamples(_buffer, 0, sampleCount);
var byteCount = read * sizeof(ushort);
if (offset + byteCount > bytes.Length)
{
Array.Resize(ref bytes, offset + byteCount);
}
for (var i = 0; i < read; i++)
{
var sample = _buffer[i];
var asPCM = (ushort)(sample * sc16);
bytes[offset] = (byte)asPCM;
bytes[offset + 1] = (byte)(asPCM >> 8);
offset += sizeof(ushort);
}
samples -= sampleCount;
}
return(bytes);
}
public override bool load()
{
float[] readSampleBuffer = new float[AudioBuffer.MAX_BUFFER_SIZE];
short[] convBuffer = new short[AudioBuffer.MAX_BUFFER_SIZE];
myState = SourceState.LOADING;
using (myReader = new VorbisReader(myFilename))
{
myNumChannels = myReader.Channels;
mySampleRate = myReader.SampleRate;
long sampleCount = myReader.TotalSamples * myNumChannels;
int numBuffers = (int)Math.Ceiling((double)sampleCount / (double)AudioBuffer.MAX_BUFFER_SIZE);
for (int i = 0; i < numBuffers; i++)
{
AudioBuffer buffer = new AudioBuffer(myNumChannels == 1 ? AudioBuffer.AudioFormat.MONO16 : AudioBuffer.AudioFormat.STEREO16, mySampleRate);
int samplesRead = myReader.ReadSamples(readSampleBuffer, 0, AudioBuffer.MAX_BUFFER_SIZE);
buffer.size = samplesRead;
castBuffer(readSampleBuffer, buffer.data, samplesRead);
//put it in the audio system
buffer.buffer();
myBuffers.Add(buffer);
}
myState = Source.SourceState.LOADED;
Debug.print("Loaded audio file: {0}", myFilename);
}
return(true);
}
protected override void FillBuffer(byte[] buffer)
{
if (floatBuf == null)
{
floatBuf = new float[buffer.Length / 2];
}
int read = reader.ReadSamples(floatBuf, 0, floatBuf.Length);
if ((loopEnd > 0 && reader.DecodedPosition >= loopEnd) || read < floatBuf.Length)
{
reader.DecodedPosition = loopStart;
reader.ReadSamples(floatBuf, read, floatBuf.Length - read);
}
Convert(floatBuf, buffer);
}
protected override void FillBuffer(byte[] buffer)
{
if (floatBuf == null)
{
floatBuf = new float[buffer.Length / 2];
}
int read = reader.ReadSamples(floatBuf, 0, floatBuf.Length);
if (read < floatBuf.Length)
{
Reset();
reader.ReadSamples(floatBuf, read, floatBuf.Length - read);
}
Convert(floatBuf, buffer);
}
public int ReadBuffer()
{
ReadSamples = _stream.ReadSamples(_stream_buffer, 0, _stream_buffer.Length);
for (var i = 0; i < ReadSamples; i++)
{
var temp = (int)(32767f * _stream_buffer[i]);
if (temp > short.MaxValue)
{
temp = short.MaxValue;
}
else if (temp < short.MinValue)
{
temp = short.MinValue;
}
Buffer[i] = (short)temp;
}
return(ReadSamples);
}
private static RecyclableBuffer LoadVorbis(
Stream stream, out ALFormat format, out int frequency, out int channels,
out int blockAlignment, out int bitsPerSample, out int samplesPerBlock, out int sampleCount)
{
RecyclableBuffer?result = null;
var reader = new VorbisReader(stream, leaveOpen: false);
try
{
bool useFloat = ALController.Get().SupportsFloat32;
int sampleSize = useFloat ? sizeof(float) : sizeof(short);
channels = reader.Channels;
if (channels == 1)
{
format = useFloat ? ALFormat.MonoFloat32 : ALFormat.Mono16;
}
else if (channels == 2)
{
format = useFloat ? ALFormat.StereoFloat32 : ALFormat.Stereo16;
}
else
{
throw new NotSupportedException("Only mono and stereo is supported.");
}
sampleCount = (int)reader.TotalSamples;
frequency = reader.SampleRate;
blockAlignment = 0;
samplesPerBlock = 0;
bitsPerSample = sampleSize * 8;
long outputBytes = sampleCount * channels * sampleSize;
if (outputBytes > int.MaxValue)
{
throw new InvalidDataException("Size of decoded audio data exceeds " + int.MaxValue + " bytes.");
}
result = RecyclableMemoryManager.Default.GetBuffer((int)outputBytes, "Vorbis audio data");
var resultSpan = result.AsSpan();
int totalSamplesRead = 0;
int samplesRead;
// Both paths allocate around 4096 stack bytes for buffers.
if (useFloat)
{
Span <float> sampleBuffer = stackalloc float[1024];
Span <byte> sampleBufferBytes = MemoryMarshal.AsBytes(sampleBuffer);
// we can copy directly to output
while ((samplesRead = reader.ReadSamples(sampleBuffer)) > 0)
{
Span <byte> bytes = sampleBufferBytes.Slice(0, samplesRead * sizeof(float));
bytes.CopyTo(resultSpan);
resultSpan = resultSpan[bytes.Length..];
public override int ReadNextChunk(float[] target, int offset, int numFrames)
{
if (_reader.DecodedPosition + numFrames > _reader.TotalSamples) //Double check eof, some ogg files seem to have padding
{
numFrames = ( int )(_reader.TotalSamples - _reader.DecodedPosition);
}
int readFrames = _reader.ReadSamples(target, offset, numFrames * Channels) / Channels; //readsamples returns samples and not frames...
return(readFrames);
}
public static AudioClip LoadVorbis(string filename)
{
using (VorbisReader reader = new VorbisReader(filename))
{
int sampleCount = (int)reader.TotalSamples * reader.Channels;
var audioData = new float[sampleCount];
reader.ReadSamples(audioData, 0, sampleCount);
return(LoadInternal(filename, audioData, reader.Channels, reader.SampleRate));
}
}
public override long GetSamples(int samples, ref byte[] data)
{
int bytes = _audioFormat.BytesPerSample * samples;
Array.Resize(ref data, bytes);
Array.Resize(ref _readBuf, samples);
_reader.ReadSamples(_readBuf, 0, samples);
CastBuffer(_readBuf, data, samples);
return(samples);
}
public override int FillStreamBuffer(int samplePos, short[] buffer)
{
if (!Stream)
{
throw new Exception("Called FillStreamBuffer on a non-streamed sound!");
}
if (samplePos >= reader.TotalSamples * reader.Channels * 2)
{
return(0);
}
samplePos /= reader.Channels * 2;
reader.DecodedPosition = samplePos;
float[] floatBuffer = new float[buffer.Length];
int readSamples = reader.ReadSamples(floatBuffer, 0, buffer.Length / 2);
//MuffleBuffer(floatBuffer, reader.Channels);
CastBuffer(floatBuffer, buffer, readSamples);
return(readSamples * 2);
}
//public bool IsLooped { get; set; }
public static OggSound Load(string oggFile, int bufferCount = DefaultBufferCount)
{
OggSound sound = new OggSound();
sound.file = oggFile;
using (VorbisReader reader = new VorbisReader(oggFile))
{
int bufferSize = (int)reader.TotalSamples * reader.Channels;
float[] buffer = new float[bufferSize];
sound.castBuffer = new short[bufferSize];
int readSamples = reader.ReadSamples(buffer, 0, bufferSize);
CastBuffer(buffer, sound.castBuffer, readSamples);
sound.alBufferId = AL.GenBuffer();
sound.format = reader.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16;
sound.sampleRate = reader.SampleRate;
ALHelper.Check();
//alSourceId = AL.GenSource();
AL.BufferData(sound.alBufferId, reader.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16, sound.castBuffer,
readSamples * sizeof(short), reader.SampleRate);
ALHelper.Check(oggFile);
}
//AL.Source(alSourceId, ALSourcei.Buffer, alBufferId);
//if (ALHelper.XRam.IsInitialized)
//{
// ALHelper.XRam.SetBufferMode(bufferCount, ref alBufferId, XRamExtension.XRamStorage.Hardware);
// ALHelper.Check();
//}
//Volume = 1;
//if (ALHelper.Efx.IsInitialized)
//{
// alFilterId = ALHelper.Efx.GenFilter();
// ALHelper.Efx.Filter(alFilterId, EfxFilteri.FilterType, (int)EfxFilterType.Lowpass);
// ALHelper.Efx.Filter(alFilterId, EfxFilterf.LowpassGain, 1);
// LowPassHFGain = 1;
//}
return(sound);
}
private static void QueueBuffer(int source, int buffer, VorbisReader vorbis, ALFormat format, int sampleRate, int targetSamples, long endSample)
{
var shortBuffer = new short[targetSamples];
try
{
var samples = Math.Min(targetSamples, (int)(endSample - vorbis.SamplePosition) * sizeof(short));
if (samples <= 0)
{
return;
}
var floatBuffer = new float[samples];
var thread = default(Thread);
var t = Task.Factory.StartNew(() =>
{
thread = Thread.CurrentThread;
return(vorbis.ReadSamples(floatBuffer, 0, samples));
});
if (!t.Wait((int)(OggBufferSize * 100)) || t.Result <= 0)
{
thread?.Abort();
return;
}
shortBuffer = new short[samples];
for (int i = 0; i < samples; i++)
{
var temp = (int)(short.MaxValue * floatBuffer[i]);
if (temp > short.MaxValue)
{
temp = short.MaxValue;
}
else if (temp < short.MinValue)
{
temp = short.MinValue;
}
shortBuffer[i] = (short)temp;
}
}
finally
{
AL.BufferData(buffer, format, shortBuffer, shortBuffer.Length * sizeof(short), sampleRate);
AL.SourceQueueBuffer(source, buffer);
}
}
public int Read(byte[] buffer, int length)
{
float[] sampleBuffer = new float[length / 2];
int count = reader.ReadSamples(sampleBuffer, 0, sampleBuffer.Length);
int targetIndex = 0;
for (int i = 0; i < count; i++)
{
short sample = FloatToShortRange(sampleBuffer[i]);
buffer[targetIndex++] = (byte)(sample & 0x00FF);
buffer[targetIndex++] = (byte)((sample >> 8) & 0x00FF);
}
return(count * 2);
}
public override AudioClip Import(Stream stream, string filePath)
{
using var r = new VorbisReader(stream, true);
long bufferSize = r.TotalSamples * r.Channels;
var data = new float[bufferSize];
r.ReadSamples(data, 0, (int)bufferSize);
var clip = new AudioClip();
clip.SetData(data, r.Channels, sizeof(float), r.SampleRate);
return(clip);
}
private async Task PlaySoundImpl(Stream stream)
{
using (var vorbis = new VorbisReader(stream, true))
{
var channels = vorbis.Channels;
var sampleRate = vorbis.SampleRate;
var samples = new float[channels * sampleRate];
var format = new WaveFormat(sampleRate, 32, 2);
var src = new SourceVoice(_device, format);
var bufferQueue = new Queue <AudioBuffer>();
src.BufferEnd += (IntPtr _) =>
{
bufferQueue.Dequeue().Stream.Dispose();
};
src.Start();
bool doneReading = false;
do
{
if (src.State.BuffersQueued < 3 && !doneReading)
{
int bytesRead = vorbis.ReadSamples(samples, 0, samples.Length);
if (bytesRead == 0)
{
doneReading = true;
continue;
}
var dataStream = new DataStream(bytesRead * sizeof(float), true, true);
dataStream.WriteRange(samples, 0, bytesRead);
dataStream.Position = 0;
var buffer = new AudioBuffer(dataStream);
buffer.Flags = BufferFlags.EndOfStream;
bufferQueue.Enqueue(buffer);
src.SubmitSourceBuffer(buffer, null);
}
await Task.Delay(100).ConfigureAwait(false);
} while (src.State.BuffersQueued > 0);
src.DestroyVoice();
src.Dispose();
}
}
public OggSound(SoundManager owner, string filename, bool stream) : base(owner, filename, stream, true)
{
if (!ToolBox.IsProperFilenameCase(filename))
{
DebugConsole.ThrowError("Sound file \"" + filename + "\" has incorrect case!");
}
reader = new VorbisReader(filename);
ALFormat = reader.Channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16;
SampleRate = reader.SampleRate;
if (!stream)
{
int bufferSize = (int)reader.TotalSamples * reader.Channels;
float[] floatBuffer = new float[bufferSize];
short[] shortBuffer = new short[bufferSize];
int readSamples = reader.ReadSamples(floatBuffer, 0, bufferSize);
CastBuffer(floatBuffer, shortBuffer, readSamples);
AL.BufferData((int)ALBuffer, ALFormat, shortBuffer,
readSamples * sizeof(short), SampleRate);
ALError alError = AL.GetError();
if (alError != ALError.NoError)
{
throw new Exception("Failed to set buffer data for non-streamed audio! " + AL.GetErrorString(alError));
}
MuffleBuffer(floatBuffer, SampleRate, reader.Channels);
CastBuffer(floatBuffer, shortBuffer, readSamples);
AL.BufferData((int)ALMuffledBuffer, ALFormat, shortBuffer,
readSamples * sizeof(short), SampleRate);
alError = AL.GetError();
if (alError != ALError.NoError)
{
throw new Exception("Failed to set buffer data for non-streamed audio! " + AL.GetErrorString(alError));
}
reader.Dispose();
}
}
public override int Read(byte[] buffer, int offset, int count)
{
if (offset != 0)
{
throw new NotImplementedException();
}
int sampleCount = count / 2;
int readSamples;
lock (floats)
{
readSamples = reader.ReadSamples(floats, 0, sampleCount);
CastBuffer(floats, buffer, readSamples);
}
return(readSamples * 2);
}
public override int Read(byte[] buffer, int offset, int count)
{
int samples = count / reader.Channels / 4;
if (floats.Length < samples)
{
floats = new float[samples * 2];
}
int read = reader.ReadSamples(floats, 0, samples) * reader.Channels;
IntPtr pointer;
using (buffer.Pin(out pointer, offset, read * 4))
Marshal.Copy(floats, 0, pointer, read);
return(read);
}
