/// <summary>
		/// Starts the recorder.
		/// </summary>
		/// <param name="stream">The stream.</param>
		/// <param name="fileStream">The file stream.</param>
		/// <param name="sampleRate">The sample rate.</param>
		/// <returns>Task&lt;System.Boolean&gt;.</returns>
		public async Task<bool> StartRecorder(IAudioStream stream, Stream fileStream, int sampleRate)
		{
			if (_stream != null || stream == null)
			{
				return false;
			}

			_stream = stream;

			try
			{
				_writer = new BinaryWriter(fileStream, Encoding.UTF8);
			}
			catch (Exception)
			{
				return false;
			}

			_byteCount = 0;
			_stream.OnBroadcast += OnStreamBroadcast;

			var result = await _stream.Start(sampleRate);
			if (result)
			{
				_sampleRate = sampleRate;
				_bitsPerSample = stream.BitsPerSample;
				_channelCount = stream.ChannelCount;
			}
			return result;
		}

        public ColorGenerator(IAudioStream audioStream, int numberOfColors = 3)
            : base(audioStream, numberOfColors)
        {
            if (numberOfColors < 1)
            {
                throw new ArgumentOutOfRangeException();
            }

            var lowFreqMaxBucket = this.GetFrequencyBinIndex(LowFrequencyMax);
            var lowFreqBucket = new ColorGeneratorBucket(this.GetFrequencyBinIndex(LowFrequencyMin), lowFreqMaxBucket, this.IterationsPerSecond, hueShift: 0);
            this.generatorBuckets.Add(lowFreqBucket);

            var freqsPerBucket = (this.MaxFrequencyBinIndex - lowFreqMaxBucket) / (numberOfColors - 1);
            if (freqsPerBucket < 1)
            {
                throw new ArgumentOutOfRangeException("Not enough frequency bins for the remaining colors");
            }

            for (int freqIndex = lowFreqMaxBucket + 1; freqIndex <= this.MaxFrequencyBinIndex - 1; freqIndex += freqsPerBucket)
            {
                ushort hueShift = (ushort)(ushort.MaxValue / numberOfColors * this.generatorBuckets.Count);
                this.generatorBuckets.Add(
                    new ColorGeneratorBucket(freqIndex, Math.Min(freqIndex + freqsPerBucket - 1, this.MaxFrequencyBinIndex), this.IterationsPerSecond, hueShift: hueShift));
            }
        }

        public bool StartRecorder(IAudioStream stream, string fileName)
        {
            if (this.stream != null || stream == null)
            {
                return false;
            }

            this.stream = stream;

            try
            {
                this.streamWriter = new StreamWriter(fileName, false);
                this.writer = new BinaryWriter(this.streamWriter.BaseStream, Encoding.UTF8);
            }
            catch (Exception)
            {
                return false;
            }
            this.byteCount = 0;
            this.stream.OnBroadcast += OnStreamBroadcast;
            this.stream.OnActiveChanged += StreamActiveChanged;
            if (!this.stream.Active)
            {
                this.stream.Start();
            }

            return true;
        }

        public bool StartRecorder(IAudioStream stream, string fileName)
        {
            if (this.stream != null || stream == null)
            {
                return false;
            }

            this.stream = stream;

            try
            {
                //this.streamWriter = new StreamWriter(fileName, false);
                this.writer = new BinaryWriter(this.streamWriter.BaseStream, Encoding.UTF8);
            }
            catch (Exception)
            {
                return false;
            }
            this.byteCount = 0;
            this.stream.OnBroadcast += OnStreamBroadcast;

            if (this.stream.Start.CanExecute(this))
            {
                this.stream.Start.Execute(this);
                return true;
            }

            return false;
        }

 public bool Start(IAudioStream stream)
 {
     this.stream = stream;
     this.stream.OnBroadcast += HandleOnBroadcast;
     this.description = new AudioStreamBasicDescription (AudioFormatType.LinearPCM) 
     {
         BitsPerChannel = stream.BitsPerSample / stream.ChannelCount,
     };
 }

        public int Flow(IAudioStream input, short[] obuf, int count, int volLeft, int volRight)
        {
            var obufPos = 0;
            var inPos = 0;
            var oend = count;

            while (obufPos < oend)
            {
                // read enough input samples so that opos < 0
                while (FRAC_ONE_LOW <= opos)
                {
                    // Check if we have to refill the buffer
                    if (inLen == 0)
                    {
                        inPos = 0;
                        inLen = input.ReadBuffer(inBuf, RateHelper.IntermediateBufferSize);
                        if (inLen <= 0)
                            return obufPos / 2;
                    }
                    inLen -= (stereo ? 2 : 1);
                    ilast0 = icur0;
                    icur0 = inBuf[inPos++];
                    if (stereo)
                    {
                        ilast1 = icur1;
                        icur1 = inBuf[inPos++];
                    }
                    opos -= FRAC_ONE_LOW;
                }

                // Loop as long as the outpos trails behind, and as long as there is
                // still space in the output buffer.
                while (opos < FRAC_ONE_LOW && obufPos < oend)
                {
                    // interpolate
                    int out0, out1;
                    out0 = (short)(ilast0 + (((icur0 - ilast0) * opos + FRAC_HALF_LOW) >> FRAC_BITS_LOW));
                    out1 = stereo ? (short)(ilast1 + (((icur1 - ilast1) * opos + FRAC_HALF_LOW) >> FRAC_BITS_LOW)) : out0;

                    // output left channel
                    RateHelper.ClampedAdd(ref obuf[obufPos + (reverseStereo ? 1 : 0)], (out0 * volLeft) / Mixer.MaxMixerVolume);

                    // output right channel
                    RateHelper.ClampedAdd(ref obuf[obufPos + (reverseStereo ? 0 : 1)], (out1 * volRight) / Mixer.MaxMixerVolume);

                    obufPos += 2;

                    // Increment output position
                    opos += oposInc;
                }
            }
            return obufPos / 2;

        }

        public override AudioBuffer CreateBuffer(IAudioStream target)
        {
            int size = AudioBuffer.DefaultBufferSpan * target.Frequency * target.Channels * target.BitsPerSample / 8;

            WaveFormatEx fmt = new WaveFormatEx(target.Format, target.Channels, target.Frequency, target.BitsPerSample);

            DS.DSBufferCapsFlags flags = DS.DSBufferCapsFlags.CtrlVolume | DS.DSBufferCapsFlags.LocDefer | DS.DSBufferCapsFlags.GlobalFocus | DS.DSBufferCapsFlags.GetCurrentPosition2;
            DS.DSBufferDesc desc = new DS.DSBufferDesc((uint)size, flags, &fmt, Guid.Empty);

            return new wAudioBuffer(this, ref desc) { _source = target, _owner = this };
        }

        public bool Test1(IAudioStream audio, int state)
        {
            if (state == 0)
                Debug.WriteLine("Test #1: play, pause, stop and global stop");

            if (state == 2)
            {
                Debug.WriteLine("----> play for five seconds");
                audio.Play();
            }

            if (state == 7)
            {
                Debug.WriteLine("----> pause music for two seconds");
                audio.Pause();
            }

            if (state == 9)
            {
                Debug.WriteLine("----> play music for five seconds");
                audio.Play();
            }

            if (state == 14)
            {
                Debug.WriteLine("----> stop music for two seconds");
                audio.Stop();
            }

            if (state == 16)
            {
                Debug.WriteLine("----> play music for five seconds");
                audio.Play();
            }

            if (state == 21)
            {
                Debug.WriteLine("----> global stop for two seconds");
                Audio.Instance.Stop();
            }

            if (state == 23)
            {
                Debug.WriteLine("----> play music for five seconds");
                audio.Play();
            }

            if (state != 28)
                return false;

            audio.Stop();
            return true;
        }

        public bool Test2(IAudioStream audio, int state)
        {
            if (state == 0)
                Debug.WriteLine("Test #2: lower global volume from 100 to 0");

            if (state >= 2)
            {
                Audio.Instance.SetVolume(100 - ((state - 2)*20));
                Debug.WriteLine("----> global volume set to: " + Audio.Instance.GetVolume());

                audio.Play();
            }

            return state == 7;
        }

        public int Flow(IAudioStream input, short[] obuf, int count, int volLeft, int volRight)
        {
            int pos = 0;
            int oend = count * 2;

            while (pos < oend)
            {
                // read enough input samples so that opos >= 0
                do
                {
                    // Check if we have to refill the buffer
                    if (inLen == 0)
                    {
                        inPtr = 0;
                        inLen = input.ReadBuffer(inBuf, RateHelper.IntermediateBufferSize);
                        if (inLen <= 0)
                            return pos / 2;
                    }
                    inLen -= (stereo ? 2 : 1);
                    opos--;
                    if (opos >= 0)
                    {
                        inPtr += (stereo ? 2 : 1);
                    }
                } while (opos >= 0);

                short out0, out1;
                out0 = inBuf[inPtr++];
                out1 = (stereo ? inBuf[inPtr++] : out0);

                // Increment output position
                opos += oposInc;

                // output left channel
                RateHelper.ClampedAdd(ref obuf[reverseStereo ? 1 : 0], (out0 * (int)volLeft) / Mixer.MaxMixerVolume);

                // output right channel
                RateHelper.ClampedAdd(ref obuf[(reverseStereo ? 1 : 0) ^ 1], (out1 * (int)volRight) / Mixer.MaxMixerVolume);

                pos += 2;
            }
            return pos / 2;
        }

        public bool Test3(IAudioStream audio, int state)
        {
            if (state == 0)
            {
                Audio.Instance.SetVolume(100);
                audio.Volume = 0;

                Debug.WriteLine("Test #3: raise individual volume from 0 to 100");
            }

            if (state >= 2)
            {
                audio.Volume = ((state - 2)*20);
                Debug.WriteLine("----> individual volume set to: " + audio.Volume);

                audio.Play();
            }

            return (state == 7);
        }

        public SoundHandle PlayStream(SoundType type, IAudioStream stream, int id = -1, int volume = 255,
            int balance = 0, bool autofreeStream = true, bool permanent = false, bool reverseStereo = false)
        {
            lock (_gate)
            {
                if (stream == null)
                {
                    //                    Console.Error.WriteLine("stream is null");
                    return new SoundHandle();
                }

                Debug.Assert(IsReady);

                // Prevent duplicate sounds
                if (id != -1)
                {
                    for (var i = 0; i != NumChannels; i++)
                        if (_channels[i] != null && _channels[i].Id == id)
                        {
                            // Delete the stream if were asked to auto-dispose it.
                            // Note: This could cause trouble if the client code does not
                            // yet expect the stream to be gone. The primary example to
                            // keep in mind here is QueuingAudioStream.
                            // Thus, as a quick rule of thumb, you should never, ever,
                            // try to play QueuingAudioStreams with a sound id.
                            if (autofreeStream)
                                stream.Dispose();
                            return new SoundHandle();
                        }
                }

                // Create the channel
                var chan = new Channel(this, type, stream, autofreeStream, reverseStereo, id, permanent)
                {
                    Volume = volume,
                    Balance = balance
                };
                return InsertChannel(chan);
            }
        }

        public int Flow(IAudioStream input, short[] obuf, int count, int volLeft, int volRight)
        {
            Debug.Assert(input.IsStereo == stereo);

            var osamp = count / 2;

            if (stereo)
                osamp *= 2;

            // Reallocate temp buffer, if necessary
            if (osamp > _bufferSize)
            {
                _buffer = new short[osamp];
                _bufferSize = osamp;
            }

            // Read up to 'osamp' samples into our temporary buffer
            var len = input.ReadBuffer(_buffer, _bufferSize);

            int iPos = 0;
            var oPos = 0;
            var inc = stereo ? 2 : 1;
            // Mix the data into the output buffer
            for (; iPos < len; iPos += inc)
            {
                var out0 = _buffer[iPos];
                var out1 = stereo ? _buffer[iPos + 1] : out0;

                // output left channel
                RateHelper.ClampedAdd(ref obuf[oPos + (reverseStereo ? 1 : 0)], (out0 * volLeft) / Mixer.MaxMixerVolume);

                // output right channel
                RateHelper.ClampedAdd(ref obuf[oPos + (reverseStereo ? 0 : 1)], (out1 * volRight) / Mixer.MaxMixerVolume);

                oPos += 2;
            }
            return oPos / 2;
        }

        public async Task<bool> StartRecorder(IAudioStream stream, Stream fileStream, int sampleRate)
        {
            if (this.stream != null || stream == null)
            {
                return false;
            }

            this.stream = stream;

            try
            {
                this.writer = new BinaryWriter(fileStream, Encoding.UTF8);
            }
            catch (Exception)
            {
                return false;
            }

            this.byteCount = 0;
            this.stream.OnBroadcast += OnStreamBroadcast;

            return await this.stream.Start(sampleRate);
        }

    private static eAudioDualMonoMode GetDualMonoMode(IAudioStream[] streams, int currentIndex, ref int priority,
                                                      ref int idxStreamIndexmpeg, ref string mpegBasedOnLang)
    {
      eAudioDualMonoMode dualMonoMode = eAudioDualMonoMode.UNSUPPORTED;
      string leftAudioLang = streams[currentIndex].Language.Substring(0, 3);
      string rightAudioLang = streams[currentIndex].Language.Substring(3, 3);

      int indexLeft = _preferredLanguages.IndexOf(leftAudioLang);
      if (indexLeft >= 0 && indexLeft < priority)
      {
        dualMonoMode = eAudioDualMonoMode.LEFT_MONO;
        mpegBasedOnLang = leftAudioLang;
        idxStreamIndexmpeg = currentIndex;
        priority = indexLeft;
      }

      int indexRight = _preferredLanguages.IndexOf(rightAudioLang);
      if (indexRight >= 0 && indexRight < priority)
      {
        dualMonoMode = eAudioDualMonoMode.RIGHT_MONO;
        mpegBasedOnLang = rightAudioLang;
        idxStreamIndexmpeg = currentIndex;
        priority = indexRight;
      }
      return dualMonoMode;
    }

    private static int GetFirstMpegIndex(IAudioStream[] streams)
    {
      int idxFirstMpeg = -1;

      for (int i = 0; i < streams.Length; i++)
      {
        if (!IsStreamAC3(streams[i]))
        {
          idxFirstMpeg = i;
          break;
        }
      }
      return idxFirstMpeg;
    }

 private static bool IsStreamAC3(IAudioStream stream)
 {
   return (stream.StreamType == AudioStreamType.AC3 ||
           stream.StreamType == AudioStreamType.EAC3);
 }

    private static void UpdateAudioStreamIndexesBasedOnLang(IAudioStream[] streams, int i, ref int idxStreamIndexmpeg,
                                                            ref int idxStreamIndexAc3, ref string mpegBasedOnLang,
                                                            ref int idxLangPriAc3, ref int idxLangPrimpeg,
                                                            ref string ac3BasedOnLang)
    {
      int langPriority = _preferredLanguages.IndexOf(streams[i].Language);
      string langSel = streams[i].Language;
      Log.Debug("Stream {0} lang {1}, lang priority index {2}", i, langSel, langPriority);

      // is the stream language preferred?
      if (langPriority >= 0)
      {
        // has the stream a higher priority than an old one or is this the first AC3 stream with lang pri (idxLangPriAc3 == -1) (AC3)
        bool isAC3 = IsStreamAC3(streams[i]);
        if (isAC3)
        {
          if (idxLangPriAc3 == -1 || langPriority < idxLangPriAc3)
          {
            Log.Debug("Setting AC3 pref");
            idxStreamIndexAc3 = i;
            idxLangPriAc3 = langPriority;
            ac3BasedOnLang = langSel;
          }
        }
        else //not AC3
        {
          // has the stream a higher priority than an old one or is this the first mpeg stream with lang pri (idxLangPrimpeg == -1) (mpeg)
          if (idxLangPrimpeg == -1 || langPriority < idxLangPrimpeg)
          {
            Log.Debug("Setting mpeg pref");
            idxStreamIndexmpeg = i;
            idxLangPrimpeg = langPriority;
            mpegBasedOnLang = langSel;
          }
        }
      }
    }

 private static void UpdateAudioStreamIndexesAndPrioritiesBasedOnLanguage(IAudioStream[] streams, int priority,
                                                                          ref int idxStreamIndexmpeg,
                                                                          ref string mpegBasedOnLang,
                                                                          ref int idxStreamIndexAc3,
                                                                          int idxLangPriAc3, int idxLangPrimpeg,
                                                                          ref string ac3BasedOnLang,
                                                                          out eAudioDualMonoMode dualMonoMode)
 {
   dualMonoMode = eAudioDualMonoMode.UNSUPPORTED;
   if (IsPreferredAudioLanguageAvailable())
   {
     for (int i = 0; i < streams.Length; i++)
     {
       //now find the ones based on LANG prefs.        
       if (ShouldApplyDualMonoMode(streams[i].Language))
       {
         dualMonoMode = GetDualMonoMode(streams, i, ref priority, ref idxStreamIndexmpeg, ref mpegBasedOnLang);
         if (dualMonoMode != eAudioDualMonoMode.UNSUPPORTED)
         {
           break;
         }
       }
       else
       {
         // lower value means higher priority
         UpdateAudioStreamIndexesBasedOnLang(streams, i, ref idxStreamIndexmpeg, ref idxStreamIndexAc3,
                                             ref mpegBasedOnLang, ref idxLangPriAc3, ref idxLangPrimpeg, ref ac3BasedOnLang);
       }
     }
   }
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AudioStreamParsedEventArgs"/> class.
 /// </summary>
 /// <param name="audioStream">The audio stream.</param>
 public AudioStreamParsedEventArgs(IAudioStream audioStream)
 {
     AudioStream = audioStream;
 }