WPF

private static NAudioEngine instance;
private static NAudioEngine instance2;
private static NAudioEngine instance3;
private readonly DispatcherTimer positionTimer = new DispatcherTimer(DispatcherPriority.ApplicationIdle);
private readonly BackgroundWorker waveformGenerateWorker = new BackgroundWorker();
private readonly int fftDataSize = (int)FFTDataSize.FFT2048;
private bool disposed;
private bool canPlay;
private bool canPause;
private bool canStop;
private bool isPlaying;
private bool inChannelTimerUpdate;
private double channelLength;
private double channelPosition;
private bool inChannelSet;
private IWavePlayer waveOutDevice = new DirectSoundOut(50);
private WaveStream activeStream;
private WaveChannel32 inputStream;
private SampleAggregator sampleAggregator;
private SampleAggregator waveformAggregator;
private string pendingWaveformPath;
private float[] fullLevelData;
private float[] waveformData;
private TagLib.File fileTag;
private TimeSpan repeatStart;
private TimeSpan repeatStop;
private bool inRepeatSet;

private double volumeChange;
private double volumeChange_Master;

private bool allPlay;
private bool allStop;
private bool allPause;

private double equalizerChange;
private  EqualizerEffect m_eqEffect;

if (waveOutDevice != null)
            {
                waveOutDevice.Pause();
                
              
                switch (i)
                {
                    case 1:
                        m_eqEffect.LoGainFactor.Value = (float)d;
                        m_eqEffect.LoDriveFactor.Value = (float)d;
                        break;
                    case 2:
                        m_eqEffect.MedGainFactor.Value = (float)d;
                        m_eqEffect.MedDriveFactor.Value = (float)d;
                        break;
                    case 3:
                        m_eqEffect.HiGainFactor.Value = (float)d;
                        m_eqEffect.HiDriveFactor.Value = (float)d;
                        break;
                }
                m_eqEffect.OnFactorChanges();
                waveOutDevice.Play();
                
            }

if (System.IO.File.Exists(path))
           {
               try
               {
                   waveOutDevice= new DirectSoundOut(50);

                   if (path.EndsWith(".wav"))
                   {
                       ActiveStream = new WaveFileReader(path);
                   }
                   else if (path.EndsWith(".mp3"))
                   {
                       ActiveStream = new Mp3FileReader(path);
                   }
                   else
                   {
                       throw new InvalidOperationException("Unsupported extension");
                   }

                   if (ActiveStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
                   {
                       ActiveStream = WaveFormatConversionStream.CreatePcmStream(ActiveStream);
                       ActiveStream = new BlockAlignReductionStream(ActiveStream);
                   }

                   // Provide conversion to 16 bits if needed
                   if (ActiveStream.WaveFormat.BitsPerSample != 16)
                   {
                       var format = new WaveFormat(ActiveStream.WaveFormat.SampleRate,
                       16, ActiveStream.WaveFormat.Channels);
                       ActiveStream = new WaveFormatConversionStream(format, ActiveStream);
                   }

                   inputStream = new WaveChannel32(ActiveStream);
                   sampleAggregator = new SampleAggregator(fftDataSize);
                   inputStream.Sample += inputStream_Sample;
                   ChannelLength = inputStream.TotalTime.TotalSeconds;
                   FileTag = TagLib.File.Create(path);
                   GenerateWaveformData(path);
                   CanPlay = true;
                   inputStream.Volume = 0.5f;
                   waveOutDevice.Volume = 1f;

                   m_eqEffect = new EqualizerEffect();
                   m_eqEffect.SampleRate = activeStream.WaveFormat.SampleRate;
                   m_eqEffect.LoDriveFactor.Value = 75;
                   m_eqEffect.LoGainFactor.Value = 0;
                   m_eqEffect.MedDriveFactor.Value = 40;
                   m_eqEffect.MedGainFactor.Value = 0;
                   m_eqEffect.HiDriveFactor.Value = 30;
                   m_eqEffect.HiGainFactor.Value = 0;
                   m_eqEffect.Init();
                   m_eqEffect.OnFactorChanges();

                   ActiveStream = new DSPEffectStream(inputStream, m_eqEffect);
                   waveOutDevice.Init(inputStream);

               }
               catch
               {
                   ActiveStream = null;
                   CanPlay = false;
               }
           }