wavefile.cpp

Go to the documentation of this file.

//--------------------------------------
//          File: wavefile.cpp
//--------------------------------------

/* Microsoft's WAVE soundfile class */
/* Project: VoX */

/* 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.

Notes:

* The default byte ordering assumed for WAVE data files is little-endian.
Files written using the big-endian byte ordering scheme have the
identifier RIFX instead of RIFF.
* The sample data must end on an even byte boundary. Whatever that means.
* 8-bit samples are stored as unsigned bytes, ranging from 0 to 255. 16-bit
samples are stored as 2's-complement signed integers, ranging from -32768
to 32767.
* There may be additional subchunks in a Wave data stream. If so, each will
have a char[4] SubChunkID, and unsigned long SubChunkSize, and
SubChunkSize amount of data.
* RIFF stands for Resource Interchange File Format.

For more info see http://www.ora.com/centers/gff/formats/micriff/index.htm

References:

1. http://netghost.narod.ru/gff/graphics/summary/micriff.htm
2. http://www.lightlink.com/tjweber/StripWav/WAVE.html

General discussion of RIFF files:
Multimedia applications require the storage and management of a wide
variety of data, including bitmaps, audio data, video data, and peripheral
device control information. RIFF provides a way to store all these varied
types of data. The type of data a RIFF file contains is indicated by the
file extension. Examples of data that may be stored in RIFF files are:

* Audio/visual interleaved data (.AVI)
* Waveform data (.WAV)
* Bitmapped data (.RDI)
* MIDI information (.RMI)
* Color palette (.PAL)
* Multimedia movie (.RMN)
* Animated cursor (.ANI)
* A bundle of other RIFF files (.BND)

NOTE: At this point, AVI files are the only type of RIFF files that have
been fully implemented using the current RIFF specification. Although WAV
files have been implemented, these files are very simple, and their
developers typically use an older specification in constructing them.*/

using namespace std;

#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<vector>

#ifndef FILEMANAGERINCLUDED
#include"filemanager.cpp"
#endif

#ifndef PARAMETERSINCLUDED
#include "parameters.cpp"
#endif


#define WAVEFILEINCLUDED

class wavefile {
/*
Offset  Size  Name             Description

The canonical WAVE format starts with the RIFF header:

0         4   ChunkID          Contains the letters "RIFF" in ASCII form
                               (0x52494646 big-endian form).
4         4   ChunkSize        36 + SubChunk2Size, or more precisely:
                               4 + (8 + SubChunk1Size) + (8 + SubChunk2Size)
                               This is the size of the rest of the chunk
                               following this number.  This is the size of the
                               entire file in bytes minus 8 bytes for the
                               two fields not included in this count:
                               ChunkID and ChunkSize.
8         4   Format           Contains the letters "WAVE"
                               (0x57415645 big-endian form).

The "WAVE" format consists of two subchunks: "fmt " and "data":
The "fmt " subchunk describes the sound data's format:

12        4   Subchunk1ID      Contains the letters "fmt "
                               (0x666d7420 big-endian form).
16        4   Subchunk1Size    16 for PCM.  This is the size of the
                               rest of the Subchunk which follows this number.
20        2   AudioFormat      PCM = 1 (i.e. Linear quantization)
                               Values other than 1 indicate some
                               form of compression.
22        2   NumChannels      Mono = 1, Stereo = 2, etc.
24        4   SampleRate       8000, 44100, etc.
28        4   ByteRate         == SampleRate * NumChannels * BitsPerSample/8
32        2   BlockAlign       == NumChannels * BitsPerSample/8
                               The number of bytes for one sample including
                               all channels. I wonder what happens when
                               this number isn't an integer?
34        2   BitsPerSample    8 bits = 8, 16 bits = 16, etc.
          2   ExtraParamSize   if PCM, then doesn't exist
          X   ExtraParams      space for extra parameters

The "data" subchunk contains the size of the data and the actual sound:

36        4   Subchunk2ID      Contains the letters "data"
                               (0x64617461 big-endian form).
40        4   Subchunk2Size    == NumSamples * NumChannels * BitsPerSample/8
                               This is the number of bytes in the data.
                               You can also think of this as the size
                               of the read of the subchunk following this
                               number.
44        *   Data             The actual sound data.

As an example, here are the opening 72 bytes of a WAVE file with bytes shown as hexadecimal numbers:

52 49 46 46 24 08 00 00 57 41 56 45 66 6d 74 20 10 00 00 00 01 00 02 00
22 56 00 00 88 58 01 00 04 00 10 00 64 61 74 61 00 08 00 00 00 00 00 00
24 17 1e f3 3c 13 3c 14 16 f9 18 f9 34 e7 23 a6 3c f2 24 f2 11 ce 1a 0d
...
*/

