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

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

Audio

开发平台：

Unix_Linux

aiff.c：源码内容
  1. /*
  2. ** Copyright (C) 1999-2009 Erik de Castro Lopo <erikd@mega-nerd.com>
  3. ** Copyright (C) 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 <time.h>
  26. #include <ctype.h>
  27. #include <inttypes.h>
  29. #include "sndfile.h"
  30. #include "sfendian.h"
  31. #include "common.h"
  32. #include "chanmap.h"
  34. /*------------------------------------------------------------------------------
  35.  * Macros to handle big/little endian issues.
  36.  */
  38. #define FORM_MARKER (MAKE_MARKER ('F', 'O', 'R', 'M'))
  39. #define AIFF_MARKER (MAKE_MARKER ('A', 'I', 'F', 'F'))
  40. #define AIFC_MARKER (MAKE_MARKER ('A', 'I', 'F', 'C'))
  41. #define COMM_MARKER (MAKE_MARKER ('C', 'O', 'M', 'M'))
  42. #define SSND_MARKER (MAKE_MARKER ('S', 'S', 'N', 'D'))
  43. #define MARK_MARKER (MAKE_MARKER ('M', 'A', 'R', 'K'))
  44. #define INST_MARKER (MAKE_MARKER ('I', 'N', 'S', 'T'))
  45. #define APPL_MARKER (MAKE_MARKER ('A', 'P', 'P', 'L'))
  46. #define CHAN_MARKER (MAKE_MARKER ('C', 'H', 'A', 'N'))
  48. #define c_MARKER (MAKE_MARKER ('(', 'c', ')', ' '))
  49. #define NAME_MARKER (MAKE_MARKER ('N', 'A', 'M', 'E'))
  50. #define AUTH_MARKER (MAKE_MARKER ('A', 'U', 'T', 'H'))
  51. #define ANNO_MARKER (MAKE_MARKER ('A', 'N', 'N', 'O'))
  52. #define COMT_MARKER (MAKE_MARKER ('C', 'O', 'M', 'T'))
  53. #define FVER_MARKER (MAKE_MARKER ('F', 'V', 'E', 'R'))
  54. #define SFX_MARKER (MAKE_MARKER ('S', 'F', 'X', '!'))
  56. #define PEAK_MARKER (MAKE_MARKER ('P', 'E', 'A', 'K'))
  57. #define basc_MARKER (MAKE_MARKER ('b', 'a', 's', 'c'))
  59. /* Supported AIFC encodings.*/
  60. #define NONE_MARKER (MAKE_MARKER ('N', 'O', 'N', 'E'))
  61. #define sowt_MARKER (MAKE_MARKER ('s', 'o', 'w', 't'))
  62. #define twos_MARKER (MAKE_MARKER ('t', 'w', 'o', 's'))
  63. #define raw_MARKER (MAKE_MARKER ('r', 'a', 'w', ' '))
  64. #define in24_MARKER (MAKE_MARKER ('i', 'n', '2', '4'))
  65. #define ni24_MARKER (MAKE_MARKER ('4', '2', 'n', '1'))
  66. #define in32_MARKER (MAKE_MARKER ('i', 'n', '3', '2'))
  67. #define ni32_MARKER (MAKE_MARKER ('2', '3', 'n', 'i'))
  69. #define fl32_MARKER (MAKE_MARKER ('f', 'l', '3', '2'))
  70. #define FL32_MARKER (MAKE_MARKER ('F', 'L', '3', '2'))
  71. #define fl64_MARKER (MAKE_MARKER ('f', 'l', '6', '4'))
  72. #define FL64_MARKER (MAKE_MARKER ('F', 'L', '6', '4'))
  74. #define ulaw_MARKER (MAKE_MARKER ('u', 'l', 'a', 'w'))
  75. #define ULAW_MARKER (MAKE_MARKER ('U', 'L', 'A', 'W'))
  76. #define alaw_MARKER (MAKE_MARKER ('a', 'l', 'a', 'w'))
  77. #define ALAW_MARKER (MAKE_MARKER ('A', 'L', 'A', 'W'))
  79. #define DWVW_MARKER (MAKE_MARKER ('D', 'W', 'V', 'W'))
  80. #define GSM_MARKER (MAKE_MARKER ('G', 'S', 'M', ' '))
  81. #define ima4_MARKER (MAKE_MARKER ('i', 'm', 'a', '4'))
  83. /*
  84. ** This value is officially assigned to Mega Nerd Pty Ltd by Apple
  85. ** Corportation as the Application marker for libsndfile.
  86. **
  87. ** See : http://developer.apple.com/faq/datatype.html
  88. */
  89. #define m3ga_MARKER (MAKE_MARKER ('m', '3', 'g', 'a'))
  91. /* Unsupported AIFC encodings.*/
  93. #define MAC3_MARKER (MAKE_MARKER ('M', 'A', 'C', '3'))
  94. #define MAC6_MARKER (MAKE_MARKER ('M', 'A', 'C', '6'))
  95. #define ADP4_MARKER (MAKE_MARKER ('A', 'D', 'P', '4'))
  97. /* Predfined chunk sizes. */
  98. #define SIZEOF_AIFF_COMM 18
  99. #define SIZEOF_AIFC_COMM_MIN 22
  100. #define SIZEOF_AIFC_COMM 24
  101. #define SIZEOF_SSND_CHUNK 8
  102. #define SIZEOF_INST_CHUNK 20
  104. /* Is it constant? */
  106. /* AIFC/IMA4 defines. */
  107. #define AIFC_IMA4_BLOCK_LEN 34
  108. #define AIFC_IMA4_SAMPLES_PER_BLOCK 64
  110. #define AIFF_PEAK_CHUNK_SIZE(ch) (2 * sizeof (int) + ch * (sizeof (float) + sizeof (int)))
  112. /*------------------------------------------------------------------------------
  113.  * Typedefs for file chunks.
  114.  */
  116. enum
  117. { HAVE_FORM = 0x01,
  118. HAVE_AIFF = 0x02,
  119. HAVE_AIFC = 0x04,
  120. HAVE_FVER = 0x08,
  121. HAVE_COMM = 0x10,
  122. HAVE_SSND = 0x20
  123. } ;
  125. typedef struct
  126. { unsigned int size ;
  127. short numChannels ;
  128. unsigned int numSampleFrames ;
  129. short sampleSize ;
  130. unsigned char sampleRate [10] ;
  131. unsigned int encoding ;
  132. char zero_bytes [2] ;
  133. } COMM_CHUNK ;
  135. typedef struct
  136. { unsigned int offset ;
  137. unsigned int blocksize ;
  138. } SSND_CHUNK ;
  140. typedef struct
  141. { short playMode ;
  142. unsigned short beginLoop ;
  143. unsigned short endLoop ;
  144. } INST_LOOP ;
  146. typedef struct
  147. { char baseNote ; /* all notes are MIDI note numbers */
  148. char detune ; /* cents off, only -50 to +50 are significant */
  149. char lowNote ;
  150. char highNote ;
  151. char lowVelocity ; /* 1 to 127 */
  152. char highVelocity ; /* 1 to 127 */
  153. short gain ; /* in dB, 0 is normal */
  154. INST_LOOP sustain_loop ;
  155. INST_LOOP release_loop ;
  156. } INST_CHUNK ;
  159. enum
  160. { basc_SCALE_MINOR = 1,
  161. basc_SCALE_MAJOR,
  162. basc_SCALE_NEITHER,
  163. basc_SCALE_BOTH
  164. } ;
  166. enum
  167. { basc_TYPE_LOOP = 0,
  168. basc_TYPE_ONE_SHOT
  169. } ;
  172. typedef struct
  173. { unsigned int version ;
  174. unsigned int numBeats ;
  175. unsigned short rootNote ;
  176. unsigned short scaleType ;
  177. unsigned short sigNumerator ;
  178. unsigned short sigDenominator ;
  179. unsigned short loopType ;
  180. } basc_CHUNK ;
  182. typedef struct
  183. { unsigned short markerID ;
  184. unsigned int position ;
  185. } MARK_ID_POS ;
  187. typedef struct
  188. { PRIV_CHUNK4 chunk4 ;
  190. sf_count_t comm_offset ;
  191. sf_count_t ssnd_offset ;
  193. int chanmap_tag ;
  195. MARK_ID_POS *markstr ;
  196. } AIFF_PRIVATE ;
  198. /*------------------------------------------------------------------------------
  199.  * Private static functions.
  200.  */
  202. static int aiff_close (SF_PRIVATE *psf) ;
  204. static int tenbytefloat2int (unsigned char *bytes) ;
  205. static void uint2tenbytefloat (unsigned int num, unsigned char *bytes) ;
  207. static int aiff_read_comm_chunk (SF_PRIVATE *psf, COMM_CHUNK *comm_fmt) ;
  209. static int aiff_read_header (SF_PRIVATE *psf, COMM_CHUNK *comm_fmt) ;
  211. static int aiff_write_header (SF_PRIVATE *psf, int calc_length) ;
  212. static int aiff_write_tailer (SF_PRIVATE *psf) ;
  213. static void aiff_write_strings (SF_PRIVATE *psf, int location) ;
  215. static int aiff_command (SF_PRIVATE *psf, int command, void *data, int datasize) ;
  217. static const char *get_loop_mode_str (short mode) ;
  219. static short get_loop_mode (short mode) ;
  221. static int aiff_read_basc_chunk (SF_PRIVATE * psf, int) ;
  223. static int aiff_read_chanmap (SF_PRIVATE * psf, unsigned dword) ;
  225. static unsigned int marker_to_position (const MARK_ID_POS *m, unsigned short n, int marksize) ;
  227. /*------------------------------------------------------------------------------
  228. ** Public function.
  229. */
  231. int
  232. aiff_open (SF_PRIVATE *psf)
  233. { COMM_CHUNK comm_fmt ;
  234. int error, subformat ;
  236. memset (&comm_fmt, 0, sizeof (comm_fmt)) ;
  238. subformat = SF_CODEC (psf->sf.format) ;
  240. if ((psf->container_data = calloc (1, sizeof (AIFF_PRIVATE))) == NULL)
  241. return SFE_MALLOC_FAILED ;
  243. if (psf->file.mode == SFM_READ || (psf->file.mode == SFM_RDWR && psf->filelength > 0))
  244. { if ((error = aiff_read_header (psf, &comm_fmt)))
  245. return error ;
  246. psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
  247. } ;
  249. if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
  250. { if (psf->is_pipe)
  251. return SFE_NO_PIPE_WRITE ;
  253. if ((SF_CONTAINER (psf->sf.format)) != SF_FORMAT_AIFF)
  254. return SFE_BAD_OPEN_FORMAT ;
  256. if (psf->file.mode == SFM_WRITE && (subformat == SF_FORMAT_FLOAT || subformat == SF_FORMAT_DOUBLE))
  257. { if ((psf->peak_info = peak_info_calloc (psf->sf.channels)) == NULL)
  258. return SFE_MALLOC_FAILED ;
  259. psf->peak_info->peak_loc = SF_PEAK_START ;
  260. } ;
  262. if (psf->file.mode != SFM_RDWR || psf->filelength < 40)
  263. { psf->filelength = 0 ;
  264. psf->datalength = 0 ;
  265. psf->dataoffset = 0 ;
  266. psf->sf.frames = 0 ;
  267. } ;
  269. psf->str_flags = SF_STR_ALLOW_START | SF_STR_ALLOW_END ;
  271. if ((error = aiff_write_header (psf, SF_FALSE)))
  272. return error ;
  274. psf->write_header = aiff_write_header ;
  275. } ;
  277. psf->container_close = aiff_close ;
  278. psf->command = aiff_command ;
  280. switch (SF_CODEC (psf->sf.format))
  281. { case SF_FORMAT_PCM_U8 :
  282. error = pcm_init (psf) ;
  283. break ;
  285. case SF_FORMAT_PCM_S8 :
  286. error = pcm_init (psf) ;
  287. break ;
  289. case SF_FORMAT_PCM_16 :
  290. case SF_FORMAT_PCM_24 :
  291. case SF_FORMAT_PCM_32 :
  292. error = pcm_init (psf) ;
  293. break ;
  295. case SF_FORMAT_ULAW :
  296. error = ulaw_init (psf) ;
  297. break ;
  299. case SF_FORMAT_ALAW :
  300. error = alaw_init (psf) ;
  301. break ;
  303. /* Lite remove start */
  304. case SF_FORMAT_FLOAT :
  305. error = float32_init (psf) ;
  306. break ;
  308. case SF_FORMAT_DOUBLE :
  309. error = double64_init (psf) ;
  310. break ;
  312. case SF_FORMAT_DWVW_12 :
  313. error = dwvw_init (psf, 12) ;
  314. break ;
  316. case SF_FORMAT_DWVW_16 :
  317. error = dwvw_init (psf, 16) ;
  318. break ;
  320. case SF_FORMAT_DWVW_24 :
  321. error = dwvw_init (psf, 24) ;
  322. break ;
  324. case SF_FORMAT_DWVW_N :
  325. if (psf->file.mode != SFM_READ)
  326. { error = SFE_DWVW_BAD_BITWIDTH ;
  327. break ;
  328. } ;
  329. if (comm_fmt.sampleSize >= 8 && comm_fmt.sampleSize < 24)
  330. { error = dwvw_init (psf, comm_fmt.sampleSize) ;
  331. psf->sf.frames = comm_fmt.numSampleFrames ;
  332. break ;
  333. } ;
  334. psf_log_printf (psf, "AIFC/DWVW : Bad bitwidth %dn", comm_fmt.sampleSize) ;
  335. error = SFE_DWVW_BAD_BITWIDTH ;
  336. break ;
  338. case SF_FORMAT_IMA_ADPCM :
  339. /*
  340. ** IMA ADPCM encoded AIFF files always have a block length
  341. ** of 34 which decodes to 64 samples.
  342. */
  343. error = aiff_ima_init (psf, AIFC_IMA4_BLOCK_LEN, AIFC_IMA4_SAMPLES_PER_BLOCK) ;
  344. break ;
  345. /* Lite remove end */
  347. case SF_FORMAT_GSM610 :
  348. error = gsm610_init (psf) ;
  349. break ;
  351. default : return SFE_UNIMPLEMENTED ;
  352. } ;
  355. return error ;
  356. } /* aiff_open */
  358. /*==========================================================================================
  359. ** Private functions.
  360. */
  362. /* This function ought to check size */
  363. static unsigned int
  364. marker_to_position (const MARK_ID_POS *m, unsigned short n, int marksize)
  365. { int i ;
  367.     for (i = 0 ; i < marksize ; i++)
  368. if (m [i].markerID == n)
  369. return m [i].position ;
  370.     return 0 ;
  371. } /* marker_to_position */
  373. static int
  374. aiff_read_header (SF_PRIVATE *psf, COMM_CHUNK *comm_fmt)
  375. { SSND_CHUNK ssnd_fmt ;
  376. AIFF_PRIVATE *paiff ;
  377. unsigned marker, dword, FORMsize, SSNDsize, bytesread ;
  378. int k, found_chunk = 0, done = 0, error = 0 ;
  379. char *cptr ;
  380. int instr_found = 0, mark_found = 0, mark_count = 0 ;
  382. if (psf->filelength > SF_PLATFORM_S64 (0xffffffff))
  383. psf_log_printf (psf, "Warning : filelength > 0xffffffff. This is bad!!!!n") ;
  385. if ((paiff = psf->container_data) == NULL)
  386. return SFE_INTERNAL ;
  388. paiff->comm_offset = 0 ;
  389. paiff->ssnd_offset = 0 ;
  391. /* Set position to start of file to begin reading header. */
  392. psf_binheader_readf (psf, "p", 0) ;
  394. memset (comm_fmt, 0, sizeof (COMM_CHUNK)) ;
  396. /* Until recently AIF* file were all BIG endian. */
  397. psf->endian = SF_ENDIAN_BIG ;
  399. /* AIFF files can apparently have their chunks in any order. However, they
  400. ** must have a FORM chunk. Approach here is to read all the chunks one by
  401. ** one and then check for the mandatory chunks at the end.
  402. */
  403. while (! done)
  404. { psf_binheader_readf (psf, "m", &marker) ;
  406. if (psf->file.mode == SFM_RDWR && (found_chunk & HAVE_SSND))
  407. return SFE_AIFF_RW_SSND_NOT_LAST ;
  409. switch (marker)
  410. { case FORM_MARKER :
  411. if (found_chunk)
  412. return SFE_AIFF_NO_FORM ;
  414. psf_binheader_readf (psf, "E4", &FORMsize) ;
  415. pchk4_store (&(paiff->chunk4), marker, psf->headindex - 8, FORMsize) ;
  417. if (psf->fileoffset > 0 && psf->filelength > FORMsize + 8)
  418. { /* Set file length. */
  419. psf->filelength = FORMsize + 8 ;
  420. psf_log_printf (psf, "FORM : %un", FORMsize) ;
  421. }
  422. else if (FORMsize != psf->filelength - 2 * SIGNED_SIZEOF (dword))
  423. { dword = psf->filelength - 2 * sizeof (dword) ;
  424. psf_log_printf (psf, "FORM : %u (should be %u)n", FORMsize, dword) ;
  425. FORMsize = dword ;
  426. }
  427. else
  428. psf_log_printf (psf, "FORM : %un", FORMsize) ;
  429. found_chunk |= HAVE_FORM ;
  430. break ;
  432. case AIFC_MARKER :
  433. case AIFF_MARKER :
  434. if ((found_chunk & HAVE_FORM) == 0)
  435. return SFE_AIFF_AIFF_NO_FORM ;
  436. psf_log_printf (psf, " %Mn", marker) ;
  437. found_chunk |= (marker == AIFC_MARKER) ? (HAVE_AIFC | HAVE_AIFF) : HAVE_AIFF ;
  438. break ;
  440. case COMM_MARKER :
  441. paiff->comm_offset = psf_ftell (psf) - 4 ;
  442. error = aiff_read_comm_chunk (psf, comm_fmt) ;
  443. pchk4_store (&paiff->chunk4, marker, paiff->comm_offset, comm_fmt->size) ;
  446. psf->sf.samplerate = tenbytefloat2int (comm_fmt->sampleRate) ;
  447. psf->sf.frames = comm_fmt->numSampleFrames ;
  448. psf->sf.channels = comm_fmt->numChannels ;
  449. psf->bytewidth = BITWIDTH2BYTES (comm_fmt->sampleSize) ;
  451. if (error)
  452. return error ;
  454. found_chunk |= HAVE_COMM ;
  455. break ;
  457. case PEAK_MARKER :
  458. /* Must have COMM chunk before PEAK chunk. */
  459. if ((found_chunk & (HAVE_FORM | HAVE_AIFF | HAVE_COMM)) != (HAVE_FORM | HAVE_AIFF | HAVE_COMM))
  460. return SFE_AIFF_PEAK_B4_COMM ;
  462. psf_binheader_readf (psf, "E4", &dword) ;
  463. pchk4_store (&paiff->chunk4, marker, psf->headindex - 8, dword) ;
  465. psf_log_printf (psf, "%M : %dn", marker, dword) ;
  466. if (dword != AIFF_PEAK_CHUNK_SIZE (psf->sf.channels))
  467. { psf_binheader_readf (psf, "j", dword) ;
  468. psf_log_printf (psf, "*** File PEAK chunk too big.n") ;
  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, "E44", &(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, "Ef4", &value, &position) ;
  492. psf->peak_info->peaks [dword].value = value ;
  493. psf->peak_info->peaks [dword].position = position ;
  495. snprintf (cptr, sizeof (psf->u.scbuf), "    %2d   %-12" PRId64 "   %gn",
  496. dword, psf->peak_info->peaks [dword].position, psf->peak_info->peaks [dword].value) ;
  497. cptr [sizeof (psf->u.scbuf) - 1] = 0 ;
  498. psf_log_printf (psf, "%s", cptr) ;
  499. } ;
  501. psf->peak_info->peak_loc = ((found_chunk & HAVE_SSND) == 0) ? SF_PEAK_START : SF_PEAK_END ;
  502. break ;
  504. case SSND_MARKER :
  505. if ((found_chunk & HAVE_AIFC) && (found_chunk & HAVE_FVER) == 0)
  506. psf_log_printf (psf, "*** Valid AIFC files should have an FVER chunk.n") ;
  508. paiff->ssnd_offset = psf_ftell (psf) - 4 ;
  509. psf_binheader_readf (psf, "E444", &SSNDsize, &(ssnd_fmt.offset), &(ssnd_fmt.blocksize)) ;
  510. pchk4_store (&paiff->chunk4, marker, paiff->ssnd_offset, SSNDsize) ;
  512. psf->datalength = SSNDsize - sizeof (ssnd_fmt) ;
  513. psf->dataoffset = psf_ftell (psf) ;
  515. if (psf->datalength > psf->filelength - psf->dataoffset || psf->datalength < 0)
  516. { psf_log_printf (psf, " SSND : %u (should be %D)n", SSNDsize, psf->filelength - psf->dataoffset + sizeof (SSND_CHUNK)) ;
  517. psf->datalength = psf->filelength - psf->dataoffset ;
  518. }
  519. else
  520. psf_log_printf (psf, " SSND : %un", SSNDsize) ;
  522. if (ssnd_fmt.offset == 0 || psf->dataoffset + ssnd_fmt.offset == ssnd_fmt.blocksize)
  523. { psf_log_printf (psf, "  Offset     : %un", ssnd_fmt.offset) ;
  524. psf_log_printf (psf, "  Block Size : %un", ssnd_fmt.blocksize) ;
  526. psf->dataoffset += ssnd_fmt.offset ;
  527. psf->datalength -= ssnd_fmt.offset ;
  528. }
  529. else
  530. { psf_log_printf (psf, "  Offset     : %u (Should be zero)n", ssnd_fmt.offset) ;
  531. psf_log_printf (psf, "  Block Size : %u ???n", ssnd_fmt.blocksize) ;
  532. } ;
  534. /* Only set dataend if there really is data at the end. */
  535. if (psf->datalength + psf->dataoffset < psf->filelength)
  536. psf->dataend = psf->datalength + psf->dataoffset ;
  538. found_chunk |= HAVE_SSND ;
  540. if (! psf->sf.seekable)
  541. break ;
  543. /* Seek to end of SSND chunk. */
  544. psf_fseek (psf, psf->dataoffset + psf->datalength + (SSNDsize & 1), SEEK_SET) ;
  545. break ;
  547. case c_MARKER :
  548. psf_binheader_readf (psf, "E4", &dword) ;
  549. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  550. if (dword == 0)
  551. break ;
  552. if (dword >= SIGNED_SIZEOF (psf->u.scbuf))
  553. { psf_log_printf (psf, " %M : %d (too big)n", marker, dword) ;
  554. return SFE_INTERNAL ;
  555. } ;
  557. cptr = psf->u.cbuf ;
  558. psf_binheader_readf (psf, "b", cptr, dword + (dword & 1)) ;
  559. cptr [dword] = 0 ;
  561. psf_sanitize_string (cptr, dword) ;
  563. psf_log_printf (psf, " %M : %sn", marker, cptr) ;
  564. psf_store_string (psf, SF_STR_COPYRIGHT, cptr) ;
  565. break ;
  567. case AUTH_MARKER :
  568. psf_binheader_readf (psf, "E4", &dword) ;
  569. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  570. if (dword == 0)
  571. break ;
  572. if (dword >= SIGNED_SIZEOF (psf->u.scbuf) - 1)
  573. { psf_log_printf (psf, " %M : %d (too big)n", marker, dword) ;
  574. return SFE_INTERNAL ;
  575. } ;
  577. cptr = psf->u.cbuf ;
  578. psf_binheader_readf (psf, "b", cptr, dword + (dword & 1)) ;
  579. cptr [dword] = 0 ;
  580. psf_log_printf (psf, " %M : %sn", marker, cptr) ;
  581. psf_store_string (psf, SF_STR_ARTIST, cptr) ;
  582. break ;
  584. case COMT_MARKER :
  585. { unsigned short count, id, len ;
  586. unsigned int timestamp ;
  588. psf_binheader_readf (psf, "E42", &dword, &count) ;
  589. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  590. psf_log_printf (psf, " %M : %dn  count  : %dn", marker, dword, count) ;
  591. dword += (dword & 1) ;
  592. if (dword == 0)
  593. break ;
  594. dword -= 2 ;
  596. for (k = 0 ; k < count ; k++)
  597. { dword -= psf_binheader_readf (psf, "E422", &timestamp, &id, &len) ;
  598. psf_log_printf (psf, "   time   : 0x%xn   marker : %xn   length : %dn", timestamp, id, len) ;
  600. if (len + 1 > SIGNED_SIZEOF (psf->u.scbuf))
  601. { psf_log_printf (psf, "nError : string length (%d) too big.n", len) ;
  602. return SFE_INTERNAL ;
  603. } ;
  605. cptr = psf->u.cbuf ;
  606. dword -= psf_binheader_readf (psf, "b", cptr, len) ;
  607. cptr [len] = 0 ;
  608. psf_log_printf (psf, "   string : %sn", cptr) ;
  609. } ;
  611. if (dword > 0)
  612. psf_binheader_readf (psf, "j", dword) ;
  613. } ;
  614. break ;
  616. case APPL_MARKER :
  617. { unsigned appl_marker ;
  619. psf_binheader_readf (psf, "E4", &dword) ;
  620. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  621. if (dword == 0)
  622. break ;
  623. if (dword >= SIGNED_SIZEOF (psf->u.scbuf) - 1)
  624. { psf_log_printf (psf, " %M : %d (too big, skipping)n", marker, dword) ;
  625. psf_binheader_readf (psf, "j", dword + (dword & 1)) ;
  626. break ;
  627. } ;
  629. if (dword < 4)
  630. { psf_log_printf (psf, " %M : %d (too small, skipping)n", marker, dword) ;
  631. psf_binheader_readf (psf, "j", dword + (dword & 1)) ;
  632. break ;
  633. } ;
  635. cptr = psf->u.cbuf ;
  636. psf_binheader_readf (psf, "mb", &appl_marker, cptr, dword + (dword & 1) - 4) ;
  637. cptr [dword] = 0 ;
  639. for (k = 0 ; k < (int) dword ; k++)
  640. if (! psf_isprint (cptr [k]))
  641. { cptr [k] = 0 ;
  642. break ;
  643. } ;
  645. psf_log_printf (psf, " %M : %dn  AppSig : %Mn  Name   : %sn", marker, dword, appl_marker, cptr) ;
  646. psf_store_string (psf, SF_STR_SOFTWARE, cptr) ;
  647. } ;
  648. break ;
  650. case NAME_MARKER :
  651. psf_binheader_readf (psf, "E4", &dword) ;
  652. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  653. if (dword == 0)
  654. break ;
  655. if (dword >= SIGNED_SIZEOF (psf->u.scbuf) - 2)
  656. { psf_log_printf (psf, " %M : %d (too big)n", marker, dword) ;
  657. return SFE_INTERNAL ;
  658. } ;
  660. cptr = psf->u.cbuf ;
  661. psf_binheader_readf (psf, "b", cptr, dword + (dword & 1)) ;
  662. cptr [dword] = 0 ;
  663. psf_log_printf (psf, " %M : %sn", marker, cptr) ;
  664. psf_store_string (psf, SF_STR_TITLE, cptr) ;
  665. break ;
  667. case ANNO_MARKER :
  668. psf_binheader_readf (psf, "E4", &dword) ;
  669. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  670. if (dword == 0)
  671. break ;
  672. if (dword >= SIGNED_SIZEOF (psf->u.scbuf) - 2)
  673. { psf_log_printf (psf, " %M : %d (too big)n", marker, dword) ;
  674. return SFE_INTERNAL ;
  675. } ;
  677. cptr = psf->u.cbuf ;
  678. psf_binheader_readf (psf, "b", cptr, dword + (dword & 1)) ;
  679. cptr [dword] = 0 ;
  680. psf_log_printf (psf, " %M : %sn", marker, cptr) ;
  681. psf_store_string (psf, SF_STR_COMMENT, cptr) ;
  682. break ;
  684. case INST_MARKER :
  685. psf_binheader_readf (psf, "E4", &dword) ;
  686. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  687. if (dword != SIZEOF_INST_CHUNK)
  688. { psf_log_printf (psf, " %M : %d (should be %d)n", marker, dword, SIZEOF_INST_CHUNK) ;
  689. psf_binheader_readf (psf, "j", dword) ;
  690. break ;
  691. } ;
  692. psf_log_printf (psf, " %M : %dn", marker, dword) ;
  693. { unsigned char bytes [6] ;
  694. short gain ;
  696. if (psf->instrument == NULL && (psf->instrument = psf_instrument_alloc ()) == NULL)
  697. return SFE_MALLOC_FAILED ;
  699. psf_binheader_readf (psf, "b", bytes, 6) ;
  700. psf_log_printf (psf, "  Base Note : %un  Detune    : %un"
  701. "  Low  Note : %un  High Note : %un"
  702. "  Low  Vel. : %un  High Vel. : %un",
  703. bytes [0], bytes [1], bytes [2], bytes [3], bytes [4], bytes [5]) ;
  704. psf->instrument->basenote = bytes [0] ;
  705. psf->instrument->detune = bytes [1] ;
  706. psf->instrument->key_lo = bytes [2] ;
  707. psf->instrument->key_hi = bytes [3] ;
  708. psf->instrument->velocity_lo = bytes [4] ;
  709. psf->instrument->velocity_hi = bytes [5] ;
  710. psf_binheader_readf (psf, "E2", &gain) ;
  711. psf->instrument->gain = gain ;
  712. psf_log_printf (psf, "  Gain (dB) : %dn", gain) ;
  713. } ;
  714. { short mode ; /* 0 - no loop, 1 - forward looping, 2 - backward looping */
  715. const char *loop_mode ;
  716. unsigned short begin, end ;
  718. psf_binheader_readf (psf, "E222", &mode, &begin, &end) ;
  719. loop_mode = get_loop_mode_str (mode) ;
  720. mode = get_loop_mode (mode) ;
  721. if (mode == SF_LOOP_NONE)
  722. { psf->instrument->loop_count = 0 ;
  723. psf->instrument->loops [0].mode = SF_LOOP_NONE ;
  724. }
  725. else
  726. { psf->instrument->loop_count = 1 ;
  727. psf->instrument->loops [0].mode = SF_LOOP_FORWARD ;
  728. psf->instrument->loops [0].start = begin ;
  729. psf->instrument->loops [0].end = end ;
  730. psf->instrument->loops [0].count = 0 ;
  731. } ;
  732. psf_log_printf (psf, "  Sustainn   mode  : %d => %sn   begin : %un   end   : %un",
  733. mode, loop_mode, begin, end) ;
  734. psf_binheader_readf (psf, "E222", &mode, &begin, &end) ;
  735. loop_mode = get_loop_mode_str (mode) ;
  736. mode = get_loop_mode (mode) ;
  737. if (mode == SF_LOOP_NONE)
  738. psf->instrument->loops [1].mode = SF_LOOP_NONE ;
  739. else
  740. { psf->instrument->loop_count += 1 ;
  741. psf->instrument->loops [1].mode = SF_LOOP_FORWARD ;
  742. psf->instrument->loops [1].start = begin ;
  743. psf->instrument->loops [1].end = end ;
  744. psf->instrument->loops [1].count = 0 ;
  745. } ;
  746. psf_log_printf (psf, "  Releasen   mode  : %d => %sn   begin : %un   end   : %un",
  747. mode, loop_mode, begin, end) ;
  748. } ;
  749. instr_found++ ;
  750. break ;
  752. case basc_MARKER :
  753. psf_binheader_readf (psf, "E4", &dword) ;
  754. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  755. psf_log_printf (psf, " basc : %un", dword) ;
  757. if ((error = aiff_read_basc_chunk (psf, dword)))
  758. return error ;
  759. break ;
  761. case MARK_MARKER :
  762. psf_binheader_readf (psf, "E4", &dword) ;
  763. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  764. psf_log_printf (psf, " %M : %dn", marker, dword) ;
  765. { unsigned short mark_id, n = 0 ;
  766. unsigned int position ;
  768. bytesread = psf_binheader_readf (psf, "E2", &n) ;
  769. mark_count = n ;
  770. psf_log_printf (psf, "  Count : %dn", mark_count) ;
  771. if (paiff->markstr != NULL)
  772. { psf_log_printf (psf, "*** Second MARK chunk found. Throwing away the first.n") ;
  773. free (paiff->markstr) ;
  774. } ;
  775. paiff->markstr = calloc (mark_count, sizeof (MARK_ID_POS)) ;
  776. if (paiff->markstr == NULL)
  777. return SFE_MALLOC_FAILED ;
  779. for (n = 0 ; n < mark_count && bytesread < dword ; n++)
  780. { unsigned int pstr_len ;
  781. unsigned char ch ;
  783. bytesread += psf_binheader_readf (psf, "E241", &mark_id, &position, &ch) ;
  784. psf_log_printf (psf, "   Mark ID  : %un   Position : %un", mark_id, position) ;
  786. pstr_len = (ch & 1) ? ch : ch + 1 ;
  788. if (pstr_len < sizeof (psf->u.scbuf) - 1)
  789. { bytesread += psf_binheader_readf (psf, "b", psf->u.scbuf, pstr_len) ;
  790. psf->u.scbuf [pstr_len] = 0 ;
  791. }
  792. else
  793. { unsigned int read_len = pstr_len - (sizeof (psf->u.scbuf) - 1) ;
  794. bytesread += psf_binheader_readf (psf, "bj", psf->u.scbuf, read_len, pstr_len - read_len) ;
  795. psf->u.scbuf [sizeof (psf->u.scbuf) - 1] = 0 ;
  796. }
  798. psf_log_printf (psf, "   Name     : %sn", psf->u.scbuf) ;
  800. paiff->markstr [n].markerID = mark_id ;
  801. paiff->markstr [n].position = position ;
  802. /*
  803. ** TODO if psf->u.scbuf is equal to
  804. ** either Beg_loop, Beg loop or beg loop and spam
  805. ** if (psf->instrument == NULL && (psf->instrument = psf_instrument_alloc ()) == NULL)
  806. ** return SFE_MALLOC_FAILED ;
  807. */
  808. } ;
  809. } ;
  810. mark_found++ ;
  811. psf_binheader_readf (psf, "j", dword - bytesread) ;
  812. break ;
  814. case FVER_MARKER :
  815. found_chunk |= HAVE_FVER ;
  816. /* Fall through to next case. */
  818. case SFX_MARKER :
  819. psf_binheader_readf (psf, "E4", &dword) ;
  820. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  821. psf_log_printf (psf, " %M : %dn", marker, dword) ;
  823. psf_binheader_readf (psf, "j", dword) ;
  824. break ;
  826. case NONE_MARKER :
  827. /* Fix for broken AIFC files with incorrect COMM chunk length. */
  828. { unsigned char byte ;
  829. psf_binheader_readf (psf, "1", &byte) ;
  830. dword = byte ;
  831. psf_binheader_readf (psf, "j", dword) ;
  832. }
  833. break ;
  835. case CHAN_MARKER :
  836. psf_binheader_readf (psf, "E4", &dword) ;
  837. pchk4_store (&paiff->chunk4, marker, psf_ftell (psf) - 8, dword) ;
  839. if (dword < 12)
  840. { psf_log_printf (psf, " %M : %d (should be >= 12)n", marker, dword) ;
  841. psf_binheader_readf (psf, "j", dword) ;
  842. break ;
  843. }
  845. psf_log_printf (psf, " %M : %dn", marker, dword) ;
  847. if ((error = aiff_read_chanmap (psf, dword)))
  848. return error ;
  849. break ;
  851. default :
  852. if (psf_isprint ((marker >> 24) & 0xFF) && psf_isprint ((marker >> 16) & 0xFF)
  853. && psf_isprint ((marker >> 8) & 0xFF) && psf_isprint (marker & 0xFF))
  854. { psf_binheader_readf (psf, "E4", &dword) ;
  855. psf_log_printf (psf, " %M : %d (unknown marker)n", marker, dword) ;
  857. psf_binheader_readf (psf, "j", dword) ;
  858. break ;
  859. } ;
  860. if ((dword = psf_ftell (psf)) & 0x03)
  861. { psf_log_printf (psf, "  Unknown chunk marker %X at position %d. Resyncing.n", marker, dword - 4) ;
  863. psf_binheader_readf (psf, "j", -3) ;
  864. break ;
  865. } ;
  866. psf_log_printf (psf, "*** Unknown chunk marker %X at position %D. Exiting parser.n", marker, psf_ftell (psf)) ;
  867. done = 1 ;
  868. break ;
  869. } ; /* switch (marker) */
  871. if ((! psf->sf.seekable) && (found_chunk & HAVE_SSND))
  872. break ;
  874. if (psf_ftell (psf) >= psf->filelength - (2 * SIGNED_SIZEOF (dword)))
  875. break ;
  876. } ; /* while (1) */
  878. if (instr_found && mark_found)
  879. { int j ;
  881. for (j = 0 ; j<psf->instrument->loop_count ; j ++)
  882. { if (j < ARRAY_LEN (psf->instrument->loops))
  883. { psf->instrument->loops [j].start = marker_to_position (paiff->markstr, psf->instrument->loops [j].start, mark_count) ;
  884. psf->instrument->loops [j].end = marker_to_position (paiff->markstr, psf->instrument->loops [j].end, mark_count) ;
  885. psf->instrument->loops [j].mode = SF_LOOP_FORWARD ;
  886. } ;
  887.    } ;
  888. } ;
  890. if (! (found_chunk & HAVE_FORM))
  891. return SFE_AIFF_NO_FORM ;
  893. if (! (found_chunk & HAVE_AIFF))
  894. return SFE_AIFF_COMM_NO_FORM ;
  896. if (! (found_chunk & HAVE_COMM))
  897. return SFE_AIFF_SSND_NO_COMM ;
  899. if (! psf->dataoffset)
  900. return SFE_AIFF_NO_DATA ;
  902. return 0 ;
  903. } /* aiff_read_header */
  905. static int
  906. aiff_close (SF_PRIVATE *psf)
  907. { AIFF_PRIVATE *paiff = psf->container_data ;
  909. if (paiff != NULL && paiff->markstr != NULL)
  910. { free (paiff->markstr) ;
  911. paiff->markstr = NULL ;
  912. } ;
  914. if (psf->file.mode == SFM_WRITE || psf->file.mode == SFM_RDWR)
  915. { aiff_write_tailer (psf) ;
  916. aiff_write_header (psf, SF_TRUE) ;
  917. } ;
  919. return 0 ;
  920. } /* aiff_close */
  922. static int
  923. aiff_read_comm_chunk (SF_PRIVATE *psf, COMM_CHUNK *comm_fmt)
  924. { int error = 0, bytesread, subformat ;
  926. psf->u.scbuf [0] = 0 ;
  928. bytesread = psf_binheader_readf (psf, "E4", &(comm_fmt->size)) ;
  930. /* The COMM chunk has an int aligned to an odd word boundary. Some
  931. ** procesors are not able to deal with this (ie bus fault) so we have
  932. ** to take special care.
  933. */
  934. comm_fmt->size += comm_fmt->size & 1 ;
  936. bytesread +=
  937. psf_binheader_readf (psf, "E242b", &(comm_fmt->numChannels), &(comm_fmt->numSampleFrames),
  938. &(comm_fmt->sampleSize), &(comm_fmt->sampleRate), SIGNED_SIZEOF (comm_fmt->sampleRate)) ;
  940. if (comm_fmt->size > 0x10000 && (comm_fmt->size & 0xffff) == 0)
  941. { psf_log_printf (psf, " COMM : %d (0x%x) *** should be ", comm_fmt->size, comm_fmt->size) ;
  942. comm_fmt->size = ENDSWAP_INT (comm_fmt->size) ;
  943. psf_log_printf (psf, "%d (0x%x)n", comm_fmt->size, comm_fmt->size) ;
  944. }
  945. else
  946. psf_log_printf (psf, " COMM : %dn", comm_fmt->size) ;
  948. if (comm_fmt->size == SIZEOF_AIFF_COMM)
  949. comm_fmt->encoding = NONE_MARKER ;
  950. else if (comm_fmt->size == SIZEOF_AIFC_COMM_MIN)
  951. bytesread += psf_binheader_readf (psf, "Em", &(comm_fmt->encoding)) ;
  952. else if (comm_fmt->size >= SIZEOF_AIFC_COMM)
  953. { unsigned char encoding_len ;
  954. unsigned read_len ;
  956. bytesread += psf_binheader_readf (psf, "Em1", &(comm_fmt->encoding), &encoding_len) ;
  958. comm_fmt->size = SF_MIN (sizeof (psf->u.scbuf), make_size_t (comm_fmt->size)) ;
  959. memset (psf->u.scbuf, 0, comm_fmt->size) ;
  960. read_len = comm_fmt->size - SIZEOF_AIFC_COMM + 1 ;
  961. bytesread += psf_binheader_readf (psf, "b", psf->u.scbuf, read_len) ;
  962. psf->u.scbuf [read_len + 1] = 0 ;
  963. } ;
  965. psf_log_printf (psf, "  Sample Rate : %dn", tenbytefloat2int (comm_fmt->sampleRate)) ;
  966. psf_log_printf (psf, "  Frames      : %u%sn", comm_fmt->numSampleFrames, (comm_fmt->numSampleFrames == 0 && psf->filelength > 104) ? " (Should not be 0)" : "") ;
  967. psf_log_printf (psf, "  Channels    : %dn", comm_fmt->numChannels) ;
  969. /* Found some broken 'fl32' files with comm.samplesize == 16. Fix it here. */
  970. if ((comm_fmt->encoding == fl32_MARKER || comm_fmt->encoding == FL32_MARKER) && comm_fmt->sampleSize != 32)
  971. { psf_log_printf (psf, "  Sample Size : %d (should be 32)n", comm_fmt->sampleSize) ;
  972. comm_fmt->sampleSize = 32 ;
  973. }
  974. else if ((comm_fmt->encoding == fl64_MARKER || comm_fmt->encoding == FL64_MARKER) && comm_fmt->sampleSize != 64)
  975. { psf_log_printf (psf, "  Sample Size : %d (should be 64)n", comm_fmt->sampleSize) ;
  976. comm_fmt->sampleSize = 64 ;
  977. }
  978. else
  979. psf_log_printf (psf, "  Sample Size : %dn", comm_fmt->sampleSize) ;
  981. subformat = s_bitwidth_to_subformat (comm_fmt->sampleSize) ;
  983. psf->endian = SF_ENDIAN_BIG ;
  985. switch (comm_fmt->encoding)
  986. { case NONE_MARKER :
  987. psf->sf.format = (SF_FORMAT_AIFF | subformat) ;
  988. break ;
  990. case twos_MARKER :
  991. case in24_MARKER :
  992. case in32_MARKER :
  993. psf->sf.format = (SF_ENDIAN_BIG | SF_FORMAT_AIFF | subformat) ;
  994. break ;
  996. case sowt_MARKER :
  997. case ni24_MARKER :
  998. case ni32_MARKER :
  999. psf->endian = SF_ENDIAN_LITTLE ;
  1000. psf->sf.format = (SF_ENDIAN_LITTLE | SF_FORMAT_AIFF | subformat) ;
  1001. break ;
  1003. case fl32_MARKER :
  1004. case FL32_MARKER :
  1005. psf->sf.format = (SF_FORMAT_AIFF | SF_FORMAT_FLOAT) ;
  1006. break ;
  1008. case ulaw_MARKER :
  1009. case ULAW_MARKER :
  1010. psf->sf.format = (SF_FORMAT_AIFF | SF_FORMAT_ULAW) ;
  1011. break ;
  1013. case alaw_MARKER :
  1014. case ALAW_MARKER :
  1015. psf->sf.format = (SF_FORMAT_AIFF | SF_FORMAT_ALAW) ;
  1016. break ;
  1018. case fl64_MARKER :
  1019. case FL64_MARKER :
  1020. psf->sf.format = (SF_FORMAT_AIFF | SF_FORMAT_DOUBLE) ;
  1021. break ;
  1023. case raw_MARKER :
  1024. psf->sf.format = (SF_FORMAT_AIFF | SF_FORMAT_PCM_U8) ;
  1025. break ;
  1027. case DWVW_MARKER :
  1028. psf->sf.format = SF_FORMAT_AIFF ;
  1029. switch (comm_fmt->sampleSize)
  1030. { case 12 :
  1031. psf->sf.format |= SF_FORMAT_DWVW_12 ;
  1032. break ;
  1033. case 16 :
  1034. psf->sf.format |= SF_FORMAT_DWVW_16 ;
  1035. break ;
  1036. case 24 :
  1037. psf->sf.format |= SF_FORMAT_DWVW_24 ;
  1038. break ;
  1040. default :
  1041. psf->sf.format |= SF_FORMAT_DWVW_N ;
  1042. break ;
  1043. } ;
  1044. break ;
  1046. case GSM_MARKER :
  1047. psf->sf.format = SF_FORMAT_AIFF ;
  1048. psf->sf.format = (SF_FORMAT_AIFF | SF_FORMAT_GSM610) ;
  1049. break ;
  1052. case ima4_MARKER :
  1053. psf->endian = SF_ENDIAN_BIG ;
  1054. psf->sf.format = (SF_FORMAT_AIFF | SF_FORMAT_IMA_ADPCM) ;
  1055. break ;
  1057. default :
  1058. psf_log_printf (psf, "AIFC : Unimplemented format : %Mn", comm_fmt->encoding) ;
  1059. error = SFE_UNIMPLEMENTED ;
  1060. } ;
  1062. if (! psf->u.scbuf [0])
  1063. psf_log_printf (psf, "  Encoding    : %Mn", comm_fmt->encoding) ;
  1064. else
  1065. psf_log_printf (psf, "  Encoding    : %M => %sn", comm_fmt->encoding, psf->u.scbuf) ;
  1067. return error ;
  1068. } /* aiff_read_comm_chunk */
  1071. /*==========================================================================================
  1072. */
  1074. static int
  1075. aiff_rewrite_header (SF_PRIVATE *psf, AIFF_PRIVATE * paiff)
  1076. {
  1077. /* Assuming here that the header has already been written and just
  1078. ** needs to be corrected for new data length. That means that we
  1079. ** only change the length fields of the FORM and SSND chunks ;
  1080. ** everything else can be skipped over.
  1081. */
  1082. int k, ch ;
  1083. int comm_size, comm_frames ;
  1085. psf_fseek (psf, 0, SEEK_SET) ;
  1086. psf_fread (psf->header, psf->dataoffset, 1, psf) ;
  1088. psf->headindex = 0 ;
  1090. for (k = 0 ; k < paiff->chunk4.count ; k++)
  1091. { switch (paiff->chunk4.l [k].chunk)
  1092. { case FORM_MARKER :
  1093. psf_binheader_writef (psf, "Etm8", FORM_MARKER, psf->filelength - 8) ;
  1094. break ;
  1096. case COMM_MARKER :
  1097. psf->headindex = paiff->chunk4.l [k].offset ;
  1098. comm_frames = psf->sf.frames ;
  1099. comm_size = paiff->chunk4.l [k].len ;
  1100. psf_binheader_writef (psf, "Em42t4", COMM_MARKER, comm_size, psf->sf.channels, comm_frames) ;
  1101. break ;
  1103. case SSND_MARKER :
  1104. psf->headindex = paiff->chunk4.l [k].offset ;
  1105. psf_binheader_writef (psf, "Etm8", SSND_MARKER, psf->datalength + SIZEOF_SSND_CHUNK) ;
  1106. break ;
  1108. case PEAK_MARKER :
  1109. psf->headindex = paiff->chunk4.l [k].offset ;
  1110. psf_binheader_writef (psf, "Em4", PEAK_MARKER, AIFF_PEAK_CHUNK_SIZE (psf->sf.channels)) ;
  1111. psf_binheader_writef (psf, "E44", 1, time (NULL)) ;
  1112. for (ch = 0 ; ch < psf->sf.channels ; ch++)
  1113. psf_binheader_writef (psf, "Eft8", (float) psf->peak_info->peaks [ch].value, psf->peak_info->peaks [ch].position) ;
  1114. break ;
  1116. default :
  1117. /* There are a whole bunch of chunks we should just ignore. */
  1118. break ;
  1119. } ;
  1120. } ;
  1122. /* Header mangling complete so write it out. */
  1123. psf_fseek (psf, 0, SEEK_SET) ;
  1124. psf_fwrite (psf->header, psf->headindex, 1, psf) ;
  1126. return 0 ;
  1127. } /* aiff_rewrite_header */
  1129. static int
  1130. aiff_write_header (SF_PRIVATE *psf, int calc_length)
  1131. { sf_count_t current ;
  1132. AIFF_PRIVATE *paiff ;
  1133. unsigned char comm_sample_rate [10], comm_zero_bytes [2] = { 0, 0 } ;
  1134. unsigned int comm_type, comm_size, comm_encoding, comm_frames = 0 ;
  1135. int k, endian, has_data = SF_FALSE ;
  1136. short bit_width ;
  1138. if ((paiff = psf->container_data) == NULL)
  1139. return SFE_INTERNAL ;
  1141. current = psf_ftell (psf) ;
  1143. if (current > psf->dataoffset)
  1144. has_data = SF_TRUE ;
  1146. if (calc_length)
  1147. { psf->filelength = psf_get_filelen (psf) ;
  1149. psf->datalength = psf->filelength - psf->dataoffset ;
  1150. if (psf->dataend)
  1151. psf->datalength -= psf->filelength - psf->dataend ;
  1153. if (psf->bytewidth > 0)
  1154. psf->sf.frames = psf->datalength / (psf->bytewidth * psf->sf.channels) ;
  1155. } ;
  1157. if (psf->file.mode == SFM_RDWR && psf->dataoffset > 0 && paiff->chunk4.count > 0)
  1158. { int err = aiff_rewrite_header (psf, paiff) ;
  1159. if (current > 0)
  1160. psf_fseek (psf, current, SEEK_SET) ;
  1161. return err ;
  1162. } ;
  1164. endian = SF_ENDIAN (psf->sf.format) ;
  1165. if (CPU_IS_LITTLE_ENDIAN && endian == SF_ENDIAN_CPU)
  1166. endian = SF_ENDIAN_LITTLE ;
  1168. /* Standard value here. */
  1169. bit_width = psf->bytewidth * 8 ;
  1170. comm_frames = (psf->sf.frames > 0xFFFFFFFF) ? 0xFFFFFFFF : psf->sf.frames ;
  1172. switch (SF_CODEC (psf->sf.format))
  1173. { case SF_FORMAT_PCM_S8 :
  1174. case SF_FORMAT_PCM_16 :
  1175. case SF_FORMAT_PCM_24 :
  1176. case SF_FORMAT_PCM_32 :
  1177. switch (endian)
  1178. { case SF_ENDIAN_BIG :
  1179. psf->endian = SF_ENDIAN_BIG ;
  1180. comm_type = AIFC_MARKER ;
  1181. comm_size = SIZEOF_AIFC_COMM ;
  1182. comm_encoding = twos_MARKER ;
  1183. break ;
  1185. case SF_ENDIAN_LITTLE :
  1186. psf->endian = SF_ENDIAN_LITTLE ;
  1187. comm_type = AIFC_MARKER ;
  1188. comm_size = SIZEOF_AIFC_COMM ;
  1189. comm_encoding = sowt_MARKER ;
  1190. break ;
  1192. default : /* SF_ENDIAN_FILE */
  1193. psf->endian = SF_ENDIAN_BIG ;
  1194. comm_type = AIFF_MARKER ;
  1195. comm_size = SIZEOF_AIFF_COMM ;
  1196. comm_encoding = 0 ;
  1197. break ;
  1198. } ;
  1199. break ;
  1201. case SF_FORMAT_FLOAT : /* Big endian floating point. */
  1202. psf->endian = SF_ENDIAN_BIG ;
  1203. comm_type = AIFC_MARKER ;
  1204. comm_size = SIZEOF_AIFC_COMM ;
  1205. comm_encoding = FL32_MARKER ; /* Use 'FL32' because its easier to read. */
  1206. break ;
  1208. case SF_FORMAT_DOUBLE : /* Big endian double precision floating point. */
  1209. psf->endian = SF_ENDIAN_BIG ;
  1210. comm_type = AIFC_MARKER ;
  1211. comm_size = SIZEOF_AIFC_COMM ;
  1212. comm_encoding = FL64_MARKER ; /* Use 'FL64' because its easier to read. */
  1213. break ;
  1215. case SF_FORMAT_ULAW :
  1216. psf->endian = SF_ENDIAN_BIG ;
  1217. comm_type = AIFC_MARKER ;
  1218. comm_size = SIZEOF_AIFC_COMM ;
  1219. comm_encoding = ulaw_MARKER ;
  1220. break ;
  1222. case SF_FORMAT_ALAW :
  1223. psf->endian = SF_ENDIAN_BIG ;
  1224. comm_type = AIFC_MARKER ;
  1225. comm_size = SIZEOF_AIFC_COMM ;
  1226. comm_encoding = alaw_MARKER ;
  1227. break ;
  1229. case SF_FORMAT_PCM_U8 :
  1230. psf->endian = SF_ENDIAN_BIG ;
  1231. comm_type = AIFC_MARKER ;
  1232. comm_size = SIZEOF_AIFC_COMM ;
  1233. comm_encoding = raw_MARKER ;
  1234. break ;
  1236. case SF_FORMAT_DWVW_12 :
  1237. psf->endian = SF_ENDIAN_BIG ;
  1238. comm_type = AIFC_MARKER ;
  1239. comm_size = SIZEOF_AIFC_COMM ;
  1240. comm_encoding = DWVW_MARKER ;
  1242. /* Override standard value here.*/
  1243. bit_width = 12 ;
  1244. break ;
  1246. case SF_FORMAT_DWVW_16 :
  1247. psf->endian = SF_ENDIAN_BIG ;
  1248. comm_type = AIFC_MARKER ;
  1249. comm_size = SIZEOF_AIFC_COMM ;
  1250. comm_encoding = DWVW_MARKER ;
  1252. /* Override standard value here.*/
  1253. bit_width = 16 ;
  1254. break ;
  1256. case SF_FORMAT_DWVW_24 :
  1257. psf->endian = SF_ENDIAN_BIG ;
  1258. comm_type = AIFC_MARKER ;
  1259. comm_size = SIZEOF_AIFC_COMM ;
  1260. comm_encoding = DWVW_MARKER ;
  1262. /* Override standard value here.*/
  1263. bit_width = 24 ;
  1264. break ;
  1266. case SF_FORMAT_GSM610 :
  1267. psf->endian = SF_ENDIAN_BIG ;
  1268. comm_type = AIFC_MARKER ;
  1269. comm_size = SIZEOF_AIFC_COMM ;
  1270. comm_encoding = GSM_MARKER ;
  1272. /* Override standard value here.*/
  1273. bit_width = 16 ;
  1274. break ;
  1276. case SF_FORMAT_IMA_ADPCM :
  1277. psf->endian = SF_ENDIAN_BIG ;
  1278. comm_type = AIFC_MARKER ;
  1279. comm_size = SIZEOF_AIFC_COMM ;
  1280. comm_encoding = ima4_MARKER ;
  1282. /* Override standard value here.*/
  1283. bit_width = 16 ;
  1284. comm_frames = psf->sf.frames / AIFC_IMA4_SAMPLES_PER_BLOCK ;
  1285. break ;
  1287. default : return SFE_BAD_OPEN_FORMAT ;
  1288. } ;
  1290. /* Reset the current header length to zero. */
  1291. psf->header [0] = 0 ;
  1292. psf->headindex = 0 ;
  1293. psf_fseek (psf, 0, SEEK_SET) ;
  1295. psf_binheader_writef (psf, "Etm8", FORM_MARKER, psf->filelength - 8) ;
  1297. /* Write AIFF/AIFC marker and COM chunk. */
  1298. if (comm_type == AIFC_MARKER)
  1299. /* AIFC must have an FVER chunk. */
  1300. psf_binheader_writef (psf, "Emm44", comm_type, FVER_MARKER, 4, 0xA2805140) ;
  1301. else
  1302. psf_binheader_writef (psf, "Em", comm_type) ;
  1304. paiff->comm_offset = psf->headindex - 8 ;
  1306. memset (comm_sample_rate, 0, sizeof (comm_sample_rate)) ;
  1307. uint2tenbytefloat (psf->sf.samplerate, comm_sample_rate) ;
  1309. psf_binheader_writef (psf, "Em42t42", COMM_MARKER, comm_size, psf->sf.channels, comm_frames, bit_width) ;
  1310. psf_binheader_writef (psf, "b", comm_sample_rate, sizeof (comm_sample_rate)) ;
  1312. /* AIFC chunks have some extra data. */
  1313. if (comm_type == AIFC_MARKER)
  1314. psf_binheader_writef (psf, "mb", comm_encoding, comm_zero_bytes, sizeof (comm_zero_bytes)) ;
  1316. if (psf->channel_map && paiff->chanmap_tag)
  1317. psf_binheader_writef (psf, "Em4444", CHAN_MARKER, 12, paiff->chanmap_tag, 0, 0) ;
  1319. if (psf->instrument != NULL)
  1320. { MARK_ID_POS m [4] ;
  1321. INST_CHUNK ch ;
  1322. unsigned short ct = 0 ;
  1324. memset (m, 0, sizeof (m)) ;
  1325. memset (&ch, 0, sizeof (ch)) ;
  1327. ch.baseNote = psf->instrument->basenote ;
  1328. ch.detune = psf->instrument->detune ;
  1329. ch.lowNote = psf->instrument->key_lo ;
  1330. ch.highNote = psf->instrument->key_hi ;
  1331. ch.lowVelocity = psf->instrument->velocity_lo ;
  1332. ch.highVelocity = psf->instrument->velocity_hi ;
  1333. ch.gain = psf->instrument->gain ;
  1334. if (psf->instrument->loops [0].mode != SF_LOOP_NONE)
  1335. { ch.sustain_loop.playMode = 1 ;
  1336. ch.sustain_loop.beginLoop = ct ;
  1337. m [0].markerID = ct++ ;
  1338. m [0].position = psf->instrument->loops [0].start ;
  1339. ch.sustain_loop.endLoop = ct ;
  1340. m [1].markerID = ct++ ;
  1341. m [1].position = psf->instrument->loops [0].end ;
  1342. } ;
  1343. if (psf->instrument->loops [1].mode != SF_LOOP_NONE)
  1344. { ch.release_loop.playMode = 1 ;
  1345. ch.release_loop.beginLoop = ct ;
  1346. m [2].markerID = ct++ ;
  1347. m [2].position = psf->instrument->loops [1].start ;
  1348. ch.release_loop.endLoop = ct ;
  1349. m [3].markerID = ct++ ;
  1350. m [3].position = psf->instrument->loops [1].end ;
  1351. }
  1352. else
  1353. { ch.release_loop.playMode = 0 ;
  1354. ch.release_loop.beginLoop = 0 ;
  1355. ch.release_loop.endLoop = 0 ;
  1356. } ;
  1358. psf_binheader_writef (psf, "Em4111111", INST_MARKER, SIZEOF_INST_CHUNK, ch.baseNote, ch.detune,
  1359. ch.lowNote, ch.highNote, ch.lowVelocity, ch.highVelocity) ;
  1360. psf_binheader_writef (psf, "2222222", ch.gain, ch.sustain_loop.playMode,
  1361. ch.sustain_loop.beginLoop, ch.sustain_loop.endLoop, ch.release_loop.playMode,
  1362. ch.release_loop.beginLoop, ch.release_loop.endLoop) ;
  1364. if (ct == 2)
  1365. psf_binheader_writef (psf, "Em42241b241b",
  1366. MARK_MARKER, 2 + 2 * (2 + 4 + 1 + 9), 2,
  1367. m [0].markerID, m [0].position, 8, "beg loop", make_size_t (9),
  1368. m [1].markerID, m [1].position, 8, "end loop", make_size_t (9)) ;
  1369. else if (ct == 4)
  1370. psf_binheader_writef (psf, "Em42 241b 241b 241b 241b",
  1371. MARK_MARKER, 2 + 4 * (2 + 4 + 1 + 9), 4,
  1372. m [0].markerID, m [0].position, 8, "beg loop", make_size_t (9),
  1373. m [1].markerID, m [1].position, 8, "end loop", make_size_t (9),
  1374. m [2].markerID, m [2].position, 8, "beg loop", make_size_t (9),
  1375. m [3].markerID, m [3].position, 8, "end loop", make_size_t (9)) ;
  1376. } ;
  1378. if (psf->str_flags & SF_STR_LOCATE_START)
  1379. aiff_write_strings (psf, SF_STR_LOCATE_START) ;
  1381. if (psf->peak_info != NULL && psf->peak_info->peak_loc == SF_PEAK_START)
  1382. { psf_binheader_writef (psf, "Em4", PEAK_MARKER, AIFF_PEAK_CHUNK_SIZE (psf->sf.channels)) ;
  1383. psf_binheader_writef (psf, "E44", 1, time (NULL)) ;
  1384. for (k = 0 ; k < psf->sf.channels ; k++)
  1385. psf_binheader_writef (psf, "Eft8", (float) psf->peak_info->peaks [k].value, psf->peak_info->peaks [k].position) ;
  1386. } ;
  1388. /* Write SSND chunk. */
  1389. paiff->ssnd_offset = psf->headindex ;
  1390. psf_binheader_writef (psf, "Etm844", SSND_MARKER, psf->datalength + SIZEOF_SSND_CHUNK, 0, 0) ;
  1392. /* Header construction complete so write it out. */
  1393. psf_fwrite (psf->header, psf->headindex, 1, psf) ;
  1395. if (psf->error)
  1396. return psf->error ;
  1398. if (has_data && psf->dataoffset != psf->headindex)
  1399. return psf->error = SFE_INTERNAL ;
  1401. psf->dataoffset = psf->headindex ;
  1403. if (! has_data)
  1404. psf_fseek (psf, psf->dataoffset, SEEK_SET) ;
  1405. else if (current > 0)
  1406. psf_fseek (psf, current, SEEK_SET) ;
  1408. return psf->error ;
  1409. } /* aiff_write_header */
  1411. static int
  1412. aiff_write_tailer (SF_PRIVATE *psf)
  1413. { int k ;
  1415. /* Reset the current header length to zero. */
  1416. psf->header [0] = 0 ;
  1417. psf->headindex = 0 ;
  1419. psf->dataend = psf_fseek (psf, 0, SEEK_END) ;
  1421. /* Make sure tailer data starts at even byte offset. Pad if necessary. */
  1422. if (psf->dataend % 2 == 1)
  1423. { psf_fwrite (psf->header, 1, 1, psf) ;
  1424. psf->dataend ++ ;
  1425. } ;
  1427. if (psf->peak_info != NULL && psf->peak_info->peak_loc == SF_PEAK_END)
  1428. { psf_binheader_writef (psf, "Em4", PEAK_MARKER, AIFF_PEAK_CHUNK_SIZE (psf->sf.channels)) ;
  1429. psf_binheader_writef (psf, "E44", 1, time (NULL)) ;
  1430. for (k = 0 ; k < psf->sf.channels ; k++)
  1431. psf_binheader_writef (psf, "Eft8", (float) psf->peak_info->peaks [k].value, psf->peak_info->peaks [k].position) ;
  1432. } ;
  1434. if (psf->str_flags & SF_STR_LOCATE_END)
  1435. aiff_write_strings (psf, SF_STR_LOCATE_END) ;
  1437. /* Write the tailer. */
  1438. if (psf->headindex > 0)
  1439. psf_fwrite (psf->header, psf->headindex, 1, psf) ;
  1441. return 0 ;
  1442. } /* aiff_write_tailer */
  1444. static void
  1445. aiff_write_strings (SF_PRIVATE *psf, int location)
  1446. { int k, slen ;
  1448. for (k = 0 ; k < SF_MAX_STRINGS ; k++)
  1449. { if (psf->strings [k].type == 0)
  1450. break ;
  1452. if (psf->strings [k].flags != location)
  1453. continue ;
  1455. switch (psf->strings [k].type)
  1456. { case SF_STR_SOFTWARE :
  1457. slen = strlen (psf->strings [k].str) ;
  1458. psf_binheader_writef (psf, "Em4mb", APPL_MARKER, slen + 4, m3ga_MARKER, psf->strings [k].str, make_size_t (slen + (slen & 1))) ;
  1459. break ;
  1461. case SF_STR_TITLE :
  1462. psf_binheader_writef (psf, "EmS", NAME_MARKER, psf->strings [k].str) ;
  1463. break ;
  1465. case SF_STR_COPYRIGHT :
  1466. psf_binheader_writef (psf, "EmS", c_MARKER, psf->strings [k].str) ;
  1467. break ;
  1469. case SF_STR_ARTIST :
  1470. psf_binheader_writef (psf, "EmS", AUTH_MARKER, psf->strings [k].str) ;
  1471. break ;
  1473. case SF_STR_COMMENT :
  1474. psf_binheader_writef (psf, "EmS", ANNO_MARKER, psf->strings [k].str) ;
  1475. break ;
  1477. /*
  1478. case SF_STR_DATE :
  1479. psf_binheader_writef (psf, "Ems", ICRD_MARKER, psf->strings [k].str) ;
  1480. break ;
  1481. */
  1482. } ;
  1483. } ;
  1485. return ;
  1486. } /* aiff_write_strings */
  1488. static int
  1489. aiff_command (SF_PRIVATE * psf, int command, void * UNUSED (data), int UNUSED (datasize))
  1490. { AIFF_PRIVATE *paiff ;
  1492. if ((paiff = psf->container_data) == NULL)
  1493. return SFE_INTERNAL ;
  1495. switch (command)
  1496. { case SFC_SET_CHANNEL_MAP_INFO :
  1497. paiff->chanmap_tag = aiff_caf_find_channel_layout_tag (psf->channel_map, psf->sf.channels) ;
  1498. return (paiff->chanmap_tag != 0) ;
  1500. default :
  1501. break ;
  1502. } ;
  1506. return 0 ;
  1507. } /* aiff_command */
  1509. static const char*
  1510. get_loop_mode_str (short mode)
  1511. { switch (mode)
  1512. { case 0 : return "none" ;
  1513. case 1 : return "forward" ;
  1514. case 2 : return "backward" ;
  1515. } ;
  1517. return "*** unknown" ;
  1518. } /* get_loop_mode_str */
  1520. static short
  1521. get_loop_mode (short mode)
  1522. { switch (mode)
  1523. { case 0 : return SF_LOOP_NONE ;
  1524. case 1 : return SF_LOOP_FORWARD ;
  1525. case 2 : return SF_LOOP_BACKWARD ;
  1526. } ;
  1528. return SF_LOOP_NONE ;
  1529. } /* get_loop_mode */
  1531. /*==========================================================================================
  1532. ** Rough hack at converting from 80 bit IEEE float in AIFF header to an int and
  1533. ** back again. It assumes that all sample rates are between 1 and 800MHz, which
  1534. ** should be OK as other sound file formats use a 32 bit integer to store sample
  1535. ** rate.
  1536. ** There is another (probably better) version in the source code to the SoX but it
  1537. ** has a copyright which probably prevents it from being allowable as GPL/LGPL.
  1538. */
  1540. static int
  1541. tenbytefloat2int (unsigned char *bytes)
  1542. { int val = 3 ;
  1544. if (bytes [0] & 0x80) /* Negative number. */
  1545. return 0 ;
  1547. if (bytes [0] <= 0x3F) /* Less than 1. */
  1548. return 1 ;
  1550. if (bytes [0] > 0x40) /* Way too big. */
  1551. return 0x4000000 ;
  1553. if (bytes [0] == 0x40 && bytes [1] > 0x1C) /* Too big. */
  1554. return 800000000 ;
  1556. /* Ok, can handle it. */
  1558. val = (bytes [2] << 23) | (bytes [3] << 15) | (bytes [4] << 7) | (bytes [5] >> 1) ;
  1560. val >>= (29 - bytes [1]) ;
  1562. return val ;
  1563. } /* tenbytefloat2int */
  1565. static void
  1566. uint2tenbytefloat (unsigned int num, unsigned char *bytes)
  1567. { unsigned int mask = 0x40000000 ;
  1568. int count ;
  1570. if (num <= 1)
  1571. { bytes [0] = 0x3F ;
  1572. bytes [1] = 0xFF ;
  1573. bytes [2] = 0x80 ;
  1574. return ;
  1575. } ;
  1577. bytes [0] = 0x40 ;
  1579. if (num >= mask)
  1580. { bytes [1] = 0x1D ;
  1581. return ;
  1582. } ;
  1584. for (count = 0 ; count <= 32 ; count ++)
  1585. { if (num & mask)
  1586. break ;
  1587. mask >>= 1 ;
  1588. } ;
  1590. num <<= count + 1 ;
  1591. bytes [1] = 29 - count ;
  1592. bytes [2] = (num >> 24) & 0xFF ;
  1593. bytes [3] = (num >> 16) & 0xFF ;
  1594. bytes [4] = (num >> 8) & 0xFF ;
  1595. bytes [5] = num & 0xFF ;
  1597. } /* uint2tenbytefloat */
  1599. static int
  1600. aiff_read_basc_chunk (SF_PRIVATE * psf, int datasize)
  1601. { const char * type_str ;
  1602. basc_CHUNK bc ;
  1603. int count ;
  1605. count = psf_binheader_readf (psf, "E442", &bc.version, &bc.numBeats, &bc.rootNote) ;
  1606. count += psf_binheader_readf (psf, "E222", &bc.scaleType, &bc.sigNumerator, &bc.sigDenominator) ;
  1607. count += psf_binheader_readf (psf, "E2j", &bc.loopType, datasize - sizeof (bc)) ;
  1609. psf_log_printf (psf, "  Version ? : %un  Num Beats : %un  Root Note : 0x%xn",
  1610. bc.version, bc.numBeats, bc.rootNote) ;
  1612. switch (bc.scaleType)
  1613. { case basc_SCALE_MINOR :
  1614. type_str = "MINOR" ;
  1615. break ;
  1616. case basc_SCALE_MAJOR :
  1617. type_str = "MAJOR" ;
  1618. break ;
  1619. case basc_SCALE_NEITHER :
  1620. type_str = "NEITHER" ;
  1621. break ;
  1622. case basc_SCALE_BOTH :
  1623. type_str = "BOTH" ;
  1624. break ;
  1625. default :
  1626. type_str = "!!WRONG!!" ;
  1627. break ;
  1628. } ;
  1630. psf_log_printf (psf, "  ScaleType : 0x%x (%s)n", bc.scaleType, type_str) ;
  1631. psf_log_printf (psf, "  Time Sig  : %d/%dn", bc.sigNumerator, bc.sigDenominator) ;
  1633. switch (bc.loopType)
  1634. { case basc_TYPE_ONE_SHOT :
  1635. type_str = "One Shot" ;
  1636. break ;
  1637. case basc_TYPE_LOOP :
  1638. type_str = "Loop" ;
  1639. break ;
  1640. default:
  1641. type_str = "!!WRONG!!" ;
  1642. break ;
  1643. } ;
  1645. psf_log_printf (psf, "  Loop Type : 0x%x (%s)n", bc.loopType, type_str) ;
  1647. if ((psf->loop_info = calloc (1, sizeof (SF_LOOP_INFO))) == NULL)
  1648. return SFE_MALLOC_FAILED ;
  1650. psf->loop_info->time_sig_num = bc.sigNumerator ;
  1651. psf->loop_info->time_sig_den = bc.sigDenominator ;
  1652. psf->loop_info->loop_mode = (bc.loopType == basc_TYPE_ONE_SHOT) ? SF_LOOP_NONE : SF_LOOP_FORWARD ;
  1653. psf->loop_info->num_beats = bc.numBeats ;
  1655. /* Can always be recalculated from other known fields. */
  1656. psf->loop_info->bpm = (1.0 / psf->sf.frames) * psf->sf.samplerate
  1657. * ((bc.numBeats * 4.0) / bc.sigDenominator) * 60.0 ;
  1658. psf->loop_info->root_key = bc.rootNote ;
  1660. if (count < datasize)
  1661. psf_binheader_readf (psf, "j", datasize - count) ;
  1663. return 0 ;
  1664. } /* aiff_read_basc_chunk */
  1667. static int
  1668. aiff_read_chanmap (SF_PRIVATE * psf, unsigned dword)
  1669. { const AIFF_CAF_CHANNEL_MAP * map_info ;
  1670. unsigned channel_bitmap, channel_decriptions, bytesread ;
  1671. int layout_tag ;
  1673. bytesread = psf_binheader_readf (psf, "444", &layout_tag, &channel_bitmap, &channel_decriptions) ;
  1675. map_info = aiff_caf_of_channel_layout_tag (layout_tag) ;
  1677. psf_log_printf (psf, "  Tag    : %xn", layout_tag) ;
  1678. if (map_info)
  1679. psf_log_printf (psf, "  Layout : %sn", map_info->name) ;
  1681. if (bytesread < dword)
  1682. psf_binheader_readf (psf, "j", dword - bytesread) ;
  1684. if (map_info->channel_map != NULL)
  1685. { size_t chanmap_size = psf->sf.channels * sizeof (psf->channel_map [0]) ;
  1687. free (psf->channel_map) ;
  1689. if ((psf->channel_map = malloc (chanmap_size)) == NULL)
  1690. return SFE_MALLOC_FAILED ;
  1692. memcpy (psf->channel_map, map_info->channel_map, chanmap_size) ;
  1693. } ;
  1695. return 0 ;
  1696. } /* aiff_read_chanmap */