home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / System / MorphOS / SoX / Source / wav.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-07-18  |  30.7 KB  |  1,052 lines
  1. /*
  2.  * Microsoft's WAVE sound format driver
  3.  *
  4.  * This source code is freely redistributable and may be used for
  5.  * any purpose.  This copyright notice must be maintained. 
  6.  * Lance Norskog And Sundry Contributors are not responsible for 
  7.  * the consequences of using this software.
  8.  *
  9.  * Change History:
  10.  *
  11.  * September 11, 1998 - Chris Bagwell (cbagwell@sprynet.com)
  12.  *   Fixed length bug for IMA and MS ADPCM files.
  13.  *
  14.  * June 1, 1998 - Chris Bagwell (cbagwell@sprynet.com)
  15.  *   Fixed some compiler warnings as reported by Kjetil Torgrim Homme
  16.  *   <kjetilho@ifi.uio.no>.
  17.  *   Fixed bug that caused crashes when reading mono MS ADPCM files. Patch
  18.  *   was sent from Michael Brown (mjb@pootle.demon.co.uk).
  19.  *
  20.  * March 15, 1998 - Chris Bagwell (cbagwell@sprynet.com)
  21.  *   Added support for Microsoft's ADPCM and IMA (or better known as
  22.  *   DVI) ADPCM format for wav files.  Info on these formats
  23.  *   was taken from the xanim project, written by
  24.  *   Mark Podlipec (podlipec@ici.net).  For those pieces of code,
  25.  *   the following copyrights notice applies:
  26.  *
  27.  *    XAnim Copyright (C) 1990-1997 by Mark Podlipec.
  28.  *    All rights reserved.
  29.  * 
  30.  *    This software may be freely copied, modified and redistributed without
  31.  *    fee for non-commerical purposes provided that this copyright notice is
  32.  *    preserved intact on all copies and modified copies.
  33.  * 
  34.  *    There is no warranty or other guarantee of fitness of this software.
  35.  *    It is provided solely "as is". The author(s) disclaim(s) all
  36.  *    responsibility and liability with respect to this software's usage
  37.  *    or its effect upon hardware or computer systems.
  38.  *
  39.  * NOTE: Previous maintainers weren't very good at providing contact
  40.  * information.
  41.  *
  42.  * Copyright 1992 Rick Richardson
  43.  * Copyright 1991 Lance Norskog And Sundry Contributors
  44.  *
  45.  * Fixed by various contributors previous to 1998:
  46.  * 1) Little-endian handling
  47.  * 2) Skip other kinds of file data
  48.  * 3) Handle 16-bit formats correctly
  49.  * 4) Not go into infinite loop
  50.  *
  51.  * User options should override file header - we assumed user knows what
  52.  * they are doing if they specify options.
  53.  * Enhancements and clean up by Graeme W. Gill, 93/5/17
  54.  *
  55.  * Info for format tags can be found at:
  56.  *   http://www.microsoft.com/asf/resources/draft-ietf-fleischman-codec-subtree-01.txt
  57.  *
  58.  */
  59.  
  60. #include <string.h>        /* Included for strncmp */
  61. #include <stdlib.h>        /* Included for malloc and free */
  62. #ifdef HAVE_MALLOC_H
  63. #include <malloc.h>
  64. #endif
  65. #include <stdio.h>
  66.  
  67. #ifdef HAVE_UNISTD_H
  68. #include <unistd.h>        /* For SEEK_* defines if not found in stdio */
  69. #endif
  70.  
  71. #include "st.h"
  72. #include "wav.h"
  73.  
  74. /* Private data for .wav file */
  75. typedef struct wavstuff {
  76.     LONG       numSamples;
  77.     int           second_header;  /* non-zero on second header write */
  78.     unsigned short formatTag;       /* What type of encoding file is using */
  79.     
  80.     /* The following are only needed for ADPCM wav files */
  81.     unsigned short samplesPerBlock;
  82.     unsigned short bytesPerBlock;
  83.     unsigned short blockAlign;
  84.     short      *samples[2];        /* Left and Right sample buffers */
  85.     short      *samplePtr[2];    /* Pointers to current samples */
  86.     unsigned short blockSamplesRemaining;/* Samples remaining in each channel */    
  87.     unsigned char *packet;        /* Temporary buffer for packets */
  88. } *wav_t;
  89.  
  90. static char *wav_format_str();
  91.  
  92. LONG rawread(P3(ft_t, LONG *, LONG));
  93. void rawwrite(P3(ft_t, LONG *, LONG));
  94. void wavwritehdr(P1(ft_t));
  95.  
  96.  
  97. /*
  98.  *
  99.  * Lookup tables for MS ADPCM format
  100.  *
  101.  */
  102.  
  103. static LONG gaiP4[]    = { 230, 230, 230, 230, 307, 409, 512, 614,
  104.                768, 614, 512, 409, 307, 230, 230, 230 };
  105.  
  106. /* TODO : The first 7 coef's are are always hardcode and must
  107.    appear in the actual WAVE file.  They should be read in
  108.    in case a sound program added extras to the list. */
  109.  
  110. static LONG gaiCoef1[] = { 256, 512, 0, 192, 240, 460,  392 };
  111. static LONG gaiCoef2[] = { 0, -256,  0,  64,   0,-208, -232};
  112.  
  113. /*
  114.  *
  115.  * Lookup tables for IMA ADPCM format
  116.  *
  117.  */
  118. static int imaIndexAdjustTable[16] = {
  119.    -1, -1, -1, -1,  /* +0 - +3, decrease the step size */
  120.     2, 4, 6, 8,     /* +4 - +7, increase the step size */
  121.    -1, -1, -1, -1,  /* -0 - -3, decrease the step size */
  122.     2, 4, 6, 8,     /* -4 - -7, increase the step size */
  123. };
  124.  
  125. static int imaStepSizeTable[89] = {
  126.    7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31, 34,
  127.    37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143,
  128.    157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449, 494,
  129.    544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552,
  130.    1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660, 4026,
  131.    4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493, 10442,
  132.    11487, 12635, 13899, 15289, 16818, 18500, 20350, 22385, 24623,
  133.    27086, 29794, 32767
  134. };
  135.  
  136. /****************************************************************************/
  137. /* IMA ADPCM Support Functions Section                                      */
  138. /****************************************************************************/
  139.  
  140. /*
  141.  *
  142.  * MsAdpcmDecode - Decode a given sample and update state tables
  143.  *
  144.  */
  145.  
  146. short ImaAdpcmDecode(deltaCode, state) 
  147. unsigned char deltaCode;
  148. ImaState_t *state;
  149. {
  150.     /* Get the current step size */
  151.    int step;
  152.    int difference;
  153.  
  154.    step = imaStepSizeTable[state->index];
  155.    
  156.    /* Construct the difference by scaling the current step size */
  157.    /* This is approximately: difference = (deltaCode+.5)*step/4 */
  158.    difference = step>>3;
  159.    if ( deltaCode & 1 ) difference += step>>2;
  160.    if ( deltaCode & 2 ) difference += step>>1;
  161.    if ( deltaCode & 4 ) difference += step;
  162.  
  163.    if ( deltaCode & 8 ) difference = -difference;
  164.  
  165.    /* Build the new sample */
  166.    state->previousValue += difference;
  167.  
  168.    if (state->previousValue > 32767) state->previousValue = 32767;
  169.    else if (state->previousValue < -32768) state->previousValue = -32768;
  170.  
  171.    /* Update the step for the next sample */
  172.    state->index += imaIndexAdjustTable[deltaCode];
  173.    if (state->index < 0) state->index = 0;
  174.    else if (state->index > 88) state->index = 88;
  175.  
  176.    return state->previousValue;
  177.  
  178. }
  179.  
  180. /*
  181.  *
  182.  * ImaAdpcmNextBlock - Grab and decode complete block of samples
  183.  *
  184.  */
  185. unsigned short  ImaAdpcmNextBlock(ft)
  186. ft_t ft;    
  187. {
  188.     wav_t    wav = (wav_t) ft->priv;
  189.     
  190.     /* Pull in the packet and check the header */
  191.     unsigned short bytesRead;
  192.     unsigned char *bytePtr;
  193.  
  194.     ImaState_t state[2];  /* One decompressor state for each channel */
  195.     int ch;
  196.     unsigned short remaining;
  197.     unsigned short samplesThisBlock;
  198.  
  199.     int i;
  200.     unsigned char b;
  201.  
  202.     bytesRead = fread(wav->packet,1,wav->blockAlign,ft->fp);
  203.     if (bytesRead < wav->blockAlign) 
  204.     { 
  205.     /* If it looks like a valid header is around then try and */
  206.     /* work with partial blocks.  Specs say it should be null */
  207.     /* padded but I guess this is better then trailing quite. */
  208.     if (bytesRead >= (4 * ft->info.channels))
  209.     {
  210.         samplesThisBlock = (wav->blockAlign - (3 * ft->info.channels));
  211.     }
  212.     else
  213.     {
  214.         warn ("Premature EOF on .wav input file");
  215.         return 0;
  216.     }
  217.     }
  218.     else
  219.     samplesThisBlock = wav->samplesPerBlock;
  220.     
  221.     bytePtr = wav->packet;
  222.  
  223.     /* Read the four-byte header for each channel */
  224.  
  225.     /* Reset the decompressor */
  226.     for(ch=0;ch < ft->info.channels; ch++) {
  227.        
  228.     /* Got this from xanim */
  229.  
  230.     state[ch].previousValue = ((int)bytePtr[1]<<8) +
  231.         (int)bytePtr[0];
  232.     if (state[ch].previousValue & 0x8000)
  233.         state[ch].previousValue -= 0x10000;
  234.  
  235.     if (bytePtr[2] > 88)
  236.     {
  237.         warn("IMA ADPCM Format Error (bad index value) in wav file");
  238.         state[ch].index = 88;
  239.     }
  240.     else
  241.         state[ch].index = bytePtr[2];
  242.     
  243.     if (bytePtr[3])
  244.         warn("IMA ADPCM Format Error (synchronization error) in wav file");
  245.     
  246.     bytePtr+=4; /* Skip this header */
  247.  
  248.     wav->samplePtr[ch] = wav->samples[ch];
  249.     /* Decode one sample for the header */
  250.     *(wav->samplePtr[ch]++) = state[ch].previousValue;
  251.     }
  252.  
  253.     /* Decompress nybbles. Remainging is bytes in block minus header  */
  254.     /* Subtract the one sample taken from header */
  255.     remaining = samplesThisBlock-1;
  256.     
  257.     while (remaining) {
  258.     /* Always decode 8 samples */
  259.     remaining -= 8;
  260.     /* Decode 8 left samples */
  261.     for (i=0;i<4;i++) {
  262.         b = *bytePtr++;
  263.         *(wav->samplePtr[0]++) = ImaAdpcmDecode(b & 0x0f,&state[0]);
  264.         *(wav->samplePtr[0]++) = ImaAdpcmDecode((b>>4) & 0x0f,&state[0]);
  265.     }
  266.     if (ft->info.channels < 2)
  267.         continue; /* If mono, skip rest of loop */
  268.     /* Decode 8 right samples */
  269.     for (i=0;i<4;i++) {
  270.         b = *bytePtr++;
  271.         *(wav->samplePtr[1]++) = ImaAdpcmDecode(b & 0x0f,&state[1]);
  272.         *(wav->samplePtr[1]++) = ImaAdpcmDecode((b>>4) & 0x0f,&state[1]);
  273.     }
  274.     }
  275.     /* For a full block, the following should be true: */
  276.     /* wav->samplesPerBlock = blockAlign - 8byte header + 1 sample in header */
  277.     return wav->samplesPerBlock;
  278. }     
  279.  
  280. /****************************************************************************/
  281. /* MS ADPCM Support Functions Section                                       */
  282. /****************************************************************************/
  283.  
  284. /*
  285.  *
  286.  * MsAdpcmDecode - Decode a given sample and update state tables
  287.  *
  288.  */
  289.  
  290. LONG MsAdpcmDecode(deltaCode, state) 
  291. LONG deltaCode;
  292. MsState_t *state;
  293. {
  294.     LONG predict;
  295.     LONG sample;
  296.     LONG idelta;
  297.  
  298.     /** Compute next Adaptive Scale Factor (ASF) **/
  299.     idelta = state->index;
  300.     state->index = (gaiP4[deltaCode] * idelta) >> 8;
  301.     if (state->index < 16) state->index = 16;
  302.     if (deltaCode & 0x08) deltaCode = deltaCode - 0x10;
  303.     
  304.     /** Predict next sample **/
  305.     predict = ((state->sample1 * gaiCoef1[state->bpred]) + (state->sample2 * gaiCoef2[state->bpred])) >> 8;
  306.     /** reconstruct original PCM **/
  307.     sample = (deltaCode * idelta) + predict;
  308.     
  309.     if (sample > 32767) sample = 32767;
  310.     else if (sample < -32768) sample = -32768;
  311.     
  312.     state->sample2 = state->sample1;
  313.     state->sample1 = sample;
  314.     
  315.     return (sample);
  316. }
  317.     
  318.  
  319. /*
  320.  *
  321.  * MsAdpcmNextBlock - Grab and decode complete block of samples
  322.  *
  323.  */
  324. unsigned short  MsAdpcmNextBlock(ft)
  325. ft_t ft;    
  326. {
  327.     wav_t    wav = (wav_t) ft->priv;
  328.     
  329.     unsigned short bytesRead;
  330.     unsigned char *bytePtr;
  331.  
  332.     MsState_t state[2];  /* One decompressor state for each channel */
  333.     unsigned short samplesThisBlock;
  334.     unsigned short remaining;
  335.  
  336.     unsigned char b;
  337.  
  338.     /* Pull in the packet and check the header */
  339.     bytesRead = fread(wav->packet,1,wav->blockAlign,ft->fp);
  340.     if (bytesRead < wav->blockAlign) 
  341.     {
  342.     /* If it looks like a valid header is around then try and */
  343.     /* work with partial blocks.  Specs say it should be null */
  344.     /* padded but I guess this is better then trailing quite. */
  345.     if (bytesRead >= (7 * ft->info.channels))
  346.     {
  347.         samplesThisBlock = (wav->blockAlign - (6 * ft->info.channels));
  348.     }
  349.     else
  350.     {
  351.         warn ("Premature EOF on .wav input file");
  352.         return 0;
  353.     }
  354.     }
  355.     else
  356.     samplesThisBlock = wav->samplesPerBlock;
  357.     
  358.     bytePtr = wav->packet;
  359.  
  360.     /* Read the four-byte header for each channel */
  361.  
  362.     /* Reset the decompressor */
  363.     state[0].bpred = *bytePtr++;    /* Left */
  364.     if (ft->info.channels > 1)
  365.     state[1].bpred = *bytePtr++;    /* Right */
  366.     else
  367.     state[1].bpred = 0;
  368.  
  369.     /* 7 should be variable from AVI/WAV header */
  370.     if (state[0].bpred >= 7)
  371.     {
  372.     warn("MSADPCM bpred %x and should be less than 7\n",state[0].bpred);
  373.     return(0);
  374.     }
  375.     if (state[1].bpred >= 7)
  376.     {
  377.     warn("MSADPCM bpred %x and should be less than 7\n",state[1].bpred);
  378.     return(0);
  379.     }
  380.     
  381.     state[0].index = *bytePtr++;  state[0].index |= (*bytePtr++)<<8;
  382.     if (state[0].index & 0x8000) state[0].index -= 0x10000;
  383.     if (ft->info.channels > 1)
  384.     {
  385.     state[1].index = *bytePtr++;  state[1].index |= (*bytePtr++)<<8;
  386.     if (state[1].index & 0x8000) state[1].index -= 0x10000;
  387.     }
  388.  
  389.     state[0].sample1 = *bytePtr++;  state[0].sample1 |= (*bytePtr++)<<8;
  390.     if (state[0].sample1 & 0x8000) state[0].sample1 -= 0x10000;
  391.     if (ft->info.channels > 1)
  392.     {
  393.     state[1].sample1 = *bytePtr++;  state[1].sample1 |= (*bytePtr++)<<8;
  394.     if (state[1].sample1 & 0x8000) state[1].sample1 -= 0x10000;
  395.     }
  396.  
  397.     state[0].sample2 = *bytePtr++;  state[0].sample2 |= (*bytePtr++)<<8;
  398.     if (state[0].sample2 & 0x8000) state[0].sample2 -= 0x10000;
  399.     if (ft->info.channels > 1)
  400.     {
  401.     state[1].sample2 = *bytePtr++;  state[1].sample2 |= (*bytePtr++)<<8;
  402.     if (state[1].sample2 & 0x8000) state[1].sample2 -= 0x10000;
  403.     }
  404.  
  405.     wav->samplePtr[0] = wav->samples[0];
  406.     wav->samplePtr[1] = wav->samples[1];
  407.     
  408.     /* Decode two samples for the header */
  409.     *(wav->samplePtr[0]++) = state[0].sample2;
  410.     *(wav->samplePtr[0]++) = state[0].sample1;
  411.     if (ft->info.channels > 1)
  412.     {
  413.     *(wav->samplePtr[1]++) = state[1].sample2;
  414.     *(wav->samplePtr[1]++) = state[1].sample1;
  415.     }
  416.  
  417.     /* Decompress nybbles.  Minus 2 included in header */
  418.     remaining = samplesThisBlock-2;
  419.  
  420.     while (remaining) {
  421.     b = *bytePtr++;
  422.     *(wav->samplePtr[0]++) = MsAdpcmDecode((b>>4) & 0x0f, &state[0]);
  423.     remaining--;
  424.     if (ft->info.channels == 1)
  425.     {        
  426.         *(wav->samplePtr[0]++) = MsAdpcmDecode(b & 0x0f, &state[0]);
  427.         remaining--;
  428.     }
  429.     else
  430.     {
  431.         *(wav->samplePtr[1]++) = MsAdpcmDecode(b & 0x0f, &state[1]);
  432.     }
  433.     }
  434.     return samplesThisBlock;
  435. }
  436.  
  437. /****************************************************************************/
  438. /* General Sox WAV file code                                                */
  439. /****************************************************************************/
  440.  
  441. /*
  442.  * Do anything required before you start reading samples.
  443.  * Read file header. 
  444.  *    Find out sampling rate, 
  445.  *    size and style of samples, 
  446.  *    mono/stereo/quad.
  447.  */
  448. void wavstartread(ft) 
  449. ft_t ft;
  450. {
  451.     wav_t    wav = (wav_t) ft->priv;
  452.     char    magic[4];
  453.     ULONG    len;
  454.     int        littlendian = 1;
  455.     char    *endptr;
  456.  
  457.     /* wave file characteristics */
  458.     unsigned short wChannels;        /* number of channels */
  459.     ULONG    wSamplesPerSecond;     /* samples per second per channel */
  460.     ULONG    wAvgBytesPerSec;        /* estimate of bytes per second needed */
  461.     unsigned short wBitsPerSample;  /* bits per sample */
  462.     unsigned short wExtSize = 0;    /* extended field for ADPCM */
  463.     unsigned short wNumCoefs = 0;   /* Related to IMA ADPCM */
  464.     
  465.     ULONG    data_length;        /* length of sound data in bytes */
  466.     ULONG    bytespersample;        /* bytes per sample (per channel */
  467.  
  468.     /* This is needed for rawread() */
  469.     rawstartread(ft);
  470.  
  471.     endptr = (char *) &littlendian;
  472.     if (!*endptr) ft->swap = ft->swap ? 0 : 1;
  473.  
  474.     /* If you need to seek around the input file. */
  475.     if (0 && ! ft->seekable)
  476.     fail("WAVE input file must be a file, not a pipe");
  477.  
  478.     if ( fread(magic, 1, 4, ft->fp) != 4 || strncmp("RIFF", magic, 4))
  479.     fail("WAVE: RIFF header not found");
  480.  
  481.     len = rlong(ft);
  482.  
  483.     if ( fread(magic, 1, 4, ft->fp) != 4 || strncmp("WAVE", magic, 4))
  484.     fail("WAVE header not found");
  485.  
  486.     /* Now look for the format chunk */
  487.     for (;;)
  488.     {
  489.     if ( fread(magic, 1, 4, ft->fp) != 4 )
  490.         fail("WAVE file missing fmt spec");
  491.     len = rlong(ft);
  492.     if (strncmp("fmt ", magic, 4) == 0)
  493.         break;                /* Found the format chunk */
  494.  
  495.     /* skip to next chunk */    
  496.     while (len > 0 && !feof(ft->fp))
  497.     {
  498.         getc(ft->fp);
  499.         len--;
  500.     }
  501.     }
  502.  
  503.     if ( len < 16 )
  504.     fail("WAVE file fmt chunk is too short");
  505.  
  506.     wav->formatTag = rshort(ft);
  507.     len -= 2;
  508.     switch (wav->formatTag)
  509.     {
  510.     case WAVE_FORMAT_UNKNOWN:
  511.     fail("WAVE file is in unsupported Microsoft Official Unknown format.");
  512.     
  513.     case WAVE_FORMAT_PCM:
  514.         /* Default (-1) depends on sample size.  Set that later on. */
  515.     if (ft->info.style != -1 && ft->info.style != UNSIGNED &&
  516.         ft->info.style != SIGN2)
  517.         warn("User options overriding style read in .wav header");
  518.     break;
  519.     
  520.     case WAVE_FORMAT_ADPCM:
  521.     case WAVE_FORMAT_IMA_ADPCM:
  522.     if (ft->info.style == -1 || ft->info.style == ADPCM)
  523.         ft->info.style = ADPCM;
  524.     else
  525.         warn("User options overriding style read in .wav header");
  526.     break;
  527.  
  528.     case WAVE_FORMAT_IEEE_FLOAT:
  529.     fail("Sorry, this WAV file is in IEEE Float format.");
  530.     
  531.     case WAVE_FORMAT_ALAW:
  532.     if (ft->info.style == -1 || ft->info.style == ALAW)
  533.         ft->info.style = ALAW;
  534.     else
  535.         warn("User options overriding style read in .wav header");
  536.     break;
  537.     
  538.     case WAVE_FORMAT_MULAW:
  539.     if (ft->info.style == -1 || ft->info.style == ULAW)
  540.         ft->info.style = ULAW;
  541.     else
  542.         warn("User options overriding style read in .wav header");
  543.     break;
  544.     
  545.     case WAVE_FORMAT_OKI_ADPCM:
  546.     fail("Sorry, this WAV file is in OKI ADPCM format.");
  547.     case WAVE_FORMAT_DIGISTD:
  548.     fail("Sorry, this WAV file is in Digistd format.");
  549.     case WAVE_FORMAT_DIGIFIX:
  550.     fail("Sorry, this WAV file is in Digifix format.");
  551.     case WAVE_FORMAT_DOLBY_AC2:
  552.     fail("Sorry, this WAV file is in Dolby AC2 format.");
  553.     case WAVE_FORMAT_GSM610:
  554.     fail("Sorry, this WAV file is in GSM 6.10 format.");
  555.     case WAVE_FORMAT_ROCKWELL_ADPCM:
  556.     fail("Sorry, this WAV file is in Rockwell ADPCM format.");
  557.     case WAVE_FORMAT_ROCKWELL_DIGITALK:
  558.     fail("Sorry, this WAV file is in Rockwell DIGITALK format.");
  559.     case WAVE_FORMAT_G721_ADPCM:
  560.     fail("Sorry, this WAV file is in G.721 ADPCM format.");
  561.     case WAVE_FORMAT_G728_CELP:
  562.     fail("Sorry, this WAV file is in G.728 CELP format.");
  563.     case WAVE_FORMAT_MPEG:
  564.     fail("Sorry, this WAV file is in MPEG format.");
  565.     case WAVE_FORMAT_MPEGLAYER3:
  566.     fail("Sorry, this WAV file is in MPEG Layer 3 format.");
  567.     case WAVE_FORMAT_G726_ADPCM:
  568.     fail("Sorry, this WAV file is in G.726 ADPCM format.");
  569.     case WAVE_FORMAT_G722_ADPCM:
  570.     fail("Sorry, this WAV file is in G.722 ADPCM format.");
  571.     default:    fail("WAV file has unknown format type of %x",wav->formatTag);
  572.     }
  573.  
  574.     wChannels = rshort(ft);
  575.     len -= 2;
  576.     /* User options take precedence */
  577.     if (ft->info.channels == -1 || ft->info.channels == wChannels)
  578.     ft->info.channels = wChannels;
  579.     else
  580.     warn("User options overriding channels read in .wav header");
  581.     
  582.     wSamplesPerSecond = rlong(ft);
  583.     len -= 4;
  584.     if (ft->info.rate == 0 || ft->info.rate == wSamplesPerSecond)
  585.     ft->info.rate = wSamplesPerSecond;
  586.     else
  587.     warn("User options overriding rate read in .wav header");
  588.     
  589.     wAvgBytesPerSec = rlong(ft);    /* Average bytes/second */
  590.     wav->blockAlign = rshort(ft);    /* Block align */
  591.     len -= 6;
  592.  
  593.     /* bits per sample per channel */    
  594.     wBitsPerSample =  rshort(ft);
  595.     len -= 2;
  596.  
  597.     /* ADPCM formats have extended fmt chunk.  Check for those cases. */
  598.     if (wav->formatTag == WAVE_FORMAT_ADPCM)
  599.     {
  600.     if (wBitsPerSample != 4)
  601.         fail("Can only handle 4-bit MS ADPCM in wav files");
  602.  
  603.     wExtSize = rshort(ft);
  604.     wav->samplesPerBlock = rshort(ft);
  605.     wav->bytesPerBlock = (wav->samplesPerBlock + 7)/2 * ft->info.channels;
  606.     wNumCoefs = rshort(ft);
  607.     wav->packet = (unsigned char *)malloc(wav->blockAlign);
  608.     len -= 6;
  609.         
  610.     wav->samples[1] = wav->samples[0] = 0;
  611.     /* Use ft->info.channels after this becuase wChannels is now bad */
  612.     while (wChannels-- > 0)
  613.         wav->samples[wChannels] = (short *)malloc(wav->samplesPerBlock*sizeof(short));
  614.     /* Here we are setting the bytespersample AFTER de-compression */
  615.     bytespersample = WORD;
  616.     }
  617.     else if (wav->formatTag == WAVE_FORMAT_IMA_ADPCM)
  618.     {
  619.     if (wBitsPerSample != 4)
  620.         fail("Can only handle 4-bit IMA ADPCM in wav files");
  621.  
  622.     wExtSize = rshort(ft);
  623.     wav->samplesPerBlock = rshort(ft);
  624.     wav->bytesPerBlock = (wav->samplesPerBlock + 7)/2 * ft->info.channels;
  625.     wav->packet = (unsigned char *)malloc(wav->blockAlign);
  626.     len -= 4;
  627.         
  628.     wav->samples[1] = wav->samples[0] = 0;
  629.     /* Use ft->info.channels after this becuase wChannels is now bad */
  630.     while (wChannels-- > 0)
  631.         wav->samples[wChannels] = (short *)malloc(wav->samplesPerBlock*sizeof(short));
  632.     /* Here we are setting the bytespersample AFTER de-compression */
  633.     bytespersample = WORD;
  634.     }
  635.     else
  636.     {
  637.       bytespersample = (wBitsPerSample + 7)/8;
  638.     }
  639.  
  640.     switch (bytespersample)
  641.     {
  642.     
  643.     case BYTE:
  644.     /* User options take precedence */
  645.     if (ft->info.size == -1 || ft->info.size == BYTE)
  646.         ft->info.size = BYTE;
  647.     else
  648.         warn("User options overriding size read in .wav header");
  649.  
  650.     /* Now we have enough information to set default styles. */
  651.     if (ft->info.style == -1)
  652.         ft->info.style = UNSIGNED;
  653.     break;
  654.     
  655.     case WORD:
  656.     if (ft->info.size == -1 || ft->info.size == WORD)
  657.         ft->info.size = WORD;
  658.     else
  659.         warn("User options overriding size read in .wav header");
  660.  
  661.     /* Now we have enough information to set default styles. */
  662.     if (ft->info.style == -1)
  663.         ft->info.style = SIGN2;
  664.     break;
  665.     
  666.     case DWORD:
  667.     if (ft->info.size == -1 || ft->info.size == DWORD)
  668.         ft->info.size = DWORD;
  669.     else
  670.         warn("User options overriding size read in .wav header");
  671.  
  672.     /* Now we have enough information to set default styles. */
  673.     if (ft->info.style == -1)
  674.         ft->info.style = SIGN2;
  675.     break;
  676.     
  677.     default:
  678.     fail("Sorry, don't understand .wav size");
  679.     }
  680.  
  681.     /* Skip past the rest of any left over fmt chunk */
  682.     while (len > 0 && !feof(ft->fp))
  683.     {
  684.     getc(ft->fp);
  685.     len--;
  686.     }
  687.  
  688.     /* Now look for the wave data chunk */
  689.     for (;;)
  690.     {
  691.     if ( fread(magic, 1, 4, ft->fp) != 4 )
  692.         fail("WAVE file has missing data chunk");
  693.     len = rlong(ft);
  694.     if (strncmp("data", magic, 4) == 0)
  695.         break;                /* Found the data chunk */
  696.     
  697.     while (len > 0 && !feof(ft->fp))     /* skip to next chunk */
  698.     {
  699.         getc(ft->fp);
  700.         len--;
  701.     }
  702.     }
  703.     
  704.     data_length = len;
  705.     if (wav->formatTag == WAVE_FORMAT_ADPCM)
  706.     {
  707.     /* Compute easiest part of number of samples.  For every block, there
  708.        are samplesPerBlock samples to read. */
  709.     wav->numSamples = (((data_length / wav->blockAlign) * wav->samplesPerBlock) * ft->info.channels);
  710.     /* Next, for any partial blocks, substract overhead from it and it
  711.        will leave # of samples to read. */
  712.     wav->numSamples += ((data_length - ((data_length/wav->blockAlign)
  713.                         *wav->blockAlign))
  714.                 - (6 * ft->info.channels)) * ft->info.channels;
  715.     wav->blockSamplesRemaining = 0;           /* Samples left in buffer */
  716.     }
  717.     else if (wav->formatTag == WAVE_FORMAT_IMA_ADPCM)
  718.     {
  719.     /* Compute easiest part of number of samples.  For every block, there
  720.        are samplesPerBlock samples to read. */
  721.     wav->numSamples = (((data_length / wav->blockAlign) * wav->samplesPerBlock) * ft->info.channels);
  722.     /* Next, for any partial blocks, substract overhead from it and it
  723.        will leave # of samples to read. */
  724.     wav->numSamples += ((data_length - ((data_length/wav->blockAlign)
  725.                         *wav->blockAlign))
  726.                 - (3 * ft->info.channels)) * ft->info.channels;
  727.     wav->blockSamplesRemaining = 0;           /* Samples left in buffer */
  728.     }
  729.     else
  730.     wav->numSamples = data_length/ft->info.size;    /* total samples */
  731.  
  732.     report("Reading Wave file: %s format, %d channel%s, %d samp/sec",
  733.        wav_format_str(wav->formatTag), ft->info.channels,
  734.        wChannels == 1 ? "" : "s", wSamplesPerSecond);
  735.     report("        %d byte/sec, %d block align, %d bits/samp, %u data bytes",
  736.        wAvgBytesPerSec, wav->blockAlign, wBitsPerSample, data_length);
  737.  
  738.     /* Can also report exteded fmt information */
  739.     if (wav->formatTag == WAVE_FORMAT_ADPCM)
  740.     report("        %d Extsize, %d Samps/block, %d bytes/block %d Num Coefs\n",wExtSize,wav->samplesPerBlock,wav->bytesPerBlock,wNumCoefs);
  741.     else if (wav->formatTag == WAVE_FORMAT_IMA_ADPCM)
  742.     report("        %d Extsize, %d Samps/block, %d bytes/block\n",wExtSize,wav->samplesPerBlock,wav->bytesPerBlock);
  743. }
  744.  
  745. /*
  746.  * Read up to len samples from file.
  747.  * Convert to signed longs.
  748.  * Place in buf[].
  749.  * Return number of samples read.
  750.  */
  751.  
  752. LONG wavread(ft, buf, len) 
  753. ft_t ft;
  754. LONG *buf, len;
  755. {
  756.     wav_t    wav = (wav_t) ft->priv;
  757.     LONG    done;
  758.     
  759.     if (len > wav->numSamples) len = wav->numSamples;
  760.  
  761.     /* If file is in ADPCM style then read in multiple blocks else */
  762.     /* read as much as possible and return quickly. */
  763.     if (ft->info.style == ADPCM)
  764.     {
  765.         done = 0;
  766.         while (done < len) { /* Still want data? */
  767.         /* See if need to read more from disk */
  768.         if (wav->blockSamplesRemaining == 0) { 
  769.             if (wav->formatTag == WAVE_FORMAT_IMA_ADPCM)
  770.             wav->blockSamplesRemaining = ImaAdpcmNextBlock(ft);
  771.             else
  772.             wav->blockSamplesRemaining = MsAdpcmNextBlock(ft);
  773.             if (wav->blockSamplesRemaining == 0)
  774.             {
  775.             /* Don't try to read any more samples */
  776.             wav->numSamples = 0;
  777.             return done;
  778.             }
  779.             wav->samplePtr[0] = wav->samples[0];
  780.             wav->samplePtr[1] = wav->samples[1];
  781.         }
  782.  
  783.         switch(ft->info.channels) { /* Copy data into buf */
  784.         case 1: /* Mono: Just copy left channel data */
  785.             while ((wav->blockSamplesRemaining > 0) && (done < len))
  786.             {
  787.             /* Output is already signed */
  788.             *buf++ = LEFT(*(wav->samplePtr[0]++), 16);
  789.             done++;
  790.             wav->blockSamplesRemaining--;
  791.             }
  792.             break;
  793.         case 2: /* Stereo: Interleave samples */
  794.             while ((wav->blockSamplesRemaining > 0) && (done < len))
  795.             {
  796.             /* Output is already signed */
  797.             *buf++ = LEFT(*(wav->samplePtr[0]++),16); /* Left */
  798.             *buf++ = LEFT(*(wav->samplePtr[1]++),16); /* Right */
  799.             done += 2;
  800.             wav->blockSamplesRemaining--;
  801.             }
  802.             break;
  803.         default:
  804.             fail ("Can only handle stereo or mono files");
  805.         }
  806.         }
  807.     }
  808.     else /* else not ADPCM style */
  809.     {
  810.         done = rawread(ft, buf, len);
  811.         /* If software thinks there are more samples but I/O */
  812.         /* says otherwise, let the user no about this.       */
  813.         if (done == 0 && wav->numSamples != 0)
  814.         warn("Premature EOF on .wav input file");
  815.     }
  816.     wav->numSamples -= done;
  817.     return done;
  818. }
  819.  
  820. /*
  821.  * Do anything required when you stop reading samples.  
  822.  * Don't close input file! 
  823.  */
  824. void wavstopread(ft) 
  825. ft_t ft;
  826. {
  827.     wav_t    wav = (wav_t) ft->priv;
  828.  
  829.     if (wav->packet) free(wav->packet);
  830.     if (wav->samples[0]) free(wav->samples[0]);
  831.     if (wav->samples[1]) free(wav->samples[1]);
  832.  
  833.     /* Needed for rawread() */
  834.     rawstopread(ft);
  835. }
  836.  
  837. void wavstartwrite(ft) 
  838. ft_t ft;
  839. {
  840.     wav_t    wav = (wav_t) ft->priv;
  841.     int    littlendian = 1;
  842.     char    *endptr;
  843.  
  844.     endptr = (char *) &littlendian;
  845.     if (!*endptr) ft->swap = ft->swap ? 0 : 1;
  846.  
  847.     wav->numSamples = 0;
  848.     wav->second_header = 0;
  849.     if (! ft->seekable)
  850.         warn("Length in output .wav header will wrong since can't seek to fix it");
  851.     wavwritehdr(ft);
  852. }
  853.  
  854. void wavwritehdr(ft) 
  855. ft_t ft;
  856. {
  857.     wav_t    wav = (wav_t) ft->priv;
  858.  
  859.         /* wave file characteristics */
  860.         unsigned short wFormatTag = 0;          /* data format */
  861.         unsigned short wChannels;               /* number of channels */
  862.         ULONG  wSamplesPerSecond;           /* samples per second per channel */
  863.         ULONG  wAvgBytesPerSec;                 /* estimate of bytes per second needed */
  864.         unsigned short wBlockAlign;             /* byte alignment of a basic sample block */
  865.         unsigned short wBitsPerSample;          /* bits per sample */
  866.         ULONG  data_length;                 /* length of sound data in bytes */
  867.     ULONG  bytespersample;             /* bytes per sample (per channel) */
  868.  
  869.     /* Needed for rawwrite() */
  870.     rawstartwrite(ft);
  871.  
  872.     switch (ft->info.size)
  873.     {
  874.         case BYTE:
  875.                 wBitsPerSample = 8;
  876.             if (ft->info.style != UNSIGNED &&
  877.                 ft->info.style != ULAW &&
  878.                 ft->info.style != ALAW &&
  879.                 !wav->second_header)
  880.             {
  881.                 warn("Only support unsigned, ulaw, or alaw with 8-bit data.  Forcing to unsigned");
  882.                 ft->info.style = UNSIGNED;
  883.             }
  884.             break;
  885.         case WORD:
  886.             wBitsPerSample = 16;
  887.             if ((ft->info.style == UNSIGNED ||
  888.                  ft->info.style == ULAW ||
  889.                  ft->info.style == ALAW) &&
  890.                 !wav->second_header)
  891.             {
  892.                 warn("Do not support Unsigned, ulaw, or alay with 16 bit data.  Forcing to Signed");
  893.                 ft->info.style = SIGN2;
  894.             }
  895.             break;
  896.         case DWORD:
  897.             wBitsPerSample = 32;
  898.             break;
  899.         default:
  900.             wBitsPerSample = 32;
  901.             break;
  902.     }
  903.  
  904.     switch (ft->info.style)
  905.     {
  906.         case UNSIGNED:
  907.             wFormatTag = WAVE_FORMAT_PCM;
  908.             break;
  909.         case SIGN2:
  910.             wFormatTag = WAVE_FORMAT_PCM;
  911.             break;
  912.         case ALAW:
  913.             wFormatTag = WAVE_FORMAT_ALAW;
  914.             break;
  915.         case ULAW:
  916.             wFormatTag = WAVE_FORMAT_MULAW;
  917.             break;
  918.         case ADPCM:
  919.             wFormatTag = WAVE_FORMAT_PCM;
  920.                 warn("Can not support writing ADPCM style. Overriding to Signed Words\n");
  921.             ft->info.style = SIGN2;
  922.             wBitsPerSample = 16;
  923.             /* wFormatTag = WAVE_FORMAT_IMA_ADPCM;
  924.                wBitsPerSample = 4;
  925.             if (wBitsPerSample != 4 && !wav->second_header)
  926.             break; */
  927.     }
  928.     
  929.     
  930.     wSamplesPerSecond = ft->info.rate;
  931.     bytespersample = (wBitsPerSample + 7)/8;
  932.     wAvgBytesPerSec = ft->info.rate * ft->info.channels * bytespersample;
  933.     wChannels = ft->info.channels;
  934.     wBlockAlign = ft->info.channels * bytespersample;
  935.     if (!wav->second_header)    /* use max length value first time */
  936.         data_length = 0x7fffffffL - (8+16+12);
  937.     else    /* fixup with real length */
  938.     {
  939.         if (ft->info.style == ADPCM)
  940.         data_length = wav->numSamples / 2;
  941.         else
  942.         data_length = bytespersample * wav->numSamples;
  943.     }
  944.  
  945.     /* figured out header info, so write it */
  946.     fputs("RIFF", ft->fp);
  947.     wlong(ft, data_length + 8+16+12);    /* Waveform chunk size: FIXUP(4) */
  948.     fputs("WAVE", ft->fp);
  949.     fputs("fmt ", ft->fp);
  950.     wlong(ft, (LONG)16);        /* fmt chunk size */
  951.     wshort(ft, wFormatTag);
  952.     wshort(ft, wChannels);
  953.     wlong(ft, wSamplesPerSecond);
  954.     wlong(ft, wAvgBytesPerSec);
  955.     wshort(ft, wBlockAlign);
  956.     wshort(ft, wBitsPerSample);
  957.     
  958.     fputs("data", ft->fp);
  959.     wlong(ft, data_length);        /* data chunk size: FIXUP(40) */
  960.  
  961.     if (!wav->second_header) {
  962.         report("Writing Wave file: %s format, %d channel%s, %d samp/sec",
  963.                 wav_format_str(wFormatTag), wChannels,
  964.                 wChannels == 1 ? "" : "s", wSamplesPerSecond);
  965.         report("        %d byte/sec, %d block align, %d bits/samp",
  966.                     wAvgBytesPerSec, wBlockAlign, wBitsPerSample);
  967.     } else
  968.         report("Finished writing Wave file, %u data bytes\n",data_length);
  969. }
  970.  
  971. void wavwrite(ft, buf, len) 
  972. ft_t ft;
  973. LONG *buf, len;
  974. {
  975.     wav_t    wav = (wav_t) ft->priv;
  976.  
  977.     wav->numSamples += len;
  978.     rawwrite(ft, buf, len);
  979. }
  980.  
  981. void
  982. wavstopwrite(ft) 
  983. ft_t ft;
  984. {
  985.     /* Call this to flush out any remaining data. */
  986.     rawstopwrite(ft);
  987.  
  988.     /* All samples are already written out. */
  989.     /* If file header needs fixing up, for example it needs the */
  990.      /* the number of samples in a field, seek back and write them here. */
  991.     if (!ft->seekable)
  992.         return;
  993.     if (fseek(ft->fp, 0L, SEEK_SET) != 0)
  994.         fail("Sorry, can't rewind output file to rewrite .wav header.");
  995.     ((wav_t) ft->priv)->second_header = 1;
  996.     wavwritehdr(ft);
  997. }
  998.  
  999. /*
  1000.  * Return a string corresponding to the wave format type.
  1001.  */
  1002. static char *
  1003. wav_format_str(wFormatTag) 
  1004. unsigned wFormatTag;
  1005. {
  1006.     switch (wFormatTag)
  1007.     {
  1008.         case WAVE_FORMAT_UNKNOWN:
  1009.             return "Microsoft Official Unknown";
  1010.         case WAVE_FORMAT_PCM:
  1011.             return "Microsoft PCM";
  1012.         case WAVE_FORMAT_ADPCM:
  1013.             return "Microsoft ADPCM";
  1014.             case WAVE_FORMAT_IEEE_FLOAT:
  1015.                return "IEEE Float";
  1016.         case WAVE_FORMAT_ALAW:
  1017.             return "Microsoft A-law";
  1018.         case WAVE_FORMAT_MULAW:
  1019.             return "Microsoft U-law";
  1020.         case WAVE_FORMAT_OKI_ADPCM:
  1021.             return "OKI ADPCM format.";
  1022.         case WAVE_FORMAT_IMA_ADPCM:
  1023.             return "IMA ADPCM";
  1024.         case WAVE_FORMAT_DIGISTD:
  1025.             return "Digistd format.";
  1026.         case WAVE_FORMAT_DIGIFIX:
  1027.             return "Digifix format.";
  1028.         case WAVE_FORMAT_DOLBY_AC2:
  1029.             return "Dolby AC2";
  1030.         case WAVE_FORMAT_GSM610:
  1031.             return "GSM 6.10";
  1032.         case WAVE_FORMAT_ROCKWELL_ADPCM:
  1033.             return "Rockwell ADPCM";
  1034.         case WAVE_FORMAT_ROCKWELL_DIGITALK:
  1035.             return "Rockwell DIGITALK";
  1036.         case WAVE_FORMAT_G721_ADPCM:
  1037.             return "G.721 ADPCM";
  1038.         case WAVE_FORMAT_G728_CELP:
  1039.             return "G.728 CELP";
  1040.         case WAVE_FORMAT_MPEG:
  1041.             return "MPEG";
  1042.         case WAVE_FORMAT_MPEGLAYER3:
  1043.             return "MPEG Layer 3";
  1044.         case WAVE_FORMAT_G726_ADPCM:
  1045.             return "G.726 ADPCM";
  1046.         case WAVE_FORMAT_G722_ADPCM:
  1047.             return "G.722 ADPCM";
  1048.         default:
  1049.             return "Unknown";
  1050.     }
  1051. }
  1052.