  protected:char ChunkID[4];
            unsigned long int ChunkSize;
            char Format[4];
            char Subchunk1ID[4];
            unsigned long int Subchunk1Size;
            unsigned short int AudioFormat;
            unsigned short int NumChannels;
            unsigned long int SampleRate;
            unsigned long int ByteRate;
            unsigned short int BlockAlign;
            unsigned short int BitsPerSample;
            char Subchunk2ID[4];
            unsigned long int Subchunk2Size;
            char *data;
            string path; /*Location of open wavefile*/
            unsigned long int locinc; /*Size of Each Subchunk2Size of each frame*/
            unsigned long int curloc; /*Current frame start location*/
            FILE* fptr; /*Associated with mfcc.fil*/

  public: wavefile () {
            path=filemgr.newTempFile();/*generate a new temporary file*/
            strncpy(ChunkID,"RIFF",4);
            strncpy(Format,"WAVE",4);
            strncpy(Subchunk1ID,"fmt ",4);
            Subchunk1Size=16;
            AudioFormat=1;
            NumChannels=1;
            SampleRate=SAMPLERATE;
            BitsPerSample=BPS;
            ByteRate=SampleRate * NumChannels * BitsPerSample/8;
            BlockAlign=NumChannels * BitsPerSample/8;
            strncpy(Subchunk2ID,"data",4);
            data=NULL;
            Subchunk2Size=0;
            ChunkSize=4 + (8 + Subchunk1Size) + (8 + Subchunk2Size);
            locinc=(unsigned long int)((double)ByteRate*(double)FRAMELENGTH);
            curloc=0;
          }

          unsigned long int getlocinc() {
            /*gets the location increment*/
            return (unsigned long int)((double)ByteRate*(double)FRAMELENGTH);
          }

          wavefile (char* frdata,unsigned long int frsize) {
            path= filemgr.newTempFile();/*generate a new temporary file*/
            strncpy(ChunkID,"RIFF",4);
            strncpy(Format,"WAVE",4);
            strncpy(Subchunk1ID,"fmt ",4);
            Subchunk1Size=16;
            AudioFormat=1;
            NumChannels=1;
            SampleRate=SAMPLERATE;
            BitsPerSample=BPS;
            ByteRate=SampleRate * NumChannels * BitsPerSample/8;
            BlockAlign=NumChannels * BitsPerSample/8;
            strncpy(Subchunk2ID,"data",4);
            Subchunk2Size=frsize;
            if((data=(char *)malloc(Subchunk2Size))==NULL) {            
              cout<<"Cannot allocate memory\n\n";
              return;
            }
            for(unsigned long int i=0;i<Subchunk2Size;i++) {
              data[i]=frdata[i];
            }
            ChunkSize=4 + (8 + Subchunk1Size) + (8 + Subchunk2Size);
            locinc=(unsigned long int)((double)ByteRate*(double)FRAMELENGTH);
            curloc=0;
          }

