private void timer1_Tick(object sender, EventArgs e)
{
if (playbackState != StreamingPlaybackState.Stopped)
{
if (waveOut == null && bufferedWaveProvider != null)
{
waveOut = CreateWaveOut();
waveOut.PlaybackStopped += OnPlaybackStopped;
volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
volumeProvider.Volume = (float)trackBar1.Value / 1000f;
waveOut.Init(volumeProvider);
}
else if (bufferedWaveProvider != null)
{
var bufferedSeconds = bufferedWaveProvider.BufferedDuration.TotalSeconds;
// make it stutter less if we buffer up a decent amount before playing
if (bufferedSeconds < 0.5 && playbackState == StreamingPlaybackState.Playing && !fullyDownloaded)
{
Pause();
}
else if (bufferedSeconds > 4 && playbackState == StreamingPlaybackState.Buffering)
{
Play();
}
else if (fullyDownloaded && bufferedSeconds == 0)
{
StopPlayback();
}
}
}
}
private void timer1_Tick(object sender, EventArgs e)
{
if (playbackState != StreamingPlaybackState.Stopped)
{
if (waveOut == null && bufferedWaveProvider != null)
{
Console.WriteLine("waveOut Created");
waveOut = CreateWaveOut();
waveOut.PlaybackStopped += OnPlaybackStopped;
volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
volumeProvider.Volume = _volume;
waveOut.Init(volumeProvider);
}
else if (bufferedWaveProvider != null)
{
var bufferedSeconds = bufferedWaveProvider.BufferedDuration.TotalSeconds;
UpdateTimer(stopwatch.Elapsed.TotalMilliseconds);
if (bufferedSeconds < 0.5 && playbackState == StreamingPlaybackState.Playing && !fullyDownloaded)
{
pause();
}
else if (bufferedSeconds > 4 && playbackState == StreamingPlaybackState.Buffering)
{
play();
}
else if (fullyDownloaded && bufferedSeconds == 0)
{
Console.WriteLine("Reached end of stream");
Stop();
}
}
}
}
protected override void Play()
{
if (string.IsNullOrEmpty(InputPath) || File.Exists(InputPath) == false)
{
MessageBox.Show("Select a valid input file or URL first");
return;
}
if (WavePlayer == null)
{
CreatePlayer();
}
if (_lastPlayed != InputPath && _reader != null)
{
_reader.Dispose();
_reader = null;
}
if (_reader == null)
{
_reader = new Mp3FileReader(InputPath);
VolumeProvider = new VolumeWaveProvider16(_reader)
{
Volume = Volume / 100
};
_lastPlayed = InputPath;
WavePlayer.Init(VolumeProvider);
Duration = _reader.TotalTime;
}
WavePlayer.Play();
UpdatePlayerState();
PlayerTimer.Start();
TaskbarOverlay = (ImageSource)Application.Current.FindResource("PlayImage");
SetTitle("Playing " + Path.GetFileName(InputPath));
}
private void timer1_Tick(object sender, EventArgs e)
{
if (playbackState != StreamingPlaybackState.Stopped)
{
if (waveOut == null && bufferedWaveProvider != null)
{
waveOut = CreateWaveOut();
waveOut.PlaybackStopped += OnPlaybackStopped;
volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
volumeProvider.Volume = vsVolume.Volume;
waveOut.Init(volumeProvider);
pbBarBuffer.Maximum = (int)bufferedWaveProvider.BufferDuration.TotalMilliseconds; // ACA
}
else if (bufferedWaveProvider != null)
{
var bufferedSeconds = bufferedWaveProvider.BufferedDuration.TotalSeconds;
ShowBufferState(bufferedSeconds);
if (bufferedSeconds < 0.5 && playbackState == StreamingPlaybackState.Playing && !fullyDownloaded)
{
Pause();
}
else if (bufferedSeconds > 4 && playbackState == StreamingPlaybackState.Buffering)
{
Play();
}
else if (fullyDownloaded && bufferedSeconds == 0)
{
stop_stream();
}
}
}
}
public void Start(int AudioIndex, AudioDevice device)
{
if (AudioIndex != -1)
{
input.DataAvailable += new EventHandler <WaveInEventArgs>(input_DataAvailable);
input.DeviceNumber = AudioIndex;
WaveFormat format = null;
if (device.BitRate != 0 && device.SampleRate != 0)
{
format = new WaveFormat(device.SampleRate, device.BitRate, device.Channels);
input.WaveFormat = format;
}
WaveProvider = new BufferedWaveProvider(input.WaveFormat);
//WaveProvider.DiscardOnBufferOverflow = true;
//make max buffer twice as long so it doesn't crash instantly and all that
//WaveProvider.BufferLength = (int)(WaveProvider.BufferLength /5);
WaveProvider.BufferDuration = TimeSpan.FromMilliseconds(400);
//WaveProvider.ReadFully = false;
volumeHandler = new VolumeWaveProvider16(WaveProvider);
volumeHandler.Volume = volume;
//output.DesiredLatency = 0;
output.Init(volumeHandler);
output.Play();
input.StartRecording();
DeviceOpen = true;
}
}
public void DefaultVolumeIs1()
{
var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 2));
VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
Assert.AreEqual(1.0f, vwp.Volume);
}
public void PassesThroughSourceWaveFormat()
{
var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 2));
VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
Assert.AreSame(testProvider.WaveFormat, vwp.WaveFormat);
}
public override void Execute()
{
//WaveChannel32 WaveFloat = new WaveChannel32(new WaveFileReader(mSongPath));
MediaFoundationReader reader = new MediaFoundationReader(mSongPath);
VolumeWaveProvider16 ww = new VolumeWaveProvider16(reader);
if (ApplicationSettings.Volume != 100)
{
ww.Volume = (float)Math.Pow((ApplicationSettings.Volume / 100.0), 3);
}
var outFormat = new WaveFormat(22050, 16, 1);
var resampler = new MediaFoundationResampler(ww, outFormat);
resampler.ResamplerQuality = 60;
string wavFileName = Path.Combine(CsGoLocationFinder.GetCsGoLocation(), ApplicationSettings.WavFileName);
if (File.Exists(wavFileName))
{
File.Delete(wavFileName);
}
WaveFileWriter.CreateWaveFile(wavFileName, resampler);
resampler.Dispose();
Key.CsGoKeySender.SendCommands(CsComand);
}
private void PlayingMp3(object state)
{
while (playbackState != StreamingPlaybackState.Stopped)
{
if (waveOut == null && bufferedWaveProvider != null)
{
waveOut = CreateWaveOut();
volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
volumeProvider.Volume = float.Parse(state.ToString());
waveOut.Init(volumeProvider);
}
else if (bufferedWaveProvider != null)
{
var bufferedSeconds = bufferedWaveProvider.BufferedDuration.TotalSeconds;
if (bufferedSeconds < 0.1 && playbackState == StreamingPlaybackState.Playing)
{
Pause();
}
else if (bufferedSeconds > 1 && playbackState == StreamingPlaybackState.Buffering)
{
Play1();
}
}
Thread.Sleep(500);
}
}
private void timer1_Tick(object sender, EventArgs e)
{
if (playbackState != StreamingPlaybackState.Stopped)
{
if (waveOut == null && bufferedWaveProvider != null)
{
Debug.WriteLine("Creating WaveOut Device");
waveOut = CreateWaveOut();
waveOut.PlaybackStopped += OnPlaybackStopped;
volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
volumeProvider.Volume = volumeSlider1.Volume;
waveOut.Init(volumeProvider);
progressBarBuffer.Maximum = (int)bufferedWaveProvider.BufferDuration.TotalMilliseconds;
}
else if (bufferedWaveProvider != null)
{
var bufferedSeconds = bufferedWaveProvider.BufferedDuration.TotalSeconds;
ShowBufferState(bufferedSeconds);
// make it stutter less if we buffer up a decent amount before playing
if (bufferedSeconds < 0.5 && playbackState == StreamingPlaybackState.Playing && !fullyDownloaded)
{
Pause();
}
else if (bufferedSeconds > 4 && playbackState == StreamingPlaybackState.Buffering)
{
Play();
}
else if (fullyDownloaded && bufferedSeconds == 0)
{
Debug.WriteLine("Reached end of stream");
StopPlayback();
}
}
}
}
private void timer1_Tick(object sender, EventArgs e)
{
if (playbackState != StreamingPlaybackState.Stopped)
{
if (waveOut == null && bufferedWaveProvider != null)
{
Debug.WriteLine("Creating WaveOut Device");
waveOut = CreateWaveOut();
waveOut.PlaybackStopped += OnPlaybackStopped;
volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
volumeProvider.Volume = Properties.Settings.Default.Volume;
waveOut.Init(volumeProvider);
}
else if (bufferedWaveProvider != null)
{
var bufferedSeconds = bufferedWaveProvider.BufferedDuration.TotalSeconds;
if (bufferedSeconds < 0.5 && playbackState == StreamingPlaybackState.Playing && !fullyDownloaded)
{
Pause();
}
else if (bufferedSeconds > 4 && playbackState == StreamingPlaybackState.Buffering)
{
Play();
}
else if (fullyDownloaded && bufferedSeconds == 0)
{
Debug.WriteLine("Reached end of stream");
StopPlayback();
}
}
}
}
public void OutputWaveToFile(
string textToSpeak,
string waveFile)
{
if (string.IsNullOrWhiteSpace(textToSpeak))
{
return;
}
this.StartSasara();
var tempWave = Path.GetTempFileName();
talker.OutputWaveToFile(
textToSpeak,
tempWave);
// ささらは音量が小さめなので増幅する
using (var reader = new WaveFileReader(tempWave))
{
var prov = new VolumeWaveProvider16(reader);
prov.Volume = Settings.Default.SasaraGain;
WaveFileWriter.CreateWaveFile(
waveFile,
prov);
}
if (File.Exists(tempWave))
{
File.Delete(tempWave);
}
}
IWaveProvider audio_onWaveProviderCreated(IWaveProvider provider)
{
volumeProvider = new VolumeWaveProvider16(provider)
{
Volume = volume / 100
};
return(volumeProvider);
}
public static void ChangeVolume(float volume, Stream source, Stream target)
{
var reader = new WaveFileReader(source);
var vp = new VolumeWaveProvider16(reader);
vp.Volume = volume;
WaveFileWriter.WriteWavFileToStream(target, vp);
}
//------------------------------------------------------------------------------------------------------------------------
#endregion
#region Constructor
//------------------------------------------------------------------------------------------------------------------------
public Speaker()
{
waveout = new WaveOut();
bufferedWaveProvider = new BufferedWaveProvider(new WaveFormat(8000, 16, 2));
waveout.PlaybackStopped += Waveout_PlaybackStopped;
volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
waveout.Init(volumeProvider);
}
private void TgA2_Tick(object sender, EventArgs e)
{
try
{
if (estadodoplay2 != StreamingPlaybackState.Stopped)
{
if (saidadeaudiowave2 == null && provedordebuffer2 != null)
{
int dispositivoid = lstDispos.SelectedIndex;
// Debug.WriteLine("Creating WaveOut Device");
saidadeaudiowave2 = CreateWaveOut();
saidadeaudiowave2.PlaybackStopped += OnPlaybackStopped;
provedordevolumedeaudio2 = new VolumeWaveProvider16(provedordebuffer2);
provedordevolumedeaudio2.Volume = new VolumeSlider().Volume;
provedordevolumedeaudio2.Volume = regVol2.Volume;
if (dispositivoid != -1)
{
dispositivoid = dispositivoid - 1;
}
saidadeaudiowave2 = new WaveOutEvent()
{
DeviceNumber = dispositivoid
};
saidadeaudiowave2.Init(provedordevolumedeaudio2);
pbBuf2.Maximum = (int)provedordebuffer2.BufferDuration.TotalMilliseconds;
}
else if (provedordebuffer2 != null)
{
var bufferedSeconds = provedordebuffer2.BufferedDuration.TotalSeconds;
streamdois = true;
ShowBufferState(bufferedSeconds);
// make it stutter less if we buffer up a decent amount before playing
if (bufferedSeconds < 0.5 && estadodoplay2 == StreamingPlaybackState.Playing && !fullyDownloaded2)
{
// Pause();
StopPlayback();
System.Threading.Thread.Sleep(5000);
Audio2();
}
else if (bufferedSeconds > 4 && estadodoplay2 == StreamingPlaybackState.Buffering)
{
Play();
}
else if (fullyDownloaded2 && bufferedSeconds == 0)
{
// Debug.WriteLine("Reached end of stream");
StopPlayback();
}
}
}
}
catch (Exception ex)
{
ShowError(ex.Message + ex.StackTrace);
}
}
public AudioLogicFilter(AudioListener listener)
{
this.listener = listener;
listener.AudioDataAvailableEvent += Listener_AudioDataAvailableEvent;
bufferedWaveProvider = new BufferedWaveProvider(format)
{
DiscardOnBufferOverflow = true
};
volumeWaveProvider = new VolumeWaveProvider16(bufferedWaveProvider);
Stream = new Wave16ToFloatProvider(volumeWaveProvider);
}
public void SetAudioParameters(int sampleRate, int channels)
{
_waveFormat = new WaveFormat(sampleRate, channels);
_bufferedWaveProvider = new BufferedWaveProvider(_waveFormat)
{
BufferDuration = TimeSpan.FromSeconds(120),
DiscardOnBufferOverflow = false
};
_volumeWaveProvider = new VolumeWaveProvider16(_bufferedWaveProvider);
_waveOutDevice.Init(_volumeWaveProvider);
}
public void PassesThroughDataUnchangedAtVolume1()
{
var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 2));
VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
byte[] buffer = new byte[20];
int bytesRead = vwp.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, bytesRead);
Assert.AreEqual(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }, buffer);
}
private void btnPlay_Click(object sender, RoutedEventArgs e)
{
if (output != null &&
output.PlaybackState == PlaybackState.Paused)
{
output.Play();
btnPlay.IsEnabled = false;
btnPause.IsEnabled = true;
btnStop.IsEnabled = true;
}
else
{
if (txtRuta.Text != null && txtRuta.Text != "")
{
output = new WaveOutEvent();
output.PlaybackStopped += OnPlaybackStop;
reader = new Mp3FileReader(txtRuta.Text);
//Configuraciones de WaveOut
output.DeviceNumber = cbDispositivos.SelectedIndex;
output.NumberOfBuffers = 2;
output.DesiredLatency = 150;
volumeProvider =
new VolumeWaveProvider16(reader);
volumeProvider.Volume =
(float)sldVolumen.Value;
output.Init(volumeProvider);
output.Play();
btnStop.IsEnabled = true;
btnPause.IsEnabled = true;
btnPlay.IsEnabled = false;
//00:00:15.465456456
lblDuration.Text =
reader.TotalTime.ToString().Substring(0, 8);
lblPosition.Text =
reader.CurrentTime.ToString().Substring(0, 8);
sldPosition.Maximum = reader.TotalTime.TotalSeconds;
sldPosition.Value = 0;
timer.Start();
}
else
{
//Avisarle al usuario que elija un archivo
}
}
}
public void TextToWave(
string textToSpeak,
string waveFileName,
float gain = 1.0f)
{
if (string.IsNullOrEmpty(textToSpeak))
{
return;
}
this.StartCevio();
var tempWave = Path.GetTempFileName();
try
{
var result = this.cevioTalker.OutputWaveToFile(
textToSpeak,
tempWave);
if (result)
{
FileHelper.CreateDirectory(waveFileName);
if (gain != 1.0)
{
// ささらは音量が小さめなので増幅する
using (var reader = new WaveFileReader(tempWave))
{
var prov = new VolumeWaveProvider16(reader)
{
Volume = gain
};
WaveFileWriter.CreateWaveFile(
waveFileName,
prov);
}
}
else
{
File.Move(tempWave, waveFileName);
}
}
}
finally
{
if (File.Exists(tempWave))
{
File.Delete(tempWave);
}
}
}
public StreamingBuffer(WaveFormat waveformat)
{
_SamplingRate = waveformat.SampleRate;
_Channels = waveformat.Channels;
bufwaveprovider16 = new BufferedWaveProvider(new WaveFormat(_SamplingRate, 16, _Channels));
volume = new VolumeWaveProvider16(bufwaveprovider16);
volume.Volume = 0.1F;
ChannelBuffers = new Int16Buffer[2];
ChannelBuffers[0] = new Int16Buffer();
ChannelBuffers[1] = new Int16Buffer();
}
void SetupNAudio()
{
WaveFormat waveFormat = new WaveFormat(samplerate, bits, channels);
bufferedWaveProvider = new BufferedWaveProvider(waveFormat);
bufferedWaveProvider.BufferDuration = TimeSpan.FromSeconds(bufferProviderLength);
waveOut = new WaveOut();
waveOut.PlaybackStopped += OnPlaybackStopped;
volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
volumeProvider.Volume = 1.0f;
waveOut.Init(volumeProvider);
}
public StreamingBuffer(WaveFormat waveformat)
{
_SamplingRate = waveformat.SampleRate;
_Channels = waveformat.Channels;
bufwaveprovider16 = new BufferedWaveProvider(new WaveFormat(_SamplingRate, 16, _Channels));
volume = new VolumeWaveProvider16(bufwaveprovider16);
//volume.Volume = 0.1F;
ChannelBuffers = new Int16Buffer[2];
ChannelBuffers[0] = new Int16Buffer();
ChannelBuffers[1] = new Int16Buffer();
_streambuffermsec = 500;//小さいほど良いが正常動作する限界値をセットしたい。この値を下回るタイミングでbufwaveproviderにバッファを追加していく
}
public void ZeroVolumeWorks()
{
var testProvider = new TestWaveProvider(new WaveFormat(44100, 16, 2));
testProvider.ConstValue = 100;
VolumeWaveProvider16 vwp = new VolumeWaveProvider16(testProvider);
vwp.Volume = 0f;
byte[] buffer = new byte[4];
int bytesRead = vwp.Read(buffer, 0, buffer.Length);
Assert.AreEqual(new byte[] { 0, 0, 0, 0 }, buffer);
}
public byte[] raiseVolume(byte[] data, int decibels)
{
MemoryStream msInput = new MemoryStream(data);
MemoryStream msOutput = new MemoryStream();
double percentage = Math.Pow(10, ((double)decibels) / 10);
using (var reader = new WaveFileReader(msInput))
{
var volumeProvider = new VolumeWaveProvider16(reader);
volumeProvider.Volume = (float)percentage;
WaveFileWriter.WriteWavFileToStream(msOutput, volumeProvider);
return(msOutput.ToArray());
}
}
public static string adjustVolume(string path, int dBnum)
{
int indexof = path.LastIndexOf('_');
string newpath = path.Substring(0, indexof) + "_tempVOL.wav";
double percentage = Math.Pow(10, ((double)dBnum) / 10);
using (var reader = new WaveFileReader(path))
{
var volumeProvider = new VolumeWaveProvider16(reader);
volumeProvider.Volume = (float)percentage;
WaveFileWriter.CreateWaveFile(newpath, volumeProvider);
}
return(newpath);
}
private void CreateOutput()
{
var vwp = new VolumeWaveProvider16(_buffer);
var dso = new DirectSoundOut(70);
vwp.Volume = _currentVolume;
Debug.WriteLine("Now playing at {0}% volume", dso.Volume);
dso.Init(vwp);
dso.Play();
vwp.Volume = _currentVolume;
_currentOut = dso;
_volumeWaveProvider = vwp;
}
private void timer_Tick(object sender, EventArgs e)
{
_timer.Enabled = false;
if (_playbackState != StreamingPlaybackState.Stopped)
{
if (_waveOut == null && _bufferedWaveProvider != null)
{
if (IsBufferNearlyFull)
{
Debug.WriteLine("Creating WaveOut Device");
_waveOut = CreateWaveOut();
_volumeProvider = new VolumeWaveProvider16(_bufferedWaveProvider);
_volumeProvider.Volume = _volume;
try
{
_waveOut.Init(_volumeProvider);
}
catch (NotSupportedException)
{
StopPlayback();
RaisePropertyChanged("WASAPI_NonSupport");
}
//progressBarBuffer.Maximum = (int)bufferedWaveProvider.BufferDuration.TotalMilliseconds;
}
}
else if (_waveOut != null && _bufferedWaveProvider != null)
{
double bufferedSeconds = _bufferedWaveProvider.BufferedDuration.TotalSeconds;
// make it stutter less if we buffer up a decent amount before playing
if (bufferedSeconds < 0.5 && _playbackState == StreamingPlaybackState.Playing && !_fullyDownloaded)
{
Pause();
RaisePropertyChanged("Paused");
}
else if (bufferedSeconds > 4 && _playbackState == StreamingPlaybackState.Buffering)
{
Play();
RaisePropertyChanged("Playing");
}
else if (_fullyDownloaded && bufferedSeconds == 0)
{
Debug.WriteLine("Reached end of stream");
StopPlayback();
}
}
}
_timer.Enabled = true;
}
protected override void OnTick(object sender, EventArgs eventArgs)
{
try
{
if (_playbackState != StreamingPlaybackState.Stopped)
{
UpdatePosition();
if (WavePlayer == null && _bufferedWaveProvider != null)
{
Debug.WriteLine("Creating WaveOut Device");
CreatePlayer();
VolumeProvider = new VolumeWaveProvider16(_bufferedWaveProvider)
{
Volume = Volume / 100
};
WavePlayer.Init(VolumeProvider);
}
else if (_bufferedWaveProvider != null)
{
var bufferedSeconds = _bufferedWaveProvider.BufferedDuration.TotalSeconds;
ShowBufferState(bufferedSeconds);
// make it stutter less if we buffer up a decent amount before playing
if (bufferedSeconds < 0.5 && _playbackState == StreamingPlaybackState.Playing && !_fullyDownloaded)
{
_playbackState = StreamingPlaybackState.Buffering;
WavePlayer.Pause();
}
else if (bufferedSeconds >= 1 && _playbackState == StreamingPlaybackState.Buffering)
{
WavePlayer.Play();
_playbackState = StreamingPlaybackState.Playing;
}
else if (_fullyDownloaded && bufferedSeconds == 0)
{
Debug.WriteLine("Reached end of stream");
Stop();
}
}
UpdatePlayerState();
}
}
finally
{
PositionChanging = false;
}
}
private void OnTimerElapsed(object sender, ElapsedEventArgs e)
{
if (_playbackState != StreamingPlaybackState.Stopped)
{
if (_waveOut == null && _bufferedWaveProvider != null)
{
_log.Log("Grooveshark: Initializing", Category.Info, Priority.Medium);
try
{
_waveOut = new WaveOutEvent();
_volumeProvider = new VolumeWaveProvider16(_bufferedWaveProvider);
_volumeProvider.Volume = Volume;
_waveOut.Init(_volumeProvider);
}
catch (Exception ex)
{
_log.Log("Grooveshark: " + ex.ToString(), Category.Exception, Priority.High);
_elapsedTimeSpan = TimeSpan.Zero;
_playbackState = StreamingPlaybackState.Stopped;
_timer.Stop();
_isPlaying(false);
_trackComplete(_track);
}
}
else if (_bufferedWaveProvider != null)
{
try
{
var bufferedSeconds = _bufferedWaveProvider.BufferedDuration.TotalSeconds;
// make it stutter less if we buffer up a decent amount before playing
if (bufferedSeconds < 0.5 && _playbackState == StreamingPlaybackState.Playing && !_fullyDownloaded)
{
_isBuffering(true);
_log.Log("Grooveshark: Buffering..", Category.Info, Priority.Medium);
_playbackState = StreamingPlaybackState.Buffering;
if (_waveOut != null)
{
_waveOut.Pause();
_isPlaying(false);
}
}
else if (bufferedSeconds > 4 && _playbackState == StreamingPlaybackState.Buffering)
{
_log.Log("Grooveshark: Buffering complete", Category.Info, Priority.Medium);
if (_waveOut != null)
{
_waveOut.Play();
_playbackState = StreamingPlaybackState.Playing;
_isPlaying(true);
}
_isBuffering(false);
}
else if (_fullyDownloaded && bufferedSeconds < 0.5)
{
_log.Log("Grooveshark: Buffer empty and the stream is fully downloaded. Complete..", Category.Info, Priority.Medium);
_elapsedTimeSpan = TimeSpan.Zero;
_isPlaying(false);
_playbackState = StreamingPlaybackState.Stopped;
_timer.Stop();
_trackComplete(_track);
}
}
catch (Exception exception)
{
_log.Log(exception.ToString(), Category.Exception, Priority.Medium);
}
}
if (_playbackState == StreamingPlaybackState.Playing)
{
_elapsedTimeSpan = _elapsedTimeSpan.Add(TimeSpan.FromMilliseconds(_timer.Interval));
_trackProgress(_track.TotalDuration.TotalMilliseconds, _elapsedTimeSpan.TotalMilliseconds);
}
}
}
private void timer1_Tick(object sender, EventArgs e)
{
if (_playbackState != StreamingPlaybackState.Stopped)
{
if (_waveOut == null && _bufferedWaveProvider != null)
{
Debug.WriteLine("Creating WaveOut Device");
_waveOut = CreateWaveOut();
_waveOut.PlaybackStopped += waveOut_PlaybackStopped;
_volumeProvider = new VolumeWaveProvider16(_bufferedWaveProvider);
_volumeProvider.Volume = 1;
_waveOut.Init(_volumeProvider);
progressBarBuffer.Properties.Maximum = (int)_bufferedWaveProvider.BufferDuration.TotalMilliseconds;
}
else if (_bufferedWaveProvider != null)
{
var bufferedSeconds = _bufferedWaveProvider.BufferedDuration.TotalSeconds;
ShowBufferState(bufferedSeconds);
// make it stutter less if we buffer up a decent amount before playing
if (bufferedSeconds < 0.5 && _playbackState == StreamingPlaybackState.Playing && !_fullyDownloaded)
{
_playbackState = StreamingPlaybackState.Buffering;
_waveOut.Pause();
Debug.WriteLine(String.Format("Paused buffer, waveOut.PlaybackState={0}", _waveOut.PlaybackState));
}
else if (bufferedSeconds > 4 && _playbackState == StreamingPlaybackState.Buffering)
{
_waveOut.Play();
Debug.WriteLine(String.Format("Started playing, waveOut.PlaybackState={0}", _waveOut.PlaybackState));
_playbackState = StreamingPlaybackState.Playing;
}
else if (_fullyDownloaded && bufferedSeconds == 0)
{
Debug.WriteLine("End of stream");
StopPlayback();
}
}
}
}
private void timer1_Tick(object sender, EventArgs e)
{
if (playbackState != StreamingPlaybackState.Stopped)
{
if (this.waveOut == null && this.bufferedWaveProvider != null)
{
Debug.WriteLine("Creating WaveOut Device");
this.waveOut = CreateWaveOut();
waveOut.PlaybackStopped += waveOut_PlaybackStopped;
this.volumeProvider = new VolumeWaveProvider16(bufferedWaveProvider);
this.volumeProvider.Volume = this.volumeSlider1.Volume;
waveOut.Init(volumeProvider);
progressBarBuffer.Maximum = (int)bufferedWaveProvider.BufferDuration.TotalMilliseconds;
}
else if (bufferedWaveProvider != null)
{
var bufferedSeconds = bufferedWaveProvider.BufferedDuration.TotalSeconds;
ShowBufferState(bufferedSeconds);
// make it stutter less if we buffer up a decent amount before playing
if (bufferedSeconds < 0.5 && this.playbackState == StreamingPlaybackState.Playing && !this.fullyDownloaded)
{
this.playbackState = StreamingPlaybackState.Buffering;
waveOut.Pause();
Debug.WriteLine(String.Format("Paused to buffer, waveOut.PlaybackState={0}", waveOut.PlaybackState));
}
else if (bufferedSeconds > 4 && this.playbackState == StreamingPlaybackState.Buffering)
{
waveOut.Play();
Debug.WriteLine(String.Format("Started playing, waveOut.PlaybackState={0}", waveOut.PlaybackState));
this.playbackState = StreamingPlaybackState.Playing;
}
else if (this.fullyDownloaded && bufferedSeconds == 0)
{
Debug.WriteLine("Reached end of stream");
StopPlayback();
}
}
}
}
