interpretor/libsndfile-1.0.25/src/rf64.c

   1 /*
   2 ** Copyright (C) 2008-2011 Erik de Castro Lopo <erikd@mega-nerd.com>
   3 ** Copyright (C) 2009      Uli Franke <cls@nebadje.org>
   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 /*
  21 **      This format documented at:
  22 **      http://www.sr.se/utveckling/tu/bwf/prog/RF_64v1_4.pdf
  23 **
  24 **      But this may be a better reference:
  25 **      http://www.ebu.ch/CMSimages/en/tec_doc_t3306-2007_tcm6-42570.pdf
  26 */
  27
  28 #include        "sfconfig.h"
  29
  30 #include        <stdio.h>
  31 #include        <fcntl.h>
  32 #include        <string.h>
  33 #include        <ctype.h>
  34
  35 #include        "sndfile.h"
  36 #include        "sfendian.h"
  37 #include        "common.h"
  38 #include        "wav_w64.h"
  39
  40 /*------------------------------------------------------------------------------
  41 ** Macros to handle big/little endian issues.
  42 */
  43 #define RF64_MARKER             MAKE_MARKER ('R', 'F', '6', '4')
  44 #define FFFF_MARKER             MAKE_MARKER (0xff, 0xff, 0xff, 0xff)
  45 #define WAVE_MARKER             MAKE_MARKER ('W', 'A', 'V', 'E')
  46 #define ds64_MARKER             MAKE_MARKER ('d', 's', '6', '4')
  47 #define fmt_MARKER              MAKE_MARKER ('f', 'm', 't', ' ')
  48 #define fact_MARKER             MAKE_MARKER ('f', 'a', 'c', 't')
  49 #define data_MARKER             MAKE_MARKER ('d', 'a', 't', 'a')
  50
  51 #define bext_MARKER             MAKE_MARKER ('b', 'e', 'x', 't')
  52 #define OggS_MARKER             MAKE_MARKER ('O', 'g', 'g', 'S')
  53 #define wvpk_MARKER     MAKE_MARKER ('w', 'v', 'p', 'k')
  54
  55 /*------------------------------------------------------------------------------
  56 ** Typedefs.
  57 */
  58
  59 /*------------------------------------------------------------------------------
  60 ** Private static functions.
  61 */
  62
  63 static int      rf64_read_header (SF_PRIVATE *psf, int *blockalign, int *framesperblock) ;
  64 static int      rf64_write_header (SF_PRIVATE *psf, int calc_length) ;
  65 static int      rf64_close (SF_PRIVATE *psf) ;
  66 static int      rf64_command (SF_PRIVATE *psf, int command, void * UNUSED (data), int datasize) ;
  67
  68 /*------------------------------------------------------------------------------
  69 ** Public function.
  70 */
  71
  72 int
  73 rf64_open (SF_PRIVATE *psf)
  74 {       WAV_PRIVATE *wpriv ;
  75         int     subformat, error = 0 ;
  76         int blockalign, framesperblock ;
  77
  78         if ((wpriv = calloc (1, sizeof (WAV_PRIVATE))) == NULL)
  79                 return SFE_MALLOC_FAILED ;
  80         psf->container_data = wpriv ;
  81         wpriv->wavex_ambisonic = SF_AMBISONIC_NONE ;
  82
  83         /* All RF64 files are little endian. */
  84         psf->endian = SF_ENDIAN_LITTLE ;
  85
  86
  87         if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
  88         {       if ((error = rf64_read_header (psf, &blockalign, &framesperblock)) != 0)
  89                         return error ;
  90                 } ;
  91
  92         if ((psf->sf.format & SF_FORMAT_TYPEMASK) != SF_FORMAT_RF64)
  93                 return  SFE_BAD_OPEN_FORMAT ;
  94
  95         subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
  96
  97         if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
  98         {       if (psf->is_pipe)
  99                         return SFE_NO_PIPE_WRITE ;
 100
 101                 psf->blockwidth = psf->bytewidth * psf->sf.channels ;
 102
 103                 if ((error = rf64_write_header (psf, SF_FALSE)))
 104                         return error ;
 105
 106                 psf->write_header = rf64_write_header ;
 107                 } ;
 108
 109         psf->container_close = rf64_close ;
 110         psf->command = rf64_command ;
 111
 112         switch (subformat)
 113         {       case SF_FORMAT_PCM_U8 :
 114                 case SF_FORMAT_PCM_16 :
 115                 case SF_FORMAT_PCM_24 :
 116                 case SF_FORMAT_PCM_32 :
 117                                         error = pcm_init (psf) ;
 118                                         break ;
 119
 120                 case SF_FORMAT_ULAW :
 121                                         error = ulaw_init (psf) ;
 122                                         break ;
 123
 124                 case SF_FORMAT_ALAW :
 125                                         error = alaw_init (psf) ;
 126                                         break ;
 127
 128                 /* Lite remove start */
 129                 case SF_FORMAT_FLOAT :
 130                                         error = float32_init (psf) ;
 131                                         break ;
 132
 133                 case SF_FORMAT_DOUBLE :
 134                                         error = double64_init (psf) ;
 135                                         break ;
 136
 137                 /* Lite remove end */
 138
 139                 default :       return SFE_UNIMPLEMENTED ;
 140                 } ;
 141
 142         return error ;
 143 } /* rf64_open */
 144
 145 /*------------------------------------------------------------------------------
 146 */
 147 enum
 148 {       HAVE_ds64       = 0x01,
 149         HAVE_fmt        = 0x02,
 150         HAVE_bext       = 0x04,
 151         HAVE_data       = 0x08
 152 } ;
 153
 154 #define HAVE_CHUNK(CHUNK)       ((parsestage & CHUNK) != 0)
 155
 156 static int
 157 rf64_read_header (SF_PRIVATE *psf, int *blockalign, int *framesperblock)
 158 {       WAV_PRIVATE     *wpriv ;
 159         WAV_FMT         *wav_fmt ;
 160         sf_count_t riff_size = 0, frame_count = 0, ds64_datalength = 0 ;
 161         unsigned int size32, parsestage = 0 ;
 162         int marker, marks [2], error, done = 0, format = 0 ;
 163
 164         if ((wpriv = psf->container_data) == NULL)
 165                 return SFE_INTERNAL ;
 166         wav_fmt = &wpriv->wav_fmt ;
 167
 168         /* Set position to start of file to begin reading header. */
 169         psf_binheader_readf (psf, "pmmm", 0, &marker, marks, marks + 1) ;
 170         if (marker != RF64_MARKER || marks [1] != WAVE_MARKER)
 171                 return SFE_RF64_NOT_RF64 ;
 172
 173         if (marks [0] == FFFF_MARKER)
 174                 psf_log_printf (psf, "%M\n  %M\n", RF64_MARKER, WAVE_MARKER) ;
 175         else
 176                 psf_log_printf (psf, "%M : 0x%x (should be 0xFFFFFFFF)\n  %M\n", RF64_MARKER, WAVE_MARKER) ;
 177
 178         while (NOT (done))
 179         {       psf_binheader_readf (psf, "em4", &marker, &size32) ;
 180
 181                 switch (marker)
 182                 {       case ds64_MARKER :
 183                                 {       unsigned int table_len, bytesread ;
 184
 185                                         /* Read ds64 sizes (3 8-byte words). */
 186                                         bytesread = psf_binheader_readf (psf, "888", &riff_size, &ds64_datalength, &frame_count) ;
 187
 188                                         /* Read table length. */
 189                                         bytesread += psf_binheader_readf (psf, "4", &table_len) ;
 190                                         /* Skip table for now. (this was "table_len + 4", why?) */
 191                                         bytesread += psf_binheader_readf (psf, "j", table_len) ;
 192
 193                                         if (size32 == bytesread)
 194                                                 psf_log_printf (psf, "%M : %u\n", marker, size32) ;
 195                                         else if (size32 >= bytesread + 4)
 196                                         {       unsigned int next ;
 197                                                 psf_binheader_readf (psf, "m", &next) ;
 198                                                 if (next == fmt_MARKER)
 199                                                 {       psf_log_printf (psf, "%M : %u (should be %u)\n", marker, size32, bytesread) ;
 200                                                         psf_binheader_readf (psf, "j", -4) ;
 201                                                         }
 202                                                 else
 203                                                 {       psf_log_printf (psf, "%M : %u\n", marker, size32) ;
 204                                                         psf_binheader_readf (psf, "j", size32 - bytesread - 4) ;
 205                                                         } ;
 206                                                 } ;
 207
 208                                         if (psf->filelength != riff_size + 8)
 209                                                 psf_log_printf (psf, "  Riff size : %D (should be %D)\n", riff_size, psf->filelength - 8) ;
 210                                         else
 211                                                 psf_log_printf (psf, "  Riff size : %D\n", riff_size) ;
 212
 213                                         psf_log_printf (psf, "  Data size : %D\n", ds64_datalength) ;
 214
 215                                         psf_log_printf (psf, "  Frames    : %D\n", frame_count) ;
 216                                         psf_log_printf (psf, "  Table length : %u\n", table_len) ;
 217
 218                                         } ;
 219                                 parsestage |= HAVE_ds64 ;
 220                                 break ;
 221
 222                         case fmt_MARKER:
 223                                         psf_log_printf (psf, "%M : %u\n", marker, size32) ;
 224                                         if ((error = wav_w64_read_fmt_chunk (psf, size32)) != 0)
 225                                                 return error ;
 226                                         format = wav_fmt->format ;
 227                                         parsestage |= HAVE_fmt ;
 228                                         break ;
 229
 230                         case bext_MARKER :
 231                                         if ((error = wav_read_bext_chunk (psf, size32)) != 0)
 232                                                 return error ;
 233                                         parsestage |= HAVE_bext ;
 234                                         break ;
 235
 236                         case data_MARKER :
 237                                 /* see wav for more sophisticated parsing -> implement state machine with parsestage */
 238
 239                                 if (HAVE_CHUNK (HAVE_ds64))
 240                                 {       if (size32 == 0xffffffff)
 241                                                 psf_log_printf (psf, "%M : 0x%x\n", marker, size32) ;
 242                                         else
 243                                                 psf_log_printf (psf, "%M : 0x%x (should be 0xffffffff\n", marker, size32) ;
 244                                         psf->datalength = ds64_datalength ;
 245                                         }
 246                                 else
 247                                 {       if (size32 == 0xffffffff)
 248                                         {       psf_log_printf (psf, "%M : 0x%x\n", marker, size32) ;
 249                                                 psf_log_printf (psf, "  *** Data length not specified no 'ds64' chunk.\n") ;
 250                                                 }
 251                                         else
 252                                         {       psf_log_printf (psf, "%M : 0x%x\n**** Weird, RF64 file without a 'ds64' chunk and no valid 'data' size.\n", marker, size32) ;
 253                                                 psf->datalength = size32 ;
 254                                                 } ;
 255                                         } ;
 256
 257                                 psf->dataoffset = psf_ftell (psf) ;
 258
 259                                 if (psf->dataoffset > 0)
 260                                 {       if (size32 == 0 && riff_size == 8 && psf->filelength > 44)
 261                                         {       psf_log_printf (psf, "  *** Looks like a WAV file which wasn't closed properly. Fixing it.\n") ;
 262                                                 psf->datalength = psf->filelength - psf->dataoffset ;
 263                                                 } ;
 264
 265                                         /* Only set dataend if there really is data at the end. */
 266                                         if (psf->datalength + psf->dataoffset < psf->filelength)
 267                                                 psf->dataend = psf->datalength + psf->dataoffset ;
 268
 269                                         if (NOT (psf->sf.seekable) || psf->dataoffset < 0)
 270                                                 break ;
 271
 272                                         /* Seek past data and continue reading header. */
 273                                         psf_fseek (psf, psf->datalength, SEEK_CUR) ;
 274
 275                                         if (psf_ftell (psf) != psf->datalength + psf->dataoffset)
 276                                                 psf_log_printf (psf, "  *** psf_fseek past end error ***\n") ;
 277                                                 break ;
 278                                         } ;
 279                                 break ;
 280
 281                         default :
 282                                         if (isprint ((marker >> 24) & 0xFF) && isprint ((marker >> 16) & 0xFF)
 283                                                 && isprint ((marker >> 8) & 0xFF) && isprint (marker & 0xFF))
 284                                         {       psf_log_printf (psf, "*** %M : %d (unknown marker)\n", marker, size32) ;
 285                                                 if (size32 < 8)
 286                                                         done = SF_TRUE ;
 287                                                 psf_binheader_readf (psf, "j", size32) ;
 288                                                 break ;
 289                                                 } ;
 290                                         if (psf_ftell (psf) & 0x03)
 291                                         {       psf_log_printf (psf, "  Unknown chunk marker at position 0x%x. Resynching.\n", size32 - 4) ;
 292                                                 psf_binheader_readf (psf, "j", -3) ;
 293                                                 break ;
 294                                                 } ;
 295                                         psf_log_printf (psf, "*** Unknown chunk marker (0x%X) at position 0x%X. Exiting parser.\n", marker, psf_ftell (psf) - 4) ;
 296                                         done = SF_TRUE ;
 297                                 break ;
 298                         } ;     /* switch (marker) */
 299
 300                 if (psf_ftell (psf) >= psf->filelength - SIGNED_SIZEOF (marker))
 301                 {       psf_log_printf (psf, "End\n") ;
 302                         break ;
 303                         } ;
 304                 } ;
 305
 306         if (psf->dataoffset <= 0)
 307                 return SFE_WAV_NO_DATA ;
 308
 309         /* WAVs can be little or big endian */
 310         psf->endian = psf->rwf_endian ;
 311
 312         psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
 313
 314         if (psf->is_pipe == 0)
 315         {       /*
 316                 ** Check for 'wvpk' at the start of the DATA section. Not able to
 317                 ** handle this.
 318                 */
 319                 psf_binheader_readf (psf, "4", &marker) ;
 320                 if (marker == wvpk_MARKER || marker == OggS_MARKER)
 321                         return SFE_WAV_WVPK_DATA ;
 322                 } ;
 323
 324         /* Seek to start of DATA section. */
 325         psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
 326
 327         if (psf->blockwidth)
 328         {       if (psf->filelength - psf->dataoffset < psf->datalength)
 329                         psf->sf.frames = (psf->filelength - psf->dataoffset) / psf->blockwidth ;
 330                 else
 331                         psf->sf.frames = psf->datalength / psf->blockwidth ;
 332                 } ;
 333
 334         if (frame_count != psf->sf.frames)
 335                 psf_log_printf (psf, "*** Calculated frame count %d does not match value from 'ds64' chunk of %d.\n", psf->sf.frames, frame_count) ;
 336
 337         switch (format)
 338         {
 339                 case WAVE_FORMAT_EXTENSIBLE :
 340
 341                         /* with WAVE_FORMAT_EXTENSIBLE the psf->sf.format field is already set. We just have to set the major to rf64 */
 342                         psf->sf.format = (psf->sf.format & ~SF_FORMAT_TYPEMASK ) | SF_FORMAT_RF64 ;
 343
 344                         if (psf->sf.format == (SF_FORMAT_WAVEX | SF_FORMAT_MS_ADPCM))
 345                         {       *blockalign = wav_fmt->msadpcm.blockalign ;
 346                                 *framesperblock = wav_fmt->msadpcm.samplesperblock ;
 347                                 } ;
 348                         break ;
 349
 350                 case WAVE_FORMAT_PCM :
 351                                         psf->sf.format = SF_FORMAT_RF64 | u_bitwidth_to_subformat (psf->bytewidth * 8) ;
 352                                         break ;
 353
 354                 case WAVE_FORMAT_MULAW :
 355                 case IBM_FORMAT_MULAW :
 356                                         psf->sf.format = (SF_FORMAT_RF64 | SF_FORMAT_ULAW) ;
 357                                         break ;
 358
 359                 case WAVE_FORMAT_ALAW :
 360                 case IBM_FORMAT_ALAW :
 361                                         psf->sf.format = (SF_FORMAT_RF64 | SF_FORMAT_ALAW) ;
 362                                         break ;
 363
 364                 case WAVE_FORMAT_MS_ADPCM :
 365                                         psf->sf.format = (SF_FORMAT_RF64 | SF_FORMAT_MS_ADPCM) ;
 366                                         *blockalign = wav_fmt->msadpcm.blockalign ;
 367                                         *framesperblock = wav_fmt->msadpcm.samplesperblock ;
 368                                         break ;
 369
 370                 case WAVE_FORMAT_IMA_ADPCM :
 371                                         psf->sf.format = (SF_FORMAT_RF64 | SF_FORMAT_IMA_ADPCM) ;
 372                                         *blockalign = wav_fmt->ima.blockalign ;
 373                                         *framesperblock = wav_fmt->ima.samplesperblock ;
 374                                         break ;
 375
 376                 case WAVE_FORMAT_GSM610 :
 377                                         psf->sf.format = (SF_FORMAT_RF64 | SF_FORMAT_GSM610) ;
 378                                         break ;
 379
 380                 case WAVE_FORMAT_IEEE_FLOAT :
 381                                         psf->sf.format = SF_FORMAT_RF64 ;
 382                                         psf->sf.format |= (psf->bytewidth == 8) ? SF_FORMAT_DOUBLE : SF_FORMAT_FLOAT ;
 383                                         break ;
 384
 385                 case WAVE_FORMAT_G721_ADPCM :
 386                                         psf->sf.format = SF_FORMAT_RF64 | SF_FORMAT_G721_32 ;
 387                                         break ;
 388
 389                 default : return SFE_UNIMPLEMENTED ;
 390                 } ;
 391
 392         if (wpriv->fmt_is_broken)
 393                 wav_w64_analyze (psf) ;
 394
 395         /* Only set the format endian-ness if its non-standard big-endian. */
 396         if (psf->endian == SF_ENDIAN_BIG)
 397                 psf->sf.format |= SF_ENDIAN_BIG ;
 398
 399         return 0 ;
 400 } /* rf64_read_header */
 401
 402 /*  known WAVEFORMATEXTENSIBLE GUIDS  */
 403 static const EXT_SUBFORMAT MSGUID_SUBTYPE_PCM =
 404 {       0x00000001, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
 405 } ;
 406
 407 static const EXT_SUBFORMAT MSGUID_SUBTYPE_MS_ADPCM =
 408 {       0x00000002, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
 409 } ;
 410
 411 static const EXT_SUBFORMAT MSGUID_SUBTYPE_IEEE_FLOAT =
 412 {       0x00000003, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
 413 } ;
 414
 415 static const EXT_SUBFORMAT MSGUID_SUBTYPE_ALAW =
 416 {       0x00000006, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
 417 } ;
 418
 419 static const EXT_SUBFORMAT MSGUID_SUBTYPE_MULAW =
 420 {       0x00000007, 0x0000, 0x0010, {   0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
 421 } ;
 422
 423 /*
 424 ** the next two are from
 425 ** http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html
 426 */
 427 static const EXT_SUBFORMAT MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_PCM =
 428 {       0x00000001, 0x0721, 0x11d3, {   0x86, 0x44, 0xC8, 0xC1, 0xCA, 0x00, 0x00, 0x00 }
 429 } ;
 430
 431 static const EXT_SUBFORMAT MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_IEEE_FLOAT =
 432 {       0x00000003, 0x0721, 0x11d3, {   0x86, 0x44, 0xC8, 0xC1, 0xCA, 0x00, 0x00, 0x00 }
 433 } ;
 434
 435
 436 static int
 437 rf64_write_fmt_chunk (SF_PRIVATE *psf)
 438 {       WAV_PRIVATE     *wpriv ;
 439         int subformat, fmt_size ;
 440
 441         if ((wpriv = psf->container_data) == NULL)
 442                 return SFE_INTERNAL ;
 443
 444         subformat = psf->sf.format & SF_FORMAT_SUBMASK ;
 445
 446         /* initial section (same for all, it appears) */
 447         switch (subformat)
 448         {       case SF_FORMAT_PCM_U8 :
 449                 case SF_FORMAT_PCM_16 :
 450                 case SF_FORMAT_PCM_24 :
 451                 case SF_FORMAT_PCM_32 :
 452                 case SF_FORMAT_FLOAT :
 453                 case SF_FORMAT_DOUBLE :
 454                 case SF_FORMAT_ULAW :
 455                 case SF_FORMAT_ALAW :
 456                         fmt_size = 2 + 2 + 4 + 4 + 2 + 2 + 2 + 2 + 4 + 4 + 2 + 2 + 8 ;
 457
 458                         /* fmt : format, channels, samplerate */
 459                         psf_binheader_writef (psf, "4224", fmt_size, WAVE_FORMAT_EXTENSIBLE, psf->sf.channels, psf->sf.samplerate) ;
 460                         /*  fmt : bytespersec */
 461                         psf_binheader_writef (psf, "4", psf->sf.samplerate * psf->bytewidth * psf->sf.channels) ;
 462                         /*  fmt : blockalign, bitwidth */
 463                         psf_binheader_writef (psf, "22", psf->bytewidth * psf->sf.channels, psf->bytewidth * 8) ;
 464
 465                         /* cbSize 22 is sizeof (WAVEFORMATEXTENSIBLE) - sizeof (WAVEFORMATEX) */
 466                         psf_binheader_writef (psf, "2", 22) ;
 467
 468                         /* wValidBitsPerSample, for our use same as bitwidth as we use it fully */
 469                         psf_binheader_writef (psf, "2", psf->bytewidth * 8) ;
 470
 471                         /* For an Ambisonic file set the channel mask to zero.
 472                         ** Otherwise use a default based on the channel count.
 473                         */
 474                         if (wpriv->wavex_ambisonic != SF_AMBISONIC_NONE)
 475                                 psf_binheader_writef (psf, "4", 0) ;
 476                         else if (wpriv->wavex_channelmask != 0)
 477                                 psf_binheader_writef (psf, "4", wpriv->wavex_channelmask) ;
 478                         else
 479                         {       /*
 480                                 ** Ok some liberty is taken here to use the most commonly used channel masks
 481                                 ** instead of "no mapping". If you really want to use "no mapping" for 8 channels and less
 482                                 ** please don't use wavex. (otherwise we'll have to create a new SF_COMMAND)
 483                                 */
 484                                 switch (psf->sf.channels)
 485                                 {       case 1 :        /* center channel mono */
 486                                                 psf_binheader_writef (psf, "4", 0x4) ;
 487                                                 break ;
 488
 489                                         case 2 :        /* front left and right */
 490                                                 psf_binheader_writef (psf, "4", 0x1 | 0x2) ;
 491                                                 break ;
 492
 493                                         case 4 :        /* Quad */
 494                                                 psf_binheader_writef (psf, "4", 0x1 | 0x2 | 0x10 | 0x20) ;
 495                                                 break ;
 496
 497                                         case 6 :        /* 5.1 */
 498                                                 psf_binheader_writef (psf, "4", 0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20) ;
 499                                                 break ;
 500
 501                                         case 8 :        /* 7.1 */
 502                                                 psf_binheader_writef (psf, "4", 0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20 | 0x40 | 0x80) ;
 503                                                 break ;
 504
 505                                         default :       /* 0 when in doubt , use direct out, ie NO mapping*/
 506                                                 psf_binheader_writef (psf, "4", 0x0) ;
 507                                                 break ;
 508                                         } ;
 509                                 } ;
 510                         break ;
 511
 512                 case SF_FORMAT_MS_ADPCM : /* Todo, GUID exists might have different header as per wav_write_header */
 513                 default :
 514                         return SFE_UNIMPLEMENTED ;
 515                 } ;
 516
 517         /* GUID section, different for each */
 518
 519         switch (subformat)
 520         {       case SF_FORMAT_PCM_U8 :
 521                 case SF_FORMAT_PCM_16 :
 522                 case SF_FORMAT_PCM_24 :
 523                 case SF_FORMAT_PCM_32 :
 524                         wavex_write_guid (psf, wpriv->wavex_ambisonic == SF_AMBISONIC_NONE ?
 525                                                 &MSGUID_SUBTYPE_PCM : &MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_PCM) ;
 526                         break ;
 527
 528                 case SF_FORMAT_FLOAT :
 529                 case SF_FORMAT_DOUBLE :
 530                         wavex_write_guid (psf, wpriv->wavex_ambisonic == SF_AMBISONIC_NONE ?
 531                                                 &MSGUID_SUBTYPE_IEEE_FLOAT : &MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_IEEE_FLOAT) ;
 532                         break ;
 533
 534                 case SF_FORMAT_ULAW :
 535                         wavex_write_guid (psf, &MSGUID_SUBTYPE_MULAW) ;
 536                         break ;
 537
 538                 case SF_FORMAT_ALAW :
 539                         wavex_write_guid (psf, &MSGUID_SUBTYPE_ALAW) ;
 540                         break ;
 541
 542                 default : return SFE_UNIMPLEMENTED ;
 543                 } ;
 544
 545         return 0 ;
 546 } /* rf64_write_fmt_chunk */
 547
 548
 549 static int
 550 rf64_write_header (SF_PRIVATE *psf, int calc_length)
 551 {       sf_count_t      current ;
 552         int             error = 0, has_data = SF_FALSE ;
 553
 554         current = psf_ftell (psf) ;
 555
 556         if (psf->dataoffset > 0 && current > psf->dataoffset)
 557                 has_data = SF_TRUE ;
 558
 559         if (calc_length)
 560         {       psf->filelength = psf_get_filelen (psf) ;
 561                 psf->datalength = psf->filelength - psf->dataoffset ;
 562
 563                 if (psf->dataend)
 564                         psf->datalength -= psf->filelength - psf->dataend ;
 565
 566                 if (psf->bytewidth > 0)
 567                         psf->sf.frames = psf->datalength / (psf->bytewidth * psf->sf.channels) ;
 568                 } ;
 569
 570         /* Reset the current header length to zero. */
 571         psf->header [0] = 0 ;
 572         psf->headindex = 0 ;
 573         psf_fseek (psf, 0, SEEK_SET) ;
 574
 575         psf_binheader_writef (psf, "em4m", RF64_MARKER, 0xffffffff, WAVE_MARKER) ;
 576
 577         /* Currently no table. */
 578         psf_binheader_writef (psf, "m48884", ds64_MARKER, 28, psf->filelength - 8, psf->datalength, psf->sf.frames, 0) ;
 579
 580         /* WAVE and 'fmt ' markers. */
 581         psf_binheader_writef (psf, "m", fmt_MARKER) ;
 582
 583         /* Write the 'fmt ' chunk. */
 584         switch (psf->sf.format & SF_FORMAT_TYPEMASK)
 585         {       case SF_FORMAT_WAV :
 586                                 psf_log_printf (psf, "ooops SF_FORMAT_WAV\n") ;
 587                                 return SFE_UNIMPLEMENTED ;
 588                                 break ;
 589
 590                 case SF_FORMAT_WAVEX :
 591                 case SF_FORMAT_RF64 :
 592                                 if ((error = rf64_write_fmt_chunk (psf)) != 0)
 593                                         return error ;
 594                                 break ;
 595
 596                 default :
 597                                 return SFE_UNIMPLEMENTED ;
 598                 } ;
 599
 600         if (psf->broadcast_16k != NULL)
 601                 wav_write_bext_chunk (psf) ;
 602
 603 #if 0
 604         /* The LIST/INFO chunk. */
 605         if (psf->str_flags & SF_STR_LOCATE_START)
 606                 wav_write_strings (psf, SF_STR_LOCATE_START) ;
 607
 608         if (psf->peak_info != NULL && psf->peak_info->peak_loc == SF_PEAK_START)
 609         {       psf_binheader_writef (psf, "m4", PEAK_MARKER, WAV_PEAK_CHUNK_SIZE (psf->sf.channels)) ;
 610                 psf_binheader_writef (psf, "44", 1, time (NULL)) ;
 611                 for (k = 0 ; k < psf->sf.channels ; k++)
 612                         psf_binheader_writef (psf, "ft8", (float) psf->peak_info->peaks [k].value, psf->peak_info->peaks [k].position) ;
 613                 } ;
 614
 615 //      if (psf->broadcast_info != NULL)
 616 //              wav_write_bext_chunk (psf) ;
 617
 618         if (psf->instrument != NULL)
 619         {       int             tmp ;
 620                 double  dtune = (double) (0x40000000) / 25.0 ;
 621
 622                 psf_binheader_writef (psf, "m4", smpl_MARKER, 9 * 4 + psf->instrument->loop_count * 6 * 4) ;
 623                 psf_binheader_writef (psf, "44", 0, 0) ; /* Manufacturer zero is everyone */
 624                 tmp = (int) (1.0e9 / psf->sf.samplerate) ; /* Sample period in nano seconds */
 625                 psf_binheader_writef (psf, "44", tmp, psf->instrument->basenote) ;
 626                 tmp = (unsigned int) (psf->instrument->detune * dtune + 0.5) ;
 627                 psf_binheader_writef (psf, "4", tmp) ;
 628                 psf_binheader_writef (psf, "44", 0, 0) ; /* SMTPE format */
 629                 psf_binheader_writef (psf, "44", psf->instrument->loop_count, 0) ;
 630
 631                 for (tmp = 0 ; tmp < psf->instrument->loop_count ; tmp++)
 632                 {       int type ;
 633
 634                         type = psf->instrument->loops [tmp].mode ;
 635                         type = (type == SF_LOOP_FORWARD ? 0 : type==SF_LOOP_BACKWARD ? 2 : type == SF_LOOP_ALTERNATING ? 1 : 32) ;
 636
 637                         psf_binheader_writef (psf, "44", tmp, type) ;
 638                         psf_binheader_writef (psf, "44", psf->instrument->loops [tmp].start, psf->instrument->loops [tmp].end) ;
 639                         psf_binheader_writef (psf, "44", 0, psf->instrument->loops [tmp].count) ;
 640                         } ;
 641                 } ;
 642
 643         if (psf->headindex + 8 < psf->dataoffset)
 644         {       /* Add PAD data if necessary. */
 645                 k = psf->dataoffset - 16 - psf->headindex ;
 646                 psf_binheader_writef (psf, "m4z", PAD_MARKER, k, make_size_t (k)) ;
 647                 } ;
 648
 649 #endif
 650
 651         psf_binheader_writef (psf, "m4", data_MARKER, 0xffffffff) ;
 652
 653         psf_fwrite (psf->header, psf->headindex, 1, psf) ;
 654         if (psf->error)
 655                 return psf->error ;
 656
 657         if (has_data && psf->dataoffset != psf->headindex)
 658         {       printf ("Oooops : has_data && psf->dataoffset != psf->headindex\n") ;
 659                 return psf->error = SFE_INTERNAL ;
 660                 } ;
 661
 662         psf->dataoffset = psf->headindex ;
 663
 664         if (NOT (has_data))
 665                 psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
 666         else if (current > 0)
 667                 psf_fseek (psf, current, SEEK_SET) ;
 668
 669         return psf->error ;
 670 } /* rf64_write_header */
 671
 672 static int
 673 rf64_close (SF_PRIVATE *psf)
 674 {
 675         if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
 676         {       // rf64_write_tailer (psf) ;
 677
 678                 psf->write_header (psf, SF_TRUE) ;
 679                 } ;
 680
 681         return 0 ;
 682 } /* rf64_close */
 683
 684 static int
 685 rf64_command (SF_PRIVATE *psf, int command, void * UNUSED (data), int datasize)
 686 {       WAV_PRIVATE     *wpriv ;
 687
 688         if ((wpriv = psf->container_data) == NULL)
 689                 return SFE_INTERNAL ;
 690
 691         switch (command)
 692         {       case SFC_WAVEX_SET_AMBISONIC :
 693                         if ((SF_CONTAINER (psf->sf.format)) == SF_FORMAT_WAVEX)
 694                         {       if (datasize == SF_AMBISONIC_NONE)
 695                                         wpriv->wavex_ambisonic = SF_AMBISONIC_NONE ;
 696                                 else if (datasize == SF_AMBISONIC_B_FORMAT)
 697                                         wpriv->wavex_ambisonic = SF_AMBISONIC_B_FORMAT ;
 698                                 else
 699                                         return 0 ;
 700                                 } ;
 701                         return wpriv->wavex_ambisonic ;
 702
 703                 case SFC_WAVEX_GET_AMBISONIC :
 704                         return wpriv->wavex_ambisonic ;
 705
 706                 case SFC_SET_CHANNEL_MAP_INFO :
 707                         wpriv->wavex_channelmask = wavex_gen_channel_mask (psf->channel_map, psf->sf.channels) ;
 708                         return (wpriv->wavex_channelmask != 0) ;
 709
 710                 default :
 711                         break ;
 712         } ;
 713
 714         return 0 ;
 715 } /* rf64_command */
 716