src/wav_w64.c

   1 /*
   2 ** Copyright (C) 1999-2014 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 /* This stores which bit in dwChannelMask maps to which channel */
  76 static const struct chanmap_s
  77 {       int id ;
  78         const char * name ;
  79 } channel_mask_bits [] =
  80 {       /* WAVEFORMATEXTENSIBLE doesn't distuingish FRONT_LEFT from LEFT */
  81         {       SF_CHANNEL_MAP_LEFT, "L" },
  82         {       SF_CHANNEL_MAP_RIGHT, "R" },
  83         {       SF_CHANNEL_MAP_CENTER, "C" },
  84         {       SF_CHANNEL_MAP_LFE, "LFE" },
  85         {       SF_CHANNEL_MAP_REAR_LEFT, "Ls" },
  86         {       SF_CHANNEL_MAP_REAR_RIGHT, "Rs" },
  87         {       SF_CHANNEL_MAP_FRONT_LEFT_OF_CENTER, "Lc" },
  88         {       SF_CHANNEL_MAP_FRONT_RIGHT_OF_CENTER, "Rc" },
  89         {       SF_CHANNEL_MAP_REAR_CENTER, "Cs" },
  90         {       SF_CHANNEL_MAP_SIDE_LEFT, "Sl" },
  91         {       SF_CHANNEL_MAP_SIDE_RIGHT, "Sr" },
  92         {       SF_CHANNEL_MAP_TOP_CENTER, "Tc" },
  93         {       SF_CHANNEL_MAP_TOP_FRONT_LEFT, "Tfl" },
  94         {       SF_CHANNEL_MAP_TOP_FRONT_CENTER, "Tfc" },
  95         {       SF_CHANNEL_MAP_TOP_FRONT_RIGHT, "Tfr" },
  96         {       SF_CHANNEL_MAP_TOP_REAR_LEFT, "Trl" },
  97         {       SF_CHANNEL_MAP_TOP_REAR_CENTER, "Trc" },
  98         {       SF_CHANNEL_MAP_TOP_REAR_RIGHT, "Trr" },
  99 } ;
 100
 101 /*------------------------------------------------------------------------------
 102  * Private static functions.
 103  */
 104
 105 static int
 106 wavex_guid_equal (const EXT_SUBFORMAT * first, const EXT_SUBFORMAT * second)
 107 {       return !memcmp (first, second, sizeof (EXT_SUBFORMAT)) ;
 108 } /* wavex_guid_equal */
 109
 110
 111
 112 int
 113 wav_w64_read_fmt_chunk (SF_PRIVATE *psf, int fmtsize)
 114 {       WAV_PRIVATE * wpriv ;
 115         WAV_FMT *wav_fmt ;
 116         int     bytesread, k, bytespersec = 0 ;
 117
 118         if ((wpriv = psf->container_data) == NULL)
 119                 return SFE_INTERNAL ;
 120         wav_fmt = &wpriv->wav_fmt ;
 121
 122         memset (wav_fmt, 0, sizeof (WAV_FMT)) ;
 123
 124         if (fmtsize < 16)
 125                 return SFE_WAV_FMT_SHORT ;
 126
 127         /* assume psf->rwf_endian is already properly set */
 128
 129         /* Read the minimal WAV file header here. */
 130         bytesread = psf_binheader_readf (psf, "224422",
 131                                         &(wav_fmt->format), &(wav_fmt->min.channels),
 132                                         &(wav_fmt->min.samplerate), &(wav_fmt->min.bytespersec),
 133                                         &(wav_fmt->min.blockalign), &(wav_fmt->min.bitwidth)) ;
 134
 135         psf_log_printf (psf, "  Format        : 0x%X => %s\n", wav_fmt->format, wav_w64_format_str (wav_fmt->format)) ;
 136         psf_log_printf (psf, "  Channels      : %d\n", wav_fmt->min.channels) ;
 137         psf_log_printf (psf, "  Sample Rate   : %d\n", wav_fmt->min.samplerate) ;
 138
 139         if (wav_fmt->format == WAVE_FORMAT_PCM && wav_fmt->min.blockalign == 0
 140                 && wav_fmt->min.bitwidth > 0 && wav_fmt->min.channels > 0)
 141         {       wav_fmt->min.blockalign = wav_fmt->min.bitwidth / 8 + (wav_fmt->min.bitwidth % 8 > 0 ? 1 : 0) ;
 142                 wav_fmt->min.blockalign *= wav_fmt->min.channels ;
 143                 psf_log_printf (psf, "  Block Align   : 0 (should be %d)\n", wav_fmt->min.blockalign) ;
 144                 }
 145         else
 146                 psf_log_printf (psf, "  Block Align   : %d\n", wav_fmt->min.blockalign) ;
 147
 148         if (wav_fmt->format == WAVE_FORMAT_PCM && wav_fmt->min.bitwidth == 24 &&
 149                         wav_fmt->min.blockalign == 4 * wav_fmt->min.channels)
 150         {       psf_log_printf (psf, "  Bit Width     : 24\n") ;
 151
 152                 psf_log_printf (psf, "\n"
 153                         "  Ambiguous information in 'fmt ' chunk. Possibile file types:\n"
 154                         "    0) Invalid IEEE float file generated by Syntrillium's Cooledit!\n"
 155                         "    1) File generated by ALSA's arecord containing 24 bit samples in 32 bit containers.\n"
 156                         "    2) 24 bit file with incorrect Block Align value.\n"
 157                         "\n") ;
 158
 159                 wpriv->fmt_is_broken = 1 ;
 160                 }
 161         else if (wav_fmt->min.bitwidth == 0)
 162         {       switch (wav_fmt->format)
 163                 {       case WAVE_FORMAT_GSM610 :
 164                         case WAVE_FORMAT_IPP_ITU_G_723_1 :
 165                                         psf_log_printf (psf, "  Bit Width     : %d\n", wav_fmt->min.bitwidth) ;
 166                                         break ;
 167                         default :
 168                                         psf_log_printf (psf, "  Bit Width     : %d (should not be 0)\n", wav_fmt->min.bitwidth) ;
 169                         }
 170                 }
 171         else
 172         {       switch (wav_fmt->format)
 173                 {       case WAVE_FORMAT_GSM610 :
 174                         case WAVE_FORMAT_IPP_ITU_G_723_1 :
 175                 psf_log_printf (psf, "  Bit Width     : %d (should be 0)\n", wav_fmt->min.bitwidth) ;
 176                                         break ;
 177                         default :
 178                                         psf_log_printf (psf, "  Bit Width     : %d\n", wav_fmt->min.bitwidth) ;
 179                         }
 180                 } ;
 181
 182         psf->sf.samplerate      = wav_fmt->min.samplerate ;
 183         psf->sf.frames          = 0 ;                                   /* Correct this when reading data chunk. */
 184         psf->sf.channels        = wav_fmt->min.channels ;
 185
 186         switch (wav_fmt->format)
 187         {       case WAVE_FORMAT_PCM :
 188                 case WAVE_FORMAT_IEEE_FLOAT :
 189                                 bytespersec = wav_fmt->min.samplerate * wav_fmt->min.blockalign ;
 190                                 if (wav_fmt->min.bytespersec != (unsigned) bytespersec)
 191                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->min.bytespersec, bytespersec) ;
 192                                 else
 193                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->min.bytespersec) ;
 194
 195                                 psf->bytewidth = BITWIDTH2BYTES (wav_fmt->min.bitwidth) ;
 196                                 break ;
 197
 198                 case WAVE_FORMAT_ALAW :
 199                 case WAVE_FORMAT_MULAW :
 200                                 if (wav_fmt->min.bytespersec != wav_fmt->min.samplerate * wav_fmt->min.blockalign)
 201                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->min.bytespersec, wav_fmt->min.samplerate * wav_fmt->min.blockalign) ;
 202                                 else
 203                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->min.bytespersec) ;
 204
 205                                 psf->bytewidth = 1 ;
 206                                 if (fmtsize >= 18)
 207                                 {       bytesread += psf_binheader_readf (psf, "2", &(wav_fmt->size20.extrabytes)) ;
 208                                         psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->size20.extrabytes) ;
 209                                         } ;
 210                                 break ;
 211
 212                 case WAVE_FORMAT_IMA_ADPCM :
 213                                 if (wav_fmt->min.bitwidth != 4)
 214                                         return SFE_WAV_ADPCM_NOT4BIT ;
 215                                 if (wav_fmt->min.channels < 1 || wav_fmt->min.channels > 2)
 216                                         return SFE_WAV_ADPCM_CHANNELS ;
 217
 218                                 bytesread += psf_binheader_readf (psf, "22", &(wav_fmt->ima.extrabytes), &(wav_fmt->ima.samplesperblock)) ;
 219                                 psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->ima.extrabytes) ;
 220                                 if (wav_fmt->ima.samplesperblock < 1)
 221                                 {       psf_log_printf (psf, "  Samples/Block : %d (should be > 0)\n", wav_fmt->ima.samplesperblock) ;
 222                                         return SFE_WAV_ADPCM_SAMPLES ;
 223                                         }
 224                                 else
 225                                         psf_log_printf (psf, "  Samples/Block : %d\n", wav_fmt->ima.samplesperblock) ;
 226
 227                                 bytespersec = (wav_fmt->ima.samplerate * wav_fmt->ima.blockalign) / wav_fmt->ima.samplesperblock ;
 228                                 if (wav_fmt->ima.bytespersec != (unsigned) bytespersec)
 229                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->ima.bytespersec, bytespersec) ;
 230                                 else
 231                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->ima.bytespersec) ;
 232
 233                                 break ;
 234
 235                 case WAVE_FORMAT_MS_ADPCM :
 236                                 if (wav_fmt->msadpcm.bitwidth != 4)
 237                                         return SFE_WAV_ADPCM_NOT4BIT ;
 238                                 if (wav_fmt->msadpcm.channels < 1 || wav_fmt->msadpcm.channels > 2)
 239                                         return SFE_WAV_ADPCM_CHANNELS ;
 240
 241                                 bytesread += psf_binheader_readf (psf, "222", &(wav_fmt->msadpcm.extrabytes),
 242                                                                 &(wav_fmt->msadpcm.samplesperblock), &(wav_fmt->msadpcm.numcoeffs)) ;
 243
 244                                 psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->msadpcm.extrabytes) ;
 245                                 if (wav_fmt->ima.samplesperblock < 1)
 246                                 {       psf_log_printf (psf, "  Samples/Block : %d (should be > 0)\n", wav_fmt->ima.samplesperblock) ;
 247                                         return SFE_WAV_ADPCM_SAMPLES ;
 248                                         }
 249                                 else
 250                                         psf_log_printf (psf, "  Samples/Block : %d\n", wav_fmt->ima.samplesperblock) ;
 251
 252                                 bytespersec = (wav_fmt->min.samplerate * wav_fmt->min.blockalign) / wav_fmt->msadpcm.samplesperblock ;
 253                                 if (wav_fmt->min.bytespersec == (unsigned) bytespersec)
 254                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->min.bytespersec) ;
 255                                 else if (wav_fmt->min.bytespersec == (wav_fmt->min.samplerate / wav_fmt->msadpcm.samplesperblock) * wav_fmt->min.blockalign)
 256                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d (MS BUG!))\n", wav_fmt->min.bytespersec, bytespersec) ;
 257                                 else
 258                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->min.bytespersec, bytespersec) ;
 259
 260                                 if (wav_fmt->msadpcm.numcoeffs > ARRAY_LEN (wav_fmt->msadpcm.coeffs))
 261                                 {       psf_log_printf (psf, "  No. of Coeffs : %d (should be <= %d)\n", wav_fmt->msadpcm.numcoeffs, ARRAY_LEN (wav_fmt->msadpcm.coeffs)) ;
 262                                         wav_fmt->msadpcm.numcoeffs = ARRAY_LEN (wav_fmt->msadpcm.coeffs) ;
 263                                         }
 264                                 else
 265                                         psf_log_printf (psf, "  No. of Coeffs : %d\n", wav_fmt->msadpcm.numcoeffs) ;
 266
 267                                 psf_log_printf (psf, "    Index   Coeffs1   Coeffs2\n") ;
 268                                 for (k = 0 ; k < wav_fmt->msadpcm.numcoeffs ; k++)
 269                                 {       char buffer [128] ;
 270
 271                                         bytesread +=
 272                                                 psf_binheader_readf (psf, "22", &(wav_fmt->msadpcm.coeffs [k].coeff1), &(wav_fmt->msadpcm.coeffs [k].coeff2)) ;
 273                                         snprintf (buffer, sizeof (buffer), "     %2d     %7d   %7d\n", k, wav_fmt->msadpcm.coeffs [k].coeff1, wav_fmt->msadpcm.coeffs [k].coeff2) ;
 274                                         psf_log_printf (psf, buffer) ;
 275                                         } ;
 276                                 break ;
 277
 278                 case WAVE_FORMAT_GSM610 :
 279                                 if (wav_fmt->gsm610.channels != 1 || wav_fmt->gsm610.blockalign != 65)
 280                                         return SFE_WAV_GSM610_FORMAT ;
 281
 282                                 bytesread +=
 283                                 psf_binheader_readf (psf, "22", &(wav_fmt->gsm610.extrabytes), &(wav_fmt->gsm610.samplesperblock)) ;
 284
 285                                 if (wav_fmt->gsm610.samplesperblock != 320)
 286                                         return SFE_WAV_GSM610_FORMAT ;
 287
 288                                 bytespersec = (wav_fmt->gsm610.samplerate * wav_fmt->gsm610.blockalign) / wav_fmt->gsm610.samplesperblock ;
 289                                 if (wav_fmt->gsm610.bytespersec != (unsigned) bytespersec)
 290                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->gsm610.bytespersec, bytespersec) ;
 291                                 else
 292                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->gsm610.bytespersec) ;
 293
 294                                 psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->gsm610.extrabytes) ;
 295                                 psf_log_printf (psf, "  Samples/Block : %d\n", wav_fmt->gsm610.samplesperblock) ;
 296                                 break ;
 297
 298                 case WAVE_FORMAT_EXTENSIBLE :
 299                                 if (wav_fmt->ext.bytespersec != wav_fmt->ext.samplerate * wav_fmt->ext.blockalign)
 300                                         psf_log_printf (psf, "  Bytes/sec     : %d (should be %d)\n", wav_fmt->ext.bytespersec, wav_fmt->ext.samplerate * wav_fmt->ext.blockalign) ;
 301                                 else
 302                                         psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->ext.bytespersec) ;
 303
 304                                 bytesread +=
 305                                 psf_binheader_readf (psf, "224", &(wav_fmt->ext.extrabytes), &(wav_fmt->ext.validbits),
 306                                                 &(wav_fmt->ext.channelmask)) ;
 307
 308                                 psf_log_printf (psf, "  Valid Bits    : %d\n", wav_fmt->ext.validbits) ;
 309
 310                                 if (wav_fmt->ext.channelmask == 0)
 311                                         psf_log_printf (psf, "  Channel Mask  : 0x0 (should not be zero)\n") ;
 312                                 else
 313                                 {       char buffer [512] ;
 314                                         unsigned bit ;
 315
 316                                         wpriv->wavex_channelmask = wav_fmt->ext.channelmask ;
 317
 318                                         /* It's probably wise to ignore the channel mask if it is all zero */
 319                                         free (psf->channel_map) ;
 320
 321                                         if ((psf->channel_map = calloc (psf->sf.channels, sizeof (psf->channel_map [0]))) == NULL)
 322                                                 return SFE_MALLOC_FAILED ;
 323
 324                                         /* Terminate the buffer we're going to append_snprintf into. */
 325                                         buffer [0] = 0 ;
 326
 327                                         for (bit = k = 0 ; bit < ARRAY_LEN (channel_mask_bits) && k < psf->sf.channels ; bit++)
 328                                         {
 329                                                 if (wav_fmt->ext.channelmask & (1 << bit))
 330                                                 {       if (k > psf->sf.channels)
 331                                                         {       psf_log_printf (psf, "*** More channel map bits than there are channels.\n") ;
 332                                                                 break ;
 333                                                                 } ;
 334
 335                                                         psf->channel_map [k++] = channel_mask_bits [bit].id ;
 336                                                         append_snprintf (buffer, sizeof (buffer), "%s, ", channel_mask_bits [bit].name) ;
 337                                                         } ;
 338                                                 } ;
 339
 340                                         /* Remove trailing ", ". */
 341                                         bit = strlen (buffer) ;
 342                                         if (bit >= 2)
 343                                         {       buffer [--bit] = 0 ;
 344                                                 buffer [--bit] = 0 ;
 345                                                 } ;
 346
 347                                         if (k != psf->sf.channels)
 348                                         {       psf_log_printf (psf, "  Channel Mask  : 0x%X\n", wav_fmt->ext.channelmask) ;
 349                                                 psf_log_printf (psf, "*** Less channel map bits than there are channels.\n") ;
 350                                                 }
 351                                         else
 352                                                 psf_log_printf (psf, "  Channel Mask  : 0x%X (%s)\n", wav_fmt->ext.channelmask, buffer) ;
 353                                         } ;
 354
 355                                 bytesread += psf_binheader_readf (psf, "422", &(wav_fmt->ext.esf.esf_field1), &(wav_fmt->ext.esf.esf_field2), &(wav_fmt->ext.esf.esf_field3)) ;
 356
 357                                 /* compare the esf_fields with each known GUID? and print? */
 358                                 psf_log_printf (psf, "  Subformat\n") ;
 359                                 psf_log_printf (psf, "    esf_field1 : 0x%X\n", wav_fmt->ext.esf.esf_field1) ;
 360                                 psf_log_printf (psf, "    esf_field2 : 0x%X\n", wav_fmt->ext.esf.esf_field2) ;
 361                                 psf_log_printf (psf, "    esf_field3 : 0x%X\n", wav_fmt->ext.esf.esf_field3) ;
 362                                 psf_log_printf (psf, "    esf_field4 : ") ;
 363                                 for (k = 0 ; k < 8 ; k++)
 364                                 {       bytesread += psf_binheader_readf (psf, "1", &(wav_fmt->ext.esf.esf_field4 [k])) ;
 365                                         psf_log_printf (psf, "0x%X ", wav_fmt->ext.esf.esf_field4 [k] & 0xFF) ;
 366                                         } ;
 367                                 psf_log_printf (psf, "\n") ;
 368                                 psf->bytewidth = BITWIDTH2BYTES (wav_fmt->ext.bitwidth) ;
 369
 370                                 /* Compare GUIDs for known ones. */
 371                                 if (wavex_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_PCM))
 372                                 {       psf->sf.format = SF_FORMAT_WAVEX | u_bitwidth_to_subformat (psf->bytewidth * 8) ;
 373                                         psf_log_printf (psf, "    format : pcm\n") ;
 374                                         }
 375                                 else if (wavex_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_MS_ADPCM))
 376                                 {       psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_MS_ADPCM) ;
 377                                         psf_log_printf (psf, "    format : ms adpcm\n") ;
 378                                         }
 379                                 else if (wavex_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_IEEE_FLOAT))
 380                                 {       psf->sf.format = SF_FORMAT_WAVEX | ((psf->bytewidth == 8) ? SF_FORMAT_DOUBLE : SF_FORMAT_FLOAT) ;
 381                                         psf_log_printf (psf, "    format : IEEE float\n") ;
 382                                         }
 383                                 else if (wavex_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_ALAW))
 384                                 {       psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_ALAW) ;
 385                                         psf_log_printf (psf, "    format : A-law\n") ;
 386                                         }
 387                                 else if (wavex_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_MULAW))
 388                                 {       psf->sf.format = (SF_FORMAT_WAVEX | SF_FORMAT_ULAW) ;
 389                                         psf_log_printf (psf, "    format : u-law\n") ;
 390                                         }
 391                                 else if (wavex_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_PCM))
 392                                 {       psf->sf.format = SF_FORMAT_WAVEX | u_bitwidth_to_subformat (psf->bytewidth * 8) ;
 393                                         psf_log_printf (psf, "    format : pcm (Ambisonic B)\n") ;
 394                                         wpriv->wavex_ambisonic = SF_AMBISONIC_B_FORMAT ;
 395                                         }
 396                                 else if (wavex_guid_equal (&wav_fmt->ext.esf, &MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_IEEE_FLOAT))
 397                                 {       psf->sf.format = SF_FORMAT_WAVEX | ((psf->bytewidth == 8) ? SF_FORMAT_DOUBLE : SF_FORMAT_FLOAT) ;
 398                                         psf_log_printf (psf, "    format : IEEE float (Ambisonic B)\n") ;
 399                                         wpriv->wavex_ambisonic = SF_AMBISONIC_B_FORMAT ;
 400                                         }
 401                                 else
 402                                         return SFE_UNIMPLEMENTED ;
 403
 404                                 break ;
 405
 406                 case WAVE_FORMAT_G721_ADPCM :
 407                                 psf_log_printf (psf, "  Bytes/sec     : %d\n", wav_fmt->g72x.bytespersec) ;
 408                                 if (fmtsize >= 20)
 409                                 {       bytesread += psf_binheader_readf (psf, "22", &(wav_fmt->g72x.extrabytes), &(wav_fmt->g72x.auxblocksize)) ;
 410                                         if (wav_fmt->g72x.extrabytes == 0)
 411                                                 psf_log_printf (psf, "  Extra Bytes   : %d (should be 2)\n", wav_fmt->g72x.extrabytes) ;
 412                                         else
 413                                                 psf_log_printf (psf, "  Extra Bytes   : %d\n", wav_fmt->g72x.extrabytes) ;
 414                                                 psf_log_printf (psf, "  Aux Blk Size  : %d\n", wav_fmt->g72x.auxblocksize) ;
 415                                         }
 416                                 else if (fmtsize == 18)
 417                                 {       bytesread += psf_binheader_readf (psf, "2", &(wav_fmt->g72x.extrabytes)) ;
 418                                         psf_log_printf (psf, "  Extra Bytes   : %d%s\n", wav_fmt->g72x.extrabytes, wav_fmt->g72x.extrabytes != 0 ? " (should be 0)" : "") ;
 419                                         }
 420                                 else
 421                                         psf_log_printf (psf, "*** 'fmt ' chunk should be bigger than this!\n") ;
 422                                 break ;
 423
 424                 default :
 425                                 psf_log_printf (psf, "*** No 'fmt ' chunk dumper for this format!\n") ;
 426                                 return SFE_WAV_BAD_FMT ;
 427                 } ;
 428
 429         if (bytesread > fmtsize)
 430         {       psf_log_printf (psf, "*** wav_w64_read_fmt_chunk (bytesread > fmtsize)\n") ;
 431                 return SFE_WAV_BAD_FMT ;
 432                 }
 433         else
 434                 psf_binheader_readf (psf, "j", fmtsize - bytesread) ;
 435
 436         psf->blockwidth = wav_fmt->min.channels * psf->bytewidth ;
 437
 438         return 0 ;
 439 } /* wav_w64_read_fmt_chunk */
 440
 441 void
 442 wavex_write_guid (SF_PRIVATE *psf, const EXT_SUBFORMAT * subformat)
 443 {
 444         psf_binheader_writef (psf, "422b", subformat->esf_field1,
 445                                         subformat->esf_field2, subformat->esf_field3,
 446                                         subformat->esf_field4, make_size_t (8)) ;
 447 } /* wavex_write_guid */
 448
 449
 450 int
 451 wavex_gen_channel_mask (const int *chan_map, int channels)
 452 {       int chan, mask = 0, bit = -1, last_bit = -1 ;
 453
 454         if (chan_map == NULL)
 455                 return 0 ;
 456
 457         for (chan = 0 ; chan < channels ; chan ++)
 458         {       int k ;
 459
 460                 for (k = bit + 1 ; k < ARRAY_LEN (channel_mask_bits) ; k++)
 461                         if (chan_map [chan] == channel_mask_bits [k].id)
 462                         {       bit = k ;
 463                                 break ;
 464                                 } ;
 465
 466                 /* Check for bad sequence. */
 467                 if (bit <= last_bit)
 468                         return 0 ;
 469
 470                 mask += 1 << bit ;
 471                 last_bit = bit ;
 472                 } ;
 473
 474         return mask ;
 475 } /* wavex_gen_channel_mask */
 476
 477 void
 478 wav_w64_analyze (SF_PRIVATE *psf)
 479 {       unsigned char buffer [4096] ;
 480         AUDIO_DETECT ad ;
 481         int format = 0 ;
 482
 483         if (psf->is_pipe)
 484         {       psf_log_printf (psf, "*** Error : Reading from a pipe. Can't analyze data section to figure out real data format.\n\n") ;
 485                 return ;
 486                 } ;
 487
 488         psf_log_printf (psf, "---------------------------------------------------\n"
 489                                                 "Format is known to be broken. Using detection code.\n") ;
 490
 491         /* Code goes here. */
 492         ad.endianness = SF_ENDIAN_LITTLE ;
 493         ad.channels = psf->sf.channels ;
 494
 495         psf_fseek (psf, 3 * 4 * 50, SEEK_SET) ;
 496
 497         while (psf_fread (buffer, 1, sizeof (buffer), psf) == sizeof (buffer))
 498         {       format = audio_detect (psf, &ad, buffer, sizeof (buffer)) ;
 499                 if (format != 0)
 500                         break ;
 501                 } ;
 502
 503         /* Seek to start of DATA section. */
 504         psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
 505
 506         if (format == 0)
 507         {       psf_log_printf (psf, "wav_w64_analyze : detection failed.\n") ;
 508                 return ;
 509                 } ;
 510
 511         switch (format)
 512         {       case SF_FORMAT_PCM_32 :
 513                 case SF_FORMAT_FLOAT :
 514                         psf_log_printf (psf, "wav_w64_analyze : found format : 0x%X\n", format) ;
 515                         psf->sf.format = (psf->sf.format & ~SF_FORMAT_SUBMASK) + format ;
 516                         psf->bytewidth = 4 ;
 517                         psf->blockwidth = psf->sf.channels * psf->bytewidth ;
 518                         break ;
 519
 520                 case SF_FORMAT_PCM_24 :
 521                         psf_log_printf (psf, "wav_w64_analyze : found format : 0x%X\n", format) ;
 522                         psf->sf.format = (psf->sf.format & ~SF_FORMAT_SUBMASK) + format ;
 523                         psf->bytewidth = 3 ;
 524                         psf->blockwidth = psf->sf.channels * psf->bytewidth ;
 525                         break ;
 526
 527                 default :
 528                         psf_log_printf (psf, "wav_w64_analyze : unhandled format : 0x%X\n", format) ;
 529                         break ;
 530                 } ;
 531
 532         return ;
 533 } /* wav_w64_analyze */
 534
 535 /*==============================================================================
 536 */
 537
 538 typedef struct
 539 {       int                     ID ;
 540         const char      *name ;
 541 } WAV_FORMAT_DESC ;
 542
 543 #define STR(x)                  #x
 544 #define FORMAT_TYPE(x)  { x, STR (x) }
 545
 546 static WAV_FORMAT_DESC wave_descs [] =
 547 {       FORMAT_TYPE     (WAVE_FORMAT_PCM),
 548         FORMAT_TYPE (WAVE_FORMAT_MS_ADPCM),
 549         FORMAT_TYPE (WAVE_FORMAT_IEEE_FLOAT),
 550         FORMAT_TYPE (WAVE_FORMAT_VSELP),
 551         FORMAT_TYPE (WAVE_FORMAT_IBM_CVSD),
 552         FORMAT_TYPE (WAVE_FORMAT_ALAW),
 553         FORMAT_TYPE (WAVE_FORMAT_MULAW),
 554         FORMAT_TYPE (WAVE_FORMAT_OKI_ADPCM),
 555         FORMAT_TYPE (WAVE_FORMAT_IMA_ADPCM),
 556         FORMAT_TYPE (WAVE_FORMAT_MEDIASPACE_ADPCM),
 557         FORMAT_TYPE (WAVE_FORMAT_SIERRA_ADPCM),
 558         FORMAT_TYPE (WAVE_FORMAT_G723_ADPCM),
 559         FORMAT_TYPE (WAVE_FORMAT_DIGISTD),
 560         FORMAT_TYPE (WAVE_FORMAT_DIGIFIX),
 561         FORMAT_TYPE (WAVE_FORMAT_DIALOGIC_OKI_ADPCM),
 562         FORMAT_TYPE (WAVE_FORMAT_MEDIAVISION_ADPCM),
 563         FORMAT_TYPE (WAVE_FORMAT_CU_CODEC),
 564         FORMAT_TYPE (WAVE_FORMAT_YAMAHA_ADPCM),
 565         FORMAT_TYPE (WAVE_FORMAT_SONARC),
 566         FORMAT_TYPE (WAVE_FORMAT_DSPGROUP_TRUESPEECH),
 567         FORMAT_TYPE (WAVE_FORMAT_ECHOSC1),
 568         FORMAT_TYPE (WAVE_FORMAT_AUDIOFILE_AF36),
 569         FORMAT_TYPE (WAVE_FORMAT_APTX),
 570         FORMAT_TYPE (WAVE_FORMAT_AUDIOFILE_AF10),
 571         FORMAT_TYPE (WAVE_FORMAT_PROSODY_1612),
 572         FORMAT_TYPE (WAVE_FORMAT_LRC),
 573         FORMAT_TYPE (WAVE_FORMAT_DOLBY_AC2),
 574         FORMAT_TYPE (WAVE_FORMAT_GSM610),
 575         FORMAT_TYPE (WAVE_FORMAT_MSNAUDIO),
 576         FORMAT_TYPE (WAVE_FORMAT_ANTEX_ADPCME),
 577         FORMAT_TYPE (WAVE_FORMAT_CONTROL_RES_VQLPC),
 578         FORMAT_TYPE (WAVE_FORMAT_DIGIREAL),
 579         FORMAT_TYPE (WAVE_FORMAT_DIGIADPCM),
 580         FORMAT_TYPE (WAVE_FORMAT_CONTROL_RES_CR10),
 581         FORMAT_TYPE (WAVE_FORMAT_NMS_VBXADPCM),
 582         FORMAT_TYPE (WAVE_FORMAT_ROLAND_RDAC),
 583         FORMAT_TYPE (WAVE_FORMAT_ECHOSC3),
 584         FORMAT_TYPE (WAVE_FORMAT_ROCKWELL_ADPCM),
 585         FORMAT_TYPE (WAVE_FORMAT_ROCKWELL_DIGITALK),
 586         FORMAT_TYPE (WAVE_FORMAT_XEBEC),
 587         FORMAT_TYPE (WAVE_FORMAT_G721_ADPCM),
 588         FORMAT_TYPE (WAVE_FORMAT_G728_CELP),
 589         FORMAT_TYPE (WAVE_FORMAT_MSG723),
 590         FORMAT_TYPE (WAVE_FORMAT_MPEG),
 591         FORMAT_TYPE (WAVE_FORMAT_RT24),
 592         FORMAT_TYPE (WAVE_FORMAT_PAC),
 593         FORMAT_TYPE (WAVE_FORMAT_MPEGLAYER3),
 594         FORMAT_TYPE (WAVE_FORMAT_LUCENT_G723),
 595         FORMAT_TYPE (WAVE_FORMAT_CIRRUS),
 596         FORMAT_TYPE (WAVE_FORMAT_ESPCM),
 597         FORMAT_TYPE (WAVE_FORMAT_VOXWARE),
 598         FORMAT_TYPE (WAVE_FORMAT_CANOPUS_ATRAC),
 599         FORMAT_TYPE (WAVE_FORMAT_G726_ADPCM),
 600         FORMAT_TYPE (WAVE_FORMAT_G722_ADPCM),
 601         FORMAT_TYPE (WAVE_FORMAT_DSAT),
 602         FORMAT_TYPE (WAVE_FORMAT_DSAT_DISPLAY),
 603         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_BYTE_ALIGNED),
 604         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_AC8),
 605         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_AC10),
 606         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_AC16),
 607         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_AC20),
 608         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_RT24),
 609         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_RT29),
 610         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_RT29HW),
 611         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_VR12),
 612         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_VR18),
 613         FORMAT_TYPE (WAVE_FORMAT_VOXWARE_TQ40),
 614         FORMAT_TYPE (WAVE_FORMAT_SOFTSOUND),
 615         FORMAT_TYPE (WAVE_FORMAT_VOXARE_TQ60),
 616         FORMAT_TYPE (WAVE_FORMAT_MSRT24),
 617         FORMAT_TYPE (WAVE_FORMAT_G729A),
 618         FORMAT_TYPE (WAVE_FORMAT_MVI_MV12),
 619         FORMAT_TYPE (WAVE_FORMAT_DF_G726),
 620         FORMAT_TYPE (WAVE_FORMAT_DF_GSM610),
 621         FORMAT_TYPE (WAVE_FORMAT_ONLIVE),
 622         FORMAT_TYPE (WAVE_FORMAT_SBC24),
 623         FORMAT_TYPE (WAVE_FORMAT_DOLBY_AC3_SPDIF),
 624         FORMAT_TYPE (WAVE_FORMAT_ZYXEL_ADPCM),
 625         FORMAT_TYPE (WAVE_FORMAT_PHILIPS_LPCBB),
 626         FORMAT_TYPE (WAVE_FORMAT_PACKED),
 627         FORMAT_TYPE (WAVE_FORMAT_RHETOREX_ADPCM),
 628         FORMAT_TYPE (IBM_FORMAT_MULAW),
 629         FORMAT_TYPE (IBM_FORMAT_ALAW),
 630         FORMAT_TYPE (IBM_FORMAT_ADPCM),
 631         FORMAT_TYPE (WAVE_FORMAT_VIVO_G723),
 632         FORMAT_TYPE (WAVE_FORMAT_VIVO_SIREN),
 633         FORMAT_TYPE (WAVE_FORMAT_DIGITAL_G723),
 634         FORMAT_TYPE (WAVE_FORMAT_CREATIVE_ADPCM),
 635         FORMAT_TYPE (WAVE_FORMAT_CREATIVE_FASTSPEECH8),
 636         FORMAT_TYPE (WAVE_FORMAT_CREATIVE_FASTSPEECH10),
 637         FORMAT_TYPE (WAVE_FORMAT_QUARTERDECK),
 638         FORMAT_TYPE (WAVE_FORMAT_FM_TOWNS_SND),
 639         FORMAT_TYPE (WAVE_FORMAT_BZV_DIGITAL),
 640         FORMAT_TYPE (WAVE_FORMAT_VME_VMPCM),
 641         FORMAT_TYPE (WAVE_FORMAT_OLIGSM),
 642         FORMAT_TYPE (WAVE_FORMAT_OLIADPCM),
 643         FORMAT_TYPE (WAVE_FORMAT_OLICELP),
 644         FORMAT_TYPE (WAVE_FORMAT_OLISBC),
 645         FORMAT_TYPE (WAVE_FORMAT_OLIOPR),
 646         FORMAT_TYPE (WAVE_FORMAT_LH_CODEC),
 647         FORMAT_TYPE (WAVE_FORMAT_NORRIS),
 648         FORMAT_TYPE (WAVE_FORMAT_SOUNDSPACE_MUSICOMPRESS),
 649         FORMAT_TYPE (WAVE_FORMAT_DVM),
 650         FORMAT_TYPE (WAVE_FORMAT_INTERWAV_VSC112),
 651         FORMAT_TYPE (WAVE_FORMAT_IPP_ITU_G_723_1),
 652         FORMAT_TYPE (WAVE_FORMAT_EXTENSIBLE),
 653 } ;
 654
 655 char const*
 656 wav_w64_format_str (int k)
 657 {       int lower, upper, mid ;
 658
 659         lower = -1 ;
 660         upper = sizeof (wave_descs) / sizeof (WAV_FORMAT_DESC) ;
 661
 662         /* binary search */
 663         if ((wave_descs [0].ID <= k) && (k <= wave_descs [upper - 1].ID))
 664         {
 665                 while (lower + 1 < upper)
 666                 {       mid = (upper + lower) / 2 ;
 667
 668                         if (k == wave_descs [mid].ID)
 669                                 return wave_descs [mid].name ;
 670                         if (k < wave_descs [mid].ID)
 671                                 upper = mid ;
 672                         else
 673                                 lower = mid ;
 674                         } ;
 675                 } ;
 676
 677         return "Unknown format" ;
 678 } /* wav_w64_format_str */
 679
 680 int
 681 wav_w64_srate2blocksize (int srate_chan_product)
 682 {       if (srate_chan_product < 12000)
 683                 return 256 ;
 684         if (srate_chan_product < 23000)
 685                 return 512 ;
 686         if (srate_chan_product < 44000)
 687                 return 1024 ;
 688         return 2048 ;
 689 } /* srate2blocksize */