private void Join()

        {

            string path = Application.StartupPath;

            WaveReader wr1 = new WaveReader(File.OpenRead(path + @"\one.wav"));

            IntPtr format = wr1.ReadFormat();

            byte[] data1 = wr1.ReadData();

            wr1.Close();

            WaveReader wr2 = new WaveReader(File.OpenRead(path + @"\two.wav"));

            byte[] data2 = wr2.ReadData();

            wr2.Close();

            WaveWriter ww = new WaveWriter(File.Create(path + @"\join.wav"), AudioCompressionManager.FormatBytes(format));

            ww.WriteData(data1);

            ww.WriteData(data2);

            ww.Close();

        }

        private void Convert()

        {

            WaveReader read = new WaveReader(File.OpenRead(@"g:\~data\123.wav"));

            IntPtr oldFormat = read.ReadFormat();

            WaveFormat wf = AudioCompressionManager.GetWaveFormat(oldFormat);

            byte[] oldData = read.ReadData();

            FormatDetails[] fdArr = AudioCompressionManager.GetFormatList(wf);

            IntPtr newFormat = fdArr[fdArr.Length - 1].FormatHandle;

            byte[] data = AudioCompressionManager.Convert(oldFormat, newFormat, oldData, true);

            WaveWriter write = new WaveWriter(File.OpenWrite(@"g:\~data\123_new.wav"),

            AudioCompressionManager.FormatBytes(newFormat));

            write.WriteData(data);

            write.Close();

            read.Close();

        }

     string voxFile = @"C:\AlvasAudio\8000.vox";

     string mp3File = @"C:\AlvasAudio\8000.mp3";

     Vox2Mp3(voxFile, 1, 16, 8000, mp3File);

     //-------

     private static void Vox2Mp3(string voxFile, short channels, short bitsPerSample, int samplesPerSec, string mp3File)

        {

           BinaryReader br = new BinaryReader(File.OpenRead(voxFile));

           MemoryStream pcmStream = new MemoryStream();

           IntPtr pcmFormat = AudioCompressionManager.GetPcmFormat(channels, bitsPerSample, samplesPerSec);

           WaveWriter ww = new WaveWriter(pcmStream, AudioCompressionManager.FormatBytes(pcmFormat));

           Vox.Vox2Wav(br, ww);

           br.Close();

           IntPtr mp3Format = AudioCompressionManager.GetCompatibleFormat(pcmFormat, AudioCompressionManager.MpegLayer3FormatTag);

           WaveReader wr = new WaveReader(pcmStream);

           byte[] pcmData = wr.ReadData();

           wr.Close();

           byte[] data = AudioCompressionManager.Convert(pcmFormat, mp3Format, pcmData, false);

           BinaryWriter bw = new BinaryWriter(File.Create(mp3File));

           bw.Write(data, 0, data.Length);

           ww.Close();

           bw.Close();

        }

using System;

using System.Data;

using System.Configuration;

using System.Web;

using System.Web.Security;

using System.Web.UI;

using System.Web.UI.WebControls;

using System.Web.UI.WebControls.WebParts;

using System.Web.UI.HtmlControls;

using Alvas.Audio;

using System.IO;

public partial class _Default : System.Web.UI.Page

{

    protected void Page_Load(object sender, EventArgs e)

    {

        ConvertAudio();

    }

    private void ConvertAudio()

