lib/wav.c

   1 /* wav.c
   2    Routines for handling .wav files
   3
   4    Part of the swftools package.
   5
   6    Copyright (c) 2001 Matthias Kramm <kramm@quiss.org>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  21
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include "wav.h"
  26
  27 struct WAVBlock {
  28     char id[5];
  29     unsigned int size;
  30 };
  31
  32 int getWAVBlock(FILE*fi, struct WAVBlock*block)
  33 {
  34     unsigned int size;
  35     unsigned char b[4];
  36     if(fread(block->id,1,4,fi)<4)
  37         return 0;
  38     block->id[4] = 0;
  39     if(fread(b,1,4,fi)<4)
  40         return 0;
  41     block->size = b[0]|b[1]<<8|b[2]<<16|b[3]<<24;
  42     /*printf("Chunk: [%c%c%c%c] (%d bytes)\n",
  43             block->id[0],block->id[1],
  44             block->id[2],block->id[3],
  45             block->size);*/
  46     return 1;
  47 }
  48
  49 int wav_read(struct WAV*wav, char* filename)
  50 {
  51     FILE*fi = fopen(filename, "rb");
  52     unsigned char b[16];
  53     long int filesize;
  54     struct WAVBlock block;
  55     long int pos;
  56     if(!fi)
  57         return 0;
  58     fseek(fi, 0, SEEK_END);
  59     filesize = ftell(fi);
  60     fseek(fi, 0, SEEK_SET);
  61
  62     //printf("Filesize: %d\n", filesize);
  63
  64     if(!getWAVBlock (fi, &block))
  65         return 0;
  66     if(strncmp(block.id,"RIFF",4)) {
  67         fprintf(stderr, "wav_read: not a WAV file\n");
  68         return 0;
  69     }
  70     if(block.size + 8 < filesize)
  71         fprintf(stderr, "wav_read: warning - more tags (%d extra bytes)\n",
  72                 filesize - block.size - 8);
  73
  74     if(block.size == filesize) {
  75         /* some buggy software doesn't generate the right tag length */
  76         block.size = filesize - 8;
  77     }
  78
  79     if(block.size + 8 > filesize)
  80         fprintf(stderr, "wav_read: warning - short file (%d bytes missing)\n",
  81                 block.size + 8 -  filesize);
  82     if(fread(b, 1, 4, fi) < 4) {
  83         return 0;
  84     }
  85     if(strncmp(b, "WAVE", 4)) {
  86         fprintf(stderr, "wav_read: not a WAV file (2)\n");
  87         return 0;
  88     }
  89
  90     do
  91     {
  92         getWAVBlock(fi, &block);
  93         pos = ftell(fi);
  94         if(!strncmp(block.id, "fmt ", 4)) {
  95             if(fread(&b, 1, 16, fi)<16)
  96                 return 0;
  97             wav->tag = b[0]|b[1]<<8;
  98             wav->channels = b[2]|b[3]<<8;
  99             wav->sampsPerSec = b[4]|b[5]<<8|b[6]<<16|b[7]<<24;
 100             wav->bytesPerSec = b[8]|b[9]<<8|b[10]<<16|b[11]<<24;
 101             wav->align = b[12]|b[13]<<8;
 102             wav->bps = b[14]|b[15]<<8;
 103         } else if (!strncmp(block.id, "LIST", 4)) {
 104             // subchunk ICMT (comment) may exist
 105         } else if (!strncmp(block.id, "data", 4)) {
 106             int l;
 107             wav->data = malloc(block.size);
 108             if(!wav->data) {
 109                 fprintf(stderr, "Out of memory (%d bytes needed)", block.size);
 110                 return 0;
 111             }
 112             l = fread(wav->data, 1, block.size, fi);
 113             if(l < block.size) {
 114                 fprintf(stderr, "Error while reading data block of size %d (%d bytes missing)", block.size, block.size-l);
 115                 return 0;
 116             }
 117             wav->size = block.size;
 118         }
 119         pos+=block.size;
 120         fseek(fi, pos, SEEK_SET);
 121     }
 122     while (pos < filesize);
 123
 124     return 1;
 125 }
 126
 127 int wav_write(struct WAV*wav, char*filename)
 128 {
 129     FILE*fi = fopen(filename, "wb");
 130     char*b="RIFFWAVEfmt \x10\0\0\0data";
 131     char c[16];
 132     unsigned long int w32;
 133     if(!fi)
 134         return 0;
 135     fwrite(b, 4, 1, fi);
 136     w32=(/*fmt*/8+0x10+/*data*/8+wav->size);
 137     c[0] = w32;
 138     c[1] = w32>>8;
 139     c[2] = w32>>16;
 140     c[3] = w32>>24;
 141     fwrite(c, 4, 1, fi);
 142     fwrite(&b[4], 12, 1, fi);
 143     c[0] = wav->tag;
 144     c[1] = wav->tag>>8;
 145     c[2] = wav->channels;
 146     c[3] = wav->channels>>8;
 147     c[4] = wav->sampsPerSec;
 148     c[5] = wav->sampsPerSec>>8;
 149     c[6] = wav->sampsPerSec>>16;
 150     c[7] = wav->sampsPerSec>>24;
 151     c[8] = wav->bytesPerSec;
 152     c[9] = wav->bytesPerSec>>8;
 153     c[10] = wav->bytesPerSec>>16;
 154     c[11] = wav->bytesPerSec>>24;
 155     c[12] = wav->align;
 156     c[13] = wav->align>>8;
 157     c[14] = wav->bps;
 158     c[15] = wav->bps>>8;
 159     fwrite(c, 16, 1, fi);
 160     fwrite(&b[16], 4, 1, fi);
 161     c[0] = wav->size;
 162     c[1] = wav->size>>8;
 163     c[2] = wav->size>>16;
 164     c[3] = wav->size>>24;
 165     fwrite(c,4,1,fi);
 166     printf("writing %d converted bytes\n", wav->size);
 167     fwrite(wav->data,wav->size,1,fi);
 168     fclose(fi);
 169     return 1;
 170 }
 171
 172 void wav_print(struct WAV*wav)
 173 {
 174     printf("tag:%04x channels:%d samples/sec:%d bytes/sec:%d align:%d bits/sample:%d size:%d\n",
 175             wav->tag, wav->channels, wav->sampsPerSec, wav->bytesPerSec,
 176             wav->align, wav->bps, wav->size);
 177 }
 178
 179 int wav_convert2mono(struct WAV*src, struct WAV*dest, int rate)
 180 {
 181     int samplelen=src->size/src->align;
 182     int bps=src->bps;
 183     double ratio;
 184     double pos = 0;
 185     int pos2 = 0;
 186     int channels=src->channels;
 187     int i;
 188     int fill;
 189
 190     dest->sampsPerSec = rate;
 191     dest->bps = 16;
 192     dest->channels = 1;
 193     dest->align = 2;
 194     dest->tag = src->tag;
 195     dest->bytesPerSec = dest->sampsPerSec*dest->align;
 196
 197     ratio = (double)dest->sampsPerSec/(double)src->sampsPerSec;
 198     fill = (int)(ratio+1)*2;
 199
 200     dest->data = (unsigned char*)malloc((int)(samplelen*ratio*2)+128);
 201     if(!dest->data)
 202         return 0;
 203     dest->size = (int)(samplelen*ratio)*2;
 204
 205     if(bps == 8) {
 206         if(ratio <= 1) {
 207             for(i=0; i<src->size; i+=channels) {
 208                 int pos2 = ((int)pos)*2;
 209                 dest->data[pos2] = 0;
 210                 dest->data[pos2+1] = src->data[i]+128;
 211                 pos += ratio;
 212             }
 213         } else {
 214             for(i=0; i<src->size; i+=channels) {
 215                 int j;
 216                 int pos2 = ((int)pos)*2;
 217                 for(j=0;j<fill;j+=2) {
 218                     dest->data[pos2+j+0] = 0;
 219                     dest->data[pos2+j+1] = src->data[i]+128;
 220                 }
 221                 pos += ratio;
 222             }
 223         }
 224     } else if(bps == 16) {
 225         if(ratio <= 1) {
 226             for(i=0; i<src->size/2; i+=channels) {
 227                 int pos2 = ((int)pos)*2;
 228                 dest->data[pos2+0]=src->data[i*2];
 229                 dest->data[pos2+1]=src->data[i*2+1];
 230                 pos += ratio;
 231             }
 232         } else {
 233             for(i=0; i<src->size/2; i+=channels) {
 234                 int j;
 235                 int pos2 = ((int)pos)*2;
 236                 for(j=0;j<fill;j+=2) {
 237                     dest->data[pos2+j+0] = src->data[i*2];
 238                     dest->data[pos2+j+1] = src->data[i*2+1];
 239                 }
 240                 pos += ratio;
 241             }
 242         }
 243     } else if(bps == 32) {
 244         if(ratio <= 1) {
 245             for(i=0; i<src->size/4; i+=channels) {
 246                 int pos2 = ((int)pos)*2;
 247                 dest->data[pos2+0]=src->data[i*4+2];
 248                 dest->data[pos2+1]=src->data[i*4+3];
 249                 pos += ratio;
 250             }
 251         } else {
 252             for(i=0; i<src->size/4; i+=channels) {
 253                 int j;
 254                 int pos2 = ((int)pos)*2;
 255                 for(j=0;j<fill;j+=2) {
 256                     dest->data[pos2+j+0] = src->data[i*4+2];
 257                     dest->data[pos2+j+1] = src->data[i*4+3];
 258                 }
 259                 pos += ratio;
 260             }
 261         }
 262     } else {
 263         fprintf(stderr, "Unsupported bitspersample value: %d\n", bps);
 264     }
 265     return 1;
 266 }
 267
 268