Click here to Skip to main content
Click here to Skip to main content

Concatenating Wave Files Using C# 2005

, 10 Mar 2007 CPOL
Rate this:
Please Sign up or sign in to vote.
How to concatenate wave files in a single file

Introduction

The WAVE file format is a subset of Microsoft's RIFF specification for the storage of multimedia files. A RIFF file starts out with a file header followed by a sequence of data chunks. A WAVE file is often just a RIFF file with a single "WAVE" chunk which consists of two sub-chunks -- a "fmt" chunk specifying the data format and a "data" chunk containing the actual sample data. Call this form the "Canonical form".

The main idea is to create only one header for all WAV files that you want to concatenate and then write data of each file in a single file.

Wave file headers follow the standard RIFF file format structure. The first 8 bytes in the file are the standard RIFF chunk header which have a chunk ID of "RIFF" and a chunk size equal to the file size minus the 8 bytes used by the header.

So we need to know the total length of all files to define ChunkSize and read NumChannels, SampleRate and BitsPerSample.

private void WaveHeaderIN(string spath)
        {
            FileStream fs = new FileStream(spath, FileMode.Open, FileAccess.Read);

            BinaryReader br = new BinaryReader(fs);
            length = (int)fs.Length - 8;
            fs.Position = 22;
            channels = br.ReadInt16();
            fs.Position = 24;
            samplerate = br.ReadInt32();
            fs.Position = 34;

            BitsPerSample = br.ReadInt16();
            DataLength = (int)fs.Length - 44;
            br.Close ();
            fs.Close();
        }

As we know channels are stored in the WAV header in byte number 22, we move the current position of the file to this location and the size of it is 2 bytes so we use br.ReadInt16() to read only 2 bytes and so on....

Construct the Header of Merged File

private void WaveHeaderOUT(string sPath)
        {
            FileStream fs = new FileStream(sPath, FileMode.Create, FileAccess.Write );

            BinaryWriter bw = new BinaryWriter(fs);
            bw.Write(new char[4] { 'R', 'I', 'F', 'F' });

            bw.Write(length);

            bw.Write(new char[8] {'W','A','V','E','f','m','t',' '});

            bw.Write((int)16);

            bw.Write((short)1);
            bw.Write(channels);

            bw.Write(samplerate );

            bw.Write((int)(samplerate * ((BitsPerSample * channels) / 8)));

            bw.Write((short )((BitsPerSample * channels) / 8));

            bw.Write(BitsPerSample);

            bw.Write(new char[4] {'d','a','t','a'});
            bw.Write(DataLength);
            bw.Close();
            fs.Close();
        }

We must be careful when writing the header. If there is any small mistake, the merged file doesn't work, so we write "RIFF" as an array of char, not as string and use int type for storing 4 bytes and short type for storing 2 bytes.

Write Data of all Files in the Merged File

  public void Merge(string[] files, string outfile)
        {
            WaveIO wa_IN = new WaveIO();
            WaveIO wa_out = new WaveIO();

            wa_out.DataLength = 0;
            wa_out.length = 0;


            //Gather header data
            foreach (string path in files)
            {
                wa_IN.WaveHeaderIN(@path);
                wa_out.DataLength += wa_IN.DataLength;
                wa_out.length += wa_IN.length;

            }

            //Reconstruct new header
            wa_out.BitsPerSample = wa_IN.BitsPerSample;
            wa_out.channels = wa_IN.channels;
            wa_out.samplerate = wa_IN.samplerate;
            wa_out.WaveHeaderOUT(@outfile);

            foreach (string path in files)
            {
                FileStream fs = new FileStream(@path, FileMode.Open, FileAccess.Read);
                byte[] arrfile = new byte[fs.Length - 44];
                fs.Position = 44;
                fs.Read(arrfile, 0, arrfile.Length);
                fs.Close();

                FileStream fo =
                    new FileStream(@outfile, FileMode.Append, FileAccess.Write);
                BinaryWriter bw = new BinaryWriter(fo);
                bw.Write(arrfile);
                bw.Close();
                fo.Close();
            }
          }

First we need to calculate the total length and data length of all files and then specify the channels, SampleRate and BitsPerSample of the output file.The last thing is to start reading data that is stored after byte number 44 and append it to the merged file.

All we need to do is call the Merge method and specify the input files and output file.

string[] files = new string[2] { @"C:\WINDOWS\Media\Windows XP Startup.wav",
                @"C:\WINDOWS\Media\Windows XP Shutdown.wav" };

WaveIO wa = new WaveIO();
wa.Merge(files,@"c:\oou.wav");

Play the Merged File

Visual Studio 2005 provides a new class to play sound. Therefore, we don't need an API or anything else.

FileStream fs = new FileStream(@"c:\oou.wav", FileMode.Open,FileAccess.Read);
System.Media.SoundPlayer sp = new System.Media.SoundPlayer(fs);
sp.Play();
fs.Close();

References

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Ehab M. M. Essa
Computer Science Department
Faculty of Computers and Information, Mansoura University, Egypt

Comments and Discussions

 
QuestionEditing small audio files , into a "song". Pinmemberiawiliams15-Sep-14 10:46 
QuestionHola, necesito hablar con FocusedWolf por sus comentarios Pinmemberlepachec5-May-14 19:06 
Suggestionminor improvements needed Pinmembermdanh20021-Oct-11 5:24 
The code has 2 problems
 
(1) The wav files to be merged need to have exactly the same format, e.g. number of channels (mono/stereo), bits per sample (8 or 16) and sampling rate (in kHz). If the formats are not the same, the combined wav files will have distortion as indicated by some earlier comments.
 
(2) Value for ChunkSize in the merged wave file header is incorrect. The beginning of function Merge should read
 
  public void Merge(string[] files, string outfile)
        {
            WaveIO wa_IN = new WaveIO();
            WaveIO wa_out = new WaveIO();
 
            wa_out.DataLength = 0;
            wa_out.length = 0;
 

            //Gather header data
            foreach (string path in files)
            {
                wa_IN.WaveHeaderIN(@path);
                wa_out.DataLength += wa_IN.DataLength;
            }
 
            wa_out.length = wa_out.DataLength + 36;
        ....
      } 
 
ChunkSize (wa_out.length) is always 36 bytes more than Subchunk2Size (wa_out.length) so you can't sum up all the ChunkSize values of the individual wave files to get the final value.
 
This error will be ignored and inaudible by many players (including Windows Media Player), but some advanced audio editors (GoldWave for example) may detect the error and prompt the user, or refuse to open the file.
GeneralLicense Pinmemberthumb2231-Jan-11 4:10 
GeneralI have figured out a solution to the noise problem... PinmemberAbhi2028-Aug-10 16:17 
QuestionHeavy distortion in output file [modified] PinmemberGolph4217-Nov-09 9:33 
Generalvb.net: read, concat in mem, output to file or stream PinmemberMember 425506423-Sep-09 1:37 
GeneralAll in memory Pinmembershem79-Mar-09 7:17 
QuestionThank & need haelp PinmemberMember 286830623-Jan-09 7:56 
QuestionStrange "clicks" ? Pinmemberjaph13-May-08 11:12 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.141223.1 | Last Updated 10 Mar 2007
Article Copyright 2006 by Ehab Mohamed Essa
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid