Titan2Reader: wav.c Source File

00001 /*
00002  * This file is part of Titan2Reader
00003  *
00004  * Copyright (C) 2006, Sebastien Judenherc <sebastien.judenherc@agecodagis.com>
00005  *
00006  * This program is free software; you can redistribute it and/or modify
00007  * it under the terms of the GNU General Public License as published by
00008  * the Free Software Foundation; either version 2 of the License, or
00009  * (at your option) any later version.
00010  *
00011  * This program is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014  * GNU General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU General Public License
00017  * along with this program; if not, write to the Free Software
00018  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
00019  * USA
00020  *
00021  */
00022 
00023 #include <math.h>
00024 #include <stdio.h>
00025 #include <ctype.h>
00026 #include <stdlib.h>
00027 #include <unistd.h>
00028 #include <time.h>
00029 #include <string.h>
00030 #include <assert.h>
00031 #include <sys/types.h>
00032 #include <netinet/in.h>
00033 
00034 #include "common.h" 
00035 
00036 
00037 FILE *wavChannelFile[MAX_CHANNEL] = {
00038         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
00039         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
00040         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
00041         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
00042         NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,
00043 };
00044 char wavChannelFileName[MAX_CHANNEL][128];
00045 
00046 int32_t Vmin[MAX_CHANNEL],Vmax[MAX_CHANNEL];
00047 int64_t Vavg[MAX_CHANNEL];
00048 
00052 FILE* OpenWavChannel(int channel)
00053 {
00054         if (wavChannelFile[channel]==NULL)
00055         {
00056                 int fd;
00057                 Vmin[channel]=1<<30;
00058                 Vmax[channel]=-Vmin[channel];
00059                 Vavg[channel]=0;
00060                 strcpy(wavChannelFileName[channel],"titanfileXXXXXX");
00061                 fd=OpenTempFile(wavChannelFileName[channel]);
00062                 assert((wavChannelFile[channel]=fdopen(fd,"w+b"))!=NULL);
00063                 setvbuf(wavChannelFile[channel],NULL,_IOFBF,FILE_BUFFER_SIZE);
00064 
00065                 if (wavChannelFile[channel])
00066                 {
00067                         int l;
00068                         // initialized a new generic header
00069                         InitInfoHeader(channel);
00070                         // initiliaze a new wav file
00071                         // and write a dummy header to the file
00072                         for (l=0; l<11; l++)
00073                         {
00074                                 fwrite(&l,4,1,wavChannelFile[channel]);
00075                         }
00076                 }
00077                 else
00078                 {
00079                         PrintError("unable to open %s: %m\n",wavChannelFileName[channel]);
00080                 }
00081         }
00082         return(wavChannelFile[channel]);
00083 }
00084 
00088 void CloseWavFile(int channel)
00089 {
00090         char line[128];
00091         int len;
00092         int16_t du;
00093         int32_t dummy;
00094         int SR;
00095         int i,shift=0;
00096         if (wavChannelFile[channel]==NULL)
00097         {
00098                 return;
00099         }
00100         SR=(176.4*infoHeader[channel].sr.base)/infoHeader[channel].sr.div;
00101         if (SR<44100)
00102         {
00103                 SR=8000*(SR/8000);
00104                 if (SR<8000)
00105                 {
00106                         SR=8000;
00107                 }
00108         }
00109         else
00110         {
00111                 SR=22050*(SR/22050);
00112         }
00113         // update the header information
00114         UpdateInfoHeader(channel);
00115         // get the file length
00116         len=ftell(wavChannelFile[channel]);
00117         // and rewrite the header
00118         fseek(wavChannelFile[channel],0,SEEK_SET);
00119 
00120         // update average
00121         Vavg[channel]/=infoHeader[channel].npts;
00122 
00123         /* RIFF header */
00124         if (htons(0xff00)==0xff00) // big endian=network byte order
00125         {
00126                 fwrite("RIFX",4,1,wavChannelFile[channel]);
00127         }
00128         else
00129         {
00130                 fwrite("RIFF",4,1,wavChannelFile[channel]);
00131         }
00132 
00133         // total len - 8
00134         dummy=len-8;
00135         fwrite(&dummy,4,1,wavChannelFile[channel]);
00136 
00137         // WAVE !
00138         fwrite("WAVE",4,1,wavChannelFile[channel]);
00139         /* fmt header */
00140         fwrite("fmt ",4,1,wavChannelFile[channel]);
00141 
00142         dummy=16;   /* PCM */
00143         fwrite(&dummy,4,1,wavChannelFile[channel]);
00144 
00145         du=1;   /* linear */
00146         fwrite(&du,2,1,wavChannelFile[channel]);
00147 
00148         du=1;   /* channels */
00149         fwrite(&du,2,1,wavChannelFile[channel]);
00150 
00151         dummy=SR;   /* sample rate */
00152         fwrite(&dummy,4,1,wavChannelFile[channel]);
00153 
00154         dummy=SR * 32 / 8;   /* byterate */
00155         fwrite(&dummy,4,1,wavChannelFile[channel]);
00156 
00157         du=32/8;     /* BlockAlign */
00158         fwrite(&du,2,1,wavChannelFile[channel]);
00159 
00160         du=8*sizeof(int32_t);   /* BitsPerSample */
00161         fwrite(&du,2,1,wavChannelFile[channel]);
00162 
00163         /* data header */
00164         fwrite("data",4,1,wavChannelFile[channel]);
00165 
00166         // remaining bytes
00167         dummy=len-44;
00168         fwrite(&dummy,4,1,wavChannelFile[channel]);
00169 
00170         for (i=0; i<23; i++)
00171         {
00172                 if ((1<<i)>Vmax[channel]-Vmin[channel])
00173                 {
00174                         shift=(32-i)-1;
00175                         break;
00176                 }
00177         }
00178         for (i=0; i<infoHeader[channel].npts; i++)
00179         {
00180                 if (fread(&dummy,4,1,wavChannelFile[channel])!=1)
00181                 {
00182                         PrintError("could not read output file (%d/%d): %m\n",
00183                                         i,infoHeader[channel].npts);
00184                         break;
00185                 }
00186                 dummy-=Vavg[channel];
00187                 dummy<<=shift;
00188                 fseek(wavChannelFile[channel],-4,SEEK_CUR);
00189                 if (fwrite(&dummy,4,1,wavChannelFile[channel])!=1)
00190                 {
00191                         PrintError("could not write output file (%d/%d): %m\n",
00192                                         i,infoHeader[channel].npts);
00193                         break;
00194                 }
00195         }
00196         fclose(wavChannelFile[channel]);
00197         wavChannelFile[channel]=NULL;
00198         strcpy(line,FileName("", ".WAV", channel, fileNameOptions));
00199         if (noWrite==0)
00200         {
00201                 Rename(wavChannelFileName[channel],line);
00202         }
00203         PrintLog("OUTPUT: %s %d samples (%.2fs)\n",line,
00204                         infoHeader[channel].npts,
00205                         (float)infoHeader[channel].npts/(float)infoHeader[channel].sr.npts);
00206         unlink(wavChannelFileName[channel]);
00207 }
00208 
00211 void AbortWavFile(int channel)
00212 {
00213         PrintDebug("abort for %s\n",wavChannelFileName[channel]);
00214         if (wavChannelFile[channel])
00215         {
00216                 fclose(wavChannelFile[channel]);
00217                 wavChannelFile[channel]=NULL;
00218                 unlink(wavChannelFileName[channel]);
00219         }
00220 }
00221 
00223 void AddWavData(int channel)
00224 {
00225         int i;
00226         int32_t d;
00227         if ((HWConfig.srObs[channel].npts==0)||(HWConfig.srExp[channel].npts==0))
00228         {
00229                 return;
00230         }
00231         if (OpenWavChannel(channel))
00232         {
00233                 for (i=0; i<HWConfig.srObs[channel].npts; i++)
00234                 {
00235                         //int tmp;
00236                         d=HWConfig.data[channel][i];
00237                         /*
00238                         tmp=(int)(80000.*log(1.+fabs((double)d)));
00239                         if (HWConfig.data[channel][i]<0) tmp*=-1;
00240                         d=tmp;
00241                         */
00242                         if (Vmin[channel]>d)
00243                         {
00244                                 Vmin[channel]=d;
00245                         }
00246                         if (Vmax[channel]<d)
00247                         {
00248                                 Vmax[channel]=d;
00249                         }
00250                         Vavg[channel]+=d;
00251                         fwrite(&d,sizeof(int32_t),
00252                                         1,
00253                                         wavChannelFile[channel]);
00254                         infoHeader[channel].npts++;
00255                 }
00256         }
00257 }