          wavefile (string wavepath) {
          /*Constructor: opens the file specified by the path and initialises all private variables, allocates buffer for data, and copy data*/
            char ID[4];
            unsigned long int size;
            unsigned short int num;
            FILE* fp;
            char str[256];
            strcpy(str,"./sig2fv ");
            strcat(str,wavepath.c_str());
            strcat(str," -shift 0.02 -o mfcc.fil -coefs melcep");
            system(str);
            cout<<"MFCCs generated"<<endl;
            fptr=fopen("mfcc.fil","rb");
            fp=fopen(wavepath.c_str(),"r+");
            if(fp==NULL) {
              printf("Error opening file\n");
              exit(0);
            }
            fread(ID,1,4,fp);
            strncpy(ChunkID,ID,4);
            fread(&size,4,1,fp);
            ChunkSize=size;
            fread(ID,1,4,fp);
            strncpy(Format,ID,4);
            fread(ID,1,4,fp);
            strncpy(Subchunk1ID,ID,4);
            fread(&size,1,4,fp);
            Subchunk1Size=size;
            fread(&num,1,2,fp);
            AudioFormat=num;
            fread(&num,1,2,fp);
            NumChannels=num;
            fread(&size,1,4,fp);
            SampleRate=size;
            fread(&size,1,4,fp);
            ByteRate=size;
            fread(&num,1,2,fp);
            BlockAlign=num;
            fread(&num,1,2,fp);
            BitsPerSample=num;
            fseek(fp,Subchunk1Size-16,SEEK_CUR); //Skipping extraParams
            if(Subchunk1Size>16 && AudioFormat==1)
              Subchunk1Size=16;
            fread(ID,1,4,fp);
            if(strncmp(ID,"fact",4)==0) { //Skipping fact subchunk
              fread(&size,1,4,fp);
              fseek(fp,size,SEEK_CUR);
              fread(ID,1,4,fp);
            }
            strncpy(Subchunk2ID,ID,4);
            fread(&size,1,4,fp);
            Subchunk2Size=size;
            data=(char *)malloc(Subchunk2Size);
            fread(data,1,Subchunk2Size,fp);
            ChunkSize=4 + (8 + Subchunk1Size) + (8 + Subchunk2Size);
            fclose(fp);
            path=wavepath;
            locinc=(unsigned long int)((double)ByteRate*(double)FRAMELENGTH);
            curloc=0;
          }

          wavefile (wavefile& wv) {
          /*Copy Constructor: copy all private variables except for the path, reallocates buffer for data, and copy data*/
            path=filemgr.newTempFile();/*generate a new temporary file*/
            strncpy(ChunkID,wv.ChunkID,4);
            ChunkSize=wv.ChunkSize;
            strncpy(Format,wv.Format,4);
            strncpy(Subchunk1ID,wv.Subchunk1ID,4);
            Subchunk1Size=wv.Subchunk1Size;
            AudioFormat=wv.AudioFormat;
            NumChannels=wv.NumChannels;
            SampleRate=wv.SampleRate;
            ByteRate=wv.ByteRate;
            BlockAlign=wv.BlockAlign;
            BitsPerSample=wv.BitsPerSample;
            strncpy(Subchunk2ID,wv.Subchunk2ID,4);
            Subchunk2Size=wv.Subchunk2Size;
            data=(char *)malloc(Subchunk2Size);
            //data  --> wv.data(Subchunk2Size bytes)
            for(unsigned long int i=0;i<Subchunk2Size;i++) {
              data[i]=wv.data[i];
            }
            curloc=wv.curloc; /*Current frame start location*/
            locinc=wv.locinc;
          }

          wavefile (const wavefile& wv) {
          /*Copy Constructor: copy all private variables except for the path, reallocates buffer for data, and copy data*/
            path=filemgr.newTempFile();/*generate a new temporary file*/
            strncpy(ChunkID,wv.ChunkID,4);
            ChunkSize=wv.ChunkSize;
            strncpy(Format,wv.Format,4);
            strncpy(Subchunk1ID,wv.Subchunk1ID,4);
            Subchunk1Size=wv.Subchunk1Size;
            AudioFormat=wv.AudioFormat;
            NumChannels=wv.NumChannels;
            SampleRate=wv.SampleRate;
            ByteRate=wv.ByteRate;
            BlockAlign=wv.BlockAlign;
            BitsPerSample=wv.BitsPerSample;
            strncpy(Subchunk2ID,wv.Subchunk2ID,4);
            Subchunk2Size=wv.Subchunk2Size;
            data=(char *)malloc(Subchunk2Size);
            // data  --> wv.data(Subchunk2Size bytes)
            for(unsigned long int i=0;i<Subchunk2Size;i++) {
              data[i]=wv.data[i];
            }
            curloc=wv.curloc; /*Current frame start location*/
            locinc=wv.locinc;
          }

