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