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

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

Audio

开发平台：

Unix_Linux

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