          int makeMono(int type) {
          /*Converts this wavefile to monochannel, if it is multichannel*/
          /*type=1 => Sum; type = 2 => Avg; ret = -1 => clip;*/
            unsigned long int i; //multi channel data iterator
            unsigned long int m; //mono channel data iterator
            short int j; //channel iterator
            unsigned char avg8; //8-bit sample avg
            short int avg16; //16-bit sample avg
            unsigned int sum8; //8-bit sample sum
            long int sum16; //16-bit sample sum
            unsigned char *monodata8; //modified (mono channel) data
            short int *monodata16; //modified (mono channel) data
            switch(BitsPerSample) {
              case 8: monodata8=(unsigned char *)malloc(Subchunk2Size/NumChannels);
                      for(i=0,m=0;i<Subchunk2Size;i+=BlockAlign,m++) {
                        for(j=0,sum8=0;j<BlockAlign;j+=BitsPerSample/8) {
                          sum8+=data[i+j];
                        }
                        avg8=sum8/NumChannels;
                        if(sum8 > 255)
                          return -1;
                        if(type==1)
                          monodata8[m]=sum8;
                        if(type==2)
                          monodata8[m]=avg8;
                      }
                      Subchunk2Size/=NumChannels;
                      free(data);
                      data=(char *)malloc(Subchunk2Size);
                      for(unsigned long int l=0;l<Subchunk2Size;l++) {
                         data[l]=monodata8[l];
                      }
                      //memcpy(data,monodata8,Subchunk2Size);
                      free(monodata8);
                      NumChannels=1;
                      BlockAlign=NumChannels*BitsPerSample/8;
                      ByteRate=SampleRate * NumChannels *BitsPerSample/8;
                      ChunkSize=4 + (8 + Subchunk1Size) + (8 + Subchunk2Size);
                      commit();
                      break;
              case 16:monodata16=(short int *)malloc(Subchunk2Size/NumChannels);
                      for(i=0,m=0;i<Subchunk2Size;i+=BlockAlign,m++) {
                        for(j=0,sum16=0;j<BlockAlign;j+=BitsPerSample/8) {
                          sum16+=data[i+j];
                        }
                        avg16=sum16/NumChannels;
                        if(sum16 > 32767 || sum16 < -32768)
                          return 1;
                        if(type==1)
                          monodata16[m]=sum16;
                        if(type==2)
                          monodata16[m]=avg16;
                      }
                      Subchunk2Size/=NumChannels;
                      free(data);
                      data=(char *)malloc(Subchunk2Size);
                      for(unsigned long int l=0;l<Subchunk2Size;l++) {
                         data[l]=monodata16[l];
                      }
                      //memcpy(data,monodata16,Subchunk2Size);
                      free(monodata16);
                      NumChannels=1;
                      BlockAlign=NumChannels*BitsPerSample/8;
                      ByteRate=SampleRate * NumChannels *BitsPerSample/8;
                      ChunkSize=4 + (8 + Subchunk1Size) + (8 + Subchunk2Size);
                      commit();
                      break;
              default://unhandled
                      break;
            }
            return 0;
          }

 
         int makePerm(string dest) {
          /*makes a wave file permanent*/
            string tpath=path;
            filemgr.makePerm(dest,tpath);
            path=dest;
          }

          int getFirstFrame (char *frmdata,unsigned long int* frsize) {
          /*Copies first frame of locinc samples (if needed, padding is done) in wf and returns the length of frame*/
            *frsize=locinc;
            // frmdata-->data(locinc bytes)
            for(unsigned long int i=0;i<locinc;i++) {
              frmdata[i]=data[i];
            }
            curloc=locinc;
            *frsize=locinc;
            // frmdata-->data(locinc bytes)
            for(unsigned long int i=0;i<locinc;i++) {
              frmdata[i]=data[i];
            }
            curloc=locinc;
            return SUCCESS;
          }

