Exemplo n.º 1
0
 public void StartRecord(byte poId)
 {
     if (!IsRecording)
     {
         this.CurrentPOId = poId;
         _waveFile        = new WAVFile();
         _waveFile.Create(NewRecordFileName(), false, 8000, 8);
         //this.IsPaused = false;
         this.PausedTime = null;
     }
 }
Exemplo n.º 2
0
        public void TestMethod1()
        {
            var bg   = BackgroundSound.Instance;
            var wave = new WAVFile();

            wave.Create("dv.wav", false, 8000, 8);

            wave.AddSample_ByteArray(bg.Sounds[2]);

            //var si = new byte[8000 * 5];
            //wave.AddSample_ByteArray(si);
            wave.Close();
        }
Exemplo n.º 3
0
        /// <summary>
        /// creats a wav file of the given bitmap under the given name.
        /// </summary>
        /// <param name="bitmap">btimap to creat a wav file of</param>
        /// <param name="name"></param>
        public void createWav(Bitmap bitmap, string name, bool create_img)
        {
            _myEyeMusic.model.bmpName = name;
            bitmap = managementGUI.resizeImage(bitmap, _scanWidth, _scanHeight, _myEyeMusic.ResizeMode);
            Rectangle rect = new Rectangle(0, 0, bitmap.Width, bitmap.Height);

            System.Drawing.Imaging.BitmapData bmpData = bitmap.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat);

            float[,] imArr = ReconstructColor(bmpData);
            bitmap.UnlockBits(bmpData);

            if (create_img)
            {
                Bitmap clusteredImage = generatePostClassifictionBitmap(imArr);
                // display image
                _myEyeMusic.setScanPictureBoxes(clusteredImage, name);
            }

            WAVFile sonifiedWAV = new WAVFile();

            sonifiedWAV.Create(_myEyeMusic.OutDirectory + "\\" + name + ".wav", false, 44100, 16);
            double volume = _myEyeMusic.MyVolume;

            if (_myEyeMusic.MyCueType.Equals(eyeMusic2.CueType.NoCue))
            {
                volume = 0.0;
            }

            short   sample;
            WAVFile cueWAVFile = new WAVFile();             // adding cue

            cueWAVFile.Open(_cueTypeFileName, WAVFile.WAVFileMode.READ);
            for (int j = 0; j < cueWAVFile.NumSamples; j++)
            {
                sample = (short)(volume * cueWAVFile.GetNextSample_16bit());
                sample = Math.Min(short.MaxValue, sample);
                sonifiedWAV.AddSample_16bit(sample);
            }
            cueWAVFile.Close();
            for (int i = 0; i < _scanWidth; i++)
            {
                createMixer(i, sonifiedWAV, imArr);
            }
            if (sonifiedWAV != null)
            {
                sonifiedWAV.Close();
            }
        }
Exemplo n.º 4
0
        /// <summary>
        ///     Store a wavfile generated from the provided sample at the specified location.
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="sample"></param>
        private static void StoreWAV(string filename, Sample sample)
        {
            var wav = new WAVFile();

            // TODO: Clamp Sample.BitDepth to 8/16 (or not?)
            wav.Create(filename, false, (int)sample.SampleRate, (short)sample.BitDepth, true);
            if (sample.BitDepth == 8)
            {
                for (int i = 0; i < sample.SampleCount; i++)
                {
                    // Need to add 128 because AddSample_8bit takes unsigned bytes.
                    wav.AddSample_8bit((byte)(sample.ValueAt(i * sample.Resolution) + 128));
                }
            }
            else // Assume 16-bit for now.
            {
                for (int i = 0; i < sample.SampleCount; i++)
                {
                    wav.AddSample_16bit((short)sample.ValueAt(i * sample.Resolution));
                }
            }
            wav.Close();
        }
