/// <summary>
        /// WaveStream to resample using the DMO Resampler
        /// </summary>
        /// <param name="inputProvider">Input Stream</param>
        /// <param name="outputFormat">Desired Output Format</param>
        public ResamplerDmoStream(IWaveProvider inputProvider, WaveFormat outputFormat)
        {
            this.inputProvider = inputProvider;
            this.inputStream = inputProvider as WaveStream;
            this.outputFormat = outputFormat;
            this.resampler = new Resampler();
            if (!resampler.MediaObject.SupportsInputWaveFormat(0, inputProvider.WaveFormat))
            {
                throw new ArgumentException("Unsupported Input Stream format", "inputStream");
            }

            resampler.MediaObject.SetInputWaveFormat(0, inputProvider.WaveFormat);
            if (!resampler.MediaObject.SupportsOutputWaveFormat(0, outputFormat))
            {
                throw new ArgumentException("Unsupported Output Stream format", "outputStream");
            }

            resampler.MediaObject.SetOutputWaveFormat(0, outputFormat);
            if (inputStream != null)
            {
                position = InputToOutputPosition(inputStream.Position);
            }
            this.inputMediaBuffer = new MediaBuffer(inputProvider.WaveFormat.AverageBytesPerSecond);
            this.outputBuffer = new DmoOutputDataBuffer(outputFormat.AverageBytesPerSecond);
        }

 public bool Load(string path, Guid device)
 {
     var cext = path.GetExt();
     _myWaveOut = new DirectSoundOut(device);
     try
     {
         _myWaveStream = _codecs.First(v => v.Extensions.Contains(cext)).CreateWaveStream(path);
     }
     catch
     {
         return false;
     }
     if (_myWaveStream == null) return false;
     if (_myWaveStream.WaveFormat.Channels == 2)
     {
         _myBalanceSampleProvider = new BalanceSampleProvider(_myWaveStream.ToSampleProvider());
         _myVolumeSampleProvider = new VolumeSampleProvider(_myBalanceSampleProvider);
         _myBalanceSampleProvider.Pan = (float)Balance;
     }
     else _myVolumeSampleProvider = new VolumeSampleProvider(_myWaveStream.ToSampleProvider());
     _myEqualizer = new Equalizer(_myVolumeSampleProvider, _equalizerBands) { Enabled = _enableEqualizer };
     _myWaveOut.Init(_myEqualizer);
     _myWaveOut.PlaybackStopped += MyWaveOutOnPlaybackStopped;
     _myVolumeSampleProvider.Volume = (float)Volume;
     return true;
 }

        /// <summary>
        /// Add a new input to the mixer
        /// </summary>
        /// <param name="waveStream">The wave input to add</param>
        public void AddInputStream(WaveStream waveStream)
        {
            if (waveStream.WaveFormat.Encoding != WaveFormatEncoding.IeeeFloat)
                throw new ArgumentException("Must be IEEE floating point", "waveStream");
            if (waveStream.WaveFormat.BitsPerSample != 32)
                throw new ArgumentException("Only 32 bit audio currently supported", "waveStream");

            if (inputStreams.Count == 0)
            {
                // first one - set the format
                int sampleRate = waveStream.WaveFormat.SampleRate;
                int channels = waveStream.WaveFormat.Channels;
                this.waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sampleRate, channels);
            }
            else
            {
                if (!waveStream.WaveFormat.Equals(waveFormat))
                    throw new ArgumentException("All incoming channels must have the same format", "waveStream");
            }

            lock (inputsLock)
            {
                this.inputStreams.Add(waveStream);
                this.length = Math.Max(this.length, waveStream.Length);
                // get to the right point in this input file
                waveStream.Position = Position;
            }
        }

        public WaveListenerProvider(WaveStream sourceStream)
        {
            this.sourceStream = sourceStream;
            waveFormat = WaveFormat.CreateIeeeFloatWaveFormat(sourceStream.WaveFormat.SampleRate, sourceStream.WaveFormat.Channels);

            sampleAggregator.FftCalculated += new EventHandler<FftEventArgs>(FftCalculated);
            sampleAggregator.PerformFFT = true;
        }

 /// <summary>
 /// Create a new WaveFormat conversion stream
 /// </summary>
 /// <param name="targetFormat">Desired output format</param>
 /// <param name="sourceStream">Source stream</param>
 public WaveFormatConversionStream(WaveFormat targetFormat, WaveStream sourceStream)
 {
     this.sourceStream = sourceStream;
     this.targetFormat = targetFormat;
     conversionProvider = new WaveFormatConversionProvider(targetFormat, sourceStream);
     length = EstimateSourceToDest((int)sourceStream.Length);
     position = 0;
 }

 public MeteringStream(WaveStream sourceStream, int samplesPerNotification)
 {
     SourceStream = sourceStream;
     if (sourceStream.WaveFormat.BitsPerSample != 32)
         throw new ArgumentException("Metering Stream expects 32 bit floating point audio", "sourceStream");
     maxSamples = new float[sourceStream.WaveFormat.Channels];
     this.SamplesPerNotification = samplesPerNotification;
 }

 public EffectStream(EffectChain effects, WaveStream sourceStream)
 {
     this.effects = effects;
     this.source = sourceStream;
     foreach (Effect effect in effects)
     {
         InitialiseEffect(effect);
     }
 }

 /// <summary>
 /// Creates a stream that can convert to PCM
 /// </summary>
 /// <param name="sourceStream">The source stream</param>
 /// <returns>A PCM stream</returns>
 public static WaveStream CreatePcmStream(WaveStream sourceStream)
 {
     if (sourceStream.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
     {
         return sourceStream;
     }
     WaveFormat pcmFormat = AcmStream.SuggestPcmFormat(sourceStream.WaveFormat);
     return new WaveFormatConversionStream(pcmFormat, sourceStream);
 }

 private IWaveProvider CreateReader()
 {
     if (reader is RawSourceWaveStream)
     {
         reader.Position = 0;
         return reader;
     }
     reader = new MediaFoundationReaderRT(selectedStream);
     return reader;
 }        

 /// <summary>
 /// Create a new simple compressor stream
 /// </summary>
 /// <param name="sourceStream">Source stream</param>
 public SimpleCompressorStream(WaveStream sourceStream)
 {
     this.sourceStream = sourceStream;
     this.channels = sourceStream.WaveFormat.Channels;
     this.bytesPerSample = sourceStream.WaveFormat.BitsPerSample / 8;
     simpleCompressor = new SimpleCompressor(5.0, 10.0, sourceStream.WaveFormat.SampleRate);
     simpleCompressor.Threshold = 16;
     simpleCompressor.Ratio = 6;
     simpleCompressor.MakeUpGain = 16;
 }

        /// <summary>
        /// Create a new WaveFormat conversion stream
        /// </summary>
        /// <param name="targetFormat">Desired output format</param>
        /// <param name="sourceStream">Source stream</param>
        public WaveFormatConversionStream(WaveFormat targetFormat, WaveStream sourceStream)
        {
            this.sourceStream = sourceStream;
            this.targetFormat = targetFormat;

            conversionStream = new AcmStream(sourceStream.WaveFormat, targetFormat);
            // work out how many bytes the entire input stream will convert to
            length = SourceToDest((int)sourceStream.Length);
            blockAlign = SourceToDest(sourceStream.BlockAlign);
            position = 0;
        }

        private static void TestSeekPosition(WaveStream mainOutputStream, TimeSpan timeSpan)
        {
            Console.WriteLine("Hit key to reposition..");
            Console.ReadKey();

            Console.ForegroundColor = ConsoleColor.Blue;
            Console.WriteLine("Seeking to new time: {0}...", timeSpan);
            (mainOutputStream as WaveChannel32).CurrentTime = timeSpan;
            Console.WriteLine("New position after seek: " + (mainOutputStream as WaveChannel32).CurrentTime);

            Console.ResetColor();
        }

        private static void Extract(Stream output, WaveStream waveStream, byte[] buffer)
        {
            if (waveStream == null)
                return;

            using (WaveFileWriter writer = new WaveFileWriter(output, waveStream.WaveFormat))
            {
                int count;
                while ((count = waveStream.Read(buffer, 0, buffer.Length)) != 0)
                    writer.Write(buffer, 0, count);
            }
        }

		private float[] bufferFloat; // 32bit float audio
		
		/// <summary>
		/// Creates a new delay effect
		/// </summary>
		/// <param name="inStream">The incoming audio data</param>
		/// <param name="length">The delay length in milliseconds</param>
		/// <param name="wetPercent">Percentage of output delay</param>
		/// <param name="feedbackPercent">Percentage feedback</param>
		public Delay(WaveStream inStream, int length, float wetPercent, float feedbackPercent) 
		{
			this.inStream = inStream;
			if(inStream.WaveFormat.Encoding == WaveFormatEncoding.IeeeFloat) 
			{
				bufferFloat = new float[(inStream.WaveFormat.AverageBytesPerSecond * length)/ 1000];
			}
			else if(inStream.WaveFormat.Encoding == WaveFormatEncoding.Pcm)
			{
				buffer16 = new short[(inStream.WaveFormat.AverageBytesPerSecond * length)/ 1000];
			}
		}

 public int PlaySong(string path)
 {
     int result = 0;
     sync.InvokeIfRequired((Action)delegate
     {
         CleanPlayerAndStream();
         result = -1;
         if (!string.IsNullOrEmpty(path))
         {
             try
             {
                 MakePlayerInternal();
                 stream = CreateStream(path);
                 player.Init(stream);
                 player.Play();
                 result = (int)(stream.Length / stream.WaveFormat.AverageBytesPerSecond);
             }
             catch (Exception)
             {
                 CleanPlayerAndStream();
             }
         }
     });
     return result;
 }

 public MainForm()
 {
     waveOutDevice = null;
     mainOutputStream = null;
     volumeStream = null;
     InitializeComponent();
 }

 /// <summary>
 /// Lejátszik egy .mp3 fájlt
 /// </summary>
 /// <param name="audioFile">.mp3 fájl</param>
 public static void playWave(string audioFile)
 {
     thread = new WaveOut();
     stream = CreateInputStream(audioFile);
     thread.Init(stream);
     thread.Play();
 }

        private void Initialize()
        {
            var extension = Path.GetExtension(file).ToLowerInvariant();

            if (extension.Equals(".wav"))
            {
                reader = new WaveFileReader(file);
            }
            else
            {
                reader = new Mp3FileReader(file);
            }

            var format = reader.WaveFormat;

            this.sampleRate = format.SampleRate;
            this.channels = format.Channels;

            this.Format = new AudioProperties(format.SampleRate, format.BitsPerSample,
                format.Channels, (int)reader.TotalTime.TotalSeconds);

            if (format.BitsPerSample != 16)
            {
                Dispose(true);
            }
        }

        public NAudioDecoder(string file)
        {
            extension = Path.GetExtension(file).ToLowerInvariant();

            ready = false;

            if (extension.Equals(".wav"))
            {
                reader = new WaveFileReader(file);
            }
            else
            {
                reader = new Mp3FileReader(file);
            }

            var format = reader.WaveFormat;

            bitsPerSample = format.BitsPerSample;
            sampleRate = format.SampleRate;
            channels = format.Channels;
            
            duration = (int)reader.TotalTime.TotalSeconds;

            ready = (format.BitsPerSample == 16);
        }

        public SoundResource(ResourceManager mgr, string fullName, Stream stream, Format fmt)
        {
            _manager = mgr;
            FullName = fullName;

            switch (fmt)
            {
                case Format.MP3:
                {
                    Mp3FileReader mp3 = new Mp3FileReader(stream);
                    _reader = mp3;
                    break;
                }
                case Format.WAV:
                {
                    WaveFileReader wav = new WaveFileReader(stream);
                    _reader = wav;
                    break;
                }
                default:
                    throw new InvalidOperationException("Unsupported extension.");
            }

            _stream = new WaveChannel32(_reader);
            _stream.PadWithZeroes = false;

            _wavDevice.PlaybackStopped += _wavDevice_PlaybackStopped;
        }