          int getNextFrame (char *frmdata,unsigned long int* frsize) {
          /*Copies next frame of locinc samples (if needed, padding is done) in wf and returns the length of frame*/
            if((curloc+locinc)>Subchunk2Size) {
              return 2;
            }
            *frsize=locinc;
            // frmdata-->data+curloc(locinc bytes)
            for(unsigned long int i=0;i<locinc;i++) {
              frmdata[i]=data[i+curloc];
            }
            curloc=curloc+locinc;
              return SUCCESS;
          }

          int getFrame(unsigned long int i, string framename) {
            curloc=i*getlocinc();
            char* frmdata=(char*)malloc(getlocinc());
            for(i=0;i<locinc;i++) {
              frmdata[i]=data[i+curloc];
            }
            char ID[4];
            unsigned long int size;
            unsigned short int num;
            FILE* frmptr=fopen(framename.c_str(),"w+");
            if(frmptr==NULL) {
              printf("Error committing file\n");
              return 1;
            }
            strncpy(ID,ChunkID,4);
            fwrite(ID,1,4,frmptr);
            size=4 + (8 + Subchunk1Size) + (8 + getlocinc());
            fwrite(&size,4,1,frmptr);
            strncpy(ID,Format,4);
            fwrite(ID,1,4,frmptr);
            strncpy(ID,Subchunk1ID,4);
            fwrite(ID,1,4,frmptr);
            size=Subchunk1Size;
            fwrite(&size,1,4,frmptr);
            num=AudioFormat;
            fwrite(&num,1,2,frmptr);
            num=NumChannels;
            fwrite(&num,1,2,frmptr);
            size=SampleRate;
            fwrite(&size,1,4,frmptr);
            size=ByteRate;
            fwrite(&size,1,4,frmptr);
            num=BlockAlign;
            fwrite(&num,1,2,frmptr);
            num=BitsPerSample;
            fwrite(&num,1,2,frmptr);
            strncpy(ID,Subchunk2ID,4);
            fwrite(ID,1,4,frmptr);
            size=getlocinc();
            fwrite(&size,1,4,frmptr);
            fwrite(frmdata,1,getlocinc(),frmptr);
            fclose(frmptr);
            return 1;
         }  
            
         vector<double> getMFCC(int *status) {
           unsigned long int line_no;
           char str[16];
           vector<double> mfcc;
           char** endptr;
           endptr=(char**)malloc(sizeof(char**));
           double temp;
           for(int i=0;i<MAX_DIM;i++) {
             if(( fscanf(fptr,"%s",str))==EOF) {
               *status=FAILURE;
               return mfcc;
             }
             temp=strtod(str,endptr);
             mfcc.push_back(temp);
           } 
           *status=SUCCESS;
           return mfcc;
         }

         int appendFrame (string fpath) {/*simple, no smoothening*//*appends a frame to this wavefile*/
            char* frmdata;
            unsigned long int frsize=getlocinc();
            FILE* fptr;
            frmdata=(char*)malloc(getlocinc());
            fptr=fopen(fpath.c_str(),"r+");
            fseek(fptr,44,SEEK_SET);
            fread((char*)frmdata,sizeof(char),getlocinc(),fptr) ;          
            char* olddata;
            olddata=(char*)malloc(Subchunk2Size);
            for(unsigned long int i=0;i<Subchunk2Size;i++) {
              olddata[i]=data[i];
            }
            free(data);
            Subchunk2Size=Subchunk2Size+frsize;
            if((data=(char*)malloc(Subchunk2Size))==NULL) {
              cout<<"Error reallocating data\n";
              abort();
            }
            for(unsigned long int i=0;i<Subchunk2Size-frsize;i++) {
              data[i]=olddata[i];
            }
            for(unsigned long int i=Subchunk2Size-frsize;i<Subchunk2Size;i++) {
              data[i]=frmdata[i-(Subchunk2Size-frsize)];
            }            
            ChunkSize=4 + (8 + Subchunk1Size) + (8 + Subchunk2Size);
            free(olddata);
            free(frmdata);
            fclose(fptr);
          }

