public void SetWaveData(byte[] data)
{
if (data == null || data.Length == 0)
{
lock (lockObj) {
this.data = new float[0];
}
return;
}
var samples = new List <float>();
using (var stream = new MemoryStream(data)) {
using (var waveFileReader = new WaveFileReader(stream)) {
if (waveFileReader.WaveFormat.SampleRate != 44100)
{
throw new Exception($"SampleRate {waveFileReader.WaveFormat.SampleRate}");
}
ISampleProvider sampleProvider = null;
switch (waveFileReader.WaveFormat.BitsPerSample)
{
case 8:
sampleProvider = new Pcm8BitToSampleProvider(waveFileReader);
break;
case 16:
sampleProvider = new Pcm16BitToSampleProvider(waveFileReader);
break;
case 24:
sampleProvider = new Pcm24BitToSampleProvider(waveFileReader);
break;
case 32:
sampleProvider = new Pcm32BitToSampleProvider(waveFileReader);
break;
default:
throw new Exception($"Unexpected bits per sample {waveFileReader.WaveFormat.BitsPerSample}");
}
if (waveFileReader.WaveFormat.Channels == 2)
{
sampleProvider = sampleProvider.ToMono(1, 0);
}
else if (waveFileReader.WaveFormat.Channels != 1)
{
throw new Exception($"Unexpected channel count {waveFileReader.WaveFormat.Channels}");
}
var buffer = new float[sampleProvider.WaveFormat.SampleRate];
int n;
while ((n = sampleProvider.Read(buffer, 0, buffer.Length)) > 0)
{
samples.AddRange(buffer.Take(n));
}
}
}
lock (lockObj) {
this.data = samples.ToArray();
ApplyEnvelope(this.data, envelope);
}
}
public ClientAudioProvider()
{
_filters = new OnlineFilter[2];
_filters[0] =
OnlineFilter.CreateBandpass(ImpulseResponse.Finite, AudioManager.INPUT_SAMPLE_RATE, 560, 3900);
_filters[1] =
OnlineFilter.CreateBandpass(ImpulseResponse.Finite, AudioManager.INPUT_SAMPLE_RATE, 100, 4500);
JitterBufferProviderInterface =
new JitterBufferProviderInterface(new WaveFormat(AudioManager.INPUT_SAMPLE_RATE, 2));
SampleProvider = new Pcm16BitToSampleProvider(JitterBufferProviderInterface);
_decoder = OpusDecoder.Create(AudioManager.INPUT_SAMPLE_RATE, 1);
_decoder.ForwardErrorCorrection = false;
_highPassFilter = BiQuadFilter.HighPassFilter(AudioManager.INPUT_SAMPLE_RATE, 520, 0.97f);
_lowPassFilter = BiQuadFilter.LowPassFilter(AudioManager.INPUT_SAMPLE_RATE, 4130, 2.0f);
var effect = new CachedAudioEffect(CachedAudioEffect.AudioEffectTypes.NATO_TONE);
if (effect.AudioEffectBytes.Length > 0)
{
natoTone = ConversionHelpers.ByteArrayToShortArray(effect.AudioEffectBytes);
var vol = Settings.GlobalSettingsStore.Instance.GetClientSetting(GlobalSettingsKeys.NATOToneVolume)
.FloatValue;
for (int i = 0; i < natoTone.Length; i++)
{
natoTone[i] = (short)(natoTone[i] * vol);
}
}
}
public ClientAudioProvider()
{
_highPassFilter = BiQuadFilter.HighPassFilter(AudioManager.INPUT_SAMPLE_RATE, 520, 0.97f);
_lowPassFilter = BiQuadFilter.LowPassFilter(AudioManager.INPUT_SAMPLE_RATE, 4130, 2.0f);
JitterBufferProviderInterface = new JitterBufferProviderInterface(new WaveFormat(AudioManager.INPUT_SAMPLE_RATE, 2));
SampleProvider = new Pcm16BitToSampleProvider(JitterBufferProviderInterface);
}
public RadioAudioProvider(int sampleRate)
{
BufferedWaveProvider = new BufferedWaveProvider(new WaveFormat(sampleRate, 16, 2));
BufferedWaveProvider.ReadFully = false;
BufferedWaveProvider.DiscardOnBufferOverflow = true;
var pcm = new Pcm16BitToSampleProvider(BufferedWaveProvider);
VolumeSampleProvider = new VolumeSampleProvider(pcm);
}
void ReadWave()
{
WaveStream reader;
if (fileLocation.Text.Contains(".mp3"))
{
reader = new Mp3FileReader(fileLocation.Text);
reader = WaveFormatConversionStream.CreatePcmStream(reader);
}
else
{
reader = new WaveFileReader(fileLocation.Text);
}
ISampleProvider provider = new Pcm16BitToSampleProvider(reader);
float[] buffer = new float[bufferLength];
byte[] test = new byte[bufferLength];
notes = new Dictionary <string, Note>();
sampleRate = reader.WaveFormat.SampleRate * 4;
//provider.Read(buffer, 0, buffer.Length);
while (provider.Read(buffer, 0, buffer.Length) != 0)
{
detectPitch(buffer);
}
Note[] key = new Note[12];
notes.Values.CopyTo(key, 0);
Array.Sort(key);
Note[] tonal = new Note[7];
for (int i = 0; i < 7; i++)
{
tonal[i] = key[i];
}
Tonality tonality = new Tonality(tonal);
TonalityCoincidence coincidence = new TonalityCoincidence();
coincidence.calculateCoincidence(tonality);
Tonality[] tonalities = new Tonality[24];
coincidence.coincidence.Keys.CopyTo(tonalities, 0);
System.Windows.Controls.Label label;
for (int i = 0; i < coincidence.coincidence.Values.Count; i++)
{
label = (System.Windows.Controls.Label)A.FindName(tonalities[i].name);
label.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#" + Convert.ToInt32((255 * (1 - coincidence.coincidence[tonalities[i]]))).ToString("X2") + Convert.ToInt32((255 * coincidence.coincidence[tonalities[i]])).ToString("X2") + "00"));
Console.WriteLine(tonalities[i].name + " - > " + coincidence.coincidence[tonalities[i]] * 100 + "%");
}
foreach (var j in key)
{
Console.WriteLine(j.name + " - > " + j.magnitude);
}
}
public RadioAudioProvider()
{
BufferedWaveProvider = new BufferedWaveProvider(new WaveFormat(AudioManager.SAMPLE_RATE, 16, 2));
BufferedWaveProvider.DiscardOnBufferOverflow = true;
BufferedWaveProvider.BufferDuration = new TimeSpan(0, 0, 2); //2 seconds buffer
var pcm = new Pcm16BitToSampleProvider(BufferedWaveProvider);
VolumeSampleProvider = new VolumeSampleProvider(pcm);
_settings = Settings.Instance;
}
public ClientAudioProvider()
{
_filters = new OnlineFilter[2];
_filters[0] =
OnlineFilter.CreateBandpass(ImpulseResponse.Finite, AudioManager.INPUT_SAMPLE_RATE, 560, 3900);
_filters[1] =
OnlineFilter.CreateBandpass(ImpulseResponse.Finite, AudioManager.INPUT_SAMPLE_RATE, 100, 4500);
JitterBufferProviderInterface =
new JitterBufferProviderInterface(new WaveFormat(AudioManager.INPUT_SAMPLE_RATE, 2));
SampleProvider = new Pcm16BitToSampleProvider(JitterBufferProviderInterface);
}
private byte[] ResampleLinux(byte[] pcm)
{
using (MemoryStream mem = new MemoryStream(pcm))
{
using (RawSourceWaveStream stream = new RawSourceWaveStream(mem, oldFormat))
{
Pcm16BitToSampleProvider sampleProvider = new Pcm16BitToSampleProvider(stream);
WdlResamplingSampleProvider resampedWavFile = new WdlResamplingSampleProvider(sampleProvider, newFormat.SampleRate);
SampleToWaveProvider16 sampleToWavProvider = new SampleToWaveProvider16(resampedWavFile);
int resampled_length = (int)((float)pcm.Length * ((float)newFormat.SampleRate / (float)oldFormat.SampleRate));
byte[] ret = new byte[resampled_length];
sampleToWavProvider.Read(ret, 0, resampled_length);
return(ret);
}
}
}
public PlaybackMixer(WaveFormat waveFormat)
{
/*
* var mmFmt = outputDevice.AudioClient.MixFormat;
* WaveFormat = new WaveFormat(mmFmt.SampleRate, mmFmt.BitsPerSample <= 16 ? mmFmt.BitsPerSample : 16, mmFmt.Channels);
*/
WaveFormat = waveFormat;
mixer = new MixingSampleProvider(WaveFormat.CreateIeeeFloatWaveFormat(WaveFormat.SampleRate, WaveFormat.Channels));
mixer.ReadFully = true;
// convert to 32 bit floating point
bufferStream32 = new Pcm16BitToSampleProvider(mixer.ToWaveProvider16());
// pass through the effects
effectStream = new EffectStream(bufferStream32);
//effectStream.UpdateEffectChain(effects.ToArray());
}
public void QueueForPlayback(string path)
{
WaveStream reader = new WaveFileReader(path);
if (reader.WaveFormat.SampleRate != mixer.WaveFormat.SampleRate)
{
reader = new WaveFormatConversionStream(new WaveFormat(mixer.WaveFormat.SampleRate, reader.WaveFormat.BitsPerSample, reader.WaveFormat.Channels), reader);
}
var sampleReader = new Pcm16BitToSampleProvider(reader);
/*ISampleProvider reader = new AudioFileReader(path);
* if (reader.WaveFormat.Channels > 1)
* {
* reader = new MultiplexingSampleProvider(new ISampleProvider[] { reader }, 1);
* }*/
this.mixer.AddMixerInput(sampleReader);
}
public ClientAudioProvider()
{
_filters = new OnlineFilter[2];
_filters[0] =
OnlineFilter.CreateBandpass(ImpulseResponse.Finite, AudioManager.INPUT_SAMPLE_RATE, 560, 3900);
_filters[1] =
OnlineFilter.CreateBandpass(ImpulseResponse.Finite, AudioManager.INPUT_SAMPLE_RATE, 100, 4500);
JitterBufferProviderInterface =
new JitterBufferProviderInterface(new WaveFormat(AudioManager.INPUT_SAMPLE_RATE, 2));
SampleProvider = new Pcm16BitToSampleProvider(JitterBufferProviderInterface);
_decoder = OpusDecoder.Create(AudioManager.INPUT_SAMPLE_RATE, 1);
_decoder.ForwardErrorCorrection = false;
_highPassFilter = BiQuadFilter.HighPassFilter(AudioManager.INPUT_SAMPLE_RATE, 520, 0.97f);
_lowPassFilter = BiQuadFilter.LowPassFilter(AudioManager.INPUT_SAMPLE_RATE, 4130, 2.0f);
}
public AudioPipeline(EffectChain effects)
{
// Audio pipeline:
// get the audio from Skype
this.bufferStream = new SkypeBufferProvider(16000);
// convert to 32 bit floating point
var bufferStream32 = new Pcm16BitToSampleProvider(bufferStream);
// pass through the effects
var effectStream = new EffectStream(bufferStream32);
// now mix in any sound effects
mixer = new MixingSampleProvider(effectStream.WaveFormat);
mixer.AddMixerInput(effectStream);
// and convert back to 16 bit ready to be given back to skype
outputProvider = new SampleToWaveProvider16(mixer);
effects.Modified += (s, a) => effectStream.UpdateEffectChain(effects.ToArray());
}
public static MemorySampleProvider FromStream(Stream stream)
{
using (var waveProvider = new WaveFileReader(stream)) {
ISampleProvider sampleProvider = null;
switch (waveProvider.WaveFormat.BitsPerSample)
{
case 8:
sampleProvider = new Pcm8BitToSampleProvider(waveProvider);
break;
case 16:
sampleProvider = new Pcm16BitToSampleProvider(waveProvider);
break;
case 24:
sampleProvider = new Pcm24BitToSampleProvider(waveProvider);
break;
case 32:
sampleProvider = new Pcm32BitToSampleProvider(waveProvider);
break;
default:
Log.Error($"Unknown PCM bits per sample {waveProvider.WaveFormat.BitsPerSample}");
return(null);
}
var format = sampleProvider.WaveFormat;
var samples = new List <float>();
var buffer = new float[format.SampleRate];
var n = 0;
while ((n = sampleProvider.Read(buffer, 0, buffer.Length)) > 0)
{
samples.AddRange(buffer.Take(n));
}
var data = samples.ToArray();
return(new MemorySampleProvider()
{
WaveFormat = format,
data = data,
});
}
}
public static SampleSource CreateFromWaveFile(string fileName)
{
using (var reader = new WaveFileReader(fileName))
{
ISampleProvider sp;
int sourceSamples;
if (reader.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
{
if (reader.WaveFormat.BitsPerSample == 16)
{
sp = new Pcm16BitToSampleProvider(reader);
sourceSamples = (int)(reader.Length / 2);
}
else if (reader.WaveFormat.BitsPerSample == 24)
{
sp = new Pcm24BitToSampleProvider(reader);
sourceSamples = (int)(reader.Length / 3);
}
else
{
throw new ArgumentException("Currently only 16 or 24 bit PCM samples are supported");
}
}
else if (reader.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
{
sp = new WaveToSampleProvider(reader);
sourceSamples = (int)(reader.Length / 4);
}
else
{
throw new ArgumentException("Must be PCM or IEEE float");
}
float[] sampleData = new float[sourceSamples];
int n = sp.Read(sampleData, 0, sourceSamples);
if (n != sourceSamples)
{
throw new InvalidOperationException(String.Format("Couldn't read the whole sample, expected {0} samples, got {1}", n, sourceSamples));
}
SampleSource ss = new SampleSource(sampleData, sp.WaveFormat);
return(ss);
}
}
public BufferedWaveProvider GetWaveProvider(T key)
{
Tuple <BufferedWaveProvider, ISampleProvider> val;
if (waveProviders.TryGetValue(key, out val))
{
return(val.Item1);
}
if (waveProviders.Count >= maxChannels)
{
var keyToDel = waveProviders.Keys.First();
var todel = waveProviders[keyToDel];
mixer.RemoveMixerInput(todel.Item2);
waveProviders.Remove(keyToDel);
}
var wave = new BufferedWaveProvider(new WaveFormat(sampleRate, 1));
var sample = new Pcm16BitToSampleProvider(wave);
waveProviders.Add(key, Tuple.Create <BufferedWaveProvider, ISampleProvider>(wave, sample));
mixer.AddMixerInput(sample);
return(wave);
}
private void Connect()
{
if (this.currentState != UiState.ReadyToConnect)
{
return;
}
Stopwatch watch = Stopwatch.StartNew();
UpdateUiState(UiState.Connecting);
if (ShowMiniWindow.IsChecked.Value)
{
miniwindow.Show();
}
//This section is putting default values in case there are missing values in the UI
// Minimal validation
if (this.IsMissingInput(this.FromLanguage.SelectedItem, "source language"))
{
return;
}
if (this.IsMissingInput(this.ToLanguage.SelectedItem, "target language"))
{
return;
}
//if (this.IsMissingInput(this.Voice.SelectedItem, "voice")) return;
if (this.IsMissingInput(this.Profanity.SelectedItem, "profanity filter"))
{
return;
}
if (this.IsMissingInput(this.Mic.SelectedItem, "microphone"))
{
return;
}
if (this.IsMissingInput(this.Speaker.SelectedItem, "speaker"))
{
return;
}
if (this.LogAutoSave.IsChecked.Value)
{
this.autoSaveFrom = this.Logs.Items.Count;
}
string tag = ((ComboBoxItem)Mic.SelectedItem).Tag as string;
string audioFileInputPath = null;
if (tag == "File")
{
audioFileInputPath = this.AudioFileInput.Text;
if (!File.Exists(audioFileInputPath))
{
SetMessage(String.Format("Invalid audio source: selected file does not exist."), "", MessageKind.Error);
UpdateUiState(UiState.ReadyToConnect);
return;
}
}
bool shouldSuspendInputAudioDuringTTS = this.CutInputAudioCheckBox.IsChecked.HasValue ? this.CutInputAudioCheckBox.IsChecked.Value : false;
this.correlationId = Guid.NewGuid().ToString("D").Split('-')[0].ToUpperInvariant();
// Setup speech translation client options
SpeechClientOptions options;
string voicename = "";
if (this.Voice.SelectedItem != null)
{
voicename = ((ComboBoxItem)this.Voice.SelectedItem).Tag.ToString();
}
options = new SpeechTranslateClientOptions()
{
TranslateFrom = ((ComboBoxItem)this.FromLanguage.SelectedItem).Tag.ToString(),
TranslateTo = ((ComboBoxItem)this.ToLanguage.SelectedItem).Tag.ToString(),
Voice = voicename,
};
options.Hostname = baseUrl;
options.AuthHeaderKey = "Authorization";
options.AuthHeaderValue = ""; // set later in ConnectAsync.
options.ClientAppId = new Guid("EA66703D-90A8-436B-9BD6-7A2707A2AD99");
options.CorrelationId = this.correlationId;
options.Features = GetFeatures().ToString().Replace(" ", "");
options.Profanity = ((SpeechClient.ProfanityFilter)Enum.Parse(typeof(SpeechClient.ProfanityFilter), ((ComboBoxItem)this.Profanity.SelectedItem).Tag.ToString(), true)).ToString();
// Setup player and recorder but don't start them yet.
WaveFormat waveFormat = new WaveFormat(16000, 16, 1);
// WaveProvider for incoming TTS
// We use a rather large BVufferDuration because we need to be able to hold an entire utterance.
// TTS audio is received in bursts (faster than real-time).
textToSpeechBytes = 0;
playerTextToSpeechWaveProvider = new BufferedWaveProvider(waveFormat);
playerTextToSpeechWaveProvider.BufferDuration = TimeSpan.FromMinutes(5);
ISampleProvider sampleProvider = null;
if (audioFileInputPath != null)
{
// Setup mixing of audio from input file and from TTS
playerAudioInputWaveProvider = new BufferedWaveProvider(waveFormat);
var srce1 = new Pcm16BitToSampleProvider(playerTextToSpeechWaveProvider);
var srce2 = new Pcm16BitToSampleProvider(playerAudioInputWaveProvider);
var mixer = new MixingSampleProvider(srce1.WaveFormat);
mixer.AddMixerInput(srce1);
mixer.AddMixerInput(srce2);
sampleProvider = mixer;
}
else
{
recorder = new WaveIn();
recorder.DeviceNumber = (int)((ComboBoxItem)Mic.SelectedItem).Tag;
recorder.WaveFormat = waveFormat;
recorder.DataAvailable += OnRecorderDataAvailable;
sampleProvider = playerTextToSpeechWaveProvider.ToSampleProvider();
}
player = new WaveOut();
player.DeviceNumber = (int)((ComboBoxItem)Speaker.SelectedItem).Tag;
player.Init(sampleProvider);
this.audioBytesSent = 0;
string logAudioFileName = null;
if (LogSentAudio.IsChecked.Value || LogReceivedAudio.IsChecked.Value)
{
string logAudioPath = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), Properties.Settings.Default.OutputDirectory);
try
{
Directory.CreateDirectory(logAudioPath);
}
catch
{
this.AddItemToLog(string.Format("Could not create folder {0}", logAudioPath));
}
if (LogSentAudio.IsChecked.Value)
{
logAudioFileName = System.IO.Path.Combine(logAudioPath, string.Format("audiosent_{0}.wav", this.correlationId));
}
if (LogReceivedAudio.IsChecked.Value)
{
string fmt = System.IO.Path.Combine(logAudioPath, string.Format("audiotts_{0}_{{0}}.wav", this.correlationId));
this.audioReceived = new BinaryMessageDecoder(fmt);
}
}
ConnectAsync(options, shouldSuspendInputAudioDuringTTS).ContinueWith((t) =>
{
if (t.IsFaulted || t.IsCanceled || !s2smtClient.IsConnected()) //t.isfaulted OR t.iscancelled OR NOT s2smtclient.isconnected() do the following
{
this.Log(t.Exception, "E: Unable to connect: cid='{0}', elapsedMs='{1}'.",
this.correlationId, watch.ElapsedMilliseconds);
this.SafeInvoke(() => {
this.AutoSaveLogs();
this.UpdateUiState(UiState.ReadyToConnect);
});
}
else
{
// Start playing incoming audio
player.Play();
// Start recording and sending
if (logAudioFileName != null)
{
audioSent = new WaveFileWriter(logAudioFileName, waveFormat);
this.Log("I: Recording outgoing audio in {0}", logAudioFileName);
}
// Send the WAVE header
s2smtClient.SendBinaryMessage(new ArraySegment <byte>(GetWaveHeader(waveFormat)));
if (audioFileInputPath != null)
{
streamAudioFromFileInterrupt = new CancellationTokenSource();
Task.Run(() => this.StreamFile(audioFileInputPath, streamAudioFromFileInterrupt.Token))
.ContinueWith((x) =>
{
if (x.IsFaulted)
{
this.Log(x.Exception, "E: Error while playing audio from input file.");
}
else
{
this.Log("I: Done playing audio from input file.");
}
});
}
else
{
// Start sending audio from the recoder.
recorder.StartRecording();
}
this.Log("I: Connected: cid='{0}', elapsedMs='{1}'.",
this.correlationId, watch.ElapsedMilliseconds);
this.SafeInvoke(() => this.UpdateUiState(UiState.Connected));
}
}).ContinueWith((t) => {
if (t.IsFaulted)
{
Log(t.Exception, "E: Failed to start sending audio.");
this.SafeInvoke(() => {
this.AutoSaveLogs();
this.UpdateUiState(UiState.ReadyToConnect);
});
}
});
}
private void StreamMP3_New(object state)
{
Thread.CurrentThread.Name = state.ToString();
string url = (string)state;
byte[] buffer = new byte[16384 * 4];
Dictionary <int, IMp3FrameDecompressor> Decompressors = new Dictionary <int, IMp3FrameDecompressor>();
WaveFormat outputFormat = new WaveFormat(44100, 16, 2);
this.bufferedWaveProvider = new BufferedWaveProvider(outputFormat);
this.bufferedWaveProvider.BufferDuration = TimeSpan.FromSeconds(2);
// WaveToSampleProvider wav2sample = new WaveToSampleProvider(this.bufferedWaveProvider);
ISampleProvider sampleProvider = new Pcm16BitToSampleProvider(this.bufferedWaveProvider);
SampleAggregator sa = new SampleAggregator(128);
sa.NotificationCount = 882;
sa.PerformFFT = true;
sa.FftCalculated += sa_FftCalculated;
NotifyingSampleProvider notifyProvider = new NotifyingSampleProvider(sampleProvider);
notifyProvider.Sample += (a, b) => sa.Add(b.Left);
volumeProvider = new VolumeSampleProvider(notifyProvider);
//volumeProvider = new SampleChannel(this.bufferedWaveProvider, true);
volumeProvider.Volume = 0.0f;
//volumeProvider.PreVolumeMeter += waveChannel_PreVolumeMeter;
for (int j = 0; j < 5; ++j)
{
try {
using (IWavePlayer waveOut = new WaveOut()) {
waveOut.PlaybackStopped += waveOut_PlaybackStopped;
waveOut.Init(volumeProvider);
using (var readFullyStream = new ShoutcastStream(url)) {
waveOut.Play();
if (OnStartPlay != null)
{
OnStartPlay(this);
}
do
{
if (bufferedWaveProvider != null && bufferedWaveProvider.BufferLength - bufferedWaveProvider.BufferedBytes < bufferedWaveProvider.WaveFormat.AverageBytesPerSecond / 4)
{
int x = 0;
while (playbackState != StreamingPlaybackState.Stopped && x < 5)
{
x++;
Thread.Sleep(50);
}
}
else
{
Mp3Frame frame = Mp3Frame.LoadFromStream(readFullyStream, true);
if (currentTrack != readFullyStream.StreamTitle)
{
currentTrack = readFullyStream.StreamTitle;
if (!string.IsNullOrEmpty(currentTrack))
{
ThreadPool.QueueUserWorkItem(Search, currentTrack);
}
else
{
CurrentTrack = null;
if (OnNewTrack != null)
{
OnNewTrack(this, null);
}
}
}
IMp3FrameDecompressor dec;
if (!Decompressors.TryGetValue(frame.SampleRate, out dec))
{
WaveFormat waveFormat = new Mp3WaveFormat(frame.SampleRate,
frame.ChannelMode == ChannelMode.Mono ? 1 : 2,
frame.FrameLength, frame.BitRate);
var suggFromat = AcmStream.SuggestPcmFormat(waveFormat);
dec = new VbrAcmMp3FrameDecompressor(waveFormat, outputFormat);
Decompressors[frame.SampleRate] = dec;
}
int decompressed = dec.DecompressFrame(frame, buffer, 0);
bufferedWaveProvider.AddSamples(buffer, 0, decompressed);
}
} while (playbackState != StreamingPlaybackState.Stopped);
waveOut.Stop();
}
}
return;
} catch (Exception exe) {
int x = 0;
while (playbackState != StreamingPlaybackState.Stopped && x < 20)
{
x++;
Thread.Sleep(50);
}
if (playbackState == StreamingPlaybackState.Stopped)
{
return;
}
} finally {
foreach (var dc in Decompressors)
{
dc.Value.Dispose();
}
Decompressors.Clear();
}
}
if (OnError != null)
{
OnError(this);
}
}