Exemplo n.º 5
0
        // STAThread is ESSENTIAL to make this work
		[STAThread] public static void Main(string[] args)
		{
            // no messing, this is high priority stuff
			Thread.CurrentThread.Priority = ThreadPriority.Highest;
            Process myP = Process.GetCurrentProcess();
            myP.ProcessorAffinity = (IntPtr)1;
            
			// make sure we have at least one ASIO driver installed
			if (AsioDriver.InstalledDrivers.Length == 0)
			{
				Console.WriteLine("There appears to be no ASIO drivers installed on your system.");
				Console.WriteLine("If your soundcard supports ASIO natively, install the driver");
				Console.WriteLine("from the support disc. If your soundcard has no native ASIO support");
				Console.WriteLine("you can probably use the generic ASIO4ALL driver.");
				Console.WriteLine("You can download this from: http://www.asio4all.com/");
				Console.WriteLine("It's very good!");
				Console.WriteLine();
				Console.WriteLine("Hit Enter to exit...");
				Console.ReadLine();
				return;
			}

            // bingo, we've got at least one
			Console.WriteLine("Your system has the following ASIO drivers installed:");
			Console.WriteLine();

            // so iterate through them
			for (int index = 0; index < AsioDriver.InstalledDrivers.Length; index++)
			{
                // and display them
				Console.WriteLine(string.Format("  {0}. {1}", index + 1, AsioDriver.InstalledDrivers[index]));
			}

			Console.WriteLine();

			int driverNumber = 0;

            // get them to choose one
			while (driverNumber < 1 || driverNumber > AsioDriver.InstalledDrivers.Length)
			{
				// we'll keep telling them this until they make a valid selection
				Console.Write("Select which driver you wish to use (x for exit): ");
				ConsoleKeyInfo key = Console.ReadKey();
				Console.WriteLine();

				// deal with exit condition
				if (key.KeyChar == 'x') return;

				// convert from ASCII to int
				driverNumber = key.KeyChar - 48;
			}

			Console.WriteLine();
			Console.WriteLine("Using: " + AsioDriver.InstalledDrivers[driverNumber - 1]);
			Console.WriteLine();

			// load and activate the desited driver
			AsioDriver driver = AsioDriver.SelectDriver(AsioDriver.InstalledDrivers[driverNumber - 1]);

			// popup the driver's control panel for configuration
            driver.ShowControlPanel();

			// now dump some details
            Console.WriteLine("  Driver name = " + driver.DriverName);
            Console.WriteLine("  Driver version = " + driver.Version);
            Console.WriteLine("  Input channels = " + driver.NumberInputChannels);
            Console.WriteLine("  Output channels = " + driver.NumberOutputChannels);
            Console.WriteLine("  Min buffer size = " + driver.BufferSizex.MinSize);
            Console.WriteLine("  Max buffer size = " + driver.BufferSizex.MaxSize);
            Console.WriteLine("  Preferred buffer size = " + driver.BufferSizex.PreferredSize);
            Console.WriteLine("  Granularity = " + driver.BufferSizex.Granularity);
            Console.WriteLine("  Sample rate = " + driver.SampleRate);

			// get our driver wrapper to create its buffers
			driver.CreateBuffers(false);

			// write out the input channels
            Console.WriteLine("  Input channels found = " + driver.InputChannels.Length);
			Console.WriteLine("  ----");

            foreach (Channel channel in driver.InputChannels)
			{
				Console.WriteLine(channel.Name);
			}

			// and the output channels
            Console.WriteLine("  Output channels found = " + driver.OutputChannels.Length);
            Console.WriteLine("----");

            foreach (Channel channel in driver.OutputChannels)
			{
				Console.WriteLine(channel.Name);
			}

            Console.Write("Select which effect you wish to use (1 = delay, 2 = flanger, 3 = phaser, 4 = reverb): ");
            ConsoleKeyInfo useEffect = Console.ReadKey();
            if (useEffect.KeyChar == '1')
                effectType = effect.delay;
            else if (useEffect.KeyChar == '2')
                effectType = effect.flanger;
            else if (useEffect.KeyChar == '3')
                effectType = effect.phaser;
            else if (useEffect.KeyChar == '4')
                effectType = effect.reverb;
            else
                effectType = effect.none;



            // create standard sized buffers with a size of PreferredSize x MaxBuffers 
            _delayBuffer = new float[driver.BufferSizex.PreferredSize, MaxBuffers];

            // create a feedback buffer for the delay effect
            _delayFBbuffer = new float[driver.BufferSizex.PreferredSize, MaxBuffers];

            // create a input buffer for reverb effect
            _delayINbuffer = new float[driver.BufferSizex.PreferredSize, MaxBuffers];

            // create a output buffer for reverb effect
            _delayOUTbuffer = new float[driver.BufferSizex.PreferredSize, MaxBuffers];

            // this is our buffer fill event we need to respond to
            driver.BufferUpdate += new EventHandler(AsioDriver_BufferUpdate);

            // and off we go
            driver.Start();

            // create a wav file for recording
            wav.Create("test.wav", true, 44100, 16);

            // wait for enter key
            Console.WriteLine();
            Console.WriteLine("Press Enter to end");
			Console.ReadLine();

            // and all done
            driver.Stop();

            // close the wav file
            wav.Close();

        }
