public async Task PlayAudioStream(string url)
{
var response = await WebRequest.Create(url).GetResponseAsync();
using (Stream ms = new MemoryStream())
{
using (Stream stream = response.GetResponseStream())
{
byte[] buffer = new byte[32768];
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
}
ms.Position = 0;
using (WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(ms))))
using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
waveOut.Init(blockAlignedStream);
waveOut.Play();
while (waveOut.PlaybackState == PlaybackState.Playing)
{
System.Threading.Thread.Sleep(100);
}
}
}
}
public static WaveStream CreateInputStream(string name)
{
WaveChannel32 inputStream;
if (name.EndsWith(".wav"))
{
WaveStream readerStream = new WaveFileReader(name);
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
if (readerStream.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(readerStream.WaveFormat.SampleRate, 16, readerStream.WaveFormat.Channels);
readerStream = new WaveFormatConversionStream(format, readerStream);
}
inputStream = new WaveChannel32(readerStream);
}
else
{
throw new InvalidOperationException("Invalid extension");
}
return(inputStream);
}
private WaveOut CreatePlay(string file)
{
string ext = Path.GetExtension(file);
if (file.EndsWith(".mp3"))
{
using (var reader = new Mp3FileReader(file))
{
using (var waveStream = WaveFormatConversionStream.CreatePcmStream(reader))
{
using (var blockStream = new BlockAlignReductionStream(waveStream))
{
play = new WaveOut(WaveCallbackInfo.FunctionCallback());
play.Init(blockStream);
}
}
}
}
System.Media.SoundPlayer
else if (file.EndsWith(".wma"))
{
using (var reader = new WMAFileReader(file))
{
using (var waveStream = WaveFormatConversionStream.CreatePcmStream(reader))
{
using (var blockStream = new BlockAlignReductionStream(waveStream))
{
play = new WaveOut(WaveCallbackInfo.FunctionCallback());
play.Init(blockStream);
}
}
}
}
}
/// <summary>
/// Creates a wave stream from the given file.
/// </summary>
/// <param name="fileName">A WAVE or MP3 file.</param>
private WaveChannel32 CreateInputStream(string fileName)
{
WaveChannel32 inputStream;
if (fileName.EndsWith(".wav"))
{
WaveStream readerStream = new WaveFileReader(fileName);
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
if (readerStream.WaveFormat.BitsPerSample != 16)
{
var format = new WaveFormat(readerStream.WaveFormat.SampleRate, 16, readerStream.WaveFormat.Channels);
readerStream = new WaveFormatConversionStream(format, readerStream);
}
inputStream = new WaveChannel32(readerStream);
}
else if (fileName.EndsWith(".mp3"))
{
WaveStream mp3Reader = new Mp3FileReader(fileName);
WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(mp3Reader);
WaveStream blockAlignedStream = new BlockAlignReductionStream(pcmStream);
inputStream = new WaveChannel32(blockAlignedStream);
}
else
{
throw new InvalidOperationException("Unsupported audio extension");
}
return(inputStream);
}
private void PlayNotificationSound()
{
if (DateTime.UtcNow >= nextAudioAlertPlay)
{
DisableAudioAlertForDuration();
try
{
System.Windows.Resources.StreamResourceInfo sri = Application.GetResourceStream(new Uri("WPFApp/Resources/audio/FeenPhoneDJAlert.wav", UriKind.Relative));
using (WaveStream ws =
new BlockAlignReductionStream(
WaveFormatConversionStream.CreatePcmStream(
new WaveFileReader(sri.Stream))))
{
var length = ws.Length;
if (length < int.MaxValue)
{
byte[] data = new byte[length];
var format = ws.WaveFormat;
int read = ws.Read(data, 0, (int)length);
EventSource.InvokePlaySoundEffect(this, format, data);
}
}
}
catch { }
}
}
/// <summary>
/// Resample wavefile to new waveformat and return WaveStream
/// </summary>
/// <param name="wavInFilePath">audiofile</param>
/// <param name="waveFormat">waveformat</param>
/// <returns>WaveStream</returns>
public static WaveStream ResampleToWaveStream(string wavInFilePath, WaveFormat waveFormat)
{
//WaveStream sourceStream = CreateInputWaveStream(wavInFilePath);
WaveStream sourceStream = null;
try {
sourceStream = (WaveStream) new AudioFileReader(wavInFilePath);
} catch (Exception) {
return(null);
}
if (sourceStream.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
{
// TODO: if the source is IeeFloat, the CreatePcmSteeam and ConverstionStream fail!?
return(sourceStream);
}
else if (sourceStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
{
sourceStream = WaveFormatConversionStream.CreatePcmStream(sourceStream);
sourceStream = new BlockAlignReductionStream(sourceStream);
}
if (sourceStream.WaveFormat.SampleRate != waveFormat.SampleRate ||
sourceStream.WaveFormat.BitsPerSample != waveFormat.BitsPerSample ||
sourceStream.WaveFormat.Channels != waveFormat.Channels)
{
sourceStream = new WaveFormatConversionStream(waveFormat, sourceStream);
sourceStream = new BlockAlignReductionStream(sourceStream);
}
return(sourceStream);
}
public void open()
{
DisposeWave();
Graph();
if (inputpath.EndsWith(".mp3"))
{
WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(inputpath));
stream = new BlockAlignReductionStream(pcm);
}
else
{
throw new InvalidOperationException("Not a correct audio file type.");
}
FileInfo fileInf = new FileInfo(inputpath);
trackDuration = string.Format("Duration: {0:D2} hrs, {1:D2} mins, {2:D2} secs", TimeMP3(inputpath).Hours, TimeMP3(inputpath).Minutes, TimeMP3(inputpath).Seconds);
audioLength = (fileInf.Length) / (1024 * 1024);
output = new DirectSoundOut();
output.Init(stream);
output.Play();
}
public void DisposeAudioOutput()
{
if (mainDirectSoundOut != null)
{
if (mainDirectSoundOut.PlaybackState != PlaybackState.Stopped)
{
mainDirectSoundOut.Stop();
}
mainDirectSoundOut.Dispose();
mainDirectSoundOut = null;
}
if (mainBARStream != null)
{
mainBARStream.Dispose();
mainBARStream = null;
}
if (mainWaveIn != null)
{
mainWaveIn.StopRecording();
mainWaveIn.Dispose();
mainWaveIn = null;
}
SetTemp();
label1.Text = "";
errormessage.Text = "The audio was disposed";
}
/// <summary>
/// 播放声音
/// </summary>
private void PlaySound()
{
using (var ms = File.OpenRead("record/temp.wav"))
using (var rdr = new WaveFileReader(ms))
using (var wavStream = WaveFormatConversionStream.CreatePcmStream(rdr))
using (var baStream = new BlockAlignReductionStream(wavStream))
using (var waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
waveOut.Init(baStream);
waveOut.Play();
int i = 0;
while (waveOut.PlaybackState == PlaybackState.Playing)
{
Thread.Sleep(100);
//动画展示
images = talk.GetFiles();
if (i == images.Length - 8)
{
i = 0;
}
this.BackgroundImage = Image.FromFile(images[i].FullName);
i++;
}
}
isGoNextAni = true;
isGoNextMusic = true;
}
void PlaySound(string link, int WaveOutDeviceId)
{
using (Stream ms = new MemoryStream())
{
using (Stream stream = WebRequest.Create(link).GetResponse().GetResponseStream())
{
byte[] buffer = new byte[4096];
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
}
ms.Position = 0;
using (WaveStream mf = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(ms))))
using (var wo = new WaveOutEvent())
{
wo.DeviceNumber = WaveOutDeviceId;
PitchProvider = new SmbPitchShiftingSampleProvider(mf.ToSampleProvider().ToMono());
PitchProvider.PitchFactor = Pitch;
wo.Init(PitchProvider);
wo.Volume = VoiceVolume;
wo.Play();
while (wo.PlaybackState == PlaybackState.Playing)
{
PitchProvider.PitchFactor = Pitch;
wo.Volume = VoiceVolume;
Thread.Sleep(500);
}
}
}
}
public static void PlayNASound(string url)
{
using (Stream ms = new MemoryStream())
{
using (Stream stream = File.Open(url, FileMode.Open))
{
byte[] buffer = new byte[32768];
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
}
ms.Position = 0;
using (WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(ms))))
{
using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
waveOut.Init(blockAlignedStream);
waveOut.PlaybackStopped += (sender, e) =>
{
waveOut.Stop();
};
waveOut.Play();
waiting = true;
stop.WaitOne(10000);
waiting = false;
}
}
}
}
private void PlayMp3()
{
try
{
using (Mp3FileReader reader = new Mp3FileReader(currentTrack.Data))
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(reader))
using (WaveStream blockAlignedStream = new BlockAlignReductionStream(pcm))
{
using (_waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
_waveOut.Init(blockAlignedStream);
_waveOut.Play();
while (
!WindowClosed &&
!_stop &&
_waveOut != null &&
_waveOut.PlaybackState == PlaybackState.Playing)
{
System.Threading.Thread.Sleep(100);
}
_waveOut.Stop();
}
}
}
catch (Exception e)
{
}
}
public WaveStream GetStream(string path)
{
WaveStream ret = null;
string lp = path.ToLower();
if (lp.EndsWith(".wav"))
{
ret = new WaveFileReader(path);
if (ret.WaveFormat.Encoding != WaveFormatEncoding.Pcm && ret.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat)
{
ret = WaveFormatConversionStream.CreatePcmStream(ret);
ret = new BlockAlignReductionStream(ret);
}
}
else if (lp.EndsWith(".mp3"))
{
ret = new Mp3FileReader(path);
}
else if (lp.EndsWith(".aiff"))
{
ret = new AiffFileReader(path);
}
else if (lp.EndsWith(".wma"))
{
ret = new NAudio.WindowsMediaFormat.WMAFileReader(path);
}
return(ret);
}
public WaveStream CreateWaveStream(string fileName)
{
if (Path.GetExtension(fileName) == ".wav")
{
WaveStream readerStream = new WaveFileReader(fileName);
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm && readerStream.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
return(readerStream);
}
else if (Path.GetExtension(fileName) == ".mp3")
{
Mp3FileReader readerStream = new Mp3FileReader(fileName);
return(new Mp3FileReader(fileName));
}
else if (Path.GetExtension(fileName) == ".aiff")
{
return(new AiffFileReader(fileName));
}
else
{
return(null);
}
}
/// <summary>
/// 再生を開始します。
/// </summary>
public void PlayStreaming(string url)
{
if (_waveOut == null)
{
new Thread(delegate(object o)
{
var response = WebRequest.Create(url).GetResponse();
using (var stream = response.GetResponseStream())
{
byte[] buffer = new byte[65536]; // 64KB chunks
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
var pos = ms.Position;
ms.Position = ms.Length;
ms.Write(buffer, 0, read);
ms.Position = pos;
}
}
}).Start();
}
// Pre-buffering some data to allow NAudio to start playing
while (ms.Length < 65536 * 10)
{
Thread.Sleep(1000);
}
int errorCont = 0;
try
{
using (reader = new Mp3FileReader(ms))
using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(reader))
using (WaveStream blockAlignedStream = new BlockAlignReductionStream(pcm))
{
using (_waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
_waveOut.Init(blockAlignedStream);
_waveOut.Play();
while (_waveOut.PlaybackState == PlaybackState.Playing)
{
Console.WriteLine(reader.CurrentTime);
System.Threading.Thread.Sleep(100);
}
}
}
}
catch
{
if (errorCont > 10)
{
MessageBox.Show("10回Tryしましたが再生に失敗しました。");
}
errorCont++;
}
}
public void test_play_stream_urlMP3Online_v3(string url, int timeout)
{
using (Stream ms = new MemoryStream())
{
using (Stream stream = WebRequest.Create(url)
.GetResponse().GetResponseStream())
{
byte[] buffer = new byte[32768];
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
}
ms.Position = 0;
using (WaveStream blockAlignedStream =
new BlockAlignReductionStream(
WaveFormatConversionStream.CreatePcmStream(
new Mp3FileReader(ms))))
{
using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
waveOut.Init(blockAlignedStream);
waveOut.PlaybackStopped += (sender, e) =>
{
waveOut.Stop();
};
waveOut.Play();
waiting = true;
stop.WaitOne(timeout);
waiting = false;
}
}
}
}
private void List_Son_SelectedIndexChanged(object sender, EventArgs e)
{
if (List_Son.SelectedItem != null)
{
// Avoir l'item selectionné
string itemSelectionne = ((AvoirPath)List_Son.SelectedItem).Path;
Dispose();
//condition si c'est MP3 on le convertit
if (itemSelectionne.EndsWith(".mp3"))
{
WaveStream convert = WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(itemSelectionne));
song = new BlockAlignReductionStream(convert);
}
else if (itemSelectionne.EndsWith(".wav"))
{
WaveStream convert = new WaveChannel32(new WaveFileReader(itemSelectionne));
song = new BlockAlignReductionStream(convert);
}
output = new DirectSoundOut();
//initialisation du son
output.Init(song);
output.Play();
}
}
public override void LoadStream()
{
try
{
WebStream = new MemoryStream();
using (Stream stream = WebRequest.Create(Url)
.GetResponse().GetResponseStream())
{
byte[] buffer = new byte[32768];
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
WebStream.Write(buffer, 0, read);
}
}
WebStream.Position = 0;
Stream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(
new Mp3FileReader(WebStream)));
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
public WaveFile(WaveFileReader reader, BlockAlignReductionStream stream, string path) : base(stream, path)
{
this.Reader = reader;
this.Samples = new byte[this.Reader.Length];
this.Channels = reader.WaveFormat.Channels;
this.callRead();
}
private static WaveStream CreateReaderStream(string fileName)
{
WaveStream readerStream = null;
if (fileName.EndsWith(".wav", StringComparison.OrdinalIgnoreCase))
{
readerStream = new WaveFileReader(fileName);
if (readerStream.WaveFormat.Encoding == WaveFormatEncoding.Pcm ||
readerStream.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat)
{
return(readerStream);
}
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
else if (fileName.EndsWith(".mp3", StringComparison.OrdinalIgnoreCase))
{
readerStream = new Mp3FileReader(fileName);
}
else if (fileName.EndsWith(".aiff"))
{
readerStream = new AiffFileReader(fileName);
}
return(readerStream);
}
public async Task PlayUrlAsync(Uri url, IAudioClient client)
{
_client = client;
_client.SpeakingUpdated += OnSpeakingUpdated;
_isPlaying = true;
using (var ms = new MemoryStream())
{
using (Stream stream = WebRequest.Create(url.ToString())
.GetResponse().GetResponseStream())
{
byte[] buffer = new byte[32768];
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
}
ms.Position = 0;
using (WaveStream blockAlignedStream =
new BlockAlignReductionStream(
WaveFormatConversionStream.CreatePcmStream(
new Mp3FileReader(ms))))
{
var audioStream = _client.CreatePCMStream(AudioApplication.Mixed, 98304);
await blockAlignedStream.CopyToAsync(audioStream);
}
}
}
public void Play(string path)
{
Dispose();
_path = path;
if (System.IO.Path.GetExtension(_path) == ".mp3")
{
pcm = WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(_path));
blockAlignStream = new BlockAlignReductionStream(pcm);
output.Init(blockAlignStream);
}
else if (System.IO.Path.GetExtension(_path) == ".wav")
{
wavereader = new WaveFileReader(_path);
output.Init(new WaveChannel32(wavereader));
}
else if (System.IO.Path.GetExtension(_path) == ".aif")
{
aiffreader = new AiffFileReader(_path);
output.Init(new WaveChannel32(aiffreader));
}
else
{
audioreader = new AudioFileReader(_path);
output.Init(new WaveChannel32(audioreader));
}
output.Play();
}
private void PlayMp3(string url)
{
try
{
Stream ms = new MemoryStream();
// 设置参数
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
//发送请求并获取相应回应数据
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
//直到request.GetResponse()程序才开始向目标网页发送Post请求
Stream responseStream = response.GetResponseStream();
byte[] buffer = new byte[1024];
int size = 0;
//size是读入缓冲区中的总字节数。 如果当前可用的字节数没有请求的字节数那么多，则总字节数可能小于请求的字节数，或者如果已到达流的末尾，则为零 (0)。
while ((size = responseStream.Read(buffer, 0, buffer.Length)) != 0) //将responseStream的内容读入buffer数组
{
ms.Write(buffer, 0, size); //将buffer数组的内容写入内存流ms
}
responseStream.Close(); //关闭流并释放连接以供重用
ms.Position = 0; //将内存流数据读取位置归零
WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(ms)));
WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback());
waveOut.Init(blockAlignedStream);
//waveOut.PlaybackStopped += (sender, e) => { waveOut.Stop(); };
waveOut.Play();
while (waveOut.PlaybackState == PlaybackState.Playing)
{
Thread.Sleep(100);
}
}
catch (Exception ex)
{
ex.Message.ToString();
}
}
public static void PlayMp3FromUrl(string url)
{
Task.Factory.StartNew(() =>
{
using (Stream ms = new MemoryStream())
{
using (Stream stream = System.Net.WebRequest.Create(url)
.GetResponse().GetResponseStream())
{
byte[] buffer = new byte[32768];
int read;
while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
{
ms.Write(buffer, 0, read);
}
}
ms.Position = 0;
using (WaveStream blockAlignedStream =
new BlockAlignReductionStream(
WaveFormatConversionStream.CreatePcmStream(
new Mp3FileReader(ms))))
{
using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
waveOut.Init(blockAlignedStream);
waveOut.Play();
while (waveOut.PlaybackState == PlaybackState.Playing)
{
System.Threading.Thread.Sleep(100);
}
}
}
}
});
}
public void DownloadFile(string urlAddress, string location)
{
using (webClient = new WebClient())
{
try
{
Uri URL = new Uri(urlAddress);
// Start downloading the file
webClient.DownloadFile(URL, location);
using (FileStream memoryStream = File.OpenRead(location))
{
memoryStream.Position = 0;
using (
WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(memoryStream))))
{
using (_waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
_waveOut.Init(blockAlignedStream);
_waveOut.Play();
while (_waveOut.PlaybackState == PlaybackState.Playing)
{
Thread.Sleep(100);
}
_waveOut.Stop();
_waveOut.Dispose();
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
public void DisposeWave()
{
if (ts.IsCancellationRequested && !MainWindow.instance.bottomTimeSlider.IsMouseOver)
{
try
{
if (output != null)
{
if (output.PlaybackState == PlaybackState.Playing)
{
output.Stop();
}
output.Dispose();
output = null;
}
if (stream != null)
{
stream.Dispose();
stream = null;
}
}
catch (NAudio.MmException mmex) {
Console.Error.WriteLine(mmex.Message);
}
}
}
public void PlaySound(CachedSound sound)
{
switch (sound.Type)
{
case TYPE_SOURCE.FILE_LOCAL:
AddMixerInput(new CachedSoundSampleProvider(sound));
break;
case TYPE_SOURCE.FILE_MP3_ONLINE:
using (MemoryStream mp3file = new MemoryStream(sound.AudioData_FILE_MP3_ONLINE))
{
using (WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(
new Mp3FileReader(mp3file))))
{
using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
waveOut.Init(blockAlignedStream);
waveOut.Play();
while (waveOut.PlaybackState == PlaybackState.Playing)
{
System.Threading.Thread.Sleep(100);
}
}
}
}
break;
}
}
public void CanRepositionToNonBlockAlignedPositions()
{
BlockAlignedWaveStream inputStream = new BlockAlignedWaveStream(726, 80000);
BlockAlignReductionStream blockStream = new BlockAlignReductionStream(inputStream);
byte[] inputBuffer = new byte[1024];
int read = blockStream.Read(inputBuffer, 0, 1024);
Assert.AreEqual(1024, read, "bytes read 1");
Assert.AreEqual(blockStream.Position, 1024);
CheckReadBuffer(inputBuffer, 1024, 0);
read = blockStream.Read(inputBuffer, 0, 1024);
Assert.AreEqual(1024, read, "bytes read 2");
Assert.AreEqual(2048, blockStream.Position, "position 2");
CheckReadBuffer(inputBuffer, 1024, 1024);
// can reposition correctly
blockStream.Position = 1000;
read = blockStream.Read(inputBuffer, 0, 1024);
Assert.AreEqual(1024, read, "bytes read 3");
Assert.AreEqual(2024, blockStream.Position, "position 3");
CheckReadBuffer(inputBuffer, 1024, 1000);
}
private static WaveStream FindCorrectWaveStream(Stream stream)
{
try
{
WaveStream readerStream = new WaveFileReader(stream);
if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm && readerStream.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat)
{
readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
readerStream = new BlockAlignReductionStream(readerStream);
}
return(readerStream);
}
catch { }
try
{
return(new Mp3FileReader(stream));
}
catch { }
try
{
return(new AiffFileReader(stream));
}
catch
{
return(null);
}
}
/// <summary>
/// 播放录音文件
/// </summary>
public void StartPlay()
{
Task.Factory.StartNew(() =>
{
try
{
using (var wfr = new WaveFileReader(tempWavFile))
using (WaveStream wavStream = WaveFormatConversionStream.CreatePcmStream(wfr))
using (var baStream = new BlockAlignReductionStream(wavStream))
using (waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
{
waveOut.Init(baStream);
waveOut.Play();
while (waveOut.PlaybackState == PlaybackState.Playing)
{
Thread.Sleep(TimeSpan.FromSeconds(0.1));
}
WaveOut_PlayStopped(true);
}
}
catch (Exception ex)
{
}
}, pToken);
}
