libs/libsndfile/src/wav_w64.c

   1 /*
   2 ** Copyright (C) 1999-2005 Erik de Castro Lopo <erikd@mega-nerd.com>
   3 ** Copyright (C) 2004-2005 David Viens <davidv@plogue.com>
   4 **
   5 ** This program is free software; you can redistribute it and/or modify
   6 ** it under the terms of the GNU Lesser General Public License as published by
   7 ** the Free Software Foundation; either version 2.1 of the License, or
   8 ** (at your option) any later version.
   9 **
  10 ** This program is distributed in the hope that it will be useful,
  11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 ** GNU Lesser General Public License for more details.
  14 **
  15 ** You should have received a copy of the GNU Lesser General Public License
  16 ** along with this program; if not, write to the Free Software
  17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 */
  19
  20 #include        "sfconfig.h"
  21
  22 #include        <stdio.h>
  23 #include        <string.h>
  24 #include        <ctype.h>
  25 #include        <time.h>
  26
  27 #include        "sndfile.h"
  28 #include        "sfendian.h"
  29 #include        "common.h"
  30 #include        "wav_w64.h"
  31
  32 /*  Known WAVEFORMATEXTENSIBLE GUIDS.  */
  33 static const EXT_SUBFORMAT MSGUID_SUBTYPE_PCM =
  34 {       0x00000001, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  35 } ;
  36
  37 static const EXT_SUBFORMAT MSGUID_SUBTYPE_MS_ADPCM =
  38 {       0x00000002, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  39 } ;
  40
  41 static const EXT_SUBFORMAT MSGUID_SUBTYPE_IEEE_FLOAT =
  42 {       0x00000003, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  43 } ;
  44
  45 static const EXT_SUBFORMAT MSGUID_SUBTYPE_ALAW =
  46 {       0x00000006, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  47 } ;
  48
  49 static const EXT_SUBFORMAT MSGUID_SUBTYPE_MULAW =
  50 {       0x00000007, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  51 } ;
  52
  53 /*
  54 ** the next two are from
  55 ** http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html
  56 */
  57
  58 static const EXT_SUBFORMAT MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_PCM =
  59 {       0x00000001, 0x0721, 0x11d3, {   0x86, 0x44, 0xC8, 0xC1, 0xCA, 0x00, 0x00, 0x00 }
  60 } ;
  61
  62 static const EXT_SUBFORMAT MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_IEEE_FLOAT =
  63 {       0x00000003, 0x0721, 0x11d3, {   0x86, 0x44, 0xC8, 0xC1, 0xCA, 0x00, 0x00, 0x00 }
  64 } ;
  65
  66
  67 #if 0
  68 /* maybe interesting one day to read the following through sf_read_raw */
  69 /* http://www.bath.ac.uk/~masrwd/pvocex/pvocex.html */
  70 static const EXT_SUBFORMAT MSGUID_SUBTYPE_PVOCEX =
  71 {       0x8312B9C2, 0x2E6E, 0x11d4, {   0xA8, 0x24, 0xDE, 0x5B, 0x96, 0xC3, 0xAB, 0x21 }
  72 } ;
  73 #endif
  74
  75 /*------------------------------------------------------------------------------
  76  * Private static functions.
  77  */
  78
  79 static int
  80 wavex_write_guid_equal (const EXT_SUBFORMAT * first, const EXT_SUBFORMAT * second)
  81 {       return !memcmp (first, second, sizeof (EXT_SUBFORMAT)) ;
  82 } /* wavex_write_guid_equal */
  83
  84
  85
  86 int
  87 wav_w64_read_fmt_chunk (SF_PRIVATE *psf, WAV_FMT *wav_fmt, int structsize)
  88 {       int     bytesread, k, bytespersec = 0 ;
  89
  90         memset (wav_fmt, 0, sizeof (WAV_FMT)) ;
  91
  92         if (structsize < 16)
  93                 return SFE_WAV_FMT_SHORT ;
  94
  95         /* assume psf->rwf_endian is already properly set */
  96
  97         /* Read the minimal WAV file header here. */
  98         bytesread =
  99         psf_binheader_readf (psf, "224422", &(wav_fmt->format), &(wav_fmt->min.channels),
 100                         &(wav_fmt->min.samplerate), &(wav_fmt->min.bytespersec),
 101                         &(wav_fmt->min.blockalign), &(wav_fmt->min.bitwidth)) ;
 102
 103         psf_log_printf (psf, "  Format        : 0x%X => %s\n", wav_fmt->format, wav_w64_format_str (wav_fmt->format)) ;
 104         psf_log_printf (psf, "  Channels      : %d\n", wav_fmt->min.channels) ;
 105         psf_log_printf (psf, "  Sample Rate   : %d\n", wav_fmt->min.samplerate) ;
 106         psf_log_printf (psf, "  Block Align   : %d\n", wav_fmt->min.blockalign) ;
 107
 108         if (wav_fmt->format == WAVE_FORMAT_PCM && wav_fmt->min.bitwidth == 24 &&
 109                         wav_fmt->min.blockalign == 4 * wav_fmt->min.channels)
 110         {
 111                 psf_log_printf (psf, "\nInvalid file generated by Syntrillium's Cooledit!\n"
 112                                 "Treating as WAVE_FORMAT_IEEE_FLOAT 32 bit floating point file.\n\n") ;
 113                 psf_log_printf (psf, "  Bit Width     : 24 (should be 32)\n") ;
 114                 wav_fmt->min.bitwidth = 32 ;
 115                 wav_fmt->format = WAVE_FORMAT_IEEE_FLOAT ;
 116                 }
 117         else if (wav_fmt->format != WAVE_FORMAT_GSM610 && wav_fmt->min.bitwidth == 0)
 118                 psf_log_printf (psf, "  Bit Width     : %d (should not be 0)\n", wav_fmt->min.bitwidth) ;
 119         else if (wav_fmt->format == WAVE_FORMAT_GSM610 && wav_fmt->min.bitwidth != 0)
 120                 psf_log_printf (psf, "  Bit Width     : %d (should be 0)\n", wav_fmt->min.bitwidth) ;
 121         else
 122                 psf_log_printf (psf, "  Bit Width     : %d\n", wav_fmt->min.bitwidth) ;
 123
 124         psf->sf.samplerate      = wav_fmt->min.samplerate ;
 125         psf->sf.frames          = 0 ;                                   /* Correct this when reading data chunk. */
 126         psf->sf.channels        = wav_fmt->min.channels ;
 127
 128         switch (wav_fmt->format)
 129         {       case WAVE_FORMAT_PCM :
 130                 case WAVE_FORMAT_IEEE_FLOAT :
 131                                 bytespersec = wav_fmt->min.samplerate * wav_fmt->min.blockalign ;
 132                                 if (wav_fmt->min.bytespersec != (unsigned) bytespersec)
 133                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->min.bytespersec, bytespersec) ;
 134                                 else
 135                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->min.bytespersec) ;
 136
 137                                 psf->bytewidth = BITWIDTH2BYTES (wav_fmt->min.bitwidth) ;
 138                                 break ;
 139
 140                 case WAVE_FORMAT_ALAW :
 141                 case WAVE_FORMAT_MULAW :
 142                                 if (wav_fmt->min.bytespersec / wav_fmt->min.blockalign != wav_fmt->min.samplerate)
 143                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->min.bytespersec, wav_fmt->min.samplerate * wav_fmt->min.blockalign) ;
 144                                 else
 145                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->min.bytespersec) ;
 146
 147                                 psf->bytewidth = 1 ;
 148                                 if (structsize >= 18)
 149                                 {       bytesread += psf_binheader_readf (psf, "2", &(wav_fmt->size20.extrabytes)) ;
 150                                         psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->size20.extrabytes) ;
 151                                         } ;
 152                                 break ;
 153
 154                 case WAVE_FORMAT_IMA_ADPCM :
 155                                 if (wav_fmt->min.bitwidth != 4)
 156                                         return SFE_WAV_ADPCM_NOT4BIT ;
 157                                 if (wav_fmt->min.channels < 1 || wav_fmt->min.channels > 2)
 158                                         return SFE_WAV_ADPCM_CHANNELS ;
 159
 160                                 bytesread +=
 161                                 psf_binheader_readf (psf, "22", &(wav_fmt->ima.extrabytes), &(wav_fmt->ima.samplesperblock)) ;
 162
 163                                 bytespersec = (wav_fmt->ima.samplerate * wav_fmt->ima.blockalign) / wav_fmt->ima.samplesperblock ;
 164                                 if (wav_fmt->ima.bytespersec != (unsigned) bytespersec)
 165                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->ima.bytespersec, bytespersec) ;
 166                                 else
 167                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->ima.bytespersec) ;
 168
 169                                 psf->bytewidth = 2 ;
 170                                 psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->ima.extrabytes) ;
 171                                 psf_log_printf (psf, "  Samples/Block : %d\n", wav_fmt->ima.samplesperblock) ;
 172                                 break ;
 173
 174                 case WAVE_FORMAT_MS_ADPCM :
 175                                 if (wav_fmt->msadpcm.bitwidth != 4)
 176                                         return SFE_WAV_ADPCM_NOT4BIT ;
 177                                 if (wav_fmt->msadpcm.channels < 1 || wav_fmt->msadpcm.channels > 2)
 178                                         return SFE_WAV_ADPCM_CHANNELS ;
 179
 180                                 bytesread +=
 181                                 psf_binheader_readf (psf, "222", &(wav_fmt->msadpcm.extrabytes),
 182                                                 &(wav_fmt->msadpcm.samplesperblock), &(wav_fmt->msadpcm.numcoeffs)) ;
 183
 184                                 bytespersec = (wav_fmt->min.samplerate * wav_fmt->min.blockalign) / wav_fmt->msadpcm.samplesperblock ;
 185                                 if (wav_fmt->min.bytespersec == (unsigned) bytespersec)
 186                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->min.bytespersec) ;
 187                                 else if (wav_fmt->min.bytespersec == (wav_fmt->min.samplerate / wav_fmt->msadpcm.samplesperblock) * wav_fmt->min.blockalign)
 188                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d (MS BUG!))\n", wav_fmt->min.bytespersec, bytespersec) ;
 189                                 else
 190                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->min.bytespersec, bytespersec) ;
 191
 192
 193                                 psf->bytewidth = 2 ;
 194                                 psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->msadpcm.extrabytes) ;
 195                                 psf_log_printf (psf, "  Samples/Block : %d\n", wav_fmt->msadpcm.samplesperblock) ;
 196                                 if (wav_fmt->msadpcm.numcoeffs > SIGNED_SIZEOF (MS_ADPCM_WAV_FMT) / SIGNED_SIZEOF (int))
 197                                 {       psf_log_printf (psf, "  No. of Coeffs : %d ****\n", wav_fmt->msadpcm.numcoeffs) ;
 198                                         wav_fmt->msadpcm.numcoeffs = SIGNED_SIZEOF (MS_ADPCM_WAV_FMT) / SIGNED_SIZEOF (int) ;
 199                                         }
 200                                 else
 201                                         psf_log_printf (psf, "  No. of Coeffs : %d\n", wav_fmt->msadpcm.numcoeffs) ;
 202
 203                                 psf_log_printf (psf, "    Index   Coeffs1   Coeffs2\n") ;
 204                                 for (k = 0 ; k < wav_fmt->msadpcm.numcoeffs ; k++)
 205                                 {       bytesread +=
 206                                         psf_binheader_readf (psf, "22", &(wav_fmt->msadpcm.coeffs [k].coeff1), &(wav_fmt->msadpcm.coeffs [k].coeff2)) ;
 207                                         LSF_SNPRINTF (psf->u.cbuf, sizeof (psf->u.cbuf), "     %2d     %7d   %7d\n", k, wav_fmt->msadpcm.coeffs [k].coeff1, wav_fmt->msadpcm.coeffs [k].coeff2) ;
 208                                         psf_log_printf (psf, psf->u.cbuf) ;
 209                                         } ;
 210                                 break ;
 211
 212                 case WAVE_FORMAT_GSM610 :
 213                                 if (wav_fmt->gsm610.channels != 1 || wav_fmt->gsm610.blockalign != 65)
 214                                         return SFE_WAV_GSM610_FORMAT ;
 215
 216                                 bytesread +=
 217                                 psf_binheader_readf (psf, "22", &(wav_fmt->gsm610.extrabytes), &(wav_fmt->gsm610.samplesperblock)) ;
 218
 219                                 if (wav_fmt->gsm610.samplesperblock != 320)
 220                                         return SFE_WAV_GSM610_FORMAT ;
 221
 222                                 bytespersec = (wav_fmt->gsm610.samplerate * wav_fmt->gsm610.blockalign) / wav_fmt->gsm610.samplesperblock ;
 223                                 if (wav_fmt->gsm610.bytespersec != (unsigned) bytespersec)
 224                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->gsm610.bytespersec, bytespersec) ;
 225                                 else
 226                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->gsm610.bytespersec) ;
 227
 228                                 psf->bytewidth = 2 ;
 229                                 psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->gsm610.extrabytes) ;
 230                                 psf_log_printf (psf, "  Samples/Block : %d\n", wav_fmt->gsm610.samplesperblock) ;
 231                                 break ;
 232
 233                 case WAVE_FORMAT_EXTENSIBLE :
 234                                 if (wav_fmt->ext.bytespersec / wav_fmt->ext.blockalign != wav_fmt->ext.samplerate)
 235                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->ext.bytespersec, wav_fmt->ext.samplerate * wav_fmt->ext.blockalign) ;
 236                                 else
 237                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->ext.bytespersec) ;
 238
 239                                 bytesread +=
 240                                 psf_binheader_readf (psf, "224", &(wav_fmt->ext.extrabytes), &(wav_fmt->ext.validbits),
 241                                                 &(wav_fmt->ext.channelmask)) ;
 242
 243                                 psf_log_printf (psf, "  Valid Bits    : %d\n", wav_fmt->ext.validbits) ;
 244                                 psf_log_printf (psf, "  Channel Mask  : 0x%X\n", wav_fmt->ext.channelmask) ;
 245
 246                                 bytesread +=
 247                                 psf_binheader_readf (psf, "422", &(wav_fmt->ext.esf.esf_field1), &(wav_fmt->ext.esf.esf_field2),
 248                                                 &(wav_fmt->ext.esf.esf_field3)) ;
 249
 250                                 /* compare the esf_fields with each known GUID? and print? */
 251                                 psf_log_printf (psf, "  Subformat\n") ;
 252                                 psf_log_printf (psf, "    esf_field1 : 0x%X\n", wav_fmt->ext.esf.esf_field1) ;
 253                                 psf_log_printf (psf, "    esf_field2 : 0x%X\n", wav_fmt->ext.esf.esf_field2) ;
 254                                 psf_log_printf (psf, "    esf_field3 : 0x%X\n", wav_fmt->ext.esf.esf_field3) ;
 255                                 psf_log_printf (psf, "    esf_field4 : ") ;
 256                                 for (k = 0 ; k < 8 ; k++)
 257                                 {       bytesread += psf_binheader_readf (psf, "1", &(wav_fmt->ext.esf.esf_field4 [k])) ;
 258                                         psf_log_printf (psf, "0x%X ", wav_fmt->ext.esf.esf_field4 [k] & 0xFF) ;
 259                                         } ;
 260                                 psf_log_printf (psf, "\n") ;
 261                                 psf->bytewidth = BITWIDTH2BYTES (wav_fmt->ext.bitwidth) ;
 262
 263                                 /* Compare GUIDs for known ones. */
 264                                 if (wavex_write_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_PCM)
 265                                         || wavex_write_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_PCM))
 266                                 {       psf->sf.format = SF_FORMAT_WAVEX | u_bitwidth_to_subformat (psf->bytewidth * 8) ;
 267                                         psf_log_printf (psf, "    format : pcm\n") ;
 268                                         }
 269                                 else if (wavex_write_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_MS_ADPCM))
 270                                 {       psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_MS_ADPCM) ;
 271                                         psf_log_printf (psf, "    format : ms adpcm\n") ;
 272                                         }
 273                                 else if (wavex_write_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_IEEE_FLOAT)
 274                                                 || wavex_write_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_PCM))
 275                                 {       psf->sf.format = SF_FORMAT_WAVEX | ((psf->bytewidth == 8) ? SF_FORMAT_DOUBLE : SF_FORMAT_FLOAT) ;
 276                                         psf_log_printf (psf, "    format : IEEE float\n") ;
 277                                         }
 278                                 else if (wavex_write_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_ALAW))
 279                                 {       psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_ALAW) ;
 280                                         psf_log_printf (psf, "    format : A-law\n") ;
 281                                         }
 282                                 else if (wavex_write_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_MULAW))
 283                                 {       psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_ULAW) ;
 284                                         psf_log_printf (psf, "    format : u-law\n") ;
 285                                         }
 286                                 else
 287                                         return SFE_UNIMPLEMENTED ;
 288                                 break ;
 289
 290                 case WAVE_FORMAT_G721_ADPCM :
 291                                 psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->g72x.bytespersec) ;
 292                                 if (structsize >= 20)
 293                                 {       bytesread += psf_binheader_readf (psf, "22", &(wav_fmt->g72x.extrabytes), &(wav_fmt->g72x.auxblocksize)) ;
 294                                         if (wav_fmt->g72x.extrabytes == 0)
 295                                                 psf_log_printf (psf, "  Extra Bytes   : %d (should be 2)\n", wav_fmt->g72x.extrabytes) ;
 296                                         else
 297                                                 psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->g72x.extrabytes) ;
 298                                                 psf_log_printf (psf, "  Aux Blk Size  : %d\n", wav_fmt->g72x.auxblocksize) ;
 299                                         }
 300                                 else if (structsize == 18)
 301                                 {       bytesread += psf_binheader_readf (psf, "2", &(wav_fmt->g72x.extrabytes)) ;
 302                                         psf_log_printf (psf, "  Extra Bytes   : %d%s\n", wav_fmt->g72x.extrabytes, wav_fmt->g72x.extrabytes != 0 ? " (should be 0)" : "") ;
 303                                         }
 304                                 else
 305                                         psf_log_printf (psf, "*** 'fmt ' chunk should be bigger than this!\n") ;
 306                                 break ;
 307
 308                 default :
 309                                 psf_log_printf (psf, "*** No 'fmt ' chunk dumper for this format!\n") ;
 310                                 break ;
 311                 } ;
 312
 313         if (bytesread > structsize)
 314         {       psf_log_printf (psf, "*** wav_w64_read_fmt_chunk (bytesread > structsize)\n") ;
 315                 return SFE_W64_FMT_SHORT ;
 316                 }
 317         else
 318                 psf_binheader_readf (psf, "j", structsize - bytesread) ;
 319
 320         psf->blockwidth = wav_fmt->min.channels * psf->bytewidth ;
 321
 322         return 0 ;
 323 } /* wav_w64_read_fmt_chunk */
 324
 325 void
 326 wavex_write_guid (SF_PRIVATE *psf, const EXT_SUBFORMAT * subformat)
 327 {
 328         psf_binheader_writef (psf, "422b", subformat->esf_field1,
 329                                         subformat->esf_field2, subformat->esf_field3,
 330                                         subformat->esf_field4, 8) ;
 331 } /* wavex_write_guid */
 332
 333
 334 /*==============================================================================
 335 */
 336
 337 typedef struct
 338 {       int                     ID ;
 339         const char      *name ;
 340 } WAV_FORMAT_DESC ;
 341
 342 #define STR(x)                  #x
 343 #define FORMAT_TYPE(x)  { x, STR (x) }
 344
 345 static WAV_FORMAT_DESC wave_descs [] =
 346 {       FORMAT_TYPE     (WAVE_FORMAT_PCM),
 347         FORMAT_TYPE (WAVE_FORMAT_MS_ADPCM),
 348         FORMAT_TYPE (WAVE_FORMAT_IEEE_FLOAT),
 349         FORMAT_TYPE (WAVE_FORMAT_VSELP),
 350         FORMAT_TYPE (WAVE_FORMAT_IBM_CVSD),
 351         FORMAT_TYPE (WAVE_FORMAT_ALAW),
 352         FORMAT_TYPE (WAVE_FORMAT_MULAW),
 353         FORMAT_TYPE (WAVE_FORMAT_OKI_ADPCM),
 354         FORMAT_TYPE (WAVE_FORMAT_IMA_ADPCM),
 355         FORMAT_TYPE (WAVE_FORMAT_MEDIASPACE_ADPCM),
 356         FORMAT_TYPE (WAVE_FORMAT_SIERRA_ADPCM),
 357         FORMAT_TYPE (WAVE_FORMAT_G723_ADPCM),
 358         FORMAT_TYPE (WAVE_FORMAT_DIGISTD),
 359         FORMAT_TYPE (WAVE_FORMAT_DIGIFIX),
 360         FORMAT_TYPE (WAVE_FORMAT_DIALOGIC_OKI_ADPCM),
 361         FORMAT_TYPE (WAVE_FORMAT_MEDIAVISION_ADPCM),
 362         FORMAT_TYPE (WAVE_FORMAT_CU_CODEC),
 363         FORMAT_TYPE (WAVE_FORMAT_YAMAHA_ADPCM),
 364         FORMAT_TYPE (WAVE_FORMAT_SONARC),
 365         FORMAT_TYPE (WAVE_FORMAT_DSPGROUP_TRUESPEECH),
 366         FORMAT_TYPE (WAVE_FORMAT_ECHOSC1),
 367         FORMAT_TYPE (WAVE_FORMAT_AUDIOFILE_AF36),
 368         FORMAT_TYPE (WAVE_FORMAT_APTX),
 369         FORMAT_TYPE (WAVE_FORMAT_AUDIOFILE_AF10),
 370         FORMAT_TYPE (WAVE_FORMAT_PROSODY_1612),
 371         FORMAT_TYPE (WAVE_FORMAT_LRC),
 372         FORMAT_TYPE (WAVE_FORMAT_DOLBY_AC2),
 373         FORMAT_TYPE (WAVE_FORMAT_GSM610),
 374         FORMAT_TYPE (WAVE_FORMAT_MSNAUDIO),
 375         FORMAT_TYPE (WAVE_FORMAT_ANTEX_ADPCME),
 376         FORMAT_TYPE (WAVE_FORMAT_CONTROL_RES_VQLPC),
 377         FORMAT_TYPE (WAVE_FORMAT_DIGIREAL),
 378         FORMAT_TYPE (WAVE_FORMAT_DIGIADPCM),
 379         FORMAT_TYPE (WAVE_FORMAT_CONTROL_RES_CR10),
 380         FORMAT_TYPE (WAVE_FORMAT_NMS_VBXADPCM),
 381         FORMAT_TYPE (WAVE_FORMAT_ROLAND_RDAC),
 382         FORMAT_TYPE (WAVE_FORMAT_ECHOSC3),
 383         FORMAT_TYPE (WAVE_FORMAT_ROCKWELL_ADPCM),
 384         FORMAT_TYPE (WAVE_FORMAT_ROCKWELL_DIGITALK),
 385         FORMAT_TYPE (WAVE_FORMAT_XEBEC),
 386         FORMAT_TYPE (WAVE_FORMAT_G721_ADPCM),
 387         FORMAT_TYPE (WAVE_FORMAT_G728_CELP),
 388         FORMAT_TYPE (WAVE_FORMAT_MSG723),
 389         FORMAT_TYPE (WAVE_FORMAT_MPEG),
 390         FORMAT_TYPE (WAVE_FORMAT_RT24),
 391         FORMAT_TYPE (WAVE_FORMAT_PAC),
 392         FORMAT_TYPE (WAVE_FORMAT_MPEGLAYER3),
 393         FORMAT_TYPE (WAVE_FORMAT_LUCENT_G723),
 394         FORMAT_TYPE (WAVE_FORMAT_CIRRUS),
 395         FORMAT_TYPE (WAVE_FORMAT_ESPCM),
 396         FORMAT_TYPE (WAVE_FORMAT_VOXWARE),
 397         FORMAT_TYPE (WAVE_FORMAT_CANOPUS_ATRAC),
 398         FORMAT_TYPE (WAVE_FORMAT_G726_ADPCM),
 399         FORMAT_TYPE (WAVE_FORMAT_G722_ADPCM),
 400         FORMAT_TYPE (WAVE_FORMAT_DSAT),
 401         FORMAT_TYPE (WAVE_FORMAT_DSAT_DISPLAY),
 402         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_BYTE_ALIGNED),
 403         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_AC8),
 404         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_AC10),
 405         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_AC16),
 406         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_AC20),
 407         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_RT24),
 408         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_RT29),
 409         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_RT29HW),
 410         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_VR12),
 411         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_VR18),
 412         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_TQ40),
 413         FORMAT_TYPE (WAVE_FORMAT_SOFTSOUND),
 414         FORMAT_TYPE (WAVE_FORMAT_VOXARE_TQ60),
 415         FORMAT_TYPE (WAVE_FORMAT_MSRT24),
 416         FORMAT_TYPE (WAVE_FORMAT_G729A),
 417         FORMAT_TYPE (WAVE_FORMAT_MVI_MV12),
 418         FORMAT_TYPE (WAVE_FORMAT_DF_G726),
 419         FORMAT_TYPE (WAVE_FORMAT_DF_GSM610),
 420         FORMAT_TYPE (WAVE_FORMAT_ONLIVE),
 421         FORMAT_TYPE (WAVE_FORMAT_SBC24),
 422         FORMAT_TYPE (WAVE_FORMAT_DOLBY_AC3_SPDIF),
 423         FORMAT_TYPE (WAVE_FORMAT_ZYXEL_ADPCM),
 424         FORMAT_TYPE (WAVE_FORMAT_PHILIPS_LPCBB),
 425         FORMAT_TYPE (WAVE_FORMAT_PACKED),
 426         FORMAT_TYPE (WAVE_FORMAT_RHETOREX_ADPCM),
 427         FORMAT_TYPE (IBM_FORMAT_MULAW),
 428         FORMAT_TYPE (IBM_FORMAT_ALAW),
 429         FORMAT_TYPE (IBM_FORMAT_ADPCM),
 430         FORMAT_TYPE (WAVE_FORMAT_VIVO_G723),
 431         FORMAT_TYPE (WAVE_FORMAT_VIVO_SIREN),
 432         FORMAT_TYPE (WAVE_FORMAT_DIGITAL_G723),
 433         FORMAT_TYPE (WAVE_FORMAT_CREATIVE_ADPCM),
 434         FORMAT_TYPE (WAVE_FORMAT_CREATIVE_FASTSPEECH8),
 435         FORMAT_TYPE (WAVE_FORMAT_CREATIVE_FASTSPEECH10),
 436         FORMAT_TYPE (WAVE_FORMAT_QUARTERDECK),
 437         FORMAT_TYPE (WAVE_FORMAT_FM_TOWNS_SND),
 438         FORMAT_TYPE (WAVE_FORMAT_BZV_DIGITAL),
 439         FORMAT_TYPE (WAVE_FORMAT_VME_VMPCM),
 440         FORMAT_TYPE (WAVE_FORMAT_OLIGSM),
 441         FORMAT_TYPE (WAVE_FORMAT_OLIADPCM),
 442         FORMAT_TYPE (WAVE_FORMAT_OLICELP),
 443         FORMAT_TYPE (WAVE_FORMAT_OLISBC),
 444         FORMAT_TYPE (WAVE_FORMAT_OLIOPR),
 445         FORMAT_TYPE (WAVE_FORMAT_LH_CODEC),
 446         FORMAT_TYPE (WAVE_FORMAT_NORRIS),
 447         FORMAT_TYPE (WAVE_FORMAT_SOUNDSPACE_MUSICOMPRESS),
 448         FORMAT_TYPE (WAVE_FORMAT_DVM),
 449         FORMAT_TYPE (WAVE_FORMAT_INTERWAV_VSC112),
 450         FORMAT_TYPE (WAVE_FORMAT_EXTENSIBLE),
 451 } ;
 452
 453 char const*
 454 wav_w64_format_str (int k)
 455 {       int lower, upper, mid ;
 456
 457         lower = -1 ;
 458         upper = sizeof (wave_descs) / sizeof (WAV_FORMAT_DESC) ;
 459
 460         /* binary search */
 461         if ((wave_descs [0].ID <= k) & (k <= wave_descs [upper - 1].ID))
 462         {
 463                 while (lower + 1 < upper)
 464                 {       mid = (upper + lower) / 2 ;
 465
 466                         if (k == wave_descs [mid].ID)
 467                                 return wave_descs [mid].name ;
 468                         if (k < wave_descs [mid].ID)
 469                                 upper = mid ;
 470                         else
 471                                 lower = mid ;
 472                         } ;
 473                 } ;
 474
 475         return "Unknown format" ;
 476 } /* wav_w64_format_str */
 477
 478 int
 479 wav_w64_srate2blocksize (int srate_chan_product)
 480 {       if (srate_chan_product < 12000)
 481                 return 256 ;
 482         if (srate_chan_product < 23000)
 483                 return 512 ;
 484         if (srate_chan_product < 44000)
 485                 return 1024 ;
 486         return 2048 ;
 487 } /* srate2blocksize */
 488 /*
 489 ** Do not edit or modify anything in this comment block.
 490 ** The arch-tag line is a file identity tag for the GNU Arch
 491 ** revision control system.
 492 **
 493 ** arch-tag: 43c1b1dd-8abd-43da-a8cd-44da914b64a5
 494 */