public void RaiseBufferReady(RoutingEventArgs e)
{
if (sinks.Count == 0)
{
return;
}
for (int i = 0; i < sinks.Count; i++)
{
float[] buffer;
if (i == 0)
{
// The first (or only) receiver can just reuse the buffer
// so there is no need to clone it
buffer = e.Buffer;
}
else
{
sinkBuffers[i] = BufferHelpers.Ensure(sinkBuffers[i], e.Count);
Buffer.BlockCopy(e.Buffer, 0, sinkBuffers[i], 0, e.Count * sizeof(float));
buffer = sinkBuffers[i];
}
sinks[i].ReceiveDataFromSource(
new RoutingEventArgs
{
Buffer = buffer,
Count = e.Count,
Format = e.Format,
Index = i
});
}
}
protected override void FillBuffers(float[][] buffer, int offset, int count)
{
if (FInput != null && FInput.SliceCount != 0)
{
FTempBuffer = BufferHelpers.Ensure(FTempBuffer, count);
for (int outSlice = 0; outSlice < FOutputCount; outSlice++)
{
var outbuf = buffer[outSlice];
for (int inSlice = 0; inSlice < FInput.SliceCount; inSlice++)
{
var gain = GainMatrix[outSlice + inSlice * FOutputCount];
var inSig = FInput[inSlice];
if (inSig != null)
{
inSig.Read(FTempBuffer, offset, count);
if (inSlice == 0)
{
for (int j = 0; j < count; j++)
{
outbuf[j] = FTempBuffer[j] * gain;
}
}
else
{
for (int j = 0; j < count; j++)
{
outbuf[j] += FTempBuffer[j] * gain;
}
}
}
}
}
}
}
/// <summary>
/// Reads samples from this sample provider
/// </summary>
/// <param name="buffer">Sample buffer</param>
/// <param name="offset">Offset into sample buffer</param>
/// <param name="count">Number of samples required</param>
/// <returns>Number of samples read</returns>
public int Read(float[] buffer, int offset, int count)
{
int outputSamples = 0;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, count);
lock (sources)
{
int index = sources.Count - 1;
while (index >= 0)
{
var source = sources[index];
int samplesRead = source.Read(this.sourceBuffer, 0, count);
int outIndex = offset;
for (int n = 0; n < samplesRead; n++)
{
if (n >= outputSamples)
{
buffer[outIndex++] = this.sourceBuffer[n];
}
else
{
buffer[outIndex++] += this.sourceBuffer[n];
}
}
outputSamples = Math.Max(samplesRead, outputSamples);
if (samplesRead == 0)
{
sources.RemoveAt(index);
}
index--;
}
}
return(outputSamples);
}
public int Read(byte[] destBuffer, int offset, int numBytes)
{
int num = numBytes / 3;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, num);
int num2 = this.sourceProvider.Read(this.sourceBuffer, 0, num);
int num3 = offset;
for (int i = 0; i < num2; i++)
{
float num4 = this.sourceBuffer[i] * this.volume;
if (num4 > 1f)
{
num4 = 1f;
}
if (num4 < -1f)
{
num4 = -1f;
}
int num5 = (int)((double)num4 * 8388607.0);
destBuffer[num3++] = (byte)num5;
destBuffer[num3++] = (byte)(num5 >> 8);
destBuffer[num3++] = (byte)(num5 >> 16);
}
return(num2 * 3);
}
/// <summary>
/// Reads bytes from this wave stream, clipping if necessary
/// </summary>
/// <param name="destBuffer">The destination buffer</param>
/// <param name="offset">Offset into the destination buffer</param>
/// <param name="numBytes">Number of bytes read</param>
/// <returns>Number of bytes read.</returns>
public int Read(byte[] destBuffer, int offset, int numBytes)
{
var samplesRequired = numBytes / 3;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, samplesRequired);
var sourceSamples = sourceProvider.Read(sourceBuffer, 0, samplesRequired);
int destOffset = offset;
for (var sample = 0; sample < sourceSamples; sample++)
{
// adjust volume
var sample32 = sourceBuffer[sample] * volume;
// clip
if (sample32 > 1.0f)
{
sample32 = 1.0f;
}
if (sample32 < -1.0f)
{
sample32 = -1.0f;
}
var sample24 = (int)(sample32 * 8388607.0);
destBuffer[destOffset++] = (byte)(sample24);
destBuffer[destOffset++] = (byte)(sample24 >> 8);
destBuffer[destOffset++] = (byte)(sample24 >> 16);
}
return(sourceSamples * 3);
}
/// <summary>
/// Attempts to read from the transform
/// Some useful info here:
/// http://msdn.microsoft.com/en-gb/library/windows/desktop/aa965264%28v=vs.85%29.aspx#process_data
/// </summary>
/// <returns></returns>
private int ReadFromTransform()
{
var outputDataBuffer = new TOutputDataBuffer[1];
// we have to create our own for
using var sample = MediaFactory.CreateSample();
using var pBuffer = MediaFactory.CreateMemoryBuffer(outputBuffer.Length);
sample.AddBuffer(pBuffer);
sample.SampleTime = outputPosition; // hopefully this is not needed
outputDataBuffer[0].PSample = sample; //.NativePointer;
var needsMoreInput = transform.ProcessOutput(TransformProcessOutputFlags.None, outputDataBuffer, out TransformProcessOutputStatus status);
// **** BUG in SharpDX Transform.ProcessOutput - returns the opposite of what you expect
if (!needsMoreInput)
{
// nothing to read
return(0);
}
using var outputMediaBuffer = sample.ConvertToContiguousBuffer();
//outputDataBuffer[0].PSample.ConvertToContiguousBuffer(out outputMediaBuffer);
IntPtr pOutputBuffer = outputMediaBuffer.Lock(out int maxSize, out int outputBufferLength);
outputBuffer = BufferHelpers.Ensure(outputBuffer, outputBufferLength);
Marshal.Copy(pOutputBuffer, outputBuffer, 0, outputBufferLength);
outputBufferOffset = 0;
outputBufferCount = outputBufferLength;
outputMediaBuffer.Unlock();
outputPosition += BytesToNsPosition(outputBufferCount, WaveFormat); // hopefully not needed
return(outputBufferLength);
}
public int Read(byte[] buffer, int offset, int count)
{
int num = count * 2;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, num);
WaveBuffer waveBuffer = new WaveBuffer(this.sourceBuffer);
WaveBuffer waveBuffer2 = new WaveBuffer(buffer);
int num2 = this.sourceProvider.Read(this.sourceBuffer, 0, num);
int num3 = num2 / 2;
int num4 = offset / 2;
for (int i = 0; i < num3; i += 2)
{
short num5 = waveBuffer.ShortBuffer[i];
short num6 = waveBuffer.ShortBuffer[i + 1];
float num7 = (float)num5 * this.LeftVolume + (float)num6 * this.RightVolume;
if (num7 > 32767f)
{
num7 = 32767f;
}
if (num7 < -32768f)
{
num7 = -32768f;
}
waveBuffer2.ShortBuffer[num4++] = (short)num7;
}
return(num2 / 2);
}
/// <summary>
/// Reads bytes from this wave stream
/// </summary>
/// <param name="destBuffer">The destination buffer</param>
/// <param name="offset">Offset into the destination buffer</param>
/// <param name="numBytes">Number of bytes read</param>
/// <returns>Number of bytes read.</returns>
public int Read(byte[] destBuffer, int offset, int numBytes)
{
int samplesRequired = numBytes / 2;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, samplesRequired);
int sourceSamples = sourceProvider.Read(sourceBuffer, 0, samplesRequired);
var destWaveBuffer = new WaveBuffer(destBuffer);
int destOffset = offset / 2;
for (int sample = 0; sample < sourceSamples; sample++)
{
// adjust volume
float sample32 = sourceBuffer[sample] * volume;
// clip
if (sample32 > 1.0f)
{
sample32 = 1.0f;
}
if (sample32 < -1.0f)
{
sample32 = -1.0f;
}
destWaveBuffer.ShortBuffer[destOffset++] = (short)(sample32 * 32767);
}
return(sourceSamples * 2);
}
/// <summary>
/// Reads bytes from this wave stream
/// </summary>
/// <param name="destBuffer">The destination buffer</param>
/// <param name="offset">Offset into the destination buffer</param>
/// <param name="numBytes">Number of bytes read</param>
/// <returns>Number of bytes read.</returns>
// Token: 0x06000A8A RID: 2698 RVA: 0x0001F044 File Offset: 0x0001D244
public int Read(byte[] destBuffer, int offset, int numBytes)
{
int num = numBytes * 2;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, num);
int num2 = this.sourceProvider.Read(this.sourceBuffer, 0, num);
WaveBuffer waveBuffer = new WaveBuffer(this.sourceBuffer);
WaveBuffer waveBuffer2 = new WaveBuffer(destBuffer);
int num3 = num2 / 4;
int num4 = offset / 2;
for (int i = 0; i < num3; i++)
{
float num5 = waveBuffer.FloatBuffer[i] * this.volume;
if (num5 > 1f)
{
num5 = 1f;
}
if (num5 < -1f)
{
num5 = -1f;
}
waveBuffer2.ShortBuffer[num4++] = (short)(num5 * 32767f);
}
return(num3 * 2);
}
/// <summary>
/// Reads bytes from this WaveProvider
/// </summary>
public int Read(byte[] buffer, int offset, int count)
{
int sourceBytesRequired = count * 2;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, sourceBytesRequired);
WaveBuffer sourceWaveBuffer = new WaveBuffer(sourceBuffer);
WaveBuffer destWaveBuffer = new WaveBuffer(buffer);
int sourceBytesRead = sourceProvider.Read(sourceBuffer, 0, sourceBytesRequired);
int samplesRead = sourceBytesRead / 2;
int destOffset = offset / 2;
for (int sample = 0; sample < samplesRead; sample += 2)
{
short left = sourceWaveBuffer.ShortBuffer[sample];
short right = sourceWaveBuffer.ShortBuffer[sample + 1];
float outSample = (left * LeftVolume) + (right * RightVolume);
// hard limiting
if (outSample > Int16.MaxValue)
{
outSample = Int16.MaxValue;
}
if (outSample < Int16.MinValue)
{
outSample = Int16.MinValue;
}
destWaveBuffer.ShortBuffer[destOffset++] = (short)outSample;
}
return(sourceBytesRead / 2);
}
public void LoadNextChunk(IWaveProvider source, int samplePairsRequired)
{
int num = samplePairsRequired * 6;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, num);
this.sourceBytes = source.Read(this.sourceBuffer, 0, num);
this.offset = 0;
}
public void LoadNextChunk(IWaveProvider source, int samplePairsRequired)
{
int sourceBytesRequired = samplePairsRequired;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, sourceBytesRequired);
sourceBytes = source.Read(sourceBuffer, 0, sourceBytesRequired);
offset = 0;
}
public void LoadNextChunk(IWaveProvider source, int samplePairsRequired)
{
int num = samplePairsRequired * 2;
this.sourceSample = 0;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, num);
this.sourceWaveBuffer = new WaveBuffer(this.sourceBuffer);
this.sourceSamples = source.Read(this.sourceBuffer, 0, num) / 2;
}
public void LoadNextChunk(IWaveProvider source, int samplePairsRequired)
{
int sourceBytesRequired = samplePairsRequired * 8;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, sourceBytesRequired);
sourceWaveBuffer = new WaveBuffer(sourceBuffer);
sourceSamples = source.Read(sourceBuffer, 0, sourceBytesRequired) / 4;
sourceSample = 0;
}
/// <summary>
/// Reads bytes from this wave stream
/// </summary>
/// <param name="destBuffer">Destination buffer</param>
/// <param name="offset">Offset into destination buffer</param>
/// <param name="numBytes"></param>
/// <returns>Number of bytes read.</returns>
public override int Read(byte[] destBuffer, int offset, int numBytes)
{
lock (lockObject)
{
int count = numBytes * 2;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, count);
int bytesRead = sourceStream.Read(sourceBuffer, 0, count);
Convert32To16(destBuffer, offset, sourceBuffer, bytesRead);
position += (bytesRead / 2);
return(bytesRead / 2);
}
}
public int Read(float[] buffer, int offset, int count)
{
int num = count / 2;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, num);
int num2 = this.source.Read(this.sourceBuffer, 0, num);
int num3 = offset;
for (int i = 0; i < num2; i++)
{
buffer[num3++] = this.leftMultiplier * this.sourceBuffer[i];
buffer[num3++] = this.rightMultiplier * this.sourceBuffer[i];
}
return(num2 * 2);
}
/// <summary>
/// Reads samples from this sample provider
/// </summary>
/// <param name="buffer">Sample buffer</param>
/// <param name="offset">Offset into sample buffer</param>
/// <param name="count">Number of samples desired</param>
/// <returns>Number of samples read</returns>
public int Read(float[] buffer, int offset, int count)
{
int sourceSamplesRequired = count / 2;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, sourceSamplesRequired);
int sourceSamplesRead = source.Read(sourceBuffer, 0, sourceSamplesRequired);
int outIndex = offset;
for (int n = 0; n < sourceSamplesRead; n++)
{
buffer[outIndex++] = leftMultiplier * sourceBuffer[n];
buffer[outIndex++] = rightMultiplier * sourceBuffer[n];
}
return(sourceSamplesRead * 2);
}
/// <summary>
/// Reads data from this WaveProvider
/// </summary>
/// <param name="buffer">Buffer to be filled with sample data</param>
/// <param name="offset">Offset to write to within buffer, usually 0</param>
/// <param name="count">Number of bytes required</param>
/// <returns>Number of bytes read</returns>
public int Read(byte[] buffer, int offset, int count)
{
int outputBytesPerFrame = bytesPerSample * outputChannelCount;
int sampleFramesRequested = count / outputBytesPerFrame;
int inputOffset = 0;
int sampleFramesRead = 0;
// now we must read from all inputs, even if we don't need their data, so they stay in sync
foreach (var input in inputs)
{
int inputBytesPerFrame = bytesPerSample * input.WaveFormat.Channels;
int bytesRequired = sampleFramesRequested * inputBytesPerFrame;
this.inputBuffer = BufferHelpers.Ensure(this.inputBuffer, bytesRequired);
int bytesRead = input.Read(inputBuffer, 0, bytesRequired);
sampleFramesRead = Math.Max(sampleFramesRead, bytesRead / inputBytesPerFrame);
for (int n = 0; n < input.WaveFormat.Channels; n++)
{
int inputIndex = inputOffset + n;
for (int outputIndex = 0; outputIndex < outputChannelCount; outputIndex++)
{
if (mappings[outputIndex] == inputIndex)
{
int inputBufferOffset = n * bytesPerSample;
int outputBufferOffset = offset + outputIndex * bytesPerSample;
int sample = 0;
while (sample < sampleFramesRequested && inputBufferOffset < bytesRead)
{
Array.Copy(inputBuffer, inputBufferOffset, buffer, outputBufferOffset, bytesPerSample);
outputBufferOffset += outputBytesPerFrame;
inputBufferOffset += inputBytesPerFrame;
sample++;
}
// clear the end
while (sample < sampleFramesRequested)
{
Array.Clear(buffer, outputBufferOffset, bytesPerSample);
outputBufferOffset += outputBytesPerFrame;
sample++;
}
}
}
}
inputOffset += input.WaveFormat.Channels;
}
return(sampleFramesRead * outputBytesPerFrame);
}
public int Read(float[] buffer, int offset, int count)
{
int sample = 0;
int sourceSamplesRead = 0;
lock (lockObject)
{
sourceSampleFromBuffer = BufferHelpers.Ensure(sourceSampleFromBuffer, count);
sourceSampleToBuffer = BufferHelpers.Ensure(sourceSampleToBuffer, count);
if (SourceSampleFrom == null)
{
Array.Fill(sourceSampleFromBuffer, 0, 0, count);
sourceSamplesRead = count;
}
else
{
sourceSamplesRead = SourceSampleFrom.Read(sourceSampleFromBuffer, 0, count);
}
if (SourceSampleTo == null)
{
Array.Fill(sourceSampleToBuffer, 0, 0, count);
}
else
{
SourceSampleTo.Read(sourceSampleToBuffer, 0, count);
}
while (sample < sourceSamplesRead)
{
for (int ch = 0; ch < WaveFormat.Channels; ch++)
{
fadeInFactor = (float)fadeSamplePosition / fadeSampleEndPosition;
var fadeOutFactor = oldFadeInFactor - fadeInFactor;
fadeOutFactor = fadeOutFactor < 0 ? 0 : fadeOutFactor;
buffer[offset + sample] =
(fadeOutFactor * sourceSampleFromBuffer[sample]) +
(fadeInFactor * sourceSampleToBuffer[sample]);
sample++;
}
if (fadeSamplePosition <= fadeSampleEndPosition)
{
fadeSamplePosition++;
}
}
}
return(sourceSamplesRead);
}
public int Read(float[] buffer, int offset, int count)
{
int num = 0;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, count);
List <ISampleProvider> obj = this.sources;
lock (obj)
{
for (int i = this.sources.Count - 1; i >= 0; i--)
{
ISampleProvider sampleProvider = this.sources[i];
int num2 = sampleProvider.Read(this.sourceBuffer, 0, count);
int num3 = offset;
for (int j = 0; j < num2; j++)
{
if (j >= num)
{
buffer[num3++] = this.sourceBuffer[j];
}
else
{
buffer[num3++] += this.sourceBuffer[j];
}
}
num = Math.Max(num2, num);
if (num2 < count)
{
EventHandler <SampleProviderEventArgs> expr_AC = this.MixerInputEnded;
if (expr_AC != null)
{
expr_AC(this, new SampleProviderEventArgs(sampleProvider));
}
this.sources.RemoveAt(i);
}
}
}
if (this.ReadFully && num < count)
{
int k = offset + num;
while (k < offset + count)
{
buffer[k++] = 0f;
}
num = count;
}
return(num);
}
/// <summary>
/// Reads samples from this sample provider
/// </summary>
/// <param name="buffer">Sample buffer</param>
/// <param name="offset">Offset into sample buffer</param>
/// <param name="count">Number of samples required</param>
/// <returns>Number of samples read</returns>
public int Read(float[] buffer, int offset, int count)
{
int outputSamples = 0;
float channelGain = 1.0f;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, count);
lock (sources)
{
int index = sources.Count - 1;
while (index >= 0)
{
var source = sources[index];
int samplesRead = source.sampleProvider.Read(this.sourceBuffer, 0, count);
int outIndex = offset;
channelGain = gain[source.index % gainCount];
for (int n = 0; n < samplesRead; n++)
{
if (n >= outputSamples)
{
buffer[outIndex++] = this.sourceBuffer[n] * channelGain;
}
else
{
buffer[outIndex++] += this.sourceBuffer[n] * channelGain;
}
}
outputSamples = Math.Max(samplesRead, outputSamples);
if (samplesRead == 0)
{
sources.RemoveAt(index);
//we want to loop
}
index--;
}
}
// optionally ensure we return a full buffer
if (ReadFully && outputSamples < count)
{
int outputIndex = offset + outputSamples;
while (outputIndex < offset + count)
{
buffer[outputIndex++] = 0;
}
outputSamples = count;
}
return(outputSamples);
}
public override int Read(byte[] destBuffer, int offset, int numBytes)
{
object obj = this.lockObject;
int result;
lock (obj)
{
int num = numBytes * 2;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, num);
int num2 = this.sourceStream.Read(this.sourceBuffer, 0, num);
this.Convert32To16(destBuffer, offset, this.sourceBuffer, num2);
this.position += (long)(num2 / 2);
result = num2 / 2;
}
return(result);
}
public int Read(float[] buffer, int offset, int count)
{
var sourceBytesRequired = count * sourceChannels;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, sourceBytesRequired);
var samplesRead = sourceProvider.Read(sourceBuffer, 0, sourceBytesRequired);
var sampleFramesRead = samplesRead / sourceChannels;
for (var sampleIndex = 0; sampleIndex < samplesRead; sampleIndex += sourceChannels)
{
buffer[offset++] = Clamp(AverageOfSampleFrame(sampleIndex));
}
return(sampleFramesRead);
}
/// <summary>
/// Converts the 16-bit ACM stream to 8-bit MuLaw on read.
/// </summary>
/// <param name="destinationBuffer">The destination buffer to output into.</param>
/// <param name="offset">The offset to store at.</param>
/// <param name="readingCount">The requested size to read.</param>
/// <returns></returns>
public int Read(byte[] destinationBuffer, int offset, int readingCount)
{
// Source buffer has twice as many items as the output array.
var sizeOfPcmBuffer = readingCount * 2;
sourceBuffer = BufferHelpers.Ensure(sourceBuffer, sizeOfPcmBuffer);
var sourceBytesRead = ieeeToPcm.Read(sourceBuffer, 0, sizeOfPcmBuffer);
var samplesRead = sourceBytesRead / 2;
var outIndex = 0;
for (var n = 0; n < sizeOfPcmBuffer; n += 2)
{
destinationBuffer[outIndex++] = MuLawEncoder.LinearToMuLawSample(BitConverter.ToInt16(sourceBuffer, offset + n));
}
return(samplesRead);
}
public int Read(byte[] buffer, int offset, int count)
{
int num = this.bytesPerSample * this.outputChannelCount;
int num2 = count / num;
int num3 = 0;
int num4 = 0;
foreach (IWaveProvider waveProvider in this.inputs)
{
int num5 = this.bytesPerSample * waveProvider.WaveFormat.Channels;
int num6 = num2 * num5;
this.inputBuffer = BufferHelpers.Ensure(this.inputBuffer, num6);
int num7 = waveProvider.Read(this.inputBuffer, 0, num6);
num4 = Math.Max(num4, num7 / num5);
for (int i = 0; i < waveProvider.WaveFormat.Channels; i++)
{
int num8 = num3 + i;
for (int j = 0; j < this.outputChannelCount; j++)
{
if (this.mappings[j] == num8)
{
int num9 = i * this.bytesPerSample;
int num10 = offset + j * this.bytesPerSample;
int k;
for (k = 0; k < num2; k++)
{
if (num9 >= num7)
{
break;
}
Array.Copy(this.inputBuffer, num9, buffer, num10, this.bytesPerSample);
num10 += num;
num9 += num5;
}
while (k < num2)
{
Array.Clear(buffer, num10, this.bytesPerSample);
num10 += num;
k++;
}
}
}
}
num3 += waveProvider.WaveFormat.Channels;
}
return(num4 * num);
}
/// <summary>
/// Attempts to read from the transform
/// Some useful info here:
/// http://msdn.microsoft.com/en-gb/library/windows/desktop/aa965264%28v=vs.85%29.aspx#process_data
/// </summary>
/// <returns></returns>
private int ReadFromTransform()
{
var outputDataBuffer = new MFT_OUTPUT_DATA_BUFFER[1];
// we have to create our own for
var sample = MediaFoundationApi.CreateSample();
var pBuffer = MediaFoundationApi.CreateMemoryBuffer(outputBuffer.Length);
sample.AddBuffer(pBuffer);
sample.SetSampleTime(outputPosition); // hopefully this is not needed
outputDataBuffer[0].pSample = sample;
_MFT_PROCESS_OUTPUT_STATUS status;
var hr = transform.ProcessOutput(_MFT_PROCESS_OUTPUT_FLAGS.None,
1, outputDataBuffer, out status);
if (hr == MediaFoundationErrors.MF_E_TRANSFORM_NEED_MORE_INPUT)
{
Marshal.ReleaseComObject(pBuffer);
Marshal.ReleaseComObject(sample);
// nothing to read
return(0);
}
else if (hr != 0)
{
Marshal.ThrowExceptionForHR(hr);
}
IMFMediaBuffer outputMediaBuffer;
outputDataBuffer[0].pSample.ConvertToContiguousBuffer(out outputMediaBuffer);
IntPtr pOutputBuffer;
int outputBufferLength;
int maxSize;
outputMediaBuffer.Lock(out pOutputBuffer, out maxSize, out outputBufferLength);
outputBuffer = BufferHelpers.Ensure(outputBuffer, outputBufferLength);
Marshal.Copy(pOutputBuffer, outputBuffer, 0, outputBufferLength);
outputBufferOffset = 0;
outputBufferCount = outputBufferLength;
outputMediaBuffer.Unlock();
outputPosition += BytesToNsPosition(outputBufferCount, WaveFormat); // hopefully not needed
Marshal.ReleaseComObject(pBuffer);
sample.RemoveAllBuffers(); // needed to fix memory leak in some cases
Marshal.ReleaseComObject(sample);
Marshal.ReleaseComObject(outputMediaBuffer);
return(outputBufferLength);
}
/// <summary>
/// Reads samples from this sample provider
/// </summary>
/// <param name="buffer">Buffer to be filled with sample data</param>
/// <param name="offset">Offset into buffer to start writing to, usually 0</param>
/// <param name="count">Number of samples required</param>
/// <returns>Number of samples read</returns>
public int Read(float[] buffer, int offset, int count)
{
int sampleFramesRequested = count / outputChannelCount;
int inputOffset = 0;
int sampleFramesRead = 0;
// now we must read from all inputs, even if we don't need their data, so they stay in sync
foreach (var input in inputs)
{
int samplesRequired = sampleFramesRequested * input.WaveFormat.Channels;
this.inputBuffer = BufferHelpers.Ensure(this.inputBuffer, samplesRequired);
int samplesRead = input.Read(inputBuffer, 0, samplesRequired);
sampleFramesRead = Math.Max(sampleFramesRead, samplesRead / input.WaveFormat.Channels);
for (int n = 0; n < input.WaveFormat.Channels; n++)
{
int inputIndex = inputOffset + n;
for (int outputIndex = 0; outputIndex < outputChannelCount; outputIndex++)
{
if (mappings[outputIndex] == inputIndex)
{
int inputBufferOffset = n;
int outputBufferOffset = offset + outputIndex;
int sample = 0;
while (sample < sampleFramesRequested && inputBufferOffset < samplesRead)
{
buffer[outputBufferOffset] = inputBuffer[inputBufferOffset];
outputBufferOffset += outputChannelCount;
inputBufferOffset += input.WaveFormat.Channels;
sample++;
}
// clear the end
while (sample < sampleFramesRequested)
{
buffer[outputBufferOffset] = 0;
outputBufferOffset += outputChannelCount;
sample++;
}
}
}
}
inputOffset += input.WaveFormat.Channels;
}
return(sampleFramesRead * outputChannelCount);
}
private void processMatrix(ChannelData channel, float[] buffer, int count)
{
var c = coefficients.Length;
var src = 1 - c;
var dst = 0;
var offset = c - 1;
matrix = BufferHelpers.Ensure(matrix, count * c);
history = BufferHelpers.Ensure(history, c);
channel.InputHistory = BufferHelpers.Ensure(channel.InputHistory, c);
Buffer.BlockCopy(channel.InputHistory, 0, history, 0, sizeof(float) * c);
for (int i = 0; i < count; i++)
{
Buffer.BlockCopy(
buffer,
sizeof(float) * (src + offset),
matrix,
sizeof(float) * (dst + offset),
sizeof(float) * (c - offset));
if (offset > 0)
{
Buffer.BlockCopy(
history,
sizeof(float) * (c - offset),
matrix,
sizeof(float) * dst,
sizeof(float) * offset);
offset -= 1;
}
src += 1;
dst += c;
}
Buffer.BlockCopy(buffer, sizeof(float) * (count - c), channel.InputHistory, 0, sizeof(float) * c);
var X = new DenseMatrix(coefficients.Length, count, matrix);
var B = new DenseMatrix(1, count, buffer);
C.Multiply(X, B);
}
public int Read(float[] buffer, int offset, int count)
{
FReadBuffer = BufferHelpers.Ensure(FReadBuffer, count);
if (FNeedsRead)
{
this.FillBuffer(FReadBuffer, offset, count);
FNeedsRead = false;
}
for (int i = 0; i < count; i++)
{
buffer[offset + i] = FReadBuffer[i];
}
return(count);
}
public int Read(byte[] destBuffer, int offset, int numBytes)
{
int num = numBytes / 2;
this.sourceBuffer = BufferHelpers.Ensure(this.sourceBuffer, num);
int arg_3D_0 = this.sourceProvider.Read(this.sourceBuffer, offset, num);
WaveBuffer waveBuffer = new WaveBuffer(this.sourceBuffer);
WaveBuffer waveBuffer2 = new WaveBuffer(destBuffer);
int num2 = arg_3D_0 / 2;
int num3 = offset / 4;
for (int i = 0; i < num2; i++)
{
waveBuffer2.FloatBuffer[num3++] = (float)waveBuffer.ShortBuffer[i] / 32768f * this.volume;
}
return(num2 * 4);
}
