public static void PlayFromFile(string filename, int frequency)
        {
            using (
               FileStream stream = new FileStream(filename, FileMode.Open))
            {
                var waveFormat = WaveFormat.CreateMuLawFormat(frequency * 2, 1);
                var reader = new NAudio.Wave.RawSourceWaveStream(stream, waveFormat);
                using (WaveStream convertedStream = WaveFormatConversionStream.CreatePcmStream(reader))
                {

                    convertedStream.Seek(0, 0);
                    WaveOutEvent player = new WaveOutEvent();
                    WaveChannel32 volumeStream = new WaveChannel32(convertedStream);
                    player.Init(volumeStream);
                    player.Play();

                    while (player.PlaybackState == PlaybackState.Playing)
                    {
                        System.Threading.Thread.Sleep(100);
                        var input = Console.ReadKey();
                        if (input.KeyChar > 1) ;
                        {
                            player.Stop();
                        }

                    }
                }
            }
        }

        public Form1()
        {
            _serialPort.PortName = "COM6";
            _serialPort.BaudRate = 9600;
            _serialPort.Parity = Parity.None;
            _serialPort.DataBits = 8;
            _serialPort.StopBits = StopBits.Two;
            _serialPort.Handshake = Handshake.None;
            _serialPort.DataReceived += new SerialDataReceivedEventHandler(sp_DataReceived);

            _serialPort.Open();

            //Set up audio outputs
            jaws[0] = new WaveOut();
            jaws[1] = new WaveOut();
            jaws[2] = new WaveOut();

            var jawsAudio1 = new WaveChannel32(new WaveFileReader("Sounds/Jaws3.wav"));
            jaws[0].Init(jawsAudio1);
            var jawsAudio2 = new LoopStream(new WaveFileReader("Sounds/Jaws2.wav"));
            jaws[1].Init(jawsAudio2);
            var jawsAudio3 = new LoopStream(new WaveFileReader("Sounds/Jaws1.wav"));
            jaws[2].Init(jawsAudio3);

            //Set the shark to a random position
            resetShark();

            InitializeComponent();
        }

        // set everything up
        public BonIverStemPlayer(Engine.Engine engine) {
            mixer.AutoStop = false;
            waveOutDevice.Init(mixer);
            Engine = engine;

            // load in each of our files
            reader[0] = new WaveFileReader(@"C:\\Users\\Badger\\repos\\balloon\\SkeletalTracking\\boniver\\bangorkook.wav");
            reader[1] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\chippewa_falls.wav");
            reader[2] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\eleva.wav");
            reader[3] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\gilman.wav");
            reader[4] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\grand_rapids.wav");
            reader[5] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\heigh_on.wav");
            reader[6] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\lake_hallie.wav");
            reader[7] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\le_grange_wi.wav");
            reader[8] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\long_plain.wav");
            reader[9] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\mandolin_wa.wav");
            reader[10] = new WaveFileReader(@"C:\Users\Badger\repos\balloon\SkeletalTracking\boniver\virginia.wav");

            // set the starting positions
            // and load into the mixer
            for (int i = 0; i < 11; i++) {
                channelStream[i] = new WaveChannel32(reader[i]);
                channelStream[i].Position = 0;
                mixer.AddInputStream(channelStream[i]);
            }
        }

        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;
        }

        public AudioSample(string fileName)
        {
            _fileName = fileName;
            WaveFileReader reader = new WaveFileReader(fileName);
            //offsetStream = new WaveOffsetStream(reader);
            //channelStream = new WaveChannel32(offsetStream);
            channelStream = new WaveChannel32(reader);
            muted = false;
            volume = 1.0f;



            #region ReverseStuff

            //Code to reverse
            NAudioBufferReverse nbr = new NAudioBufferReverse();
            reversedSample = new byte[(int)channelStream.Length];
            channelStream.Read(reversedSample, 0, (int)channelStream.Length);
            bytesPerSample = (channelStream.WaveFormat.BitsPerSample / 8) * channelStream.WaveFormat.Channels;
            reversedSample = nbr.reverseSample(reversedSample, (int)channelStream.Length, bytesPerSample);

            #endregion


        }

        public TestMix()
        {
            //WaveStream str1 = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\guitar1.mp3");
            //WaveStream str2 = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\molecules.mp3");
            //WaveMixerStream32 mix = new WaveMixerStream32(new [] {str1, str2}, false);

            var background = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\ferriss.mp3");
            var message = new Mp3FileReader("C:\\Users\\mtemkine\\Desktop\\snd\\guitar1.mp3");

            var mixer = new WaveMixerStream32();
            mixer.AutoStop = true;

            var messageOffset = background.TotalTime;
            var messageOffsetted = new WaveOffsetStream(message, TimeSpan.FromSeconds(1.5), TimeSpan.Zero, message.TotalTime.Subtract(TimeSpan.FromSeconds(1)));

            var background32 = new WaveChannel32(background);
            background32.PadWithZeroes = false;
            background32.Volume = 0.9f;

            var message32 = new WaveChannel32(messageOffsetted);
            message32.PadWithZeroes = false;
            message32.Volume = 0.7f;

            var s1 = new RawSourceWaveStream(background32, new WaveFormat(8000, 16, 1));
            var s2 = new RawSourceWaveStream(message32, new WaveFormat(8000, 16, 1));
            WaveFormat targetFormat = WaveFormat.CreateIeeeFloatWaveFormat(128, 2);
            var ss1 = new WaveFormatConversionStream(targetFormat, background32);
            //var c = new WaveFormatConversionStream(WaveFormat.CreateALawFormat(8000, 1), background32);
            //var stream_background32 = new WaveFormatConversionStream(new WaveFormat(256, 32, 2), background32);
            //var stream_message32 = new WaveFormatConversionStream(new WaveFormat(256, 32, 2), message32);
            mixer.AddInputStream(s1);
            mixer.AddInputStream(s2);

            WaveFileWriter.CreateWaveFile("mycomposed.wav", new Wave32To16Stream(mixer));
        }

        public PianoSynth()
        {
            mixer = new WaveMixerStream32();
            mixer.AutoStop = false;

            int i = 0;
            foreach (var note in noteFiles)
            {
                reader[i] = new WaveFileReader(note);

                offsetStream[i] = new WaveOffsetStream(reader[i]);
                channelSteam[i] = new WaveChannel32(offsetStream[i]);
                channelSteam[i].Position = channelSteam[i].Length;
                mixer.AddInputStream(channelSteam[i]);

                i++;
            }

            if (waveOutDevice == null)
            {
                waveOutDevice = new WaveOut {DeviceNumber = 0};
                waveOutDevice.Init(mixer);
                waveOutDevice.Volume = 0;
                waveOutDevice.Play();
                waveOutDevice.Volume = 100;
            }
        }

 public void playbackFile(string filename)
 {
     WaveFileReader reader = new WaveFileReader(filename);
     WaveChannel32 channelStream = new WaveChannel32(reader);
     mixer.AddInputStream(channelStream);
     channelStream.Position = 0;
 }

        public void LoadFile()
        {
            var wave = new WaveChannel32(new Mp3FileReader(@"file.mp3"));

            var buffer = new byte[16384*2];
            var read = 0;

            var i = 0;
            while (wave.Position < wave.Length)
            {
                read = wave.Read(buffer, 0, 16384*2);

                var max = 0f;
                var absMax = 0f;
                for (int j = 0; j < read / 4; j++)
                {
                    var s = BitConverter.ToSingle(buffer, j*4);
                    var abs = Math.Abs(s);
                    if (abs > absMax)
                    {
                        absMax = abs;
                        max = s;
                    }
                }
                Samples.Add(new TLSample(i += 2, max));
            }
        }

 public MixDiffStream(string fileName)
 {
     WaveFileReader reader = new WaveFileReader(fileName);
     offsetStream = new WaveOffsetStream(reader);
     channelSteam = new WaveChannel32(offsetStream);
     muted = false;
     volume = 1.0f;
 }

		public void SetInputWave(string waveInputFilePath, float volume) {
			// 4 bytes per sample (32 bit)
			this.wavFileReader = new WaveFileReader(waveInputFilePath);
			this.wavStream = new WaveChannel32(this.wavFileReader);
			
			// Leave headroom for plugin processing (0.20 seems OK, any higher causes digital clipping)
			this.wavStream.Volume = volume;
		}

        public MixerForm(WaveChannel32 channel)
        {
            InitializeComponent();

            waveChannel = channel;
            tbPan.Value = 50+(int)(channel.Pan*50.0f);
            tbVolume.Value = (int)(channel.Volume*100.0f);
        }

 public Key(string name, string sampleFile)
 {
     this.notePitch = name;
         WaveFileReader reader = new WaveFileReader(sampleFile);
         offsetStream = new WaveOffsetStream(reader);
         channelStream = new WaveChannel32(offsetStream);
         channelStream.Position = channelStream.Length;
 }

 private static WaveChannel32 OpenMp3Stream(string fileName)
 {
     WaveChannel32 inputStream;
     WaveStream mp3Reader = new Mp3FileReader(fileName);
     WaveStream pcmStream = WaveFormatConversionStream.CreatePcmStream(mp3Reader);
     WaveStream blockAlignedStream = new BlockAlignReductionStream(pcmStream);
     inputStream = new WaveChannel32(blockAlignedStream);
     return inputStream;
 }

        private static WaveStream CreateInputStream(byte[] mediacontent)
        {
            var memoryStream = new MemoryStream(mediacontent);
            var mp3Reader = new Mp3FileReader(memoryStream);

            var inputStream = new WaveChannel32(mp3Reader);

            return inputStream;
        }

        private static void AddIntroOutro(string SermonFileName = "",
            string IntroFileName = "",
            string OutroFileName = "",
            double StartSermonTime = 0,
            double StartOutroTime = 0,
            string ResultingFile = "")
        {
            if (String.IsNullOrWhiteSpace(SermonFileName)) throw new ArgumentException("SermonFileName must reference a valid file.");

            if (String.IsNullOrWhiteSpace(IntroFileName)) throw new ArgumentException("IntroFileName must reference a valid file.");

            if (String.IsNullOrWhiteSpace(OutroFileName)) throw new ArgumentException("OutroFileName must reference a valid file.");

            if (String.IsNullOrWhiteSpace(ResultingFile)) ResultingFile = Settings.Default.IntroOutroDirectory;

            WaveFileReader intro = new WaveFileReader(IntroFileName);
            WaveFileReader outro = new WaveFileReader(OutroFileName);
            WaveFileReader audio = new WaveFileReader(SermonFileName);

            WaveMixerStream32 mixer = new WaveMixerStream32();
            //mixer.AutoStop;

            WaveOffsetStream audioOffsetted = new WaveOffsetStream(
                audio,
                TimeSpan.FromSeconds(StartSermonTime), //N seconds after start of intro.
                TimeSpan.Zero,
                audio.TotalTime);

            TimeSpan outroOffset = TimeSpan.FromSeconds(StartSermonTime) + audio.TotalTime - TimeSpan.FromSeconds(StartOutroTime);

            WaveOffsetStream outroOffsetted = new WaveOffsetStream(
               outro,
               outroOffset,
               TimeSpan.Zero,
               outro.TotalTime);

            WaveChannel32 intro32 = new WaveChannel32(intro);
            intro32.PadWithZeroes = false;
            mixer.AddInputStream(intro32);

            WaveChannel32 outro32 = new WaveChannel32(outroOffsetted);
            outro32.PadWithZeroes = false;
            mixer.AddInputStream(outro32);

            WaveChannel32 audio32 = new WaveChannel32(audioOffsetted);
            audio32.PadWithZeroes = false;
            mixer.AddInputStream(audio32);

            FileInfo file = new FileInfo(SermonFileName);
            if (!Directory.Exists(ResultingFile)) Directory.CreateDirectory(ResultingFile);

            string FileOut = String.Format(@"{0}\{1}", ResultingFile, file.Name);

            WaveFileWriter.CreateWaveFile(FileOut, new Wave32To16Stream(mixer));
        }

 public void CanCreateWavFileFromWaveChannel32()
 {
     string inFile = @"F:\Recording\wav\pcm\16bit mono 8kHz.wav";
     string outFile = @"F:\Recording\wav\pcm\32bit stereo 8kHz.wav";
     if (!File.Exists(inFile))
     {
         Assert.Ignore("Input test file not found");
     }
     var audio32 = new WaveChannel32(new WaveFileReader(inFile));
     audio32.PadWithZeroes = false;
     WaveFileWriter.CreateWaveFile(outFile, audio32);
 }

        private static WaveStream CreateInputStream(string fileName)
        {
            WaveChannel32 inputStream;
            WaveStream readerStream = null;

            if (fileName.EndsWith(".wav"))
            {
                readerStream = new WaveFileReader(fileName);
            }
            //else if (fileName.EndsWith(".wma"))
            //{
            //    //                readerStream = new WMAFileReader2(fileName);

            //    MemoryStream memoryStream = new MemoryStream();
            //    using (FileStream infile = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            //    {
            //        while (infile.Position < infile.Length)
            //        {
            //            byte data = (byte)infile.ReadByte();
            //            memoryStream.WriteByte(data);
            //        }
            //    }
            //    memoryStream.Position = 0;
            //    readerStream = new WMAFileReader2(memoryStream);
            //}
            else
            {
                throw new InvalidOperationException("Unsupported extension");
            }

            // Provide PCM conversion if needed
            if (readerStream.WaveFormat.Encoding != WaveFormatEncoding.Pcm)
            {
                readerStream = WaveFormatConversionStream.CreatePcmStream(readerStream);
                readerStream = new BlockAlignReductionStream(readerStream);
            }

            // Provide conversion to 16 bits if needed
            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);

            return inputStream;
        }

 public MyItemControl(Word word)
 {
     InitializeComponent();
     _word = word;
     Picture = null;// con.ByteToWPFImage(word.Picture);
     waveReader = new WaveFileReader(con.byteArrayToStream(_word.Sound));
     SoundLength = waveReader.TotalTime;
     wc = new WaveChannel32(waveReader);
     audioOutput = new DirectSoundOut();
     audioOutput.Init(wc);
     track.ValueChangedManually += track_PositionChangedManually;
     myTrack.ValueChangedManually += track_PositionChangedManually;
     myTrack.MouseLeftButtonDown += track_MouseLeftButtonDown;
     myTrack.Loaded += track_Loaded;
 }

 private WaveStream CreateInputStream(string fileName)
 {
     WaveChannel32 inputstream;
     if (fileName.EndsWith(".mp3"))
     {
         WaveStream mp3Reader = new Mp3FileReader(fileName);
         inputstream = new WaveChannel32(mp3Reader);
     }
     else
     {
         throw new InvalidOperationException("Unsupported extension");
     }
     volumeStream = inputstream;
     return volumeStream;
 }