Exemplo n.º 6
0
    // Added by Ali Adams
    public static void GenerateWAVFile(ref string path, List<long> values, int frequency)
    {
        WAVFile wavfile = new WAVFile();
        // update ref path.csv to .wav
        path = path.Substring(0, path.Length - 4) + ".wav";
        wavfile.Create(path, false, frequency, 8);

        Normalize(ref values, 0L, 255L);

        //byte[] bytes = new byte[4 * values.Count];
        //for (int i = 0; i < values.Count; i++)
        //{
        //    int j = 4 * i;
        //    bytes[j + 0] = (byte)(values[i] >>  0 & 0xFF);
        //    bytes[j + 1] = (byte)(values[i] >>  8 & 0xFF);
        //    bytes[j + 2] = (byte)(values[i] >> 16 & 0xFF);
        //    bytes[j + 3] = (byte)(values[i] >> 24 & 0xFF);
        //    wavfile.AddSample_8bit(bytes[j + 0]);
        //    wavfile.AddSample_8bit(bytes[j + 1]);
        //    wavfile.AddSample_8bit(bytes[j + 2]);
        //    wavfile.AddSample_8bit(bytes[j + 3]);
        //}

        byte[] bytes = new byte[values.Count];
        for (int i = 0; i < values.Count; i++)
        {
            wavfile.AddSample_8bit((byte)(values[i]));
        }

        // write the wavefile
        wavfile.Close();
    }
