public void CanDownsampleAnMp3File()
{
string testFile = @"D:\Audio\Music\Coldplay\Mylo Xyloto\03 - Paradise.mp3";
if (!File.Exists(testFile)) Assert.Ignore(testFile);
string outFile = @"d:\test22.wav";
using (var reader = new AudioFileReader(testFile))
{
// downsample to 22kHz
var resampler = new WdlResamplingSampleProvider(reader, 22050);
var wp = new SampleToWaveProvider(resampler);
using (var writer = new WaveFileWriter(outFile, wp.WaveFormat))
{
byte[] b = new byte[wp.WaveFormat.AverageBytesPerSecond];
while (true)
{
int read = wp.Read(b, 0, b.Length);
if (read > 0)
writer.Write(b, 0, read);
else
break;
}
}
//WaveFileWriter.CreateWaveFile(outFile, );
}
}
public void CanResampleUpAndDown(int from, int to)
{
var channels = 1;
var offset = CreateSignalGenerator(@from, channels);
var resampler = new WdlResamplingSampleProvider(offset, to);
//string fileName = "From {0}"
//WaveFileWriter.CreateWaveFile16(;
var buffer = new float[to * channels];
Console.WriteLine("From {0} to {1}", from, to);
for (int n = 0; n < 10; n++)
{
var read = resampler.Read(buffer, 0, buffer.Length);
Console.WriteLine("read {0}", read);
}
}
public void ConvertMp3ToWav(FileInfo inputFile)
{
var samplesOutWav = @"..\..\..\samples\wav\";
using (var mp3 = new Mp3FileReader(inputFile.FullName))
{
using (var reader = new AudioFileReader(inputFile.FullName))
{
var filename = Path.Combine(samplesOutWav, inputFile.Name.Replace(inputFile.Extension, string.Empty) + ".wav");
var outRate = 16000;
{
var resampler = new WdlResamplingSampleProvider(reader, outRate);
WaveFileWriter.CreateWaveFile16(filename, resampler);
}
}
}
}
public static byte[] ConvertAiffToMp3(byte[] aiffFile, string directory)
{
byte[] mp3bytes = null;
var newFormat = new WaveFormat(bitRate, bitDepth, channels);
try
{
uniqueTempFileCounter += 1;
var tempFile = Path.Combine(directory, "tempdata"+ uniqueTempFileCounter +".wav");
using (var ms = new MemoryStream(aiffFile))
using (var rdr = new AiffFileReader(ms))
{
if (rdr.WaveFormat.BitsPerSample == 24) //can't go from 24 bits aif to mp3 directly, create temporary 16 bit wav
{
ISampleProvider sampleprovider = new Pcm24BitToSampleProvider(rdr); //24 bit to sample
var resampler = new WdlResamplingSampleProvider(sampleprovider, sampleRate); //sample to new sample rate
WaveFileWriter.CreateWaveFile16(tempFile, resampler); //sample to actual wave file
mp3bytes = ConvertWavToMp3(tempFile, true); //file to mp3 bytes
}
else
{
using (var retMs = new MemoryStream())
using (var wtr = new LameMP3FileWriter(retMs, rdr.WaveFormat, bitRate))
{
rdr.CopyTo(wtr);
mp3bytes = retMs.ToArray();
}
}
}
}
catch (Exception e)
{
Debug.WriteLine(e);
}
return mp3bytes;
}
private async void PlayThread()
{
await Activate();
var playbackProvider = Init();
bool isClientRunning = false;
try
{
if (this.resamplerNeeded)
{
var resampler = new WdlResamplingSampleProvider(playbackProvider.ToSampleProvider(), outputFormat.SampleRate);
playbackProvider = new SampleToWaveProvider(resampler);
}
// fill a whole buffer
bufferFrameCount = audioClient.BufferSize;
bytesPerFrame = outputFormat.Channels*outputFormat.BitsPerSample/8;
readBuffer = new byte[bufferFrameCount*bytesPerFrame];
FillBuffer(playbackProvider, bufferFrameCount);
int timeout = 3 * latencyMilliseconds;
while (playbackState != WasapiOutState.Disposed)
{
if (playbackState != WasapiOutState.Playing)
{
playThreadEvent.WaitOne(500);
}
// If still playing and notification is ok
if (playbackState == WasapiOutState.Playing)
{
if (!isClientRunning)
{
audioClient.Start();
isClientRunning = true;
}
// If using Event Sync, Wait for notification from AudioClient or Sleep half latency
var r = NativeMethods.WaitForSingleObjectEx(frameEventWaitHandle, timeout, true);
if (r != 0) throw new InvalidOperationException("Timed out waiting for event");
// See how much buffer space is available.
int numFramesPadding = 0;
// In exclusive mode, always ask the max = bufferFrameCount = audioClient.BufferSize
numFramesPadding = (shareMode == AudioClientShareMode.Shared) ? audioClient.CurrentPadding : 0;
int numFramesAvailable = bufferFrameCount - numFramesPadding;
if (numFramesAvailable > 0)
{
FillBuffer(playbackProvider, numFramesAvailable);
}
}
if (playbackState == WasapiOutState.Stopping)
{
// play the buffer out
while (audioClient.CurrentPadding > 0)
{
await Task.Delay(latencyMilliseconds / 2);
}
audioClient.Stop();
isClientRunning = false;
audioClient.Reset();
playbackState = WasapiOutState.Stopped;
RaisePlaybackStopped(null);
}
if (playbackState == WasapiOutState.Disposing)
{
audioClient.Stop();
isClientRunning = false;
audioClient.Reset();
playbackState = WasapiOutState.Disposed;
var disposablePlaybackProvider = playbackProvider as IDisposable;
if (disposablePlaybackProvider!=null)
disposablePlaybackProvider.Dispose(); // do everything on this thread, even dispose in case it is Media Foundation
RaisePlaybackStopped(null);
}
}
}
catch (Exception e)
{
RaisePlaybackStopped(e);
}
finally
{
audioClient.Dispose();
audioClient = null;
renderClient = null;
NativeMethods.CloseHandle(frameEventWaitHandle);
}
}
