Alexandre Lision | 7c6f4a6 | 2013-09-05 13:27:01 -0400 | [diff] [blame] | 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 | |