Exemplo n.º 7
0
    /// <summary>
    /// Converts a WAV file's bits/sample and number of channels to a separate WAV file.
    /// </summary>
    /// <param name="pSrcFilename">The name of the file to convert</param>
    /// <param name="pDestFilename">The destination file name</param>
    /// <param name="pBitsPerSample">The destination's number of bits/sample</param>
    /// <param name="pStereo">Whether or not the destination should be stereo</param>
    /// <param name="pVolumeMultiplier">A multiplier that can be used to adjust the volume of the output audio file</param>
    public static void CopyAndConvert(String pSrcFilename, String pDestFilename, short pBitsPerSample, bool pStereo, double pVolumeMultiplier)
    {
        WAVFile srcFile = new WAVFile();
        String retval = srcFile.Open(pSrcFilename, WAVFileMode.READ);
        if (retval.Length > 0)
            throw new WAVFileException(retval, "WAVFile.Convert_Copy()");

        WAVFile destFile = new WAVFile();
        destFile.Create(pDestFilename, pStereo, srcFile.SampleRateHz, pBitsPerSample);
        if ((srcFile.BitsPerSample == 8) && (pBitsPerSample == 8))
        {
            byte sample = 0;
            if (srcFile.IsStereo && !pStereo)
            {
                // 8-bit to 8-bit, stereo to mono: Average each 2 samples
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = (byte)((short)((short)srcFile.GetNextSample_8bit() + (short)srcFile.GetNextSample_8bit()) / 2);
                    if (pVolumeMultiplier != 1.0)
                        sample = (byte)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_8bit(sample);
                }
            }
            else if ((srcFile.IsStereo && pStereo) || (!srcFile.IsStereo && !pStereo))
            {
                // 8-bit to 8-bit, stereo to stereo or mono to mono
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = srcFile.GetNextSample_8bit();
                    if (pVolumeMultiplier != 1.0)
                        sample = (byte)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_8bit(sample);
                }
            }
            else if (!srcFile.IsStereo && pStereo)
            {
                // 8-bit to 8-bit, mono to stereo: Write each sample twice
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = srcFile.GetNextSample_8bit();
                    if (pVolumeMultiplier != 1.0)
                        sample = (byte)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_8bit(sample);
                    destFile.AddSample_8bit(sample);
                }
            }
        }
        else if ((srcFile.BitsPerSample == 8) && (pBitsPerSample == 16))
        {
            short sample = 0;
            if (srcFile.IsStereo && !pStereo)
            {
                // 8-bit to 16 bit, stereo to mono: Average each 2 samples
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = (short)((int)((int)srcFile.GetNextSampleAs16Bit() + (int)srcFile.GetNextSampleAs16Bit()) / 2);
                    if (pVolumeMultiplier != 1.0)
                        sample = (short)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_16bit(sample);
                }
            }
            else if ((srcFile.IsStereo && pStereo) || (!srcFile.IsStereo && !pStereo))
            {
                // 8-bit to 16 bit, stereo to stereo or mono to mono
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = srcFile.GetNextSampleAs16Bit();
                    if (pVolumeMultiplier != 1.0)
                        sample = (short)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_16bit(sample);
                }
            }
            else if (!srcFile.IsStereo && pStereo)
            {
                // 8-bit to 16 bit, mono to stereo: Write each sample twice
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = srcFile.GetNextSampleAs16Bit();
                    if (pVolumeMultiplier != 1.0)
                        sample = (short)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_16bit(sample);
                    destFile.AddSample_16bit(sample);
                }
            }
        }
        else if ((srcFile.BitsPerSample == 16) && (pBitsPerSample == 8))
        {
            byte sample = 0;
            if (srcFile.IsStereo && !pStereo)
            {
                // 16-bit to 8-bit, stereo to mono: Average each 2 samples
                short sample_16bit = 0;
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample_16bit = (short)((int)srcFile.GetNextSample_16bit() + (int)srcFile.GetNextSample_16bit() / 2);
                    if (pVolumeMultiplier != 1.0)
                        sample_16bit = (short)((double)sample_16bit * pVolumeMultiplier);
                    sample = ScaleShortToByte(sample_16bit);
                    destFile.AddSample_8bit(sample);
                }
            }
            else if ((srcFile.IsStereo && pStereo) || (!srcFile.IsStereo && !pStereo))
            {
                // 16-bit to 8-bit, stereo to stereo or mono to mono
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = ScaleShortToByte(srcFile.GetNextSample_16bit());
                    if (pVolumeMultiplier != 1.0)
                        sample = (byte)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_8bit(sample);
                }
            }
            else if (!srcFile.IsStereo && pStereo)
            {
                // 16-bit to 8-bit, mono to stereo: Write each sample twice
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = ScaleShortToByte(srcFile.GetNextSample_16bit());
                    if (pVolumeMultiplier != 1.0)
                        sample = (byte)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_8bit(sample);
                    destFile.AddSample_8bit(sample);
                }
            }
        }
        else if ((srcFile.BitsPerSample == 16) && (pBitsPerSample == 16))
        {
            short sample = 0;
            if (srcFile.IsStereo && !pStereo)
            {
                // 16-bit to 16-bit, stereo to mono: Average each 2 samples
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = (short)((int)((int)srcFile.GetNextSample_16bit() + (int)srcFile.GetNextSample_16bit()) / 2);
                    if (pVolumeMultiplier != 1.0)
                        sample = (short)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_16bit(sample);
                }
            }
            else if ((srcFile.IsStereo && pStereo) || (!srcFile.IsStereo && !pStereo))
            {
                // 16-bit to 16-bit, stereo to stereo or mono to mono
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = srcFile.GetNextSample_16bit();
                    if (pVolumeMultiplier != 1.0)
                        sample = (short)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_16bit(sample);
                }
            }
            else if (!srcFile.IsStereo && pStereo)
            {
                // 16-bit to 16-bit, mono to stereo: Write each sample twice
                while (srcFile.NumSamplesRemaining > 0)
                {
                    sample = srcFile.GetNextSample_16bit();
                    if (pVolumeMultiplier != 1.0)
                        sample = (short)((double)sample * pVolumeMultiplier);
                    destFile.AddSample_16bit(sample);
                    destFile.AddSample_16bit(sample);
                }
            }
        }

        destFile.Close();
        srcFile.Close();
    }