          int getData(char* frmdata,unsigned long int* frsize) {
            if((frmdata=(char*)malloc( Subchunk2Size ))==NULL)
              return FAILURE;
            *frsize= Subchunk2Size ;
            for(unsigned long int i=0;i<Subchunk2Size;i++) {
              frmdata[i]=data[i];
            }
            return SUCCESS;         
         }
            
         int commit(void) {
         /*copies all private variables & data back to the location specified by path*/
            char ID[4];
            unsigned long int size;
            unsigned short int num;
            FILE* fp;

            fp=fopen(path.c_str(),"w+");
            if(fp==NULL) {
              printf("Error committing file\n");
              return 1;
            }
            strncpy(ID,ChunkID,4);
            fwrite(ID,1,4,fp);
            size=ChunkSize;
            fwrite(&size,4,1,fp);
            strncpy(ID,Format,4);
            fwrite(ID,1,4,fp);
            strncpy(ID,Subchunk1ID,4);
            fwrite(ID,1,4,fp);
            size=Subchunk1Size;
            fwrite(&size,1,4,fp);
            num=AudioFormat;
            fwrite(&num,1,2,fp);
            num=NumChannels;
            fwrite(&num,1,2,fp);
            size=SampleRate;
            fwrite(&size,1,4,fp);
            size=ByteRate;
            fwrite(&size,1,4,fp);
            num=BlockAlign;
            fwrite(&num,1,2,fp);
            num=BitsPerSample;
            fwrite(&num,1,2,fp);
            strncpy(ID,Subchunk2ID,4);
            fwrite(ID,1,4,fp);
            size=Subchunk2Size;
            fwrite(&size,1,4,fp);
            fwrite(data,1,Subchunk2Size,fp);
            fclose(fp);
            return 1;
         }


         int showDetails() {
            cout << "ChunkID\t\t:" << ChunkID[0] << ChunkID[1] << ChunkID[2] << ChunkID[3] << "\n";
            cout << "ChunkSize\t:" << ChunkSize << "\n" ;
            cout << "Format\t\t:" << Format[0] << Format[1] << Format[2] << Format[3] << "\n" ;
            cout << "-----------------------------\n";
            cout << "Subchunk1ID\t:" << Subchunk1ID[0] << Subchunk1ID[1] << Subchunk1ID[2] << Subchunk1ID[3] << "\n" ;
            cout << "Subchunk1Size\t:" << Subchunk1Size << "\n" ;
            cout << "AudioFormat\t:" << AudioFormat << "\n" ;
            cout << "NumChannels\t:" << NumChannels << "\n" ;
            cout << "SampleRate\t:" << SampleRate << "\n" ;
            cout << "ByteRate\t:" << ByteRate << "\n" ;
            cout << "BlockAlign\t:" << BlockAlign << "\n" ;
            cout << "BitsPerSample\t:" << BitsPerSample << "\n" ;
            cout << "-----------------------------\n";
            cout << "Subchunk2ID\t:" << Subchunk2ID[0] << Subchunk2ID[1] << Subchunk2ID[2] << Subchunk2ID[3] << "\n" ;
            cout << "Subchunk2Size\t:" << Subchunk2Size << "\n" ;
            cout << "data\t\t:" << "/* Unprintable data */\n";
            //cout << "data\t\t:" << data << "\n" ;
            cout << "-----------------------------\n";
            cout << "path\t\t:" << path << "\n" ;
            cout << "locinc\t\t:" << locinc << "\n" ;
            cout << "curloc\t\t:" << curloc << "\n" ;
            return SUCCESS; 
         }

          ~wavefile () {
          /*Destructor: closes the file specified by the path and copies all private variables & data back, deallocates buffer for data, and try to delete the temporary file */
            if((filemgr.checkTempFile(path))==0)/*this is permanent file*/ {
              commit();
            }
            else {    
              filemgr.delTempFile(path);
            }            
            free(data);
          }

          unsigned long int nFrames() {
            return Subchunk2Size/getlocinc();
          }
};

---