    {

        string webFile = @"D:\AudioCS\bin\Debug\_web.mp3";

        string pcmFile = @"D:\AudioCS\bin\Debug\_AudioCS.wav";

        using (WaveReader wr = new WaveReader(File.OpenRead(pcmFile)))

        {

            IntPtr pcmFormat = wr.ReadFormat();

            byte[] pcmData = wr.ReadData();

            IntPtr webFormat = AudioCompressionManager.GetCompatibleFormat(pcmFormat,

            AudioCompressionManager.MpegLayer3FormatTag);

            byte[] webData = AudioCompressionManager.Convert(pcmFormat, webFormat,

            pcmData, false);

            MemoryStream ms = new MemoryStream();

            using (WaveWriter ww = new WaveWriter(ms,

            AudioCompressionManager.FormatBytes(webFormat)))

            {

                ww.WriteData(webData);

                using (WaveReader wr2 = new WaveReader(ms))

                {

                    using (FileStream fs = File.OpenWrite(webFile))

                    {

                        wr2.MakeMP3(fs);

                    }

                }

            }

        }

    }

}

            string path = @"c:\test.wav";

            WaveReader wr = new WaveReader(File.OpenRead(path));

            int durationInMS = wr.GetDurationInMS();

            wr.Close();

        Private Sub btnConvert_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnConvert.Click

            Dim inFile As String = "path_to_your_file.wav"

            Dim outFile As String = "path_to_output_file.mp3"

            Convert(inFile, outFile)

        End Sub

        Public Sub Convert(ByVal inFile As String, ByVal outFile As String)

            Dim inFs As FileStream = File.OpenRead(inFile)

            Dim wr As WaveReader = New WaveReader(inFs)

            Dim inFormat As IntPtr = wr.ReadFormat()

            Dim inData As Byte() = wr.ReadData

            Dim pcmFormat As IntPtr = AudioCompressionManager.GetCompatibleFormat(inFormat, AudioCompressionManager.PcmFormatTag)

            Dim pcmData As Byte() = AudioCompressionManager.Convert(inFormat, pcmFormat, inData, False)

            Dim mp3Format As IntPtr = AudioCompressionManager.GetCompatibleFormat(pcmFormat, AudioCompressionManager.MpegLayer3FormatTag)

            Dim mp3Data As Byte() = AudioCompressionManager.Convert(pcmFormat, mp3Format, pcmData, False)

            Dim outFs As MemoryStream = New MemoryStream()

            Dim ww As WaveWriter = New WaveWriter(outFs, AudioCompressionManager.FormatBytes(mp3Format))

            ww.WriteData(mp3Data)

            Dim outWr As WaveReader = New WaveReader(outFs)

            outWr.MakeMP3(File.Create(outFile))

            ww.Close()

        End Sub

        //---

        private static IntPtr GetFormat()

        {

            WaveFormat wf = new WaveFormat();

            wf.wFormatTag = AudioCompressionManager.MpegLayer3FormatTag;

            wf.nChannels = 1;

            wf.nSamplesPerSec = 11025;

            FormatDetails[] fdArr = AudioCompressionManager.GetFormatList(wf);

            foreach (FormatDetails fd in fdArr)

            {

                WaveFormat fdWf = AudioCompressionManager.GetWaveFormat(fd.FormatHandle);

                if (fdWf.nAvgBytesPerSec * 8 == 20000)

                {

                    return fd.FormatHandle;

                }

            }

            return IntPtr.Zero;

        }

            Vox2Pcm(@"C:\AlvasAudio\8000.vox", @"C:\AlvasAudio\8000.wav", 8000);

            Vox2Pcm(@"C:\AlvasAudio\6000.vox", @"C:\AlvasAudio\6000.wav", 6000);

            uLaw(@"C:\AlvasAudio\8000.pcm", @"C:\AlvasAudio\8000.pcm.wav");

        //-------

        private static void uLaw(string inFile, string outFile)

        {

            BinaryReader br = new BinaryReader(File.OpenRead(inFile));

            byte[] data = new byte[br.BaseStream.Length];

            br.Read(data, 0, data.Length);

            WaveFormat wf = new WaveFormat();

            wf.nChannels = 1;

            wf.nSamplesPerSec = 8000;

            wf.wFormatTag = AudioCompressionManager.MuLawFormatTag;

            FormatDetails[] fdArr = AudioCompressionManager.GetFormatList(wf);

            IntPtr format = fdArr[0].FormatHandle;

            WaveWriter ww = new WaveWriter(File.Create(outFile),

            AudioCompressionManager.FormatBytes(format));

            ww.WriteData(data);

        }

        private static void Vox2Pcm(string inFile, string outFile, int samplesPerSec)

        {

            BinaryReader br = new BinaryReader(File.OpenRead(inFile));

            IntPtr format = AudioCompressionManager.GetPcmFormat(1, 16, samplesPerSec);

            WaveWriter ww = new WaveWriter(File.Create(outFile),

            AudioCompressionManager.FormatBytes(format));

            Vox.Vox2Wav(br, ww);

            br.Close();

            ww.Close();

        }

            Wav2Vox(@"C:\AlvasAudio\6000.wav", @"C:\AlvasAudio\6000.wav.vox", 8000);

        private static void Wav2Vox(string inFile, string outFile, int samplesPerSec)

        {

            WaveReader wr = new WaveReader(File.OpenRead(inFile));

            IntPtr format = wr.ReadFormat();

            byte[] data = wr.ReadData();

            wr.Close();

            WaveFormat wf = AudioCompressionManager.GetWaveFormat(format);

            if (wf.wFormatTag != AudioCompressionManager.PcmFormatTag)//Decode if not PCM data

            {

                Decode2Pcm(ref format, ref data, ref wf);

            }

            if (wf.nSamplesPerSec != samplesPerSec)

            {

                Resample(ref format, ref data, ref wf, samplesPerSec);

            }

            BinaryWriter bw = new BinaryWriter(File.OpenWrite(outFile));

            BinaryReader br = new BinaryReader(new MemoryStream(data));

            Vox.Raw2Vox(br, bw, wf.wBitsPerSample);

            br.Close();

            bw.Close();

        }

        private static void Resample(ref IntPtr format, ref byte[] data, ref WaveFormat wf,

        int samplesPerSec)

        {

            foreach (FormatDetails fd in

            AudioCompressionManager.GetCompatibleFormatList(format))

            {

                if (fd.FormatTag == AudioCompressionManager.PcmFormatTag)

                {

                    WaveFormat wfFd = AudioCompressionManager.GetWaveFormat(fd.FormatHandle);

                    if (wf.wBitsPerSample == wfFd.wBitsPerSample && wf.nChannels ==

                    wfFd.nChannels && wfFd.nSamplesPerSec == samplesPerSec)

                    {

                        byte[] buffer = AudioCompressionManager.Convert(format, fd.FormatHandle, data, false);

                        format = fd.FormatHandle;

                        data = buffer;

                        wf = wfFd;

                    }

                }

            }

        }

        private static void Decode2Pcm(ref IntPtr format, ref byte[] data, ref WaveFormat wf)

        {

            IntPtr newFormat = AudioCompressionManager.GetCompatibleFormat(format,

            AudioCompressionManager.PcmFormatTag);

            byte[] buffer = AudioCompressionManager.Convert(format, newFormat, data, false);

            wf = AudioCompressionManager.GetWaveFormat(newFormat);

            format = newFormat;

            data = buffer;

        }

        PlayerEx pl = new PlayerEx();

        private static void PlayArray(PlayerEx pl)

        {

            double fs = 8000; // sample freq

            double freq = 1000; // desired tone

            short[] mySound = new short[4000];

            for (int i = 0; i < 4000; i++)

            {

                double t = (double)i / fs; // current time

                mySound[i] = (short)(Math.Cos(t * freq) * (short.MaxValue));

            }

            IntPtr format = AudioCompressionManager.GetPcmFormat(1, 16, (int)fs);

            pl.OpenPlayer(format);

            byte[] mySoundByte = new byte[mySound.Length * 2];

            Buffer.BlockCopy(mySound, 0, mySoundByte, 0, mySoundByte.Length);

            pl.AddData(mySoundByte);

            pl.StartPlay();

        }

            Wav2Sln(@"C:\AlvasAudio\obrigada.wav", @"C:\AlvasAudio\obrigada.sln");

        //---

        private static void Wav2Sln(string inFile, string outFile)

        {

            IntPtr newFormat = AudioCompressionManager.GetPcmFormat(1, 16, 8000);

            WaveReader wr = new WaveReader(File.OpenRead(inFile));

            IntPtr oldFormat = wr.ReadFormat();

            byte[] data = wr.ReadData();

            wr.Close();

            byte[] buffer = AudioCompressionManager.Convert(oldFormat, newFormat, data, false);

            using (BinaryWriter bw = new BinaryWriter(File.Create(outFile)))

            {

                bw.Write(buffer, 0, buffer.Length);

            }

        }

            string pcmFile = @"C:\AlvasAudio\obrigada.wav";

            string alawFile = @"C:\AlvasAudio\obrigada.alaw";

            Pcm2ALaw(pcmFile, alawFile);

        //---

        private static void Pcm2ALaw(string wavFile, string alawFile)

        {

            WaveReader wr = new WaveReader(File.OpenRead(wavFile));

            IntPtr format = wr.ReadFormat();

            byte[] data = wr.ReadData();

            wr.Close();

            WaveFormat wfAlaw = new WaveFormat();

            wfAlaw.wFormatTag = AudioCompressionManager.ALawFormatTag;

            wfAlaw.nChannels = 1;

            wfAlaw.nSamplesPerSec = 8000;

            FormatDetails[] fdArr = AudioCompressionManager.GetFormatList(wfAlaw);

            WaveFormat wf = AudioCompressionManager.GetWaveFormat(format);

            if (wf.wFormatTag != AudioCompressionManager.PcmFormatTag)//Decode if not PCM data

            {

                Decode2Pcm(ref format, ref data, ref wf);

            }

            if (wf.nSamplesPerSec != wfAlaw.nSamplesPerSec || wf.nChannels != wfAlaw.nChannels)

            {

                Resample(ref format, ref data, ref wf, wfAlaw.nSamplesPerSec, wfAlaw.nChannels);

            }

            byte[] buffer = AudioCompressionManager.Convert(format, fdArr[0].FormatHandle, data, false);

            BinaryWriter bw = new BinaryWriter(File.Create(alawFile));

            bw.Write(buffer, 0, buffer.Length);

            bw.Close();

        }

        private static void Resample(ref IntPtr format, ref byte[] data, ref WaveFormat wf, int samplesPerSec, short channels)

        {

            IntPtr newFormat = AudioCompressionManager.GetPcmFormat(channels, wf.wBitsPerSample, samplesPerSec);

            byte[] buffer = AudioCompressionManager.Convert(format, newFormat, data, true);

            format = newFormat;

            wf = AudioCompressionManager.GetWaveFormat(newFormat);

            data = buffer;

        }

        private static void Decode2Pcm(ref IntPtr format, ref byte[] data, ref WaveFormat wf)

        {

            IntPtr newFormat = AudioCompressionManager.GetCompatibleFormat(format,

            AudioCompressionManager.PcmFormatTag);

            byte[] buffer = AudioCompressionManager.Convert(format, newFormat, data, false);

            wf = AudioCompressionManager.GetWaveFormat(newFormat);

            format = newFormat;

            data = buffer;

        }

            ChangeSpeed(@"g:\AlvasAudio\obrigada.wav", @"g:\AlvasAudio\obrigada1.wav", 50);//two times as quickly

            ChangeSpeed(@"g:\AlvasAudio\obrigada.wav", @"g:\AlvasAudio\obrigada2.wav", 200);//two times as slowly

        public static void ChangeSpeed(string inFile, string outFile, int persent)

        {

            if (persent < 1)

            {

                throw new ArgumentOutOfRangeException("persent");

            }

            WaveReader wr = new WaveReader(File.OpenRead(inFile));

            IntPtr inFormat = wr.ReadFormat();

            byte[] data = wr.ReadData();

            wr.Close();

            WaveWriter ww = new WaveWriter(File.Create(outFile), AudioCompressionManager.FormatBytes(inFormat));

            WaveFormat wf = AudioCompressionManager.GetWaveFormat(inFormat);

            WaveFormat wfPrev = wf;

            if (wf.wFormatTag != AudioCompressionManager.PcmFormatTag)//Decode if not PCM da

            {

                Decode2Pcm(ref inFormat, ref data, ref wf);

            }

            int samplesPerSecond = wf.nSamplesPerSec * persent / 100;

            IntPtr pcmFormat = AudioCompressionManager.GetPcmFormat(wf.nChannels, wf.wBitsPerSample, samplesPerSecond);

            byte[] buffer = AudioCompressionManager.Convert(inFormat, pcmFormat, data, false);

            if (!wfPrev.Equals(wf))

            {

                buffer = AudioCompressionManager.Convert(inFormat, ww.GetFormat(), buffer, false);

            }

            ww.WriteData(buffer);

            ww.Close();

        }