tools/wavtrim.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2004 by Jörg Hohensohn
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  * Details at http://www.rockbox.org/twiki/bin/view/Main/VoiceBuilding
  21  *
  22  ****************************************************************************/
  23
  24
  25 #include <stdio.h>  /* for file I/O */
  26 #include <stdlib.h> /* for malloc */
  27
  28 #include "wavtrim.h"
  29
  30 /* place a 32 bit value into memory, little endian */
  31 void Write32(unsigned char* pByte, unsigned long value)
  32 {
  33     pByte[0] = (unsigned char)value;
  34     pByte[1] = (unsigned char)(value >> 8);
  35     pByte[2] = (unsigned char)(value >> 16);
  36     pByte[3] = (unsigned char)(value >> 24) ;
  37 }
  38
  39
  40 /* read a 32 bit value from memory, little endian */
  41 unsigned long Read32(unsigned char* pByte)
  42 {
  43     unsigned long value = 0;
  44
  45     value |= (unsigned long)pByte[0];
  46     value |= (unsigned long)pByte[1] << 8;
  47     value |= (unsigned long)pByte[2] << 16;
  48     value |= (unsigned long)pByte[3] << 24;
  49
  50     return value;
  51 }
  52
  53
  54 /* place a 16 bit value into memory, little endian */
  55 void Write16(unsigned char* pByte, unsigned short value)
  56 {
  57     pByte[0] = (unsigned char)value;
  58     pByte[1] = (unsigned char)(value >> 8);
  59 }
  60
  61
  62 /* read a 16 bit value from memory, little endian */
  63 unsigned long Read16(unsigned char* pByte)
  64 {
  65     unsigned short value = 0;
  66
  67     value |= (unsigned short)pByte[0];
  68     value |= (unsigned short)pByte[1] << 8;
  69
  70     return value;
  71 }
  72
  73 int wavtrim(char * filename, int maxsilence ,char* errstring,int errsize)
  74 {
  75     FILE* pFile;
  76     long lFileSize, lGot;
  77     unsigned char* pBuf;
  78     int bps; /* byte per sample */
  79     int sps; /* samples per second */
  80     int datapos; /* where the payload starts */
  81     int datalen; /* Length of the data chunk */
  82     unsigned char *databuf; /* Pointer to the data chunk payload */
  83     int skip_head, skip_tail, pad_head, pad_tail;
  84     int i;
  85     int max_silence = maxsilence;
  86     signed char sample8;
  87     short sample16;
  88
  89     pFile = fopen(filename, "rb");
  90     if (pFile == NULL)
  91     {
  92         snprintf(errstring,errsize,"Error opening file %s for reading\n", filename);
  93         return -1;
  94     }
  95
  96     fseek(pFile, 0, SEEK_END);
  97     lFileSize = ftell(pFile);
  98     fseek(pFile, 0, SEEK_SET);
  99
 100     pBuf = malloc(lFileSize);
 101     if (pBuf == NULL)
 102     {
 103         snprintf(errstring,errsize,"Out of memory to allocate %ld bytes for file.\n", lFileSize);
 104         fclose(pFile);
 105         return -1;
 106     }
 107
 108     lGot = fread(pBuf, 1, lFileSize, pFile);
 109     fclose(pFile);
 110     if (lGot != lFileSize)
 111     {
 112         snprintf(errstring,errsize,"File read error, got only %ld bytes out of %ld.\n", lGot, lFileSize);
 113         free(pBuf);
 114         return -1;
 115     }
 116
 117
 118     bps = Read16(pBuf + 32);
 119     datapos = 28 + Read16(pBuf + 16);
 120     databuf = &pBuf[datapos];
 121
 122     if (Read32(pBuf) != 0x46464952 /* "RIFF" */
 123      || Read32(pBuf+8) != 0x45564157 /* "WAVE" */
 124      || Read32(pBuf+12) != 0x20746d66 /* "fmt " */
 125      || Read32(pBuf+datapos-8) != 0x61746164) /* "data" */
 126     {
 127         snprintf(errstring,errsize,"No valid input WAV file?\n");
 128         free(pBuf);
 129         return -1;
 130     }
 131
 132     datalen = Read32(pBuf+datapos-4);
 133     skip_head = skip_tail = 0;
 134
 135     sps = Read32(pBuf + 24);
 136     pad_head = sps * 10 / 1000; /* 10 ms */
 137     pad_tail = sps * 10 / 1000; /* 10 ms */
 138
 139     if (bps == 1) /* 8 bit samples */
 140     {
 141
 142         max_silence >>= 8;
 143
 144         /* clip the start */
 145         for (i=0; i<datalen; i++)
 146         {
 147             sample8 = databuf[i] - 0x80;
 148             if (abs(sample8) > max_silence)
 149                 break;
 150         }
 151         skip_head = i;
 152         skip_head = (skip_head > pad_head) ? skip_head - pad_head : 0;
 153
 154         /* clip the end */
 155         for (i=datalen-1; i>skip_head; i--)
 156         {
 157             sample8 = databuf[i] - 0x80;
 158             if (abs(sample8) > max_silence)
 159                 break;
 160         }
 161         skip_tail = datalen - 1 - i;
 162         skip_tail = (skip_tail > pad_tail) ? skip_tail - pad_tail : 0;
 163     }
 164     else if (bps == 2) /* 16 bit samples */
 165     {
 166
 167         /* clip the start */
 168         for (i=0; i<datalen; i+=2)
 169         {
 170             /* samples are little endian */
 171             sample16 = (*(databuf + i + 1) << 8) | *(databuf + i);
 172
 173             if (abs(sample16) > max_silence)
 174                 break;
 175         }
 176         skip_head = i;
 177         skip_head = (skip_head > 2 * pad_head) ?
 178                      skip_head - 2 * pad_head : 0;
 179
 180         /* clip the end */
 181         for (i=datalen-2; i>skip_head; i-=2)
 182         {
 183             /* samples are little endian */
 184             sample16 = (*(databuf + i + 1) << 8) | *(databuf + i);
 185             if (abs(sample16) > max_silence)
 186                 break;
 187         }
 188         skip_tail = datalen - 2 - i;
 189         skip_tail = (skip_tail > 2 * pad_tail) ?
 190                      skip_tail - 2 * pad_tail : 0;
 191     }
 192
 193     /* update the size in the headers */
 194     Write32(pBuf+4, Read32(pBuf+4) - skip_head - skip_tail);
 195     Write32(pBuf+datapos-4, datalen - skip_head - skip_tail);
 196
 197     pFile = fopen(filename, "wb");
 198     if (pFile == NULL)
 199     {
 200         snprintf(errstring,errsize,"Error opening file %s for writing\n",filename);
 201         return -1;
 202     }
 203
 204     /* write the new file */
 205     fwrite(pBuf, 1, datapos, pFile); /* write header */
 206     fwrite(pBuf + datapos + skip_head, 1, datalen - skip_head - skip_tail, pFile);
 207     fclose(pFile);
 208
 209     free(pBuf);
 210     return 0;
 211
 212 }
 213
 214 #ifndef RBUTIL
 215 int main (int argc, char** argv)
 216 {
 217     int max_silence = 0;
 218     char errbuffer[255];
 219     int ret=0;
 220
 221     if (argc < 2)
 222     {
 223         printf("wavtrim removes silence at the begin and end of a WAV file.\n");
 224         printf("usage: wavtrim <filename.wav> [<max_silence>]\n");
 225         return 0;
 226     }
 227
 228     if (argc == 3)
 229     {
 230         max_silence = atoi(argv[2]);
 231     }
 232
 233
 234     ret = wavtrim(argv[1],max_silence,errbuffer,255 );
 235     if( ret< 0)
 236     {
 237         printf("%s", errbuffer);
 238     }
 239     return ret;
 240 }
 241 #endif
 242 /*
 243 RIFF Chunk (12 bytes in length total)
 244 0 - 3  "RIFF" (ASCII Characters)
 245 4 - 7  Total Length Of Package To Follow (Binary, little endian)
 246 8 - 11  "WAVE" (ASCII Characters)
 247
 248
 249 FORMAT Chunk (24 or 26 bytes in length total) Byte Number
 250 12 - 15  "fmt_" (ASCII Characters)
 251 16 - 19  Length Of FORMAT Chunk (Binary, 0x10 or 0x12 seen)
 252 20 - 21  Always 0x01
 253 22 - 23  Channel Numbers (Always 0x01=Mono, 0x02=Stereo)
 254 24 - 27 Sample Rate (Binary, in Hz)
 255 28 - 31 Bytes Per Second
 256 32 - 33 Bytes Per Sample: 1=8 bit Mono, 2=8 bit Stereo or 16 bit Mono, 4=16 bit Stereo
 257 34 - 35 Bits Per Sample
 258
 259
 260 DATA Chunk Byte Number
 261 36 - 39 "data" (ASCII Characters)
 262 40 - 43  Length Of Data To Follow
 263 44 - end
 264  Data (Samples)
 265 */