开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
wav.c
资源名称：libsndfile-1.0.21.tar.gz　[点击查看]
上传用户：shw771010
上传日期：2022-01-05
资源大小：991k
文件大小：57k
源码类别：

Audio

开发平台：

Unix_Linux

wav.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2009 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. */
  20. #include "sfconfig.h"
  22. #include <stdio.h>
  23. #include <stdlib.h>
  24. #include <string.h>
  25. #include <ctype.h>
  26. #include <time.h>
  27. #include <inttypes.h>
  29. #include "sndfile.h"
  30. #include "sfendian.h"
  31. #include "common.h"
  32. #include "wav_w64.h"
  34. /*------------------------------------------------------------------------------
  35.  * Macros to handle big/little endian issues.
  36.  */
  38. #define RIFF_MARKER  (MAKE_MARKER ('R', 'I', 'F', 'F'))
  39. #define RIFX_MARKER  (MAKE_MARKER ('R', 'I', 'F', 'X'))
  40. #define WAVE_MARKER  (MAKE_MARKER ('W', 'A', 'V', 'E'))
  41. #define fmt_MARKER  (MAKE_MARKER ('f', 'm', 't', ' '))
  42. #define data_MARKER  (MAKE_MARKER ('d', 'a', 't', 'a'))
  43. #define fact_MARKER  (MAKE_MARKER ('f', 'a', 'c', 't'))
  44. #define PEAK_MARKER  (MAKE_MARKER ('P', 'E', 'A', 'K'))
  46. #define cue_MARKER  (MAKE_MARKER ('c', 'u', 'e', ' '))
  47. #define LIST_MARKER  (MAKE_MARKER ('L', 'I', 'S', 'T'))
  48. #define slnt_MARKER  (MAKE_MARKER ('s', 'l', 'n', 't'))
  49. #define wavl_MARKER  (MAKE_MARKER ('w', 'a', 'v', 'l'))
  50. #define INFO_MARKER  (MAKE_MARKER ('I', 'N', 'F', 'O'))
  51. #define plst_MARKER  (MAKE_MARKER ('p', 'l', 's', 't'))
  52. #define adtl_MARKER  (MAKE_MARKER ('a', 'd', 't', 'l'))
  53. #define labl_MARKER  (MAKE_MARKER ('l', 'a', 'b', 'l'))
  54. #define ltxt_MARKER  (MAKE_MARKER ('l', 't', 'x', 't'))
  55. #define note_MARKER  (MAKE_MARKER ('n', 'o', 't', 'e'))
  56. #define smpl_MARKER  (MAKE_MARKER ('s', 'm', 'p', 'l'))
  57. #define bext_MARKER  (MAKE_MARKER ('b', 'e', 'x', 't'))
  58. #define iXML_MARKER  (MAKE_MARKER ('i', 'X', 'M', 'L'))
  59. #define levl_MARKER  (MAKE_MARKER ('l', 'e', 'v', 'l'))
  60. #define MEXT_MARKER  (MAKE_MARKER ('M', 'E', 'X', 'T'))
  61. #define DISP_MARKER  (MAKE_MARKER ('D', 'I', 'S', 'P'))
  62. #define acid_MARKER  (MAKE_MARKER ('a', 'c', 'i', 'd'))
  63. #define strc_MARKER  (MAKE_MARKER ('s', 't', 'r', 'c'))
  64. #define PAD_MARKER  (MAKE_MARKER ('P', 'A', 'D', ' '))
  65. #define afsp_MARKER  (MAKE_MARKER ('a', 'f', 's', 'p'))
  66. #define clm_MARKER  (MAKE_MARKER ('c', 'l', 'm', ' '))
  67. #define elmo_MARKER  (MAKE_MARKER ('e', 'l', 'm', 'o'))
  68. #define cart_MARKER  (MAKE_MARKER ('c', 'a', 'r', 't'))
  70. #define exif_MARKER  (MAKE_MARKER ('e', 'x', 'i', 'f'))
  71. #define ever_MARKER  (MAKE_MARKER ('e', 'v', 'e', 'r'))
  72. #define etim_MARKER  (MAKE_MARKER ('e', 't', 'i', 'm'))
  73. #define ecor_MARKER  (MAKE_MARKER ('e', 'c', 'o', 'r'))
  74. #define emdl_MARKER  (MAKE_MARKER ('e', 'm', 'd', 'l'))
  75. #define emnt_MARKER  (MAKE_MARKER ('e', 'm', 'n', 't'))
  76. #define erel_MARKER  (MAKE_MARKER ('e', 'r', 'e', 'l'))
  77. #define eucm_MARKER  (MAKE_MARKER ('e', 'u', 'c', 'm'))
  79. #define ISFT_MARKER  (MAKE_MARKER ('I', 'S', 'F', 'T'))
  80. #define ICRD_MARKER  (MAKE_MARKER ('I', 'C', 'R', 'D'))
  81. #define ICOP_MARKER  (MAKE_MARKER ('I', 'C', 'O', 'P'))
  82. #define IARL_MARKER  (MAKE_MARKER ('I', 'A', 'R', 'L'))
  83. #define IART_MARKER  (MAKE_MARKER ('I', 'A', 'R', 'T'))
  84. #define INAM_MARKER  (MAKE_MARKER ('I', 'N', 'A', 'M'))
  85. #define IENG_MARKER  (MAKE_MARKER ('I', 'E', 'N', 'G'))
  86. #define IART_MARKER  (MAKE_MARKER ('I', 'A', 'R', 'T'))
  87. #define ICOP_MARKER  (MAKE_MARKER ('I', 'C', 'O', 'P'))
  88. #define IPRD_MARKER  (MAKE_MARKER ('I', 'P', 'R', 'D'))
  89. #define ISRC_MARKER  (MAKE_MARKER ('I', 'S', 'R', 'C'))
  90. #define ISBJ_MARKER  (MAKE_MARKER ('I', 'S', 'B', 'J'))
  91. #define ICMT_MARKER  (MAKE_MARKER ('I', 'C', 'M', 'T'))
  93. /* Weird WAVPACK marker which can show up at the start of the DATA section. */
  94. #define wvpk_MARKER (MAKE_MARKER ('w', 'v', 'p', 'k'))
  95. #define OggS_MARKER (MAKE_MARKER ('O', 'g', 'g', 'S'))
  97. #define WAV_PEAK_CHUNK_SIZE(ch)  (2 * sizeof (int) + ch * (sizeof (float) + sizeof (int)))
  98. #define WAV_BEXT_MIN_CHUNK_SIZE 602
  99. #define WAV_BEXT_MAX_CHUNK_SIZE (10 * 1024)
  101. enum
  102. { HAVE_RIFF = 0x01,
  103. HAVE_WAVE = 0x02,
  104. HAVE_fmt = 0x04,
  105. HAVE_fact = 0x08,
  106. HAVE_PEAK = 0x10,
  107. HAVE_data = 0x20,
  108. HAVE_other = 0x80000000
  109. } ;
  113. /*  known WAVEFORMATEXTENSIBLE GUIDS  */
  114. static const EXT_SUBFORMAT MSGUID_SUBTYPE_PCM =
  115. { 0x00000001, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  116. } ;
  118. static const EXT_SUBFORMAT MSGUID_SUBTYPE_MS_ADPCM =
  119. { 0x00000002, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  120. } ;
  122. static const EXT_SUBFORMAT MSGUID_SUBTYPE_IEEE_FLOAT =
  123. { 0x00000003, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  124. } ;
  126. static const EXT_SUBFORMAT MSGUID_SUBTYPE_ALAW =
  127. { 0x00000006, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  128. } ;
  130. static const EXT_SUBFORMAT MSGUID_SUBTYPE_MULAW =
  131. { 0x00000007, 0x0000, 0x0010, { 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 }
  132. } ;
  134. /*
  135. ** the next two are from
  136. ** http://dream.cs.bath.ac.uk/researchdev/wave-ex/bformat.html
  137. */
  138. static const EXT_SUBFORMAT MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_PCM =
  139. { 0x00000001, 0x0721, 0x11d3, { 0x86, 0x44, 0xC8, 0xC1, 0xCA, 0x00, 0x00, 0x00 }
  140. } ;
  142. static const EXT_SUBFORMAT MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_IEEE_FLOAT =
  143. { 0x00000003, 0x0721, 0x11d3, { 0x86, 0x44, 0xC8, 0xC1, 0xCA, 0x00, 0x00, 0x00 }
  144. } ;
  147. #if 0
  148. /* maybe interesting one day to read the following through sf_read_raw */
  149. /* http://www.bath.ac.uk/~masrwd/pvocex/pvocex.html */
  150. static const EXT_SUBFORMAT MSGUID_SUBTYPE_PVOCEX =
  151. { 0x8312B9C2, 0x2E6E, 0x11d4, { 0xA8, 0x24, 0xDE, 0x5B, 0x96, 0xC3, 0xAB, 0x21 }
  152. } ;
  153. #endif
  155. /*------------------------------------------------------------------------------
  156. ** Private static functions.
  157. */
  159. static int wav_read_header  (SF_PRIVATE *psf, int *blockalign, int *framesperblock) ;
  160. static int wav_write_header (SF_PRIVATE *psf, int calc_length) ;
  162. static int wav_write_tailer (SF_PRIVATE *psf) ;
  163. static void wav_write_strings (SF_PRIVATE *psf, int location) ;
  164. static int wav_command (SF_PRIVATE *psf, int command, void *data, int datasize) ;
  165. static int wav_close (SF_PRIVATE *psf) ;
  167. static int  wav_subchunk_parse  (SF_PRIVATE *psf, int chunk) ;
  168. static int  exif_subchunk_parse  (SF_PRIVATE *psf, unsigned int length) ;
  169. static int wav_read_smpl_chunk (SF_PRIVATE *psf, unsigned int chunklen) ;
  170. static int wav_read_acid_chunk (SF_PRIVATE *psf, unsigned int chunklen) ;
  172. /*------------------------------------------------------------------------------
  173. ** Public function.
  174. */
  176. int
  177. wav_open  (SF_PRIVATE *psf)
  178. { WAV_PRIVATE * wpriv ;
  179. int format, subformat, error, blockalign = 0, framesperblock = 0 ;
  181. if ((wpriv = calloc (1, sizeof (WAV_PRIVATE))) == NULL)
  182. return SFE_MALLOC_FAILED ;
  183. psf->container_data = wpriv ;
  185. wpriv->wavex_ambisonic = SF_AMBISONIC_NONE ;
  186. psf->str_flags = SF_STR_ALLOW_START | SF_STR_ALLOW_END ;
  188. if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
  189. { if ((error = wav_read_header (psf, &blockalign, &framesperblock)))
  190. return error ;
  191. } ;
  193. subformat = SF_CODEC (psf->sf.format) ;
  195. if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
  196. { if (psf->is_pipe)
  197. return SFE_NO_PIPE_WRITE ;
  199. wpriv->wavex_ambisonic = SF_AMBISONIC_NONE ;
  201. format = SF_CONTAINER (psf->sf.format) ;
  202. if (format != SF_FORMAT_WAV && format != SF_FORMAT_WAVEX)
  203. return SFE_BAD_OPEN_FORMAT ;
  205. psf->blockwidth = psf->bytewidth * psf->sf.channels ;
  207. /* RIFF WAVs are little-endian, RIFX WAVs are big-endian, default to little */
  208. psf->endian = SF_ENDIAN (psf->sf.format) ;
  209. if (CPU_IS_BIG_ENDIAN && psf->endian == SF_ENDIAN_CPU)
  210. psf->endian = SF_ENDIAN_BIG ;
  211. else if (psf->endian != SF_ENDIAN_BIG)
  212. psf->endian = SF_ENDIAN_LITTLE ;
  214. if (psf->file.mode != SFM_RDWR || psf->filelength < 44)
  215. { psf->filelength = 0 ;
  216. psf->datalength = 0 ;
  217. psf->dataoffset = 0 ;
  218. psf->sf.frames = 0 ;
  219. } ;
  221. if (subformat == SF_FORMAT_IMA_ADPCM || subformat == SF_FORMAT_MS_ADPCM)
  222. { blockalign = wav_w64_srate2blocksize (psf->sf.samplerate * psf->sf.channels) ;
  223. framesperblock = -1 ; /* Corrected later. */
  224. } ;
  226. /* By default, add the peak chunk to floating point files. Default behaviour
  227. ** can be switched off using sf_command (SFC_SET_PEAK_CHUNK, SF_FALSE).
  228. */
  229. if (psf->file.mode == SFM_WRITE && (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE))
  230. { if ((psf->peak_info = peak_info_calloc (psf->sf.channels)) == NULL)
  231. return SFE_MALLOC_FAILED ;
  232. psf->peak_info->peak_loc = SF_PEAK_START ;
  233. } ;
  235. psf->write_header = wav_write_header ;
  236. } ;
  238. psf->container_close = wav_close ;
  239. psf->command = wav_command ;
  241. switch (subformat)
  242. { case SF_FORMAT_PCM_U8 :
  243. case SF_FORMAT_PCM_16 :
  244. case SF_FORMAT_PCM_24 :
  245. case SF_FORMAT_PCM_32 :
  246. error = pcm_init (psf) ;
  247. break ;
  249. case SF_FORMAT_ULAW :
  250. error = ulaw_init (psf) ;
  251. break ;
  253. case SF_FORMAT_ALAW :
  254. error = alaw_init (psf) ;
  255. break ;
  257. /* Lite remove start */
  258. case SF_FORMAT_FLOAT :
  259. error = float32_init (psf) ;
  260. break ;
  262. case SF_FORMAT_DOUBLE :
  263. error = double64_init (psf) ;
  264. break ;
  266. case SF_FORMAT_IMA_ADPCM :
  267. error = wav_w64_ima_init (psf, blockalign, framesperblock) ;
  268. break ;
  270. case SF_FORMAT_MS_ADPCM :
  271. error = wav_w64_msadpcm_init (psf, blockalign, framesperblock) ;
  272. break ;
  274. case SF_FORMAT_G721_32 :
  275. error = g72x_init (psf) ;
  276. break ;
  277. /* Lite remove end */
  279. case SF_FORMAT_GSM610 :
  280. error = gsm610_init (psf) ;
  281. break ;
  283. default :  return SFE_UNIMPLEMENTED ;
  284. } ;
  286. if (psf->file.mode == SFM_WRITE || (psf->file.mode == SFM_RDWR && psf->filelength == 0))
  287. return psf->write_header (psf, SF_FALSE) ;
  289. return error ;
  290. } /* wav_open */
  292. /*=========================================================================
  293. ** Private functions.
  294. */
  296. static int
  297. wav_read_header  (SF_PRIVATE *psf, int *blockalign, int *framesperblock)
  298. { WAV_PRIVATE *wpriv ;
  299. WAV_FMT *wav_fmt ;
  300. FACT_CHUNK fact_chunk ;
  301. unsigned dword = 0, marker, RIFFsize, done = 0 ;
  302. int parsestage = 0, error, format = 0 ;
  303. char *cptr ;
  305. if (psf->filelength > SF_PLATFORM_S64 (0xffffffff))
  306. psf_log_printf (psf, "Warning : filelength > 0xffffffff. This is bad!!!!n") ;
  308. if ((wpriv = psf->container_data) == NULL)
  309. return SFE_INTERNAL ;
  310. wav_fmt = &wpriv->wav_fmt ;
  312. /* Set position to start of file to begin reading header. */
  313. psf_binheader_readf (psf, "p", 0) ;
  315. while (! done)
  316. { psf_binheader_readf (psf, "m", &marker) ;
  318. switch (marker)
  319. { case RIFF_MARKER :
  320. case RIFX_MARKER :
  321. if (parsestage)
  322. return SFE_WAV_NO_RIFF ;
  324. parsestage |= HAVE_RIFF ;
  326. /* RIFX signifies big-endian format for all header and data
  327. ** to prevent lots of code copying here, we'll set the psf->rwf_endian
  328. ** flag once here, and never specify endian-ness for all other header ops
  329. */
  330. if (marker == RIFF_MARKER)
  331. psf->rwf_endian = SF_ENDIAN_LITTLE ;
  332. else
  333. psf->rwf_endian = SF_ENDIAN_BIG ;
  335. psf_binheader_readf (psf, "4", &RIFFsize) ;
  337. if (psf->fileoffset > 0 && psf->filelength > RIFFsize + 8)
  338. { /* Set file length. */
  339. psf->filelength = RIFFsize + 8 ;
  340. if (marker == RIFF_MARKER)
  341. psf_log_printf (psf, "RIFF : %un", RIFFsize) ;
  342. else
  343. psf_log_printf (psf, "RIFX : %un", RIFFsize) ;
  344. }
  345. else if (psf->filelength < RIFFsize + 2 * SIGNED_SIZEOF (dword))
  346. { if (marker == RIFF_MARKER)
  347. psf_log_printf (psf, "RIFF : %u (should be %D)n", RIFFsize, psf->filelength - 2 * SIGNED_SIZEOF (dword)) ;
  348. else
  349. psf_log_printf (psf, "RIFX : %u (should be %D)n", RIFFsize, psf->filelength - 2 * SIGNED_SIZEOF (dword)) ;
  351. RIFFsize = dword ;
  352. }
  353. else
  354. { if (marker == RIFF_MARKER)
  355. psf_log_printf (psf, "RIFF : %un", RIFFsize) ;
  356. else
  357. psf_log_printf (psf, "RIFX : %un", RIFFsize) ;
  358. } ;
  359. break ;
  361. case WAVE_MARKER :
  362. if ((parsestage & HAVE_RIFF) != HAVE_RIFF)
  363. return SFE_WAV_NO_WAVE ;
  364. parsestage |= HAVE_WAVE ;
  366. psf_log_printf (psf, "WAVEn") ;
  367. break ;
  369. case fmt_MARKER :
  370. if ((parsestage & (HAVE_RIFF | HAVE_WAVE)) != (HAVE_RIFF | HAVE_WAVE))
  371. return SFE_WAV_NO_FMT ;
  373. /* If this file has a SECOND fmt chunk, I don't want to know about it. */
  374. if (parsestage & HAVE_fmt)
  375. break ;
  377. parsestage |= HAVE_fmt ;
  379. psf_binheader_readf (psf, "4", &dword) ;
  380. psf_log_printf (psf, "fmt  : %dn", dword) ;
  382. if ((error = wav_w64_read_fmt_chunk (psf, dword)))
  383. return error ;
  385. format = wav_fmt->format ;
  386. break ;
  388. case data_MARKER :
  389. if ((parsestage & (HAVE_RIFF | HAVE_WAVE | HAVE_fmt)) != (HAVE_RIFF | HAVE_WAVE | HAVE_fmt))
  390. return SFE_WAV_NO_DATA ;
  392. if (psf->file.mode == SFM_RDWR && (parsestage & HAVE_other) != 0)
  393. return SFE_RDWR_BAD_HEADER ;
  395. parsestage |= HAVE_data ;
  397. psf_binheader_readf (psf, "4", &dword) ;
  399. psf->datalength = dword ;
  400. psf->dataoffset = psf_ftell (psf) ;
  402. if (psf->dataoffset > 0)
  403. { if (dword == 0 && RIFFsize == 8 && psf->filelength > 44)
  404. { psf_log_printf (psf, "*** Looks like a WAV file which wasn't closed properly. Fixing it.n") ;
  405. psf->datalength = psf->filelength - psf->dataoffset ;
  406. } ;
  408. if (psf->datalength > psf->filelength - psf->dataoffset)
  409. { psf_log_printf (psf, "data : %D (should be %D)n", psf->datalength, psf->filelength - psf->dataoffset) ;
  410. psf->datalength = psf->filelength - psf->dataoffset ;
  411. }
  412. else
  413. psf_log_printf (psf, "data : %Dn", psf->datalength) ;
  415. /* Only set dataend if there really is data at the end. */
  416. if (psf->datalength + psf->dataoffset < psf->filelength)
  417. psf->dataend = psf->datalength + psf->dataoffset ;
  419. if (format == WAVE_FORMAT_MS_ADPCM && psf->datalength % 2)
  420. { psf->datalength ++ ;
  421. psf_log_printf (psf, "*** Data length odd. Increasing it by 1.n") ;
  422. } ;
  423. } ;
  425. if (! psf->sf.seekable || psf->dataoffset < 0)
  426. break ;
  428. /* Seek past data and continue reading header. */
  429. psf_fseek (psf, psf->datalength, SEEK_CUR) ;
  431. if (psf_ftell (psf) != psf->datalength + psf->dataoffset)
  432. psf_log_printf (psf, "*** psf_fseek past end error ***n") ;
  433. break ;
  435. case fact_MARKER :
  436. if ((parsestage & (HAVE_RIFF | HAVE_WAVE)) != (HAVE_RIFF | HAVE_WAVE))
  437. return SFE_WAV_BAD_FACT ;
  439. parsestage |= HAVE_fact ;
  441. if ((parsestage & HAVE_fmt) != HAVE_fmt)
  442. psf_log_printf (psf, "*** Should have 'fmt ' chunk before 'fact'n") ;
  444. psf_binheader_readf (psf, "44", &dword, & (fact_chunk.frames)) ;
  446. if (dword > SIGNED_SIZEOF (fact_chunk))
  447. psf_binheader_readf (psf, "j", (int) (dword - SIGNED_SIZEOF (fact_chunk))) ;
  449. if (dword)
  450. psf_log_printf (psf, "%M : %dn", marker, dword) ;
  451. else
  452. psf_log_printf (psf, "%M : %d (should not be zero)n", marker, dword) ;
  454. psf_log_printf (psf, "  frames  : %dn", fact_chunk.frames) ;
  455. break ;
  457. case PEAK_MARKER :
  458. if ((parsestage & (HAVE_RIFF | HAVE_WAVE | HAVE_fmt)) != (HAVE_RIFF | HAVE_WAVE | HAVE_fmt))
  459. return SFE_WAV_PEAK_B4_FMT ;
  461. parsestage |= HAVE_PEAK ;
  463. psf_binheader_readf (psf, "4", &dword) ;
  465. psf_log_printf (psf, "%M : %dn", marker, dword) ;
  466. if (dword != WAV_PEAK_CHUNK_SIZE (psf->sf.channels))
  467. { psf_binheader_readf (psf, "j", dword) ;
  468. psf_log_printf (psf, "*** File PEAK chunk size doesn't fit with number of channels (%d).n", psf->sf.channels) ;
  469. return SFE_WAV_BAD_PEAK ;
  470. } ;
  472. if ((psf->peak_info = peak_info_calloc (psf->sf.channels)) == NULL)
  473. return SFE_MALLOC_FAILED ;
  475. /* read in rest of PEAK chunk. */
  476. psf_binheader_readf (psf, "44", & (psf->peak_info->version), & (psf->peak_info->timestamp)) ;
  478. if (psf->peak_info->version != 1)
  479. psf_log_printf (psf, "  version    : %d *** (should be version 1)n", psf->peak_info->version) ;
  480. else
  481. psf_log_printf (psf, "  version    : %dn", psf->peak_info->version) ;
  483. psf_log_printf (psf, "  time stamp : %dn", psf->peak_info->timestamp) ;
  484. psf_log_printf (psf, "    Ch   Position       Valuen") ;
  486. cptr = psf->u.cbuf ;
  487. for (dword = 0 ; dword < (unsigned) psf->sf.channels ; dword++)
  488. { float value ;
  489. unsigned int position ;
  491. psf_binheader_readf (psf, "f4", &value, &position) ;
  492. psf->peak_info->peaks [dword].value = value ;
  493. psf->peak_info->peaks [dword].position = position ;
  495. snprintf (cptr, sizeof (psf->u.cbuf), "    %2d   %-12" PRId64 "   %gn",
  496. dword, psf->peak_info->peaks [dword].position, psf->peak_info->peaks [dword].value) ;
  497. cptr [sizeof (psf->u.cbuf) - 1] = 0 ;
  498. psf_log_printf (psf, "%s", cptr) ;
  499. } ;
  501. psf->peak_info->peak_loc = ((parsestage & HAVE_data) == 0) ? SF_PEAK_START : SF_PEAK_END ;
  502. break ;
  504. case cue_MARKER :
  505. parsestage |= HAVE_other ;
  507. { unsigned bytesread, cue_count ;
  508. int id, position, chunk_id, chunk_start, block_start, offset ;
  510. bytesread = psf_binheader_readf (psf, "44", &dword, &cue_count) ;
  511. bytesread -= 4 ; /* Remove bytes for first dword. */
  512. psf_log_printf (psf, "%M : %un", marker, dword) ;
  514. if (cue_count > 10)
  515. { psf_log_printf (psf, "  Count : %d (skipping)n", cue_count) ;
  516. psf_binheader_readf (psf, "j", cue_count * 24) ;
  517. break ;
  518. } ;
  520. psf_log_printf (psf, "  Count : %dn", cue_count) ;
  522. while (cue_count)
  523. { bytesread += psf_binheader_readf (psf, "444444", &id, &position,
  524. &chunk_id, &chunk_start, &block_start, &offset) ;
  525. psf_log_printf (psf, "   Cue ID : %2d"
  526.  "  Pos : %5u  Chunk : %M"
  527.  "  Chk Start : %d  Blk Start : %d"
  528.  "  Offset : %5dn",
  529. id, position, chunk_id, chunk_start, block_start, offset) ;
  530. cue_count -- ;
  531. } ;
  533. if (bytesread != dword)
  534. { psf_log_printf (psf, "**** Chunk size weirdness (%d != %d)n", dword, bytesread) ;
  535. psf_binheader_readf (psf, "j", dword - bytesread) ;
  536. } ;
  537. } ;
  538. break ;
  540. case smpl_MARKER :
  541. parsestage |= HAVE_other ;
  543. psf_binheader_readf (psf, "4", &dword) ;
  544. psf_log_printf (psf, "smpl : %un", dword) ;
  546. if ((error = wav_read_smpl_chunk (psf, dword)))
  547. return error ;
  548. break ;
  550. case acid_MARKER :
  551. parsestage |= HAVE_other ;
  553. psf_binheader_readf (psf, "4", &dword) ;
  554. psf_log_printf (psf, "acid : %un", dword) ;
  556. if ((error = wav_read_acid_chunk (psf, dword)))
  557. return error ;
  558. break ;
  560. case INFO_MARKER :
  561. case LIST_MARKER :
  562. parsestage |= HAVE_other ;
  564. if ((error = wav_subchunk_parse (psf, marker)) != 0)
  565. return error ;
  566. break ;
  568. case bext_MARKER :
  569. /*
  570. The 'bext' chunk can actually be updated, so don't need to set this.
  571. parsestage |= HAVE_other ;
  572. */
  573. psf_binheader_readf (psf, "4", &dword) ;
  574. if ((error = wav_read_bext_chunk (psf, dword)))
  575. return error ;
  576. break ;
  578. case PAD_MARKER :
  579. /*
  580. We can eat into a 'PAD ' chunk if we need to.
  581. parsestage |= HAVE_other ;
  582. */
  583. psf_binheader_readf (psf, "4", &dword) ;
  584. psf_log_printf (psf, "%M : %un", marker, dword) ;
  585. dword += (dword & 1) ;
  586. psf_binheader_readf (psf, "j", dword) ;
  587. break ;
  589. case iXML_MARKER : /* See http://en.wikipedia.org/wiki/IXML */
  590. case strc_MARKER : /* Multiple of 32 bytes. */
  591. case afsp_MARKER :
  592. case clm_MARKER :
  593. case elmo_MARKER :
  594. case cart_MARKER :
  595. case levl_MARKER :
  596. case plst_MARKER :
  597. case DISP_MARKER :
  598. case MEXT_MARKER :
  599. parsestage |= HAVE_other ;
  601. psf_binheader_readf (psf, "4", &dword) ;
  602. psf_log_printf (psf, "%M : %un", marker, dword) ;
  603. dword += (dword & 1) ;
  604. psf_binheader_readf (psf, "j", dword) ;
  605. break ;
  607. default :
  608. parsestage |= HAVE_other ;
  609. if (psf_isprint ((marker >> 24) & 0xFF) && psf_isprint ((marker >> 16) & 0xFF)
  610. && psf_isprint ((marker >> 8) & 0xFF) && psf_isprint (marker & 0xFF))
  611. { psf_binheader_readf (psf, "4", &dword) ;
  612. psf_log_printf (psf, "*** %M : %d (unknown marker)n", marker, dword) ;
  613. psf_binheader_readf (psf, "j", dword) ;
  614. break ;
  615. } ;
  616. if (psf_ftell (psf) & 0x03)
  617. { psf_log_printf (psf, "  Unknown chunk marker at position %d. Resynching.n", dword - 4) ;
  618. psf_binheader_readf (psf, "j", -3) ;
  619. break ;
  620. } ;
  621. psf_log_printf (psf, "*** Unknown chunk marker (%X) at position %D. Exiting parser.n", marker, psf_ftell (psf) - 4) ;
  622. done = SF_TRUE ;
  623. break ;
  624. } ; /* switch (dword) */
  626. if (! psf->sf.seekable && (parsestage & HAVE_data))
  627. break ;
  629. if (psf_ftell (psf) >= psf->filelength - SIGNED_SIZEOF (dword))
  630. { psf_log_printf (psf, "Endn") ;
  631. break ;
  632. } ;
  633. } ; /* while (1) */
  635. if (psf->dataoffset <= 0)
  636. return SFE_WAV_NO_DATA ;
  638. /* WAVs can be little or big endian */
  639. psf->endian = psf->rwf_endian ;
  641. psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
  643. if (psf->is_pipe == 0)
  644. { /*
  645. ** Check for 'wvpk' at the start of the DATA section. Not able to
  646. ** handle this.
  647. */
  648. psf_binheader_readf (psf, "4", &marker) ;
  649. if (marker == wvpk_MARKER || marker == OggS_MARKER)
  650. return SFE_WAV_WVPK_DATA ;
  651. } ;
  653. /* Seek to start of DATA section. */
  654. psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
  656. if (psf->blockwidth)
  657. { if (psf->filelength - psf->dataoffset < psf->datalength)
  658. psf->sf.frames = (psf->filelength - psf->dataoffset) / psf->blockwidth ;
  659. else
  660. psf->sf.frames = psf->datalength / psf->blockwidth ;
  661. } ;
  663. switch (format)
  664. { case WAVE_FORMAT_EXTENSIBLE :
  665. if (psf->sf.format == (SF_FORMAT_WAVEX | SF_FORMAT_MS_ADPCM))
  666. { *blockalign = wav_fmt->msadpcm.blockalign ;
  667. *framesperblock = wav_fmt->msadpcm.samplesperblock ;
  668. } ;
  669. break ;
  671. case WAVE_FORMAT_PCM :
  672. psf->sf.format = SF_FORMAT_WAV | u_bitwidth_to_subformat (psf->bytewidth * 8) ;
  673. break ;
  675. case WAVE_FORMAT_MULAW :
  676. case IBM_FORMAT_MULAW :
  677. psf->sf.format = (SF_FORMAT_WAV | SF_FORMAT_ULAW) ;
  678. break ;
  680. case WAVE_FORMAT_ALAW :
  681. case IBM_FORMAT_ALAW :
  682. psf->sf.format = (SF_FORMAT_WAV | SF_FORMAT_ALAW) ;
  683. break ;
  685. case WAVE_FORMAT_MS_ADPCM :
  686. psf->sf.format = (SF_FORMAT_WAV | SF_FORMAT_MS_ADPCM) ;
  687. *blockalign = wav_fmt->msadpcm.blockalign ;
  688. *framesperblock = wav_fmt->msadpcm.samplesperblock ;
  689. break ;
  691. case WAVE_FORMAT_IMA_ADPCM :
  692. psf->sf.format = (SF_FORMAT_WAV | SF_FORMAT_IMA_ADPCM) ;
  693. *blockalign = wav_fmt->ima.blockalign ;
  694. *framesperblock = wav_fmt->ima.samplesperblock ;
  695. break ;
  697. case WAVE_FORMAT_GSM610 :
  698. psf->sf.format = (SF_FORMAT_WAV | SF_FORMAT_GSM610) ;
  699. break ;
  701. case WAVE_FORMAT_IEEE_FLOAT :
  702. psf->sf.format = SF_FORMAT_WAV ;
  703. psf->sf.format |= (psf->bytewidth == 8) ? SF_FORMAT_DOUBLE : SF_FORMAT_FLOAT ;
  704. break ;
  706. case WAVE_FORMAT_G721_ADPCM :
  707. psf->sf.format = SF_FORMAT_WAV | SF_FORMAT_G721_32 ;
  708. break ;
  710. default : return SFE_UNIMPLEMENTED ;
  711. } ;
  713. if (wpriv->fmt_is_broken)
  714. wav_w64_analyze (psf) ;
  716. /* Only set the format endian-ness if its non-standard big-endian. */
  717. if (psf->endian == SF_ENDIAN_BIG)
  718. psf->sf.format |= SF_ENDIAN_BIG ;
  720. return 0 ;
  721. } /* wav_read_header */
  723. static int
  724. wav_write_fmt_chunk (SF_PRIVATE *psf)
  725. { int subformat, fmt_size, add_fact_chunk = 0 ;
  727. subformat = SF_CODEC (psf->sf.format) ;
  729. switch (subformat)
  730. { case SF_FORMAT_PCM_U8 :
  731. case SF_FORMAT_PCM_16 :
  732. case SF_FORMAT_PCM_24 :
  733. case SF_FORMAT_PCM_32 :
  734. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 ;
  736. /* fmt : format, channels, samplerate */
  737. psf_binheader_writef (psf, "4224", fmt_size, WAVE_FORMAT_PCM, psf->sf.channels, psf->sf.samplerate) ;
  738. /*  fmt : bytespersec */
  739. psf_binheader_writef (psf, "4", psf->sf.samplerate * psf->bytewidth * psf->sf.channels) ;
  740. /*  fmt : blockalign, bitwidth */
  741. psf_binheader_writef (psf, "22", psf->bytewidth * psf->sf.channels, psf->bytewidth * 8) ;
  742. break ;
  744. case SF_FORMAT_FLOAT :
  745. case SF_FORMAT_DOUBLE :
  746. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 ;
  748. /* fmt : format, channels, samplerate */
  749. psf_binheader_writef (psf, "4224", fmt_size, WAVE_FORMAT_IEEE_FLOAT, psf->sf.channels, psf->sf.samplerate) ;
  750. /*  fmt : bytespersec */
  751. psf_binheader_writef (psf, "4", psf->sf.samplerate * psf->bytewidth * psf->sf.channels) ;
  752. /*  fmt : blockalign, bitwidth */
  753. psf_binheader_writef (psf, "22", psf->bytewidth * psf->sf.channels, psf->bytewidth * 8) ;
  755. add_fact_chunk = SF_TRUE ;
  756. break ;
  758. case SF_FORMAT_ULAW :
  759. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 ;
  761. /* fmt : format, channels, samplerate */
  762. psf_binheader_writef (psf, "4224", fmt_size, WAVE_FORMAT_MULAW, psf->sf.channels, psf->sf.samplerate) ;
  763. /*  fmt : bytespersec */
  764. psf_binheader_writef (psf, "4", psf->sf.samplerate * psf->bytewidth * psf->sf.channels) ;
  765. /*  fmt : blockalign, bitwidth */
  766. psf_binheader_writef (psf, "22", psf->bytewidth * psf->sf.channels, 8) ;
  768. add_fact_chunk = SF_TRUE ;
  769. break ;
  771. case SF_FORMAT_ALAW :
  772. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 ;
  774. /* fmt : format, channels, samplerate */
  775. psf_binheader_writef (psf, "4224", fmt_size, WAVE_FORMAT_ALAW, psf->sf.channels, psf->sf.samplerate) ;
  776. /*  fmt : bytespersec */
  777. psf_binheader_writef (psf, "4", psf->sf.samplerate * psf->bytewidth * psf->sf.channels) ;
  778. /*  fmt : blockalign, bitwidth */
  779. psf_binheader_writef (psf, "22", psf->bytewidth * psf->sf.channels, 8) ;
  781. add_fact_chunk = SF_TRUE ;
  782. break ;
  784. /* Lite remove start */
  785. case SF_FORMAT_IMA_ADPCM :
  786. { int blockalign, framesperblock, bytespersec ;
  788. blockalign = wav_w64_srate2blocksize (psf->sf.samplerate * psf->sf.channels) ;
  789. framesperblock = 2 * (blockalign - 4 * psf->sf.channels) / psf->sf.channels + 1 ;
  790. bytespersec = (psf->sf.samplerate * blockalign) / framesperblock ;
  792. /* fmt chunk. */
  793. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 + 2 + 2 ;
  795. /* fmt : size, WAV format type, channels, samplerate, bytespersec */
  796. psf_binheader_writef (psf, "42244", fmt_size, WAVE_FORMAT_IMA_ADPCM,
  797. psf->sf.channels, psf->sf.samplerate, bytespersec) ;
  799. /* fmt : blockalign, bitwidth, extrabytes, framesperblock. */
  800. psf_binheader_writef (psf, "2222", blockalign, 4, 2, framesperblock) ;
  801. } ;
  803. add_fact_chunk = SF_TRUE ;
  804. break ;
  806. case SF_FORMAT_MS_ADPCM :
  807. { int blockalign, framesperblock, bytespersec, extrabytes ;
  809. blockalign = wav_w64_srate2blocksize (psf->sf.samplerate * psf->sf.channels) ;
  810. framesperblock = 2 + 2 * (blockalign - 7 * psf->sf.channels) / psf->sf.channels ;
  811. bytespersec = (psf->sf.samplerate * blockalign) / framesperblock ;
  813. /* fmt chunk. */
  814. extrabytes = 2 + 2 + MSADPCM_ADAPT_COEFF_COUNT * (2 + 2) ;
  815. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 + 2 + extrabytes ;
  817. /* fmt : size, WAV format type, channels. */
  818. psf_binheader_writef (psf, "422", fmt_size, WAVE_FORMAT_MS_ADPCM, psf->sf.channels) ;
  820. /* fmt : samplerate, bytespersec. */
  821. psf_binheader_writef (psf, "44", psf->sf.samplerate, bytespersec) ;
  823. /* fmt : blockalign, bitwidth, extrabytes, framesperblock. */
  824. psf_binheader_writef (psf, "22222", blockalign, 4, extrabytes, framesperblock, 7) ;
  826. msadpcm_write_adapt_coeffs (psf) ;
  827. } ;
  829. add_fact_chunk = SF_TRUE ;
  830. break ;
  833. case SF_FORMAT_G721_32 :
  834. /* fmt chunk. */
  835. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 + 2 + 2 ;
  837. /* fmt : size, WAV format type, channels, samplerate, bytespersec */
  838. psf_binheader_writef (psf, "42244", fmt_size, WAVE_FORMAT_G721_ADPCM,
  839. psf->sf.channels, psf->sf.samplerate, psf->sf.samplerate * psf->sf.channels / 2) ;
  841. /* fmt : blockalign, bitwidth, extrabytes, auxblocksize. */
  842. psf_binheader_writef (psf, "2222", 64, 4, 2, 0) ;
  844. add_fact_chunk = SF_TRUE ;
  845. break ;
  847. /* Lite remove end */
  849. case SF_FORMAT_GSM610 :
  850. { int blockalign, framesperblock, bytespersec ;
  852. blockalign = WAV_W64_GSM610_BLOCKSIZE ;
  853. framesperblock = WAV_W64_GSM610_SAMPLES ;
  854. bytespersec = (psf->sf.samplerate * blockalign) / framesperblock ;
  856. /* fmt chunk. */
  857. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 + 2 + 2 ;
  859. /* fmt : size, WAV format type, channels. */
  860. psf_binheader_writef (psf, "422", fmt_size, WAVE_FORMAT_GSM610, psf->sf.channels) ;
  862. /* fmt : samplerate, bytespersec. */
  863. psf_binheader_writef (psf, "44", psf->sf.samplerate, bytespersec) ;
  865. /* fmt : blockalign, bitwidth, extrabytes, framesperblock. */
  866. psf_binheader_writef (psf, "2222", blockalign, 0, 2, framesperblock) ;
  867. } ;
  869. add_fact_chunk = SF_TRUE ;
  870. break ;
  872. default :  return SFE_UNIMPLEMENTED ;
  873. } ;
  875. if (add_fact_chunk)
  876. psf_binheader_writef (psf, "tm48", fact_MARKER, 4, psf->sf.frames) ;
  878. return 0 ;
  879. } /* wav_write_fmt_chunk */
  881. static int
  882. wavex_write_fmt_chunk (SF_PRIVATE *psf)
  883. { WAV_PRIVATE *wpriv ;
  884. int subformat, fmt_size, add_fact_chunk = 0 ;
  886. if ((wpriv = psf->container_data) == NULL)
  887. return SFE_INTERNAL ;
  889. subformat = SF_CODEC (psf->sf.format) ;
  891. /* initial section (same for all, it appears) */
  892. switch (subformat)
  893. { case SF_FORMAT_PCM_U8 :
  894. case SF_FORMAT_PCM_16 :
  895. case SF_FORMAT_PCM_24 :
  896. case SF_FORMAT_PCM_32 :
  897. case SF_FORMAT_FLOAT :
  898. case SF_FORMAT_DOUBLE :
  899. case SF_FORMAT_ULAW :
  900. case SF_FORMAT_ALAW :
  901. fmt_size = 2 + 2 + 4 + 4 + 2 + 2 + 2 + 2 + 4 + 4 + 2 + 2 + 8 ;
  903. /* fmt : format, channels, samplerate */
  904. psf_binheader_writef (psf, "4224", fmt_size, WAVE_FORMAT_EXTENSIBLE, psf->sf.channels, psf->sf.samplerate) ;
  905. /*  fmt : bytespersec */
  906. psf_binheader_writef (psf, "4", psf->sf.samplerate * psf->bytewidth * psf->sf.channels) ;
  907. /*  fmt : blockalign, bitwidth */
  908. psf_binheader_writef (psf, "22", psf->bytewidth * psf->sf.channels, psf->bytewidth * 8) ;
  910. /* cbSize 22 is sizeof (WAVEFORMATEXTENSIBLE) - sizeof (WAVEFORMATEX) */
  911. psf_binheader_writef (psf, "2", 22) ;
  913. /* wValidBitsPerSample, for our use same as bitwidth as we use it fully */
  914. psf_binheader_writef (psf, "2", psf->bytewidth * 8) ;
  916. /* For an Ambisonic file set the channel mask to zero.
  917. ** Otherwise use a default based on the channel count.
  918. */
  919. if (wpriv->wavex_ambisonic != SF_AMBISONIC_NONE)
  920. psf_binheader_writef (psf, "4", 0) ;
  921. else if (wpriv->wavex_channelmask != 0)
  922. psf_binheader_writef (psf, "4", wpriv->wavex_channelmask) ;
  923. else
  924. { /*
  925. ** Ok some liberty is taken here to use the most commonly used channel masks
  926. ** instead of "no mapping". If you really want to use "no mapping" for 8 channels and less
  927. ** please don't use wavex. (otherwise we'll have to create a new SF_COMMAND)
  928. */
  929. switch (psf->sf.channels)
  930. { case 1 : /* center channel mono */
  931. psf_binheader_writef (psf, "4", 0x4) ;
  932. break ;
  934. case 2 : /* front left and right */
  935. psf_binheader_writef (psf, "4", 0x1 | 0x2) ;
  936. break ;
  938. case 4 : /* Quad */
  939. psf_binheader_writef (psf, "4", 0x1 | 0x2 | 0x10 | 0x20) ;
  940. break ;
  942. case 6 : /* 5.1 */
  943. psf_binheader_writef (psf, "4", 0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20) ;
  944. break ;
  946. case 8 : /* 7.1 */
  947. psf_binheader_writef (psf, "4", 0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20 | 0x40 | 0x80) ;
  948. break ;
  950. default : /* 0 when in doubt , use direct out, ie NO mapping*/
  951. psf_binheader_writef (psf, "4", 0x0) ;
  952. break ;
  953. } ;
  954. } ;
  955. break ;
  957. case SF_FORMAT_MS_ADPCM : /* Todo, GUID exists might have different header as per wav_write_header */
  958. default :
  959. return SFE_UNIMPLEMENTED ;
  960. } ;
  962. /* GUID section, different for each */
  964. switch (subformat)
  965. { case SF_FORMAT_PCM_U8 :
  966. case SF_FORMAT_PCM_16 :
  967. case SF_FORMAT_PCM_24 :
  968. case SF_FORMAT_PCM_32 :
  969. wavex_write_guid (psf, wpriv->wavex_ambisonic == SF_AMBISONIC_NONE ?
  970. &MSGUID_SUBTYPE_PCM : &MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_PCM) ;
  971. break ;
  973. case SF_FORMAT_FLOAT :
  974. case SF_FORMAT_DOUBLE :
  975. wavex_write_guid (psf, wpriv->wavex_ambisonic == SF_AMBISONIC_NONE ?
  976. &MSGUID_SUBTYPE_IEEE_FLOAT : &MSGUID_SUBTYPE_AMBISONIC_B_FORMAT_IEEE_FLOAT) ;
  977. add_fact_chunk = SF_TRUE ;
  978. break ;
  980. case SF_FORMAT_ULAW :
  981. wavex_write_guid (psf, &MSGUID_SUBTYPE_MULAW) ;
  982. add_fact_chunk = SF_TRUE ;
  983. break ;
  985. case SF_FORMAT_ALAW :
  986. wavex_write_guid (psf, &MSGUID_SUBTYPE_ALAW) ;
  987. add_fact_chunk = SF_TRUE ;
  988. break ;
  990. #if 0
  991. /* This is dead code due to return in previous switch statement. */
  992. case SF_FORMAT_MS_ADPCM : /* todo, GUID exists */
  993. wavex_write_guid (psf, &MSGUID_SUBTYPE_MS_ADPCM) ;
  994. add_fact_chunk = SF_TRUE ;
  995. break ;
  996. return SFE_UNIMPLEMENTED ;
  997. #endif
  999. default : return SFE_UNIMPLEMENTED ;
  1000. } ;
  1002. if (add_fact_chunk)
  1003. psf_binheader_writef (psf, "tm48", fact_MARKER, 4, psf->sf.frames) ;
  1005. return 0 ;
  1006. } /* wavex_write_fmt_chunk */
  1009. static int
  1010. wav_write_header (SF_PRIVATE *psf, int calc_length)
  1011. { sf_count_t current ;
  1012. int  k, error, has_data = SF_FALSE ;
  1014. current = psf_ftell (psf) ;
  1016. if (current > psf->dataoffset)
  1017. has_data = SF_TRUE ;
  1019. if (calc_length)
  1020. { psf->filelength = psf_get_filelen (psf) ;
  1022. psf->datalength = psf->filelength - psf->dataoffset ;
  1024. if (psf->dataend)
  1025. psf->datalength -= psf->filelength - psf->dataend ;
  1027. if (psf->bytewidth > 0)
  1028. psf->sf.frames = psf->datalength / (psf->bytewidth * psf->sf.channels) ;
  1029. } ;
  1031. /* Reset the current header length to zero. */
  1032. psf->header [0] = 0 ;
  1033. psf->headindex = 0 ;
  1034. psf_fseek (psf, 0, SEEK_SET) ;
  1036. /*
  1037. ** RIFX signifies big-endian format for all header and data.
  1038. ** To prevent lots of code copying here, we'll set the psf->rwf_endian flag
  1039. ** once here, and never specify endian-ness for all other header operations.
  1040. */
  1042. /* RIFF/RIFX marker, length, WAVE and 'fmt ' markers. */
  1044. if (psf->endian == SF_ENDIAN_LITTLE)
  1045. psf_binheader_writef (psf, "etm8", RIFF_MARKER, (psf->filelength < 8) ? 8 : psf->filelength - 8) ;
  1046. else
  1047. psf_binheader_writef (psf, "Etm8", RIFX_MARKER, (psf->filelength < 8) ? 8 : psf->filelength - 8) ;
  1049. /* WAVE and 'fmt ' markers. */
  1050. psf_binheader_writef (psf, "mm", WAVE_MARKER, fmt_MARKER) ;
  1052. /* Write the 'fmt ' chunk. */
  1053. switch (SF_CONTAINER (psf->sf.format))
  1054. { case SF_FORMAT_WAV :
  1055. if ((error = wav_write_fmt_chunk (psf)) != 0)
  1056. return error ;
  1057. break ;
  1059. case SF_FORMAT_WAVEX :
  1060. if ((error = wavex_write_fmt_chunk (psf)) != 0)
  1061. return error ;
  1062. break ;
  1064. default :
  1065. return SFE_UNIMPLEMENTED ;
  1066. } ;
  1068. /* The LIST/INFO chunk. */
  1069. if (psf->str_flags & SF_STR_LOCATE_START)
  1070. wav_write_strings (psf, SF_STR_LOCATE_START) ;
  1072. if (psf->peak_info != NULL && psf->peak_info->peak_loc == SF_PEAK_START)
  1073. { psf_binheader_writef (psf, "m4", PEAK_MARKER, WAV_PEAK_CHUNK_SIZE (psf->sf.channels)) ;
  1074. psf_binheader_writef (psf, "44", 1, time (NULL)) ;
  1075. for (k = 0 ; k < psf->sf.channels ; k++)
  1076. psf_binheader_writef (psf, "ft8", (float) psf->peak_info->peaks [k].value, psf->peak_info->peaks [k].position) ;
  1077. } ;
  1079. if (psf->broadcast_var != NULL)
  1080. wav_write_bext_chunk (psf) ;
  1082. if (psf->instrument != NULL)
  1083. { int tmp ;
  1084. double dtune = (double) (0x40000000) / 25.0 ;
  1086. psf_binheader_writef (psf, "m4", smpl_MARKER, 9 * 4 + psf->instrument->loop_count * 6 * 4) ;
  1087. psf_binheader_writef (psf, "44", 0, 0) ; /* Manufacturer zero is everyone */
  1088. tmp = (int) (1.0e9 / psf->sf.samplerate) ; /* Sample period in nano seconds */
  1089. psf_binheader_writef (psf, "44", tmp, psf->instrument->basenote) ;
  1090. tmp = (unsigned int) (psf->instrument->detune * dtune + 0.5) ;
  1091. psf_binheader_writef (psf, "4", tmp) ;
  1092. psf_binheader_writef (psf, "44", 0, 0) ; /* SMTPE format */
  1093. psf_binheader_writef (psf, "44", psf->instrument->loop_count, 0) ;
  1095. for (tmp = 0 ; tmp < psf->instrument->loop_count ; tmp++)
  1096. { int type ;
  1098. type = psf->instrument->loops [tmp].mode ;
  1099. type = (type == SF_LOOP_FORWARD ? 0 : type==SF_LOOP_BACKWARD ? 2 : type == SF_LOOP_ALTERNATING ? 1 : 32) ;
  1101. psf_binheader_writef (psf, "44", tmp, type) ;
  1102. psf_binheader_writef (psf, "44", psf->instrument->loops [tmp].start, psf->instrument->loops [tmp].end - 1) ;
  1103. psf_binheader_writef (psf, "44", 0, psf->instrument->loops [tmp].count) ;
  1104. } ;
  1105. } ;
  1107. if (psf->headindex + 16 < psf->dataoffset)
  1108. { /* Add PAD data if necessary. */
  1109. k = psf->dataoffset - (psf->headindex + 16) ;
  1110. psf_binheader_writef (psf, "m4z", PAD_MARKER, k, make_size_t (k)) ;
  1111. } ;
  1113. psf_binheader_writef (psf, "tm8", data_MARKER, psf->datalength) ;
  1114. psf_fwrite (psf->header, psf->headindex, 1, psf) ;
  1115. if (psf->error)
  1116. return psf->error ;
  1118. if (has_data && psf->dataoffset != psf->headindex)
  1119. { psf_log_printf (psf, "Oooops : has_data && psf->dataoffset != psf->headindexn") ;
  1120. return psf->error = SFE_INTERNAL ;
  1121. } ;
  1123. psf->dataoffset = psf->headindex ;
  1125. if (! has_data)
  1126. psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
  1127. else if (current > 0)
  1128. psf_fseek (psf, current, SEEK_SET) ;
  1130. return psf->error ;
  1131. } /* wav_write_header */
  1134. static int
  1135. wav_write_tailer (SF_PRIVATE *psf)
  1136. { int k ;
  1138. /* Reset the current header buffer length to zero. */
  1139. psf->header [0] = 0 ;
  1140. psf->headindex = 0 ;
  1142. if (psf->dataend > 0)
  1143. psf_fseek (psf, psf->dataend, SEEK_SET) ;
  1144. else
  1145. psf->dataend = psf_fseek (psf, 0, SEEK_END) ;
  1147. /* Add a PEAK chunk if requested. */
  1148. if (psf->peak_info != NULL && psf->peak_info->peak_loc == SF_PEAK_END)
  1149. { psf_binheader_writef (psf, "m4", PEAK_MARKER, WAV_PEAK_CHUNK_SIZE (psf->sf.channels)) ;
  1150. psf_binheader_writef (psf, "44", 1, time (NULL)) ;
  1151. for (k = 0 ; k < psf->sf.channels ; k++)
  1152. psf_binheader_writef (psf, "f4", psf->peak_info->peaks [k].value, psf->peak_info->peaks [k].position) ;
  1153. } ;
  1155. if (psf->str_flags & SF_STR_LOCATE_END)
  1156. wav_write_strings (psf, SF_STR_LOCATE_END) ;
  1158. /* Write the tailer. */
  1159. if (psf->headindex > 0)
  1160. psf_fwrite (psf->header, psf->headindex, 1, psf) ;
  1162. return 0 ;
  1163. } /* wav_write_tailer */
  1165. static void
  1166. wav_write_strings (SF_PRIVATE *psf, int location)
  1167. { int k, prev_head_index, saved_head_index ;
  1169. if (psf_location_string_count (psf, location) == 0)
  1170. return ;
  1172. prev_head_index = psf->headindex + 4 ;
  1174. psf_binheader_writef (psf, "m4m", LIST_MARKER, 0xBADBAD, INFO_MARKER) ;
  1176. for (k = 0 ; k < SF_MAX_STRINGS ; k++)
  1177. { if (psf->strings [k].type == 0)
  1178. break ;
  1179. if (psf->strings [k].type < 0 || psf->strings [k].flags != location)
  1180. continue ;
  1182. switch (psf->strings [k].type)
  1183. { case SF_STR_SOFTWARE :
  1184. psf_binheader_writef (psf, "ms", ISFT_MARKER, psf->strings [k].str) ;
  1185. break ;
  1187. case SF_STR_TITLE :
  1188. psf_binheader_writef (psf, "ms", INAM_MARKER, psf->strings [k].str) ;
  1189. break ;
  1191. case SF_STR_COPYRIGHT :
  1192. psf_binheader_writef (psf, "ms", ICOP_MARKER, psf->strings [k].str) ;
  1193. break ;
  1195. case SF_STR_ARTIST :
  1196. psf_binheader_writef (psf, "ms", IART_MARKER, psf->strings [k].str) ;
  1197. break ;
  1199. case SF_STR_COMMENT :
  1200. psf_binheader_writef (psf, "ms", ICMT_MARKER, psf->strings [k].str) ;
  1201. break ;
  1203. case SF_STR_DATE :
  1204. psf_binheader_writef (psf, "ms", ICRD_MARKER, psf->strings [k].str) ;
  1205. break ;
  1207. default :
  1208. break ;
  1209. } ;
  1210. } ;
  1212. saved_head_index = psf->headindex ;
  1213. psf->headindex = prev_head_index ;
  1214. psf_binheader_writef (psf, "4", saved_head_index - prev_head_index - 4) ;
  1215. psf->headindex = saved_head_index ;
  1217. } /* wav_write_strings */
  1219. static int
  1220. wav_close (SF_PRIVATE *psf)
  1221. {
  1222. if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
  1223. { wav_write_tailer (psf) ;
  1225. if (psf->file.mode == SFM_RDWR)
  1226. { sf_count_t current = psf_ftell (psf) ;
  1228. /*
  1229. ** If the mode is RDWR and the current position is less than the
  1230. ** filelength, truncate the file.
  1231. */
  1233. if (current < psf->filelength)
  1234. { psf_ftruncate (psf, current) ;
  1235. psf->filelength = current ;
  1236. } ;
  1237. } ;
  1239. psf->write_header (psf, SF_TRUE) ;
  1240. } ;
  1242. return 0 ;
  1243. } /* wav_close */
  1245. static int
  1246. wav_command (SF_PRIVATE *psf, int command, void * UNUSED (data), int datasize)
  1247. { WAV_PRIVATE *wpriv ;
  1249. if ((wpriv = psf->container_data) == NULL)
  1250. return SFE_INTERNAL ;
  1252. switch (command)
  1253. { case SFC_WAVEX_SET_AMBISONIC :
  1254. if ((SF_CONTAINER (psf->sf.format)) == SF_FORMAT_WAVEX)
  1255. { if (datasize == SF_AMBISONIC_NONE)
  1256. wpriv->wavex_ambisonic = SF_AMBISONIC_NONE ;
  1257. else if (datasize == SF_AMBISONIC_B_FORMAT)
  1258. wpriv->wavex_ambisonic = SF_AMBISONIC_B_FORMAT ;
  1259. else
  1260. return 0 ;
  1261. } ;
  1262. return wpriv->wavex_ambisonic ;
  1264. case SFC_WAVEX_GET_AMBISONIC :
  1265. return wpriv->wavex_ambisonic ;
  1267. case SFC_SET_CHANNEL_MAP_INFO :
  1268. wpriv->wavex_channelmask = wavex_gen_channel_mask (psf->channel_map, psf->sf.channels) ;
  1269. return (wpriv->wavex_channelmask != 0) ;
  1271. default :
  1272. break ;
  1273. } ;
  1275. return 0 ;
  1276. } /* wav_command */
  1278. static int
  1279. wav_subchunk_parse (SF_PRIVATE *psf, int chunk)
  1280. { sf_count_t current_pos ;
  1281. char *cptr ;
  1282. unsigned  dword, bytesread, length ;
  1284. current_pos = psf_fseek (psf, 0, SEEK_CUR) ;
  1286. bytesread = psf_binheader_readf (psf, "4", &length) ;
  1288. if (length <= 8)
  1289. { /* This case is for broken files generated by PEAK. */
  1290. psf_log_printf (psf, "%M : %d (weird length)n", chunk, length) ;
  1291. psf_binheader_readf (psf, "mj", &chunk, length - 4) ;
  1292. psf_log_printf (psf, "  %Mn", chunk) ;
  1293. return 0 ;
  1294. } ;
  1296. if (psf->headindex + length > SIGNED_SIZEOF (psf->header))
  1297. { psf_log_printf (psf, "%M : %d (too long)n", chunk, length) ;
  1298. psf_binheader_readf (psf, "j", length) ;
  1299. return 0 ;
  1300. } ;
  1302. if (current_pos + length > psf->filelength)
  1303. { psf_log_printf (psf, "%M : %d (should be %d)n", chunk, length, (int) (psf->filelength - current_pos)) ;
  1304. length = psf->filelength - current_pos ;
  1305. }
  1306. else
  1307. psf_log_printf (psf, "%M : %dn", chunk, length) ;
  1309. while (bytesread < length)
  1310. { bytesread += psf_binheader_readf (psf, "m", &chunk) ;
  1312. switch (chunk)
  1313. { case adtl_MARKER :
  1314. case INFO_MARKER :
  1315. /* These markers don't contain anything. */
  1316. psf_log_printf (psf, "  %Mn", chunk) ;
  1317. break ;
  1319. case data_MARKER :
  1320. psf_log_printf (psf, "  %M inside a LIST block??? Backing out.n", chunk) ;
  1321. /* Jump back four bytes and return to caller. */
  1322. psf_binheader_readf (psf, "j", -4) ;
  1323. return 0 ;
  1325. case ISFT_MARKER :
  1326. case ICOP_MARKER :
  1327. case IARL_MARKER :
  1328. case IART_MARKER :
  1329. case ICMT_MARKER :
  1330. case ICRD_MARKER :
  1331. case IENG_MARKER :
  1333. case INAM_MARKER :
  1334. case IPRD_MARKER :
  1335. case ISBJ_MARKER :
  1336. case ISRC_MARKER :
  1337. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1338. dword += (dword & 1) ;
  1339. if (dword >= SIGNED_SIZEOF (psf->u.cbuf))
  1340. { psf_log_printf (psf, "  *** %M : %d (too big)n", chunk, dword) ;
  1341. psf_binheader_readf (psf, "j", dword) ;
  1342. break ;
  1343. } ;
  1345. cptr = psf->u.cbuf ;
  1346. psf_binheader_readf (psf, "b", cptr, dword) ;
  1347. bytesread += dword ;
  1348. cptr [dword] = 0 ;
  1349. psf_log_printf (psf, "    %M : %sn", chunk, cptr) ;
  1350. break ;
  1352. case labl_MARKER :
  1353. { int mark_id ;
  1355. bytesread += psf_binheader_readf (psf, "44", &dword, &mark_id) ;
  1356. dword -= 4 ;
  1357. dword += (dword & 1) ;
  1358. if (dword < 1 || dword >= SIGNED_SIZEOF (psf->u.cbuf))
  1359. { psf_log_printf (psf, "  *** %M : %d (too big)n", chunk, dword) ;
  1360. psf_binheader_readf (psf, "j", dword) ;
  1361. break ;
  1362. } ;
  1364. cptr = psf->u.cbuf ;
  1365. psf_binheader_readf (psf, "b", cptr, dword) ;
  1366. bytesread += dword ;
  1367. cptr [dword] = 0 ;
  1368. psf_log_printf (psf, "    %M : %d : %sn", chunk, mark_id, cptr) ;
  1369. } ;
  1370. break ;
  1373. case DISP_MARKER :
  1374. case ltxt_MARKER :
  1375. case note_MARKER :
  1376. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1377. dword += (dword & 1) ;
  1378. psf_binheader_readf (psf, "j", dword) ;
  1379. bytesread += dword ;
  1380. psf_log_printf (psf, "    %M : %dn", chunk, dword) ;
  1381. break ;
  1383. case exif_MARKER :
  1384. psf_log_printf (psf, "  %Mn", chunk) ;
  1385. bytesread += exif_subchunk_parse (psf, length - bytesread) ;
  1386. break ;
  1388. case 0 :
  1389. /*
  1390. ** Four zero bytes where a marker was expected. Assume this means
  1391. ** the rest of the chunk is garbage.
  1392. */
  1393. psf_log_printf (psf, "    *** Found weird-ass zero marker. Jumping to end of chunk.n") ;
  1394. if (bytesread < length)
  1395. bytesread += psf_binheader_readf (psf, "j", length - bytesread + 4) ;
  1396. psf_log_printf (psf, "    *** Offset is now : 0x%Xn", psf_fseek (psf, 0, SEEK_CUR)) ;
  1397. return 0 ;
  1399. default :
  1400. psf_binheader_readf (psf, "4", &dword) ;
  1401. bytesread += sizeof (dword) ;
  1402. dword += (dword & 1) ;
  1403. psf_binheader_readf (psf, "j", dword) ;
  1404. bytesread += dword ;
  1405. psf_log_printf (psf, "    *** %M : %dn", chunk, dword) ;
  1406. if (dword > length)
  1407. return 0 ;
  1408. break ;
  1409. } ;
  1411. switch (chunk)
  1412. { case ISFT_MARKER :
  1413. psf_store_string (psf, SF_STR_SOFTWARE, psf->u.cbuf) ;
  1414. break ;
  1415. case ICOP_MARKER :
  1416. psf_store_string (psf, SF_STR_COPYRIGHT, psf->u.cbuf) ;
  1417. break ;
  1418. case INAM_MARKER :
  1419. psf_store_string (psf, SF_STR_TITLE, psf->u.cbuf) ;
  1420. break ;
  1421. case IART_MARKER :
  1422. psf_store_string (psf, SF_STR_ARTIST, psf->u.cbuf) ;
  1423. break ;
  1424. case ICMT_MARKER :
  1425. psf_store_string (psf, SF_STR_COMMENT, psf->u.cbuf) ;
  1426. break ;
  1427. case ICRD_MARKER :
  1428. psf_store_string (psf, SF_STR_DATE, psf->u.cbuf) ;
  1429. break ;
  1430. } ;
  1431. } ;
  1433. current_pos = psf_fseek (psf, 0, SEEK_CUR) - current_pos ;
  1435. if (current_pos - 4 != length)
  1436. psf_log_printf (psf, "**** Bad chunk length %d sbould be %Dn", length, current_pos - 4) ;
  1438. return 0 ;
  1439. } /* wav_subchunk_parse */
  1441. static int
  1442. wav_read_smpl_chunk (SF_PRIVATE *psf, unsigned int chunklen)
  1443. { unsigned int bytesread = 0, dword, sampler_data, loop_count ;
  1444. unsigned int note, start, end, type = -1, count ;
  1445. int j, k ;
  1447. chunklen += (chunklen & 1) ;
  1449. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1450. psf_log_printf (psf, "  Manufacturer : %Xn", dword) ;
  1452. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1453. psf_log_printf (psf, "  Product      : %un", dword) ;
  1455. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1456. psf_log_printf (psf, "  Period       : %u nsecn", dword) ;
  1458. bytesread += psf_binheader_readf (psf, "4", &note) ;
  1459. psf_log_printf (psf, "  Midi Note    : %un", note) ;
  1461. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1462. if (dword != 0)
  1463. { snprintf (psf->u.cbuf, sizeof (psf->u.cbuf), "%f",
  1464.  (1.0 * 0x80000000) / ((unsigned int) dword)) ;
  1465. psf_log_printf (psf, "  Pitch Fract. : %sn", psf->u.cbuf) ;
  1466. }
  1467. else
  1468. psf_log_printf (psf, "  Pitch Fract. : 0n") ;
  1470. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1471. psf_log_printf (psf, "  SMPTE Format : %un", dword) ;
  1473. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1474. snprintf (psf->u.cbuf, sizeof (psf->u.cbuf), "%02d:%02d:%02d %02d",
  1475.  (dword >> 24) & 0x7F, (dword >> 16) & 0x7F, (dword >> 8) & 0x7F, dword & 0x7F) ;
  1476. psf_log_printf (psf, "  SMPTE Offset : %sn", psf->u.cbuf) ;
  1478. bytesread += psf_binheader_readf (psf, "4", &loop_count) ;
  1479. psf_log_printf (psf, "  Loop Count   : %un", loop_count) ;
  1481. /* Sampler Data holds the number of data bytes after the CUE chunks which
  1482. ** is not actually CUE data. Display value after CUE data.
  1483. */
  1484. bytesread += psf_binheader_readf (psf, "4", &sampler_data) ;
  1486. if ((psf->instrument = psf_instrument_alloc ()) == NULL)
  1487. return SFE_MALLOC_FAILED ;
  1489. psf->instrument->loop_count = loop_count ;
  1491. for (j = 0 ; loop_count > 0 && chunklen - bytesread >= 24 ; j ++)
  1492. { bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1493. psf_log_printf (psf, "    Cue ID : %2u", dword) ;
  1495. bytesread += psf_binheader_readf (psf, "4", &type) ;
  1496. psf_log_printf (psf, "  Type : %2u", type) ;
  1498. bytesread += psf_binheader_readf (psf, "4", &start) ;
  1499. psf_log_printf (psf, "  Start : %5u", start) ;
  1501. bytesread += psf_binheader_readf (psf, "4", &end) ;
  1502. psf_log_printf (psf, "  End : %5u", end) ;
  1504. bytesread += psf_binheader_readf (psf, "4", &dword) ;
  1505. psf_log_printf (psf, "  Fraction : %5u", dword) ;
  1507. bytesread += psf_binheader_readf (psf, "4", &count) ;
  1508. psf_log_printf (psf, "  Count : %5un", count) ;
  1510. if (j < ARRAY_LEN (psf->instrument->loops))
  1511. { psf->instrument->loops [j].start = start ;
  1512. psf->instrument->loops [j].end = end + 1 ;
  1513. psf->instrument->loops [j].count = count ;
  1515. switch (type)
  1516. { case 0 :
  1517. psf->instrument->loops [j].mode = SF_LOOP_FORWARD ;
  1518. break ;
  1519. case 1 :
  1520. psf->instrument->loops [j].mode = SF_LOOP_ALTERNATING ;
  1521. break ;
  1522. case 2 :
  1523. psf->instrument->loops [j].mode = SF_LOOP_BACKWARD ;
  1524. break ;
  1525. default:
  1526. psf->instrument->loops [j].mode = SF_LOOP_NONE ;
  1527. break ;
  1528. } ;
  1529. } ;
  1531. loop_count -- ;
  1532. } ;
  1534. if (chunklen - bytesread == 0)
  1535. { if (sampler_data != 0)
  1536. psf_log_printf (psf, "  Sampler Data : %u (should be 0)n", sampler_data) ;
  1537. else
  1538. psf_log_printf (psf, "  Sampler Data : %un", sampler_data) ;
  1539. }
  1540. else
  1541. { if (sampler_data != chunklen - bytesread)
  1542. { psf_log_printf (psf, "  Sampler Data : %u (should have been %u)n", sampler_data, chunklen - bytesread) ;
  1543. sampler_data = chunklen - bytesread ;
  1544. }
  1545. else
  1546. psf_log_printf (psf, "  Sampler Data : %un", sampler_data) ;
  1548. psf_log_printf (psf, "      ") ;
  1549. for (k = 0 ; k < (int) sampler_data ; k++)
  1550. { char ch ;
  1552. if (k > 0 && (k % 20) == 0)
  1553. psf_log_printf (psf, "n      ") ;
  1555. bytesread += psf_binheader_readf (psf, "1", &ch) ;
  1556. psf_log_printf (psf, "%02X ", ch & 0xFF) ;
  1557. } ;
  1559. psf_log_printf (psf, "n") ;
  1560. } ;
  1562. psf->instrument->basenote = note ;
  1563. psf->instrument->gain = 1 ;
  1564. psf->instrument->velocity_lo = psf->instrument->key_lo = 0 ;
  1565. psf->instrument->velocity_hi = psf->instrument->key_hi = 127 ;
  1567. return 0 ;
  1568. } /* wav_read_smpl_chunk */
  1570. /*
  1571. ** The acid chunk goes a little something like this:
  1572. **
  1573. ** 4 bytes          'acid'
  1574. ** 4 bytes (int)     length of chunk starting at next byte
  1575. **
  1576. ** 4 bytes (int)     type of file:
  1577. **        this appears to be a bit mask,however some combinations
  1578. **        are probably impossible and/or qualified as "errors"
  1579. **
  1580. **        0x01 On: One Shot         Off: Loop
  1581. **        0x02 On: Root note is Set Off: No root
  1582. **        0x04 On: Stretch is On,   Off: Strech is OFF
  1583. **        0x08 On: Disk Based       Off: Ram based
  1584. **        0x10 On: ??????????       Off: ????????? (Acidizer puts that ON)
  1585. **
  1586. ** 2 bytes (short)      root note
  1587. **        if type 0x10 is OFF : [C,C#,(...),B] -> [0x30 to 0x3B]
  1588. **        if type 0x10 is ON  : [C,C#,(...),B] -> [0x3C to 0x47]
  1589. **         (both types fit on same MIDI pitch albeit different octaves, so who cares)
  1590. **
  1591. ** 2 bytes (short)      ??? always set to 0x8000
  1592. ** 4 bytes (float)      ??? seems to be always 0
  1593. ** 4 bytes (int)        number of beats
  1594. ** 2 bytes (short)      meter denominator   //always 4 in SF/ACID
  1595. ** 2 bytes (short)      meter numerator     //always 4 in SF/ACID
  1596. **                      //are we sure about the order?? usually its num/denom
  1597. ** 4 bytes (float)      tempo
  1598. **
  1599. */
  1601. static int
  1602. wav_read_acid_chunk (SF_PRIVATE *psf, unsigned int chunklen)
  1603. { unsigned int bytesread = 0 ;
  1604. int beats, flags ;
  1605. short rootnote, q1, meter_denom, meter_numer ;
  1606. float q2, tempo ;
  1608. chunklen += (chunklen & 1) ;
  1610. bytesread += psf_binheader_readf (psf, "422f", &flags, &rootnote, &q1, &q2) ;
  1612. snprintf (psf->u.cbuf, sizeof (psf->u.cbuf), "%f", q2) ;
  1614. psf_log_printf (psf, "  Flags     : 0x%04x (%s,%s,%s,%s,%s)n", flags,
  1615. (flags & 0x01) ? "OneShot" : "Loop",
  1616. (flags & 0x02) ? "RootNoteValid" : "RootNoteInvalid",
  1617. (flags & 0x04) ? "StretchOn" : "StretchOff",
  1618. (flags & 0x08) ? "DiskBased" : "RAMBased",
  1619. (flags & 0x10) ? "??On" : "??Off") ;
  1621. psf_log_printf (psf, "  Root note : 0x%xn  ????      : 0x%04xn  ????      : %sn",
  1622. rootnote, q1, psf->u.cbuf) ;
  1624. bytesread += psf_binheader_readf (psf, "422f", &beats, &meter_denom, &meter_numer, &tempo) ;
  1625. snprintf (psf->u.cbuf, sizeof (psf->u.cbuf), "%f", tempo) ;
  1626. psf_log_printf (psf, "  Beats     : %dn  Meter     : %d/%dn  Tempo     : %sn",
  1627. beats, meter_numer, meter_denom, psf->u.cbuf) ;
  1629. psf_binheader_readf (psf, "j", chunklen - bytesread) ;
  1631. if ((psf->loop_info = calloc (1, sizeof (SF_LOOP_INFO))) == NULL)
  1632. return SFE_MALLOC_FAILED ;
  1634. psf->loop_info->time_sig_num = meter_numer ;
  1635. psf->loop_info->time_sig_den = meter_denom ;
  1636. psf->loop_info->loop_mode = (flags & 0x01) ? SF_LOOP_NONE : SF_LOOP_FORWARD ;
  1637. psf->loop_info->num_beats = beats ;
  1638. psf->loop_info->bpm = tempo ;
  1639. psf->loop_info->root_key = (flags & 0x02) ? rootnote : -1 ;
  1641. return 0 ;
  1642. } /* wav_read_acid_chunk */
  1644. int
  1645. wav_read_bext_chunk (SF_PRIVATE *psf, unsigned int chunksize)
  1646. {
  1647. SF_BROADCAST_INFO* b ;
  1648. unsigned int bytes = 0 ;
  1650. if (chunksize < WAV_BEXT_MIN_CHUNK_SIZE)
  1651. { psf_log_printf (psf, "bext : %u (should be >= %d)n", chunksize, WAV_BEXT_MIN_CHUNK_SIZE) ;
  1652. psf_binheader_readf (psf, "j", chunksize) ;
  1653. return 0 ;
  1654. } ;
  1656. if (chunksize > WAV_BEXT_MAX_CHUNK_SIZE)
  1657. { psf_log_printf (psf, "bext : %u (should be < %d)n", chunksize, WAV_BEXT_MAX_CHUNK_SIZE) ;
  1658. psf_binheader_readf (psf, "j", chunksize) ;
  1659. return 0 ;
  1660. } ;
  1662. psf_log_printf (psf, "bext : %un", chunksize) ;
  1664. if ((psf->broadcast_var = broadcast_var_alloc (chunksize + 128)) == NULL)
  1665. { psf->error = SFE_MALLOC_FAILED ;
  1666. return psf->error ;
  1667. } ;
  1669. b = & psf->broadcast_var->binfo ;
  1671. bytes += psf_binheader_readf (psf, "b", b->description, sizeof (b->description)) ;
  1672. bytes += psf_binheader_readf (psf, "b", b->originator, sizeof (b->originator)) ;
  1673. bytes += psf_binheader_readf (psf, "b", b->originator_reference, sizeof (b->originator_reference)) ;
  1674. bytes += psf_binheader_readf (psf, "b", b->origination_date, sizeof (b->origination_date)) ;
  1675. bytes += psf_binheader_readf (psf, "b", b->origination_time, sizeof (b->origination_time)) ;
  1676. bytes += psf_binheader_readf (psf, "442", &b->time_reference_low, &b->time_reference_high, &b->version) ;
  1677. bytes += psf_binheader_readf (psf, "bj", &b->umid, sizeof (b->umid), 190) ;
  1679. if (chunksize > WAV_BEXT_MIN_CHUNK_SIZE)
  1680. { /* File has coding history data. */
  1682. b->coding_history_size = chunksize - WAV_BEXT_MIN_CHUNK_SIZE ;
  1684. /* We do not parse the coding history */
  1685. bytes += psf_binheader_readf (psf, "b", b->coding_history, b->coding_history_size) ;
  1686. } ;
  1688. if (bytes < chunksize)
  1689. psf_binheader_readf (psf, "j", chunksize - bytes) ;
  1691. return 0 ;
  1692. } /* wav_read_bext_chunk */
  1694. int
  1695. wav_write_bext_chunk (SF_PRIVATE *psf)
  1696. { SF_BROADCAST_INFO *b ;
  1698. if (psf->broadcast_var == NULL)
  1699. return -1 ;
  1701. b = & psf->broadcast_var->binfo ;
  1703. psf_binheader_writef (psf, "m4", bext_MARKER, WAV_BEXT_MIN_CHUNK_SIZE + b->coding_history_size) ;
  1705. /*
  1706. ** Note that it is very important the the field widths of the SF_BROADCAST_INFO
  1707. ** struct match those for the bext chunk fields.
  1708. */
  1710. psf_binheader_writef (psf, "b", b->description, sizeof (b->description)) ;
  1711. psf_binheader_writef (psf, "b", b->originator, sizeof (b->originator)) ;
  1712. psf_binheader_writef (psf, "b", b->originator_reference, sizeof (b->originator_reference)) ;
  1713. psf_binheader_writef (psf, "b", b->origination_date, sizeof (b->origination_date)) ;
  1714. psf_binheader_writef (psf, "b", b->origination_time, sizeof (b->origination_time)) ;
  1715. psf_binheader_writef (psf, "442", b->time_reference_low, b->time_reference_high, b->version) ;
  1716. psf_binheader_writef (psf, "b", b->umid, sizeof (b->umid)) ;
  1717. psf_binheader_writef (psf, "z", make_size_t (190)) ;
  1719. if (b->coding_history_size > 0)
  1720. psf_binheader_writef (psf, "b", b->coding_history, make_size_t (b->coding_history_size)) ;
  1722. return 0 ;
  1723. } /* wav_write_bext_chunk */
  1725. static int
  1726. exif_fill_and_sink (SF_PRIVATE *psf, char* buf, size_t bufsz, size_t toread)
  1727. {
  1728. size_t bytesread = 0 ;
  1730. buf [0] = 0 ;
  1731. bufsz -= 1 ;
  1732. if (toread < bufsz)
  1733. bufsz = toread ;
  1734. bytesread = psf_binheader_readf (psf, "b", buf, bufsz) ;
  1735. buf [bufsz] = 0 ;
  1737. if (bytesread == bufsz && toread > bufsz)
  1738. bytesread += psf_binheader_readf (psf, "j", toread - bufsz) ;
  1740. return bytesread ;
  1741. } /* exif_fill_and_sink */
  1743. /*
  1744. ** Exif specification for audio files, at JEITA CP-3451 Exif 2.2 section 5
  1745. ** (Exif Audio File Specification) http://www.exif.org/Exif2-2.PDF
  1746. */
  1747. static int
  1748. exif_subchunk_parse (SF_PRIVATE *psf, unsigned int length)
  1749. { unsigned marker, dword, vmajor = -1, vminor = -1, bytesread = 0 ;
  1750. char buf [4096] ;
  1752. while (bytesread < length)
  1753. {
  1754. bytesread += psf_binheader_readf (psf, "m", &marker) ;
  1756. switch (marker)
  1757. {
  1758. case 0 : /* camera padding? */
  1759. break ;
  1761. case ever_MARKER :
  1762. bytesread += psf_binheader_readf (psf, "j4", 4, &dword) ;
  1763. vmajor = 10 * (((dword >> 24) & 0xff) - '0') + (((dword >> 16) & 0xff) - '0') ;
  1764. vminor = 10 * (((dword >> 8) & 0xff) - '0') + ((dword & 0xff) - '0') ;
  1765. psf_log_printf (psf, "    EXIF Version : %u.%02un", vmajor, vminor) ;
  1766. break ;
  1768. case emnt_MARKER : /* design information: null-terminated string */
  1769. case emdl_MARKER : /* model name ; null-terminated string */
  1770. case ecor_MARKER : /* manufacturer: null-terminated string */
  1771. case etim_MARKER : /* creation time: null-terminated string in the format "hour:minute:second.subsecond" */
  1772. case erel_MARKER : /* relation info: null-terminated string (filename) */
  1773. case eucm_MARKER : /* user comment: 4-byte size follows, then possibly unicode data */
  1774. psf_binheader_readf (psf, "4", &dword) ;
  1775. bytesread += sizeof (dword) ;
  1776. dword += (dword & 1) ;
  1778. if (dword >= sizeof (buf))
  1779. { psf_log_printf (psf, "*** Marker '%M' is too big %unn", marker, dword) ;
  1780. return bytesread ;
  1781. } ;
  1783. bytesread += exif_fill_and_sink (psf, buf, sizeof (buf), dword) ;
  1785. /* BAD - don't know what's going on here -- maybe a bug in the camera */
  1786. /* field should be NULL-terminated but there's no room for it with the reported number */
  1787. /*  example output:     emdl : 8 (EX-Z1050) */
  1788. if (marker == emdl_MARKER && dword == strlen (buf) /* should be >= strlen+1*/)
  1789. { psf_log_printf (psf, "    *** field size too small for string (sinking 2 bytes)n") ;
  1790. bytesread += psf_binheader_readf (psf, "j", 2) ;
  1791. } ;
  1793. psf_log_printf (psf, "    %M : %d (%s)n", marker, dword, buf) ;
  1794. if (dword > length)
  1795. return bytesread ;
  1796. break ;
  1798. default :
  1799. psf_log_printf (psf, "    *** %M (%d): -- ignored --n", marker, marker) ;
  1800. break ;
  1801. } ;
  1802. } ;
  1804. return bytesread ;
  1805. } /* exif_subchunk_parse */