public void AudioOutputMethod(Signal input)
{
if (audioFileWriter != null && waveEncoder != null)
{
waveEncoder.Encode(input);
}
}
private void source_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
// Read current frame...
Signal s = eventArgs.Signal;
// encode frame to file
_audioSaver.Encode(s);
}
public static void SalvarSinal(Signal signal)
{
File.Delete(@"C:\a\teste.wav");
using (var fs = new FileStream(@"C:\a\teste.wav", FileMode.CreateNew))
{
var audioEncoder = new WaveEncoder(fs);
audioEncoder.Encode(signal);
}
}
/// <summary>
/// This method will be called whenever there is a new input audio frame
/// to be processed. This would be the case for samples arriving at the
/// computer's microphone
/// </summary>
///
private void source_NewFrame(object sender, NewFrameEventArgs eventArgs)
{
// Save current frame
eventArgs.Signal.CopyTo(current);
// Update waveform
updateWaveform(current, eventArgs.Signal.Length);
// Save to memory
encoder.Encode(eventArgs.Signal);
// Update counters
duration += eventArgs.Signal.Duration;
samples += eventArgs.Signal.Samples;
frames += eventArgs.Signal.Length;
}
public void AudioOutputMethod(Signal input)
{
if (audioOutputDeviceOwnerHandle == null)
{
return;
}
if (audioOutputDevice == null)
{
InitAudioOutputDevice(input);
}
encoder.Encode(input);
float[] samples = new float[input.Samples];
input.CopyTo(samples);
audioOutputDevice.Play();
}
private void AudioSource_NewFrame(object sender, Accord.Audio.NewFrameEventArgs e)
{
if (isRecording)
{
System.TimeSpan diff1 = DateTime.Now.Subtract(sartRecordingTime);
if (diff1.Seconds >= 0.0)
{
//writer.WriteAudioFrame(e.Signal.RawData);
e.Signal.CopyTo(current);
encoder.Encode(e.Signal);
duration += e.Signal.Duration;
samples += e.Signal.Samples;
frames += e.Signal.Length;
}
}
}
private void adjustVolume(float value)
{
// First, we rewind the stream
stream.Seek(0, SeekOrigin.Begin);
// Then we create a decoder for it
decoder = new WaveDecoder(stream);
var signal = decoder.Decode();
// We apply the volume filter
var volume = new VolumeFilter(value);
volume.ApplyInPlace(signal);
// Then we store it again
stream.Seek(0, SeekOrigin.Begin);
encoder = new WaveEncoder(stream);
encoder.Encode(signal);
}
public void WaveEncoderConstructorTest()
{
// Load a file in PCM 16bpp format
// Number of samples: 352.800
// Number of frames: 176.400
// Sample rate: 44.100 Hz
// Block align: 4
// Channels: 2
// Duration: 4.0 s
// Bytes: 705.644
// Bitrate: 1411kbps
// sizeof(float) = 4
// sizeof(int) = 4
// sizeof(short) = 2
UnmanagedMemoryStream sourceStream = Properties.Resources.Grand_Piano___Fazioli___major_A_middle;
MemoryStream destinationStream = new MemoryStream();
// Create a decoder for the source stream
WaveDecoder sourceDecoder = new WaveDecoder(sourceStream);
Assert.AreEqual(2, sourceDecoder.Channels);
Assert.AreEqual(352800, sourceDecoder.Samples);
Assert.AreEqual(176400, sourceDecoder.Frames);
Assert.AreEqual(4000, sourceDecoder.Duration);
Assert.AreEqual(44100, sourceDecoder.SampleRate);
Assert.AreEqual(16, sourceDecoder.BitsPerSample);
Assert.AreEqual(1411200, sourceDecoder.AverageBitsPerSecond);
// Decode the signal in the source stream
Signal sourceSignal = sourceDecoder.Decode();
Assert.AreEqual(352800, sourceSignal.Samples);
Assert.AreEqual(176400, sourceSignal.Length);
Assert.AreEqual(4000, sourceSignal.Duration);
Assert.AreEqual(2, sourceSignal.Channels);
Assert.AreEqual(44100, sourceSignal.SampleRate);
Assert.AreEqual(sizeof(float) * 352800, sourceSignal.RawData.Length);
Assert.AreEqual(sizeof(short) * 352800, sourceDecoder.Bytes);
// Create a encoder for the destination stream
WaveEncoder encoder = new WaveEncoder(destinationStream);
// Encode the signal to the destination stream
encoder.Encode(sourceSignal);
Assert.AreEqual(2, encoder.Channels);
Assert.AreEqual(352800, encoder.Samples);
Assert.AreEqual(176400, encoder.Frames);
Assert.AreEqual(4000, encoder.Duration);
Assert.AreEqual(44100, encoder.SampleRate);
Assert.AreEqual(32, encoder.BitsPerSample);
Assert.AreEqual(sizeof(float) * 352800, encoder.Bytes);
// Rewind both streams, them attempt to read the destination
sourceStream.Seek(0, SeekOrigin.Begin);
destinationStream.Seek(0, SeekOrigin.Begin);
// Create a decoder to read the destination stream
WaveDecoder destDecoder = new WaveDecoder(destinationStream);
Assert.AreEqual(2, destDecoder.Channels);
Assert.AreEqual(176400, destDecoder.Frames);
Assert.AreEqual(352800, destDecoder.Samples);
Assert.AreEqual(4000, destDecoder.Duration);
Assert.AreEqual(44100, destDecoder.SampleRate);
Assert.AreEqual(32, destDecoder.BitsPerSample);
Assert.AreEqual(1411200, sourceDecoder.AverageBitsPerSecond);
// Decode the destination stream
Signal destSignal = destDecoder.Decode();
// Assert that the signal which has been saved to the destination
// stream and the signal which has just been read from this same
// stream are identical
Assert.AreEqual(sourceSignal.Length, destSignal.Length);
Assert.AreEqual(sourceSignal.SampleFormat, destSignal.SampleFormat);
Assert.AreEqual(sourceSignal.SampleRate, destSignal.SampleRate);
Assert.AreEqual(sourceSignal.Samples, destSignal.Samples);
Assert.AreEqual(sourceSignal.Duration, destSignal.Duration);
for (int i = 0; i < sourceSignal.RawData.Length; i++)
{
byte actual = sourceSignal.RawData[i];
byte expected = destSignal.RawData[i];
Assert.AreEqual(expected, actual);
}
}
private void NewAudioFrame(object sender, Accord.Audio.NewFrameEventArgs eventArgs)
{
_waveEncoder.Encode(eventArgs.Signal);
}
public void WaveEncoderConstructorTest()
{
string basePath = Path.Combine(TestContext.CurrentContext.TestDirectory, "Resources");
#region doc_properties
// Let's say we would like to decode a wave file:
string fileName = Path.Combine(basePath, "a.wav");
// File is in PCM 16bpp format:
// Number of samples: 352.800
// Number of frames: 176.400
// Sample rate: 44.100 Hz
// Block align: 4
// Channels: 2
// Duration: 4.0 s
// Bytes: 705.644
// Bitrate: 1411kbps
// First, create a decoder for the file stream:
var sourceDecoder = new WaveDecoder(fileName);
// Now we can use it to check some of the the stream properties:
int numberOfChannels = sourceDecoder.NumberOfChannels; // 2
int numberOfSamples = sourceDecoder.NumberOfSamples; // 352800
int numberOfFrames = sourceDecoder.NumberOfFrames; // 176400
int durationMilliseconds = sourceDecoder.Duration; // 4000
int sampleRate = sourceDecoder.SampleRate; // 44100
int bitsPerSample = sourceDecoder.BitsPerSample; // 16
int bps = sourceDecoder.AverageBitsPerSecond; // 141200
// Decode the signal in the source stream:
Signal sourceSignal = sourceDecoder.Decode();
// As we can see, all properties are kept in the signal:
int signalChannels = sourceSignal.NumberOfChannels; // 2
int signalSamples = sourceSignal.NumberOfSamples; // 352800
int signalFrames = sourceSignal.NumberOfFrames; // 176400
TimeSpan signalDuration = sourceSignal.Duration; // {00:00:04}
int signalLength = sourceSignal.Length; // 176400
int signalSampleRate = sourceSignal.SampleRate; // 44100
int signalBytes = sourceSignal.NumberOfBytes; // 1411200
// And this is the total number of bytes that have been read:
int numberOfBytes = sourceDecoder.NumberOfBytesRead; // 705600
#endregion
Assert.AreEqual(2, numberOfChannels);
Assert.AreEqual(352800, numberOfSamples);
Assert.AreEqual(176400, numberOfFrames);
Assert.AreEqual(4000, durationMilliseconds);
Assert.AreEqual(44100, sampleRate);
Assert.AreEqual(16, bitsPerSample);
Assert.AreEqual(1411200, bps);
Assert.AreEqual(sizeof(short) * 352800, numberOfBytes);
Assert.AreEqual(352800, signalSamples);
Assert.AreEqual(176400, signalLength);
Assert.AreEqual(4000, signalDuration.TotalMilliseconds);
Assert.AreEqual(2, signalChannels);
Assert.AreEqual(44100, signalSampleRate);
Assert.AreEqual(sizeof(float) * 352800, signalBytes);
MemoryStream destinationStream = new MemoryStream();
// Create a encoder for the destination stream
WaveEncoder encoder = new WaveEncoder(destinationStream);
// Encode the signal to the destination stream
encoder.Encode(sourceSignal);
Assert.AreEqual(2, encoder.Channels);
Assert.AreEqual(352800, encoder.Samples);
Assert.AreEqual(176400, encoder.Frames);
Assert.AreEqual(4000, encoder.Duration);
Assert.AreEqual(44100, encoder.SampleRate);
Assert.AreEqual(32, encoder.BitsPerSample);
Assert.AreEqual(sizeof(float) * 352800, encoder.Bytes);
// Rewind both streams, them attempt to read the destination
destinationStream.Seek(0, SeekOrigin.Begin);
// Create a decoder to read the destination stream
WaveDecoder destDecoder = new WaveDecoder(destinationStream);
Assert.AreEqual(2, destDecoder.Channels);
Assert.AreEqual(176400, destDecoder.Frames);
Assert.AreEqual(352800, destDecoder.Samples);
Assert.AreEqual(4000, destDecoder.Duration);
Assert.AreEqual(44100, destDecoder.SampleRate);
Assert.AreEqual(32, destDecoder.BitsPerSample);
Assert.AreEqual(1411200, sourceDecoder.AverageBitsPerSecond);
// Decode the destination stream
Signal destSignal = destDecoder.Decode();
// Assert that the signal which has been saved to the destination
// stream and the signal which has just been read from this same
// stream are identical
Assert.AreEqual(sourceSignal.Length, destSignal.Length);
Assert.AreEqual(sourceSignal.SampleFormat, destSignal.SampleFormat);
Assert.AreEqual(sourceSignal.SampleRate, destSignal.SampleRate);
Assert.AreEqual(sourceSignal.Samples, destSignal.Samples);
Assert.AreEqual(sourceSignal.Duration, destSignal.Duration);
byte[] actual = sourceSignal.ToByte();
byte[] expected = destSignal.ToByte();
Assert.AreEqual(expected, actual);
}
private void Audio_NewFrame(object sender, Accord.Audio.NewFrameEventArgs e)
{
audioEncoder.Encode(e.Signal);
}