Exemplo n.º 8
0
    /// <summary>
    /// For 8-bit WAV files: Adjusts the volume level and converts it to a 16-bit audio file.
    /// The converted data is saved to a separate file.
    /// </summary>
    /// <param name="pSrcFilename">The name of the WAV file to convert</param>
    /// <param name="pDestFilename">The name to use for the converted WAV file</param>
    /// <param name="pMultiplier">The volume multiplier</param>
    public static void AdjustVolume_Copy_8BitTo16Bit(String pSrcFilename, String pDestFilename, double pMultiplier)
    {
        // If an empty source or destination file were passed in, then throw an exception.
        if (pSrcFilename.Length == 0)
            throw new WAVFileReadException("Blank filename specified.", "WAVFile.AdjustVolume_Copy_8BitTo16Bit()");
        if (pDestFilename.Length == 0)
            throw new WAVFileWriteException("Blank filename specified.", "WAVFile.AdjustVolume_Copy_8BitTo16Bit()");

        // Open the srouce file
        WAVFile srcFile = new WAVFile();
        String retval = srcFile.Open(pSrcFilename, WAVFileMode.READ);
        if (retval.Length == 0)
        {
            // Check to make sure the input file has 8 bits per sample.  If not, then throw an exception.
            if (srcFile.BitsPerSample != 8)
            {
                WAVFileBitsPerSampleException ex = new WAVFileBitsPerSampleException(pSrcFilename +
                                                          ": 8 bits per sample required, and the file has " +
                                                          srcFile.BitsPerSample.ToString() + " bits per sample.",
                                                          "WAVFile.AdjustVolume_Copy_8BitTo16Bit()",
                                                          srcFile.BitsPerSample);
                srcFile.Close();
                throw ex;
            }

            // Open the destination file
            WAVFile destFile = new WAVFile();
            destFile.Create(pDestFilename, srcFile.IsStereo, srcFile.SampleRateHz, 16, true);

            // Copy the data
            short sample_16bit = 0;
            while (srcFile.NumSamplesRemaining > 0)
            {
                // Scale the sample from 8-bit to 16 bits
                sample_16bit = ScaleByteToShort(srcFile.GetNextSample_8bit());

                // Now, apply pMultiplier if it is not 1.0
                if (pMultiplier != 1.0)
                    sample_16bit = (short)((double)sample_16bit * pMultiplier);

                // Save the sample to the destination file
                destFile.AddSample_16bit(sample_16bit);
            }

            srcFile.Close();
            destFile.Close();
        }
        else
            throw new WAVFileReadException(retval, "WAVFile.AdjustVolume_Copy_8BitTo16Bit()");
    }
Exemplo n.º 9
0
    /// <summary>
    /// Adjusts the volume level of a WAV file, saving the adjusted file as a separate file.
    /// </summary>
    /// <param name="pSrcFilename">The name of the WAV file to adjust</param>
    /// <param name="pDestFilename">The name to use for the volume-adjusted WAV file</param>
    /// <param name="pMultiplier">The value by which to multiply the audio samples</param>
    public static void AdjustVolume_Copy(String pSrcFilename, String pDestFilename, double pMultiplier)
    {
        // If an empty source or destination file were passed in, then throw an exception.
        if (pSrcFilename.Length == 0)
            throw new WAVFileReadException("Blank filename specified.", "WAVFile.AdjustVolume_Copy()");
        if (pDestFilename.Length == 0)
            throw new WAVFileWriteException("Blank filename specified.", "WAVFile.AdjustVolume_Copy()");

        // Open the srouce file
        WAVFile srcFile = new WAVFile();
        String retval = srcFile.Open(pSrcFilename, WAVFileMode.READ);
        if (retval.Length == 0)
        {
            // Check to make sure the input file has a supported number of bits/sample and sample rate.  If
            // not, then throw an exception.
            if (!SupportedBitsPerSample(srcFile.BitsPerSample))
            {
                WAVFileBitsPerSampleException ex = new WAVFileBitsPerSampleException(pSrcFilename +
                                                          " has unsupported bits/sample ("
                                                          + srcFile.BitsPerSample.ToString() + ")",
                                                          "WAVFile.AdjustVolume_Copy()", srcFile.BitsPerSample);
                srcFile.Close();
                throw ex;
            }

            // Open the destination file and start copying the adjusted audio data to it.
            WAVFile destFile = new WAVFile();
            destFile.Create(pDestFilename, srcFile.IsStereo, srcFile.SampleRateHz, srcFile.BitsPerSample);
            if (srcFile.BitsPerSample == 8)
            {
                byte sample = 0;
                for (int i = 0; i < srcFile.NumSamples; ++i)
                {
                    // Note: Only multiply the sample if pMultiplier is not 1.0 (if the multiplier is
                    // 1.0, then it would be good to avoid any binary roundoff error).
                    sample = srcFile.GetNextSample_8bit();
                    if (pMultiplier != 1.0)
                        sample = (byte)((double)sample * pMultiplier);
                    destFile.AddSample_8bit(sample);
                }
            }
            else if (srcFile.BitsPerSample == 16)
            {
                short sample = 0;
                for (int i = 0; i < srcFile.NumSamples; ++i)
                {
                    // Note: Only multiply the sample if pMultiplier is not 1.0 (if the multiplier is
                    // 1.0, then it would be good to avoid any binary roundoff error).
                    sample = srcFile.GetNextSample_16bit();
                    if (pMultiplier != 1.0)
                        sample = (short)((double)sample * pMultiplier);
                    destFile.AddSample_16bit(sample);
                }
            }

            srcFile.Close();
            destFile.Close();
        }
        else
            throw new WAVFileReadException(retval, "WAVFile.AdjustVolume_Copy()");
    }
Exemplo n.º 10
0
    /// <summary>
    /// Merges a set of WAV file sinto a single WAV file in such a way that the audio will be overlayed.
    /// This method will throw a WAVFileException upon error.
    /// </summary>
    /// <param name="pFileList">An array containing the audio filenames</param>
    /// <param name="pOutputFilename">The name of the file to contain the resulting audio</param>
    /// <param name="pTempDir">The full path to the temporary directory to use for the work.  If this directory does not exist, it will be created and then deleted when this method no longer needs it.</param>
    public static void MergeAudioFiles(String[] pFileList, String pOutputFilename, String pTempDir)
    {
        // If pFileList is null or empty, then just return.
        if (pFileList == null)
            return;
        if (pFileList.GetLength(0) == 0)
            return;

        // Make sure all the audio files have the sample rate (we can merge 8-bit and 16-bit audio and
        // convert mono to stereo).  If the sample rates don't match, then throw an exception.
        if (!SampleRatesEqual(pFileList))
            throw new WAVFileAudioMergeException("The sample rates of the audio files differ.", "WAVFile.MergeAudioFiles()");

        // Check the audio format.  If the number of bits/sample or sample rate is not
        // supported, then throw an exception.
        WAVFormat firstFileAudioFormat = GetAudioFormat(pFileList[0]);
        if (!SupportedBitsPerSample(firstFileAudioFormat.BitsPerSample))
            throw new WAVFileBitsPerSampleException("Unsupported number of bits per sample: " + firstFileAudioFormat.BitsPerSample.ToString(), "WAVFile.MergeAudioFiles()", firstFileAudioFormat.BitsPerSample);
        if (!SupportedSampleRate(firstFileAudioFormat.SampleRateHz))
            throw new WAVFileSampleRateException("Unsupported sample rate: " + firstFileAudioFormat.SampleRateHz.ToString(), "WAVFile.MergeAudioFiles()", firstFileAudioFormat.SampleRateHz);

        // 2. Create the temporary directory if it doesn't exist already.  This checks for the
        // existence of the temp directory and stores the result in tempDirExisted so that
        // later, if the temp directory did not exist, we can delete it.
        bool tempDirExisted = Directory.Exists(pTempDir);
        if (!tempDirExisted)
        {
            try
            {
                Directory.CreateDirectory(pTempDir);
                if (!Directory.Exists(pTempDir))
                    throw new WAVFileAudioMergeException("Unable to create temporary work directory (" + pTempDir + ")", "WAVFile.MergeAudioFiles()");
            }
            catch (Exception ex)
            {
                throw new WAVFileAudioMergeException("Unable to create temporary work directory (" + pTempDir + "): "
                                                     + ex.Message, "WAVFile.MergeAudioFiles()");
            }
        }

        // 4. Find the highest sample value of all files, and calculate the sound
        //    multiplier based on this (all files will be scaled down by this amount).
        int numTracks = pFileList.GetLength(0);
        double multiplier = 0.0; // The multiplier for scaling down the audio files
        short highestSampleValue = 0; // Will store the highest sample value (8-bit will be cast to short)
        // Determine the highest # of bits per sample in all the audio files.
        short highestBitsPerSample = HighestBitsPerSample(pFileList);
        bool outputStereo = (HighestNumChannels(pFileList) > 1);
        if (highestBitsPerSample == 8)
        {
            // Get the highest sample value of all of the WAV files
            byte highestSample = HighestSampleValue_8bit(pFileList);
            highestSampleValue = (short)highestSample;

            byte difference = (byte)(highestSample - (byte.MaxValue / (byte)numTracks));
            multiplier = 1.0 - ((double)difference / (double)highestSample);
        }
        else if (highestBitsPerSample == 16)
        {
            // Get the highest sample value of all of the WAV files
            highestSampleValue = HighestSampleValueAs16Bit(pFileList);

            short difference = (short)(highestSampleValue - (short.MaxValue / (short)numTracks));
            multiplier = 1.0 - ((double)difference / (double)highestSampleValue);
        }
        if (double.IsInfinity(multiplier) || (multiplier == 0.0))
        {
            // If the temp dir did not exist, then remove it.
            if (!tempDirExisted)
                DeleteDir(pTempDir);
            // Throw the exception
            throw new WAVFileAudioMergeException("Could not calculate first volume multiplier.", "WAVFile.MergeAudioFiles()");
        }

        if (multiplier < 0.0)
            multiplier = -multiplier;

        // 5. Scale down the audio levels of the source files, and save the output
        //    in the temp directory.  Also change the path to the audio files in
        //    inputFilenames so that they point to the temp directory (we'll be
        //    combining the scaled audio files).
        // This array (scaledAudioFiles) will contain WAVFile objects for the scaled audio files.
        WAVFile[] scaledAudioFiles = new WAVFile[pFileList.GetLength(0)];
        String filename = "";               // For the scaled-down WAV filename
        WAVFile inputFile = new WAVFile();
        WAVFile outputFile = new WAVFile();
        for (int i = 0; i < pFileList.GetLength(0); ++i)
        {
            // pFileList[i] contains the fully-pathed filename.  Using just the
            // filename, construct the fully-pathed filename for the scaled-down
            // version of the file in the temporary directory.
            filename = pTempDir + "\\" + Path.GetFileName(pFileList[i]);

            // Copy the file to the temp directory, adjusting its bits/sample and number of
            // channels if necessary.  And also ajust its volume using multiplier.
            CopyAndConvert(pFileList[i], filename, highestBitsPerSample, outputStereo, multiplier);

            // Create the WAVFile object in the scaledAudioFiles array, and open the scaled
            // audio file with it.
            scaledAudioFiles[i] = new WAVFile();
            scaledAudioFiles[i].Open(filename, WAVFileMode.READ);
        }

        // 7. Now, create the final audio mix file.
        outputFile.Create(pOutputFilename, outputStereo, firstFileAudioFormat.SampleRateHz,
                          highestBitsPerSample);

        // 8. Do the merging..
        // The basic algorithm for doing the merging is as follows:
        // while there is at least 1 sample remaining in any of the source files
        //    sample = 0
        //    for each source file
        //       if the source file has any samples remaining
        //          sample = sample + next available sample from the source file
        //    sample = sample / # of source files
        //    write the sample to the output file
        if (highestBitsPerSample == 8)
        {
            byte sample = 0;
            while (SamplesRemain(scaledAudioFiles))
            {
                sample = 0;
                for (int i = 0; i < scaledAudioFiles.GetLength(0); ++i)
                {
                    if (scaledAudioFiles[i].NumSamplesRemaining > 0)
                        sample += scaledAudioFiles[i].GetNextSample_8bit();
                }
                sample /= (byte)(scaledAudioFiles.GetLength(0));
                outputFile.AddSample_8bit(sample);
            }
        }
        else if (highestBitsPerSample == 16)
        {
            short sample = 0;
            while (SamplesRemain(scaledAudioFiles))
            {
                sample = 0;
                for (int i = 0; i < scaledAudioFiles.GetLength(0); ++i)
                {
                    if (scaledAudioFiles[i].NumSamplesRemaining > 0)
                        sample += scaledAudioFiles[i].GetNextSampleAs16Bit();
                }
                sample /= (short)(scaledAudioFiles.GetLength(0));
                outputFile.AddSample_16bit(sample);
            }
        }
        outputFile.Close();

        // 9. Remove the input files(to free up disk space.
        foreach (WAVFile audioFile in scaledAudioFiles)
        {
            filename = audioFile.Filename;
            audioFile.Close();
            File.Delete(filename);
        }

        // 10. Now, increase the volume level of the output file. (will first have
        //     to see if the inputs are 8-bit or 16-bit.)
        //  Adjust the volume level of the file so that its volume is
        //  the same as the volume of the input files.  This is done by
        //  first finding the highest sample value of all files, then
        //  the highest sample value of the combined audio file, and
        //  scaling the audio of the output file to match the volume
        //  of the input files (such that the highest level of the output
        //  file is the same as the highest level of all files).
        // For 16-bit audio, this works okay, but for 8-bit audio, the
        //  output seems to sound better if we adjust the volume so that
        //  the highest sample value is 3/4 of the maximum sample value
        //  for the # of bits/sample.
        if (highestBitsPerSample == 8)
        {
            byte highestSampleVal = WAVFile.HighestSampleValue_8bit(pOutputFilename);
            byte maxValue = byte.MaxValue / 4 * 3;
            multiplier = (double)maxValue / (double)highestSampleVal;
        }
        else if (highestBitsPerSample == 16)
        {
            short finalMixFileHighestSample = WAVFile.HighestSampleValueAs16Bit(pOutputFilename);
            // Calculate the multiplier for adjusting the audio of the final mix file.
            //short difference = (short)(finalMixFileHighestSample - highestSampleValue);
            //multiplier = 1.0 - ((double)difference / (double)finalMixFileHighestSample);
            // This calculates the multiplier based on the highest sample value in the audio
            // file and the highest possible 16-bit sample value.
            multiplier = (double)short.MaxValue / (double)finalMixFileHighestSample;
        }
        if (multiplier < 0.0)
            multiplier = -multiplier;

        // Adjust the volume of the final mix file.
        AdjustVolumeInPlace(pOutputFilename, multiplier);

        // If the temporary directory did not exist prior to this method being called, then
        // delete it.
        if (!tempDirExisted)
        {
            String retval = DeleteDir(pTempDir);
            if (retval.Length > 0)
                throw new WAVFileAudioMergeException("Unable to remove temp directory (" + pTempDir + "): " + retval,
                                                     "WAVFile.MergeAudioFiles()");
        }
    }