PageRenderTime 59ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/sf/tags/RELEASE_0_1_1/src/sndlib/headers.c

#
C | 1622 lines | 1185 code | 78 blank | 359 comment | 294 complexity | 4a9d04c3a2ccb7a170b31d62775e2807 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.0 
    

  1. /* readers/writers for various sound file headers
    2. 

  2.  *
    3. 

  3.  * TODO: avi, asf, and soundfont code seriously incomplete
    4. 

  4.  *       avr doesn't match actual files
    5. 

  5.  *       quicktime is just a guess
    6. 

  6.  *       esignal not tackled yet
    7. 

  7.  *       check resource info on Mac (for SoundEdit)
    8. 

  8.  *
    9. 

  9.  * --------------------------------
    10. 

  10.  * int c_read_header (char *name): reads file's header
    11. 

  11.  * int c_write_header (char *name, int type, int in_srate, int in_chans, int loc, int size, int format, char *comment, int len): writes file's header
    12. 

  12.  * int c_update_header (char *name, int type, int size, int srate, int format, int chans, int loc): update file's header (unset fields should be 0)
    13. 

  13.  * void create_header_buffer (void): initialize (allocate) various buffers -- should be called before using c_read_header and others
    14. 

  14.  *
    15. 

  15.  *   Once c_read_header has been called, the data in it can be accessed through:
    16. 

  16.  *
    17. 

  17.  *        int c_snd_header_data_size (void):           samples 
    18. 

  18.  *        int c_snd_header_data_location (void)        location of data (bytes)
    19. 

  19.  *        int c_snd_header_chans (void)                channels
    20. 

  20.  *        int c_snd_header_srate (void)                srate
    21. 

  21.  *        int c_snd_header_type (void)                 header type (i.e. aiff, wave, etc)  (see sndlib.h)
    22. 

  22.  *        int c_snd_header_format (void)               data format (see sndlib.h)
    23. 

  23.  *        int c_snd_header_distributed (void)          true if header info is scattered around in the file
    24. 

  24.  *        int c_snd_header_comment_start (void)        comment start location (if any) (bytes)
    25. 

  25.  *        int c_snd_header_comment_end (void)          comment end location
    26. 

  26.  *        int c_snd_header_aux_comment_start (int n)   if multiple comments, nth start location
    27. 

  27.  *        int c_snd_header_aux_comment_end (int n)     if multiple comments, nth end location
    28. 

  28.  *        int c_snd_header_type_specifier (void)       original (header-specific) type ID
    29. 

  29.  *        int c_snd_header_bits_per_sample (void)      sample width in bits
    30. 

  30.  *        int c_true_file_length (void)                true (lseek) file length
    31. 

  31.  *        int c_snd_header_datum_size (void)           sample width in bytes
    32. 

  32.  * --------------------------------
    33. 

  33.  *
    34. 

  34.  *   "Linear" below means 2's complement integer.
    35. 

  35.  *
    36. 

  36.  * Currently supported read/write (in standard data formats):                         
    37. 

  37.  *      NeXT/Sun/DEC/AFsp
    38. 

  38.  *      AIFF/AIFC
    39. 

  39.  *      RIFF (microsoft wave)
    40. 

  40.  *      IRCAM (old style)
    41. 

  41.  *      no header
    42. 

  42.  *
    43. 

  43.  * Currently supported read-only (in selected data formats):
    44. 

  44.  *      8SVX (IFF), IRCAM Vax float, EBICSF, INRS, ESPS, SPPACK, ADC (OGI), NIST-SPHERE, AVR, VOC,
    45. 

  45.  *      Sound Tools, Turtle Beach SMP, SoundFont 2.0, Sound Designer I and II, PSION alaw, MAUD, 
    46. 

  46.  *      Tandy DeskMate new and old style, Gravis Ultrasound, Comdisco SPW, Goldwave sample, OMF,
    47. 

  47.  *      Sonic Foundry, SBStudio II, Delusion digital, Digiplayer ST3, Farandole Composer WaveSample,
    48. 

  48.  *      Ultratracker WaveSample, Sample Dump exchange, Yamaha SY85 and SY99 (buggy), Yamaha TX16, 
    49. 

  49.  *      Covox v8, SPL, AVI, Kurzweil 2000
    50. 

  50.  *
    51. 

  51.  * for a few of these I'm still trying to get documentation -- best sources of info
    52. 

  52.  * are ftp.cwi.nl:pub/audio (info files), the AFsp sources, and the SOX sources.
    53. 

  53.  * sox and gsm are at ftp.cwi.nl, AFsp is from kabal@Polaris.EE.McGill.CA (Peter Kabal) as
    54. 

  54.  * ftp.TSP.EE.McGill.CA:/pub/AFsp/AFsp-V3R2.tar.Z.  The Sound Designer formats are described
    55. 

  55.  * in the "Developer Documentation" from Digidesign.  Other useful sources can be found at
    56. 

  56.  * ftp.x.org:/contrib/audio/nas, svr-ftp.eng.cam.ac.uk:/comp.speech/tools, and
    57. 

  57.  * at http://www.wotsit.demon.co.uk/music.htm.  I put many of my test cases in 
    58. 

  58.  * ccrma-ftp.stanford.edu:/pub/Lisp/sf.tar.gz.  The RIFF format is described in the 
    59. 

  59.  * Microsoft Multimedia Programmer's Reference Manual at ftp.microsoft.com:/SoftLib/MSLFILES/MDRK.EXE.
    60. 

  60.  * AVI format is described in http://www.rahul.net/jfm/avi.html.
    61. 

  61.  *
    62. 

  62.  * The main problem with compressed sound files is that you can't do reliable
    63. 

  63.  * random access to the data, can't easily read backwards, and most of the compression
    64. 

  64.  * schemes are proprietary (and appalling), but to translate Mus10/Sam, HCOM, IEEE text, 
    65. 

  65.  * IBM CVSD, MIDI sample dumps, various adpcm cases, NIST shortpack files, and AVI see snd-trans.c 
    66. 

  66.  * in the sound editor (snd.tar.gz).
    67. 

  67.  *
    68. 

  68.  * If anyone has information on any other header or data formats, I would be most interested in it,
    69. 

  69.  * but only if it can be included in this file.
    70. 

  70.  */
    71. 

  71. 

  72. #if defined(HAVE_CONFIG_H)
    73. 

  73.   #include "config.h"
    74. 

  74. #endif
    75. 

  75. 

  76. #include <math.h>
    77. 

  77. #include <stdio.h>
    78. 

  78. #if (!defined(HAVE_CONFIG_H)) || (defined(HAVE_FCNTL_H))
    79. 

  79.   #include <fcntl.h>
    80. 

  80. #endif
    81. 

  81. #include <signal.h>
    82. 

  82. #if (!defined(HAVE_CONFIG_H)) || (defined(HAVE_LIMITS_H))
    83. 

  83.   #include <limits.h>
    84. 

  84. #endif
    85. 

  85. #include <errno.h>
    86. 

  86. #include <stdlib.h>
    87. 

  87. 

  88. #if (defined(NEXT) || (defined(HAVE_LIBC_H) && (!defined(HAVE_UNISTD_H))))
    89. 

  89.   #include <libc.h>
    90. 

  90. #else
    91. 

  91.   #include <unistd.h>
    92. 

  92.   #include <stdlib.h>
    93. 

  93.   #include <string.h>
    94. 

  94. #endif
    95. 

  95. 

  96. #include "sndlib.h"
    97. 

  97. 

  98. static int hdrbuf_is_inited = 0;
    99. 

  99. 

  100. #define HDRBUFSIZ 256
    101. 

  101. #ifndef MACOS
    102. 

  102.   static unsigned char *hdrbuf;
    103. 

  103. #else  
    104. 

  104.   static char *hdrbuf;
    105. 

  105. #endif
    106. 

  106. 

  107. #define INITIAL_READ_SIZE 32
    108. 

  108. 

  109. /* AIFF files can have any number of ANNO chunks, so we'll grab at least 4 of them */
    110. 

  110. /* if AUX_COMMENTS is changed, remember to change aux-comments in headers.lisp */
    111. 

  111. #define AUX_COMMENTS 4
    112. 

  112. static int *aux_comment_start = NULL, *aux_comment_end = NULL;
    113. 

  113. 

  114. #define LOOPS 2
    115. 

  115. static int *loop_modes = NULL,*loop_starts = NULL,*loop_ends = NULL;
    116. 

  116. static int markers = 0;
    117. 

  117. static int *marker_ids = NULL,*marker_positions = NULL;
    118. 

  118. 

  119. #ifdef MCL_PPC
    120. 

  120.   void reset_hdrbuf(void) {hdrbuf_is_inited = 0; markers = 0;}
    121. 

  121. #endif
    122. 

  122. 

  123. void create_header_buffer (void)
    124. 

  124. {
    125. 

  125.   if (hdrbuf_is_inited == 0)
    126. 

  126.     {
    127. 

  127.       hdrbuf_is_inited = 1;
    128. 

  128. #ifndef MACOS
    129. 

  129.       hdrbuf = (unsigned char *)CALLOC(HDRBUFSIZ,sizeof(unsigned char));
    130. 

  130. #else
    131. 

  131.       hdrbuf = (char *)CALLOC(HDRBUFSIZ,sizeof(unsigned char));
    132. 

  132. #endif
    133. 

  133.       aux_comment_start = (int *)CALLOC(AUX_COMMENTS,sizeof(int));
    134. 

  134.       aux_comment_end = (int *)CALLOC(AUX_COMMENTS,sizeof(int));
    135. 

  135.       if ((hdrbuf == NULL) || (aux_comment_start == NULL) || (aux_comment_end == NULL))
    136. 

  136. 	clm_printf("header buffer allocation trouble");
    137. 

  137.       loop_modes = (int *)CALLOC(LOOPS,sizeof(int));
    138. 

  138.       loop_starts = (int *)CALLOC(LOOPS,sizeof(int));
    139. 

  139.       loop_ends = (int *)CALLOC(LOOPS,sizeof(int));
    140. 

  140.     }
    141. 

  141. }
    142. 

  142. 

  143. static const unsigned char I_DSND[4] = {'.','s','n','d'};  /* NeXT/Sun/Dec/SGI/AFsp first word */
    144. 

  144. static const unsigned char I_FORM[4] = {'F','O','R','M'};  /* AIFF first word */
    145. 

  145. static const unsigned char I_AIFF[4] = {'A','I','F','F'};  /* AIFF second word */
    146. 

  146. static const unsigned char I_AIFC[4] = {'A','I','F','C'};  /* ditto but might be compressed data */
    147. 

  147. static const unsigned char I_COMM[4] = {'C','O','M','M'};
    148. 

  148. static const unsigned char I_COMT[4] = {'C','O','M','T'};
    149. 

  149. static const unsigned char I_INFO[4] = {'I','N','F','O'};
    150. 

  150. static const unsigned char I_INST[4] = {'I','N','S','T'};
    151. 

  151. static const unsigned char I_inst[4] = {'i','n','s','t'};  /* RIFF wants lower case, just to be different */
    152. 

  152. static const unsigned char I_MARK[4] = {'M','A','R','K'};
    153. 

  153. static const unsigned char I_SSND[4] = {'S','S','N','D'};
    154. 

  154. static const unsigned char I_FVER[4] = {'F','V','E','R'};
    155. 

  155. static const unsigned char I_NONE[4] = {'N','O','N','E'};
    156. 

  156. static const unsigned char I_ULAW[4] = {'U','L','A','W'};  /* AIFC compression types that we can handle */
    157. 

  157. static const unsigned char I_ulaw[4] = {'u','l','a','w'};  /* or maybe it's lowercase ... */
    158. 

  158. static const unsigned char I_ima4[4] = {'i','m','a','4'};  /* AIFC IMA adpcm apparently */
    159. 

  159. static const unsigned char I_ALAW[4] = {'A','L','A','W'};
    160. 

  160. static const unsigned char I_APPL[4] = {'A','P','P','L'};
    161. 

  161. static const unsigned char I_CLM_[4] = {'C','L','M',' '};  /* I hereby claim this AIFF chunk name */
    162. 

  162. static const unsigned char I_RIFF[4] = {'R','I','F','F'};  /* RIFF first word */
    163. 

  163. static const unsigned char I_RIFX[4] = {'R','I','F','X'};  /* RIFX first word (big-endian RIFF file) */
    164. 

  164. static const unsigned char I_WAVE[4] = {'W','A','V','E'};
    165. 

  165. static const unsigned char I_fmt_[4] = {'f','m','t',' '};
    166. 

  166. static const unsigned char I_data[4] = {'d','a','t','a'};
    167. 

  167. static const unsigned char I_fact[4] = {'f','a','c','t'};  /* used by compressed RIFF files */
    168. 

  168. static const unsigned char I_clm_[4] = {'c','l','m',' '};
    169. 

  169. static const unsigned char I_NIST[4] = {'N','I','S','T'};  /* first word of NIST SPHERE files */
    170. 

  170. static const unsigned char I_8SVX[4] = {'8','S','V','X'};  /* AIFF other choice */
    171. 

  171. static const unsigned char I_dcdt[4] = {'.','c','d','t'};  /* no-ffi CLM data file */
    172. 

  172. static const unsigned char I_VOC0[4] = {'C','r','e','a'};  /* Actual text is "Creative Voice File" */
    173. 

  173. static const unsigned char I_VOC1[4] = {'t','i','v','e'};
    174. 

  174. static const unsigned char I_SOUN[4] = {'S','O','U','N'};  /* Sound Tools first word="SOUND" -- not unique as SMP files start with "SOUND SAMPLE" */
    175. 

  175. static const unsigned char I_SMP1[4] = {'D',' ','S','A'};
    176. 

  176. static const unsigned char I_SMP2[4] = {'M','P','L','E'};
    177. 

  177. static const unsigned char I_BODY[4] = {'B','O','D','Y'};  /* next 4 for 8svx chunk names */
    178. 

  178. static const unsigned char I_VHDR[4] = {'V','H','D','R'};
    179. 

  179. static const unsigned char I_CHAN[4] = {'C','H','A','N'};
    180. 

  180. static const unsigned char I_ANNO[4] = {'A','N','N','O'};
    181. 

  181. static const unsigned char I_NAME[4] = {'N','A','M','E'};
    182. 

  182. static const unsigned char I_AVR_[4] = {'2','B','I','T'};  /* first word of AVR files */
    183. 

  183. static const unsigned char I_HCOM[4] = {'H','C','O','M'};
    184. 

  184. static const unsigned char I_FSSD[4] = {'F','S','S','D'};
    185. 

  185. static const unsigned char I_SPIB[4] = {'%','/','/','\n'}; /* first word of IEEE spib text sound files */
    186. 

  186. static const unsigned char I_S___[4] = {'%','-','-','-'};  /* first word of other IEEE spib text sound files */
    187. 

  187. static const unsigned char I_ALaw[4] = {'A','L','a','w'};  /* first word of PSION alaw files */
    188. 

  188. static const unsigned char I_Soun[4] = {'S','o','u','n'};  /* second */
    189. 

  189. static const unsigned char I_MAUD[4] = {'M','A','U','D'};  /* MAUD specialization of AIFF */
    190. 

  190. static const unsigned char I_MHDR[4] = {'M','H','D','R'};
    191. 

  191. static const unsigned char I_MDAT[4] = {'M','D','A','T'};
    192. 

  192. static const unsigned char I_mdat[4] = {'m','d','a','t'};  /* quicktime */
    193. 

  193. static const unsigned char I_AFsp[4] = {'A','F','s','p'};
    194. 

  194. static const unsigned char I_MThd[4] = {'M','T','h','d'};  /* sigh -- the M word */
    195. 

  195. static const unsigned char I_DVSM[4] = {'D','V','S','M'};  /* first word of DVSM files */
    196. 

  196. static const unsigned char I_DECN[4] = {'.','s','d','\0'}; /* first word of DEC files (?) */
    197. 

  197. static const unsigned char I_Esig[4] = {'E','s','i','g'};  /* first word of Esignal files */
    198. 

  198. static const unsigned char I_nalc[4] = {'n','a','l','\n'}; /* second word of Esignal files */
    199. 

  199. static const unsigned char I_sfbk[4] = {'s','f','b','k'};  /* SoundFont 2.0 */
    200. 

  200. static const unsigned char I_sdta[4] = {'s','d','t','a'};
    201. 

  201. static const unsigned char I_shdr[4] = {'s','h','d','r'};
    202. 

  202. static const unsigned char I_smpl[4] = {'s','m','p','l'};
    203. 

  203. static const unsigned char I_pdta[4] = {'p','d','t','a'};
    204. 

  204. static const unsigned char I_LIST[4] = {'L','I','S','T'};
    205. 

  205. static const unsigned char I_GF1P[4] = {'G','F','1','P'};  /* first word of Gravis Ultrsound patch files */
    206. 

  206. static const unsigned char I_ATCH[4] = {'A','T','C','H'};  /* second word */
    207. 

  207. static const unsigned char I_DSIG[4] = {'$','S','I','G'};  /* first word of Comdisco SPW file */
    208. 

  208. static const unsigned char I_NAL_[4] = {'N','A','L','_'};  /* second word */
    209. 

  209. static const unsigned char I_GOLD[4] = {'G','O','L','D'};  /* first word Goldwave(?) sample file */
    210. 

  210. static const unsigned char I__WAV[4] = {' ','S','A','M'};  /* second word */
    211. 

  211. static const unsigned char I_SRFS[4] = {'S','R','F','S'};  /* first word Sonic Resource Foundry file(?) */
    212. 

  212. static const unsigned char I_Diam[4] = {'D','i','a','m'};  /* first word DiamondWare file */
    213. 

  213. static const unsigned char I_ondW[4] = {'o','n','d','W'};  /* second word */
    214. 

  214. static const unsigned char I_Drat[4] = {'.','r','a','\xfd'};  /* first word real audio file */
    215. 

  215. static const unsigned char I_CSRE[4] = {'C','S','R','E'};  /* adf first word -- second starts with "40" */
    216. 

  216. static const unsigned char I_SND_[4] = {'S','N','D',' '};  /* SBStudio II */
    217. 

  217. static const unsigned char I_SNIN[4] = {'S','N','I','N'};
    218. 

  218. static const unsigned char I_SNDT[4] = {'S','N','D','T'};
    219. 

  219. static const unsigned char I_DDSF[4] = {'D','D','S','F'};  /* Delusion Digital Sound File */
    220. 

  220. static const unsigned char I_FSMt[4] = {'F','S','M','\376'};  /* Farandole Composer WaveSample */
    221. 

  221. static const unsigned char I_SDXc[4] = {'S','D','X',':'};  /* Sample dump exchange format */
    222. 

  222. static const unsigned char I_UWFD[4] = {'U','W','F','D'};  /* Ultratracker Wavesample */
    223. 

  223. static const unsigned char I_LM89[4] = {'L','M','8','9'};  /* Yamaha TX-16 */
    224. 

  224. static const unsigned char I_SY80[4] = {'S','Y','8','0'};  /* Yamaha SY-99 */
    225. 

  225. static const unsigned char I_SY85[4] = {'S','Y','8','5'};  /* Yamaha SY-85 */
    226. 

  226. static const unsigned char I_SCRS[4] = {'S','C','R','S'};  /* Digiplayer ST3 */
    227. 

  227. static const unsigned char I_covox[4] = {'\377','\125','\377','\252'};
    228. 

  228. static const unsigned char I_DSPL[4] = {'D','S','P','L'};  /* Digitracker SPL (now obsolete) */
    229. 

  229. static const unsigned char I_AVI_[4] = {'A','V','I',' '};  /* RIFF AVI */
    230. 

  230. static const unsigned char I_strf[4] = {'s','t','r','f'};  
    231. 

  231. static const unsigned char I_movi[4] = {'m','o','v','i'};  
    232. 

  232. static const unsigned char I_PRAM[4] = {'P','R','A','M'};  /* Kurzweil 2000 */
    233. 

  233. static const unsigned char I_ones[4] = {'\377','\377','\377','\377'};
    234. 

  234. static const unsigned char I_zeros[4] = {'\0','\0','\0','\0'};
    235. 

  235. static const unsigned char I_asf0[4] = {'\321','\051','\342','\326'};
    236. 

  236. static const unsigned char I_asf1[4] = {'\332','\065','\321','\021'};
    237. 

  237. static const unsigned char I_asf2[4] = {'\220','\064','\000','\240'};
    238. 

  238. static const unsigned char I_asf3[4] = {'\311','\003','\111','\276'};
    239. 

  239. 

  240. 

  241. #define I_IRCAM_VAX  0x0001a364
    242. 

  242. #define I_IRCAM_SUN  0x0002a364
    243. 

  243. #define I_IRCAM_MIPS 0x0003a364
    244. 

  244. #define I_IRCAM_NEXT  0x0004a364
    245. 

  245. 

  246. #define NINRS	7
    247. 

  247. static const unsigned int I_INRS[NINRS]={0xcb460020,0xd0465555,0xfa460000,0x1c470040,0x3b470080,0x7a470000,0x9c470040};
    248. 

  248. 

  249. static int data_size=0, data_location=0, srate=0, chans=0, header_type=0, sound_format=0, original_sound_format=0, true_file_length=0;
    250. 

  250. static int comment_start=0, comment_end=0, header_distributed=0, type_specifier=0, bits_per_sample=0, fact_samples=0, block_align=0;
    251. 

  251. static int base_detune = 0, base_note = 0;
    252. 

  252. 

  253. int c_snd_header_data_size (void) {return(data_size);}
    254. 

  254. int c_snd_header_data_location (void) {return(data_location);}
    255. 

  255. int c_snd_header_chans (void) {return(chans);}
    256. 

  256. int c_snd_header_srate (void) {return(srate);}
    257. 

  257. int c_snd_header_type (void) {return(header_type);}
    258. 

  258. int c_snd_header_format (void) {return(sound_format);}
    259. 

  259. int c_snd_header_distributed (void) {return(header_distributed);}
    260. 

  260. int c_snd_header_comment_start (void) {return(comment_start);}
    261. 

  261. int c_snd_header_comment_end (void) {return(comment_end);}
    262. 

  262. int c_snd_header_aux_comment_start (int n) {return(aux_comment_start[n]);}
    263. 

  263. int c_snd_header_aux_comment_end (int n) {return(aux_comment_end[n]);}
    264. 

  264. int c_snd_header_type_specifier (void) {return(type_specifier);}
    265. 

  265. int c_snd_header_bits_per_sample (void) {return(bits_per_sample);}
    266. 

  266. int c_snd_header_fact_samples (void) {return(fact_samples);}
    267. 

  267. int c_snd_header_block_align (void) {return(block_align);}
    268. 

  268. int c_true_file_length (void) {return(true_file_length);}
    269. 

  269. int c_snd_header_original_format (void) {return(original_sound_format);}
    270. 

  270. int c_snd_header_loop_mode(int which) {if (loop_modes) return(loop_modes[which]); else return(-1);}
    271. 

  271. int c_snd_header_loop_start(int which) {if (loop_starts) return(loop_starts[which]); else return(-1);}
    272. 

  272. int c_snd_header_loop_end(int which) {if (loop_ends) return(loop_ends[which]); else return(-1);}
    273. 

  273. int c_snd_header_mark_position(int id) {int i; for (i=0;i<markers;i++) {if (marker_ids[i] == id) return(marker_positions[i]);} return(-1);}
    274. 

  274. int c_snd_header_base_detune(void) {return(base_detune);}
    275. 

  275. int c_snd_header_base_note(void) {return(base_note);}
    276. 

  276. 

  277. int c_snd_datum_size (int format)
    278. 

  278. {
    279. 

  279.   switch (format)
    280. 

  280.     {
    281. 

  281.     case snd_8_linear: return(1); break;
    282. 

  282.     case snd_16_linear: return(2); break;
    283. 

  283.     case snd_8_unsigned: return(1); break;
    284. 

  284.     case snd_8_mulaw: return(1); break;
    285. 

  285.     case snd_8_alaw: return(1); break;
    286. 

  286.     case snd_32_linear: return(4); break;
    287. 

  287.     case snd_32_float: return(4); break;
    288. 

  288.     case snd_24_linear: return(3); break;
    289. 

  289.     case snd_64_double: return(8); break;
    290. 

  290.     case snd_16_linear_little_endian: return(2); break;
    291. 

  291.     case snd_32_linear_little_endian: return(4); break;
    292. 

  292.     case snd_32_float_little_endian: return(4); break;
    293. 

  293.     case snd_64_double_little_endian: return(8); break;
    294. 

  294.     case snd_24_linear_little_endian: return(3); break;
    295. 

  295.     case snd_16_unsigned: return(2); break;
    296. 

  296.     case snd_16_unsigned_little_endian: return(2); break;
    297. 

  297.     case snd_32_vax_float: return(4); break;
    298. 

  298.     default: return(1); break; /* we divide by this number, so 0 is not safe */
    299. 

  299.     }
    300. 

  300. }
    301. 

  301. 

  302. void c_set_snd_header (int in_srate, int in_chans, int in_format) 
    303. 

  303. {
    304. 

  304.   srate = in_srate; 
    305. 

  305.   chans = in_chans; 
    306. 

  306.   sound_format = in_format;
    307. 

  307.   data_size = c_snd_samples(in_format,true_file_length);
    308. 

  308. }
    309. 

  309. 

  310. int c_snd_header_datum_size (void) {return(c_snd_datum_size(sound_format));}
    311. 

  311. int c_snd_bytes (int format, int size) {return(size*(c_snd_datum_size(format)));}
    312. 

  312. int c_snd_samples (int format, int size) {return((int)(size/(c_snd_datum_size(format))));}
    313. 

  313. 

  314. static int equal_big_or_little_endian(int n1, int n2)
    315. 

  315. {
    316. 

  316.   return ((n1 == big_endian_int(n2)) || (n1 == little_endian_int(n2)));
    317. 

  317. }
    318. 

  318. 

  319. static short big_or_little_endian_short (short n, int little)
    320. 

  320. {
    321. 

  321.   if (little) return(little_endian_short(n));
    322. 

  322.   return(big_endian_short(n));
    323. 

  323. }
    324. 

  324. 

  325. static int big_or_little_endian_int (int n, int little)
    326. 

  326. {
    327. 

  327.   if (little) return(little_endian_int(n));
    328. 

  328.   return(big_endian_int(n));
    329. 

  329. }
    330. 

  330. 

  331. static float big_or_little_endian_float (unsigned char *n, int little)
    332. 

  332. {
    333. 

  333.   if (little) return(little_endian_float(n));
    334. 

  334.   return(big_endian_float(n));
    335. 

  335. }
    336. 

  336. 

  337. int match_four_chars(unsigned char *head, const unsigned char *match)
    338. 

  338. { 
    339. 

  339.   int i;
    340. 

  340.   for (i=0;i<4;i++) if (head[i] != match[i]) return(0);
    341. 

  341.   return(1);
    342. 

  342. }
    343. 

  343.   
    344. 

  344. static void write_four_chars(unsigned char *head, const unsigned char *match)
    345. 

  345. {
    346. 

  346.   int i;
    347. 

  347.   for (i=0;i<4;i++) head[i] = match[i];
    348. 

  348. }
    349. 

  349. 

  350. 

  351. static void read_bicsf_header (int chan);
    352. 

  352. 

  353. 

  354. /* ------------------------------------ NeXT (or Sun) -------------------------------- 
    355. 

  355.  * 
    356. 

  356.  *   0:  ".snd"
    357. 

  357.  *   4:  data_location (bytes) (not necessarily word aligned on Sun)
    358. 

  358.  *   8:  data_size (bytes) -- sometimes incorrect ("advisory")
    359. 

  359.  *   12: data format indicator -- see below
    360. 

  360.  *   16: srate (int)
    361. 

  361.  *   20: chans
    362. 

  362.  *   24: comment start
    363. 

  363.  *   
    364. 

  364.  * in an AFsp file, the first 4 bytes of the comment are "AFsp",
    365. 

  365.  * see headers.lisp for readers/writers of AFsp fields
    366. 

  366.  * for bicsf, the integer at 28 is 107364 or 107415
    367. 

  367.  *
    368. 

  368.  * on NeXTStep, always big-endian.  ".snd"==0x2e736e64 on big-endian machines.
    369. 

  369.  *
    370. 

  370.  * formats are: 
    371. 

  371.  * 0 unspecified, 1 mulaw_8, 2 linear_8, 3 linear_16, 4 linear_24, 5 linear_32, 6 float,
    372. 

  372.  * 7 double, 8 indirect, 9 nested, 10 dsp_core, 11 dsp_data_8, 12 dsp_data_16, 13 dsp_data_24,
    373. 

  373.  * 14 dsp_data_32, 16 display, 17 mulaw_squelch, 18 emphasized, 19 compressed, 20 compressed_emphasized
    374. 

  374.  * 21 dsp_commands, 22 dsp_commands_samples, 23 adpcm_g721, 24 adpcm_g722, 25 adpcm_g723,
    375. 

  375.  * 26 adpcm_g723_5, 27 alaw_8, 28 aes, 29 delat_mulaw_8 {internal Snd-secret format: 30=linear_32_little_endian}
    376. 

  376.  *
    377. 

  377.  */
    378. 

  378. 

  379. static void read_next_header (int chan)
    380. 

  380. {
    381. 

  381.   int maybe_bicsf;
    382. 

  382.   type_specifier = (*((int *)(hdrbuf)));
    383. 

  383.   data_location = big_endian_int((*((int *)(hdrbuf+4))));
    384. 

  384.   data_size = big_endian_int((*((int *)(hdrbuf+8))));
    385. 

  385.   /* can be bogus -- fixup if possible */
    386. 

  386.   true_file_length = lseek(chan,0L,2);
    387. 

  387.   if (data_size <= 24) data_size = (true_file_length-data_location);
    388. 

  388.   original_sound_format = big_endian_int((*((int *)(hdrbuf+12))));
    389. 

  389.   switch (original_sound_format) 
    390. 

  390.     { /* defined in /usr/include/sound/soundstruct.h */
    391. 

  391.       /* see headers.lisp for a table of all known format names */
    392. 

  392.     case 1: sound_format = snd_8_mulaw; break;
    393. 

  393.     case 2: sound_format = snd_8_linear; break;
    394. 

  394.     case 3: sound_format = snd_16_linear; break;
    395. 

  395.     case 4: sound_format = snd_24_linear; break;
    396. 

  396.     case 5: sound_format = snd_32_linear; break;
    397. 

  397.     case 6: sound_format = snd_32_float; break;
    398. 

  398.     case 7: sound_format = snd_64_double; break;
    399. 

  399.     case 18: sound_format = snd_16_linear; break; 
    400. 

  400.       /* "emphasized": Xavier Serra's de-emphasis filter: y(n) = x(n) + .9 y(n-1) */
    401. 

  401.     case 27: sound_format = snd_8_alaw; break;
    402. 

  402.     case 30: sound_format = snd_32_linear_little_endian; break; /* this is for Snd's internal benefit -- it is not used elsewhere */
    403. 

  403.     default: sound_format = snd_unsupported; break;
    404. 

  404.     }
    405. 

  405.   srate = big_endian_int((*((int *)(hdrbuf+16))));
    406. 

  406.   chans = big_endian_int((*((int *)(hdrbuf+20))));
    407. 

  407.   comment_start = 24;
    408. 

  408.   comment_end = data_location - 1;
    409. 

  409.   if (comment_end < comment_start) comment_end = comment_start;
    410. 

  410.   if (match_four_chars((unsigned char *)(hdrbuf+24),I_AFsp)) header_distributed = 1; else header_distributed = 0;
    411. 

  411.   maybe_bicsf = big_endian_int((*((int *)(hdrbuf+28))));
    412. 

  412.   if (maybe_bicsf == 107364) read_bicsf_header(chan);
    413. 

  413.   data_size = c_snd_samples(sound_format,data_size);
    414. 

  414. }
    415. 

  415. 

  416. void write_next_header (int chan, int srate, int chans, int loc, int siz, int format, char *comment, int len)
    417. 

  417. {
    418. 

  418.   int i,j;
    419. 

  419.   char *str;
    420. 

  420.   write_four_chars((unsigned char *)hdrbuf,I_DSND); /* ".snd" */
    421. 

  421.   i = len/4;
    422. 

  422.   j = 24 + (4 * (i+1));
    423. 

  423.   if (loc < j) loc = j;
    424. 

  424.   (*((int *)(hdrbuf+4))) = big_endian_int(loc);
    425. 

  425.   (*((int *)(hdrbuf+8))) = big_endian_int(siz);
    426. 

  426.   switch (format)
    427. 

  427.     {
    428. 

  428.     case snd_8_mulaw: (*((int *)(hdrbuf+12))) = big_endian_int(1); break;
    429. 

  429.     case snd_8_linear: (*((int *)(hdrbuf+12))) = big_endian_int(2); break;
    430. 

  430.     case snd_16_linear: (*((int *)(hdrbuf+12))) = big_endian_int(3); break;
    431. 

  431.     case snd_24_linear: (*((int *)(hdrbuf+12))) = big_endian_int(4); break;
    432. 

  432.     case snd_32_linear: (*((int *)(hdrbuf+12))) = big_endian_int(5); break;
    433. 

  433.     case snd_32_float: (*((int *)(hdrbuf+12))) = big_endian_int(6); break;
    434. 

  434.     case snd_64_double: (*((int *)(hdrbuf+12))) = big_endian_int(7); break;
    435. 

  435.     case snd_32_linear_little_endian: (*((int *)(hdrbuf+12))) = big_endian_int(30); break; /* see above */
    436. 

  436.     case snd_8_alaw: (*((int *)(hdrbuf+12))) = big_endian_int(27); break;
    437. 

  437.     default: 
    438. 

  438.       str=(char *)CALLOC(256,sizeof(char));
    439. 

  439.       sprintf(str,"CLM/NeXT unsupported sound data format type: %d\n",format); 
    440. 

  440.       clm_printf(str);
    441. 

  441.       FREE(str);
    442. 

  442.       break;
    443. 

  443.     }
    444. 

  444.   (*((int *)(hdrbuf+16))) = big_endian_int(srate);
    445. 

  445.   (*((int *)(hdrbuf+20))) = big_endian_int(chans);
    446. 

  446.   write(chan,hdrbuf,24);
    447. 

  447.   j = 0;
    448. 

  448.   for (i=0;i<len;i++) 
    449. 

  449.     {
    450. 

  450.       hdrbuf[j]=comment[i];
    451. 

  451.       j++;
    452. 

  452.       if (j == HDRBUFSIZ) 
    453. 

  453. 	{
    454. 

  454. 	  write(chan,hdrbuf,HDRBUFSIZ);
    455. 

  455. 	  j = 0;
    456. 

  456. 	}
    457. 

  457.     }
    458. 

  458.   for (i=0;i<(loc-(len+24));i++) /* now fill left over bytes with nulls */
    459. 

  459.     {
    460. 

  460.       hdrbuf[j]=0;
    461. 

  461.       j++;
    462. 

  462.       if (j == HDRBUFSIZ) 
    463. 

  463. 	{
    464. 

  464. 	  write(chan,hdrbuf,HDRBUFSIZ);
    465. 

  465. 	  j = 0;
    466. 

  466. 	}
    467. 

  467.     }
    468. 

  468.   if (j != 0) write(chan,hdrbuf,j);
    469. 

  469.   data_location = loc;
    470. 

  470. }
    471. 

  471. 

  472. static void update_next_header (int chan, int siz)
    473. 

  473. {
    474. 

  474.   lseek(chan,8L,0);
    475. 

  475.   (*((int *)(hdrbuf))) = big_endian_int(siz);
    476. 

  476.   write(chan,hdrbuf,4);
    477. 

  477. }
    478. 

  478. 

  479. static void update_next_header_comment (int chan, int loc, char *comment, int len)
    480. 

  480. {
    481. 

  481.   int i,j;
    482. 

  482.   lseek(chan,(long)(loc-4),0);
    483. 

  483.   read(chan,hdrbuf,4);
    484. 

  484.   lseek(chan,(long)(loc-4),0);
    485. 

  485.   for (j=0;j<4;j++) if (hdrbuf[j]==0) hdrbuf[j] = 32;
    486. 

  486.   j = 4;
    487. 

  487.   for (i=0;i<len;i++) 
    488. 

  488.     {
    489. 

  489.       hdrbuf[j]=comment[i];
    490. 

  490.       j++;
    491. 

  491.       if (j == HDRBUFSIZ) 
    492. 

  492. 	{
    493. 

  493. 	  write(chan,hdrbuf,HDRBUFSIZ); 
    494. 

  494. 	  j = 0;
    495. 

  495. 	}
    496. 

  496.     }
    497. 

  497.   if (j != 0) write(chan,hdrbuf,j);
    498. 

  498. }
    499. 

  499. 

  500. 

  501. 

  502. /* ------------------------------------ AIFF ------------------------------------ 
    503. 

  503.  *
    504. 

  504.  *  0: "FORM"
    505. 

  505.  *  4: size (bytes)
    506. 

  506.  *  8: "AIFF" or "AIFC" -- the latter includes compressed formats
    507. 

  507.  *
    508. 

  508.  *  Thereafter the file is organized into "chunks", each chunk being 
    509. 

  509.  *  a 4-byte identifer followed by an int (4-bytes) giving the chunk size
    510. 

  510.  *  not including the 8-byte header.  AIFF data is signed.  If the chunk
    511. 

  511.  *  size is odd, an extra (unaccounted-for) null byte is added at the end.
    512. 

  512.  *
    513. 

  513.  *  The chunks we want are "COMM", "SSND", and "APPL".
    514. 

  514.  *
    515. 

  515.  * COMM: 0: chans
    516. 

  516.  *       2: frames
    517. 

  517.  *       6: bits per sample
    518. 

  518.  *       8: srate as 80-bit IEEE float
    519. 

  519.  *  then if AIFC (not AIFF), 4 bytes giving compression id ("NONE"=not compressed)
    520. 

  520.  *    followed by Pascal string giving long name of compression type
    521. 

  521.  *
    522. 

  522.  * SSND: 0: data location (offset within SSND chunk)
    523. 

  523.  *
    524. 

  524.  * Other chunks include:  ANNO: a comment, INST: loop control, MARK: marker, MIDI: midi,
    525. 

  525.  *                        COMT: comment (max 65536 chars), NAME: sound name, AUTH: author's name
    526. 

  526.  *                        (c), AESD: recording data, APPL: application specific stuff
    527. 

  527.  *    "MARK" size short-#marks {marks} -- latter are short-ID long-position pstring-name.
    528. 

  528.  *    "INST" size chars[baseNote detune lowNote highNote lowVelocity HighVelocity] short-gain loops[sustain release]
    529. 

  529.  *      loop: short-playMode marker-begin marker-end (signed?) shorts)
    530. 

  530.  *         playMode: 0 no loop, 1 forward loop, 2 forward/backward loop
    531. 

  531.  *      chars are MIDI data (detune is in cents)
    532. 

  532.  *    "MIDI" size MIDI-data...
    533. 

  533.  *    "AESD" size AES Channel Status Data (24 bytes as specified by AES)
    534. 

  534.  *      see "AES: Guidelines for the use of the AES3 interface"
    535. 

  535.  *      byte 0: bit 0: 0=consumer, 1=pro
    536. 

  536.  *              bit 1: 0=audio, 1=non-audio
    537. 

  537.  *              bits 2:4: emphasis: 0:none, 4:none, 6:CD, 7:CCITT J17
    538. 

  538.  *              bits 6:7: srate: 00=48KHz, 01=48, 10=44.1, 11=32
    539. 

  539.  *      byte 1: bits 0:3: chans: 2:mono, else stereo
    540. 

  540.  *      byte 2 for word size stuff (always ends up 16-bit): bits 3-5=sample length where 4=16-bit
    541. 

  541.  *      byte 3: multi-channels modes, 4: AES sync ref, 5:unused, 6-9:ASCII source ID, 10-13:ASCII destination ID
    542. 

  542.  *      byte 14-17:local sample addr, 18-21:time of day addr, then CRC checks
    543. 

  543.  *    "APPL" size signature data
    544. 

  544.  *    "COMT" size short-#comments {comments} -- the latter are long-time marker short-text-length char-text
    545. 

  545.  *       time is in seconds since 1-Jan-1904
    546. 

  546.  *    "NAME"/"AUTH"/"(c) "/"ANNO" size char-name
    547. 

  547.  *    "FVER" size(4) AIFC-format-version -- currently always 0xA2805140
    548. 

  548.  *    "SAXL" -- a desperate kludge to get around Apple's own compression schemes!
    549. 

  549.  *
    550. 

  550.  * always big-endian
    551. 

  551.  * There was also (briefly) an AIFS file, now deprecated.
    552. 

  552.  */
    553. 

  553. 

  554. /* ieee-80 conversions -- design by committee! */
    555. 

  555. /* this code taken from CSound sources -- apparently originally written by Malcolm Slaney at Apple */
    556. 

  556. 

  557. #define ULPOW2TO31	((unsigned int)0x80000000)
    558. 

  558. #define DPOW2TO31	((double)2147483648.0)	/* 2^31 */
    559. 

  559. 

  560. static double myUlongToDouble(unsigned int ul)
    561. 

  561. {
    562. 

  562.   double val;
    563. 

  563.   if(ul & ULPOW2TO31) val = DPOW2TO31 + (ul & (~ULPOW2TO31));
    564. 

  564.   else val = ul;
    565. 

  565.   return val;
    566. 

  566. }
    567. 

  567. 

  568. static unsigned int myDoubleToUlong(double val)
    569. 

  569. {
    570. 

  570.   unsigned int ul;
    571. 

  571.   if(val < DPOW2TO31) ul = (unsigned int)val;
    572. 

  572.   else ul = ULPOW2TO31 | (unsigned int)(val-DPOW2TO31);
    573. 

  573.   return ul;
    574. 

  574. }
    575. 

  575. 

  576. static double ieee_80_to_double(unsigned char *p)
    577. 

  577. {
    578. 

  578.   unsigned char sign;
    579. 

  579.   short exp = 0;
    580. 

  580.   unsigned int mant1 = 0;
    581. 

  581.   unsigned int mant0 = 0;
    582. 

  582.   double val;
    583. 

  583.   exp = *p++;  exp <<= 8;  exp |= *p++;  sign = (exp & 0x8000) ? 1 : 0;  exp &= 0x7FFF;
    584. 

  584.   mant1 = *p++;  mant1 <<= 8;  mant1 |= *p++;  mant1 <<= 8;  mant1 |= *p++;  mant1 <<= 8;  mant1 |= *p++;
    585. 

  585.   mant0 = *p++;  mant0 <<= 8;  mant0 |= *p++;  mant0 <<= 8;  mant0 |= *p++;  mant0 <<= 8;  mant0 |= *p++;
    586. 

  586.   if(mant1 == 0 && mant0 == 0 && exp == 0 && sign == 0)
    587. 

  587.     return 0.0;
    588. 

  588.   else
    589. 

  589.     {
    590. 

  590.       val = myUlongToDouble(mant0) * pow(2.0,-63.0);
    591. 

  591.       val += myUlongToDouble(mant1) * pow(2.0,-31.0);
    592. 

  592.       val *= pow(2.0,((double) exp) - 16383.0);
    593. 

  593.       return sign ? -val : val;
    594. 

  594.     }
    595. 

  595. }
    596. 

  596. 

  597. static void double_to_ieee_80(double val, unsigned char *p)
    598. 

  598. {
    599. 

  599.   unsigned char sign = 0;
    600. 

  600.   short exp = 0;
    601. 

  601.   unsigned int mant1 = 0;
    602. 

  602.   unsigned int mant0 = 0;
    603. 

  603.   if(val < 0.0)	{  sign = 1;  val = -val; }
    604. 

  604.   if(val != 0.0)	/* val identically zero -> all elements zero */
    605. 

  605.     {
    606. 

  606.       exp = (short)(log(val)/log(2.0) + 16383.0);
    607. 

  607.       val *= pow(2.0, 31.0+16383.0-(double)exp);
    608. 

  608.       mant1 = myDoubleToUlong(val);
    609. 

  609.       val -= myUlongToDouble(mant1);
    610. 

  610.       val *= pow(2.0, 32.0);
    611. 

  611.       mant0 = myDoubleToUlong(val);
    612. 

  612.     }
    613. 

  613.   *p++ = ((sign<<7)|(exp>>8));  *p++ = 0xFF & exp;  
    614. 

  614.   *p++ = 0xFF & (mant1>>24);  *p++ = 0xFF & (mant1>>16);  *p++ = 0xFF & (mant1>> 8);  *p++ = 0xFF & (mant1);
    615. 

  615.   *p++ = 0xFF & (mant0>>24);  *p++ = 0xFF & (mant0>>16);  *p++ = 0xFF & (mant0>> 8);  *p++ = 0xFF & (mant0);
    616. 

  616. }
    617. 

  617. 

  618. 

  619. static int update_form_size, update_frames_location, update_ssnd_location;
    620. 

  620. 

  621. static int seek_and_read(int chan, unsigned char *buf, int offset, int nbytes)
    622. 

  622. {
    623. 

  623.   if (offset < 0) return(-1);
    624. 

  624.   lseek(chan, offset, 0);
    625. 

  625. #ifndef MACOS
    626. 

  626.   return(read(chan,buf,nbytes));
    627. 

  627. #else
    628. 

  628.   return(read(chan,(char *)buf,nbytes));
    629. 

  629. #endif
    630. 

  630. }
    631. 

  631. 

  632. static int read_aiff_marker(int m, int offset, unsigned char *buf)
    633. 

  633. {
    634. 

  634.   unsigned char *hb;
    635. 

  635.   int psize;
    636. 

  636.   hb = (unsigned char *)(buf+offset);
    637. 

  637.   marker_ids[m] = big_endian_short(*(short *)hb);
    638. 

  638.   marker_positions[m] = big_endian_int(*(int *)(hb+2));
    639. 

  639.   psize = (int)hb[6] + 1; 
    640. 

  640.   if (psize & 1) psize++; 
    641. 

  641.   return(psize+6);
    642. 

  642. }
    643. 

  643. 

  644. static void read_aiff_header (int chan, int overall_offset)
    645. 

  645. {
    646. 

  646.   /* we know we have checked for FORM xxxx AIFF|AIFC when we arrive here */
    647. 

  647.   /* as far as I can tell, the COMM block has the header data we seek, and the SSND block has the sound data */
    648. 

  648.   /* everything else will be ignored -- apparently we can depend on seeing a "chunk" name, then size */
    649. 

  649.   int chunksize,offset,frames,chunkloc,happy,i,j,num_marks,m,moff,msize;
    650. 

  650.   type_specifier = (*((int *)(hdrbuf+8+overall_offset)));
    651. 

  651.   update_ssnd_location = 0;
    652. 

  652.   chunkloc = 12 + overall_offset;
    653. 

  653.   offset = 0;
    654. 

  654.   comment_start = 0;
    655. 

  655.   comment_end = 0;
    656. 

  656.   for (i=0;i<AUX_COMMENTS;i++) aux_comment_start[i] = 0;
    657. 

  657.   sound_format = snd_16_linear;
    658. 

  658.   header_distributed = 1;
    659. 

  659.   srate = 0;
    660. 

  660.   chans = 0;
    661. 

  661.   happy = 1;
    662. 

  662.   data_size = 0;
    663. 

  663.   if (loop_modes)
    664. 

  664.     {
    665. 

  665.       loop_modes[0] = 0;
    666. 

  666.       loop_modes[1] = 0;
    667. 

  667.     }
    668. 

  668.   true_file_length = lseek(chan,0L,2);
    669. 

  669.   update_form_size = big_endian_int((*(int *)(hdrbuf+4+overall_offset))); /* should be file-size-8 unless there are multiple forms */
    670. 

  670.   while (happy)
    671. 

  671.     {
    672. 

  672.       offset += chunkloc;
    673. 

  673.       if (seek_and_read(chan,(unsigned char *)hdrbuf,offset,32) <= 0)
    674. 

  674. 	{
    675. 

  675. 	  clm_printf("error reading header");
    676. 

  676. 	  return;
    677. 

  677. 	}
    678. 

  678.       chunksize = big_endian_int((*(int *)(hdrbuf+4)));
    679. 

  679.       if (match_four_chars((unsigned char *)hdrbuf,I_COMM))
    680. 

  680. 	{
    681. 

  681. 	  chans = big_endian_short((*(short *)(hdrbuf+8)));
    682. 

  682. 	  frames = big_endian_int((*(int *)(hdrbuf+10)));
    683. 

  683. 	  update_frames_location = 10+offset;
    684. 

  684. 	  original_sound_format = big_endian_short((*(short *)(hdrbuf+14)));
    685. 

  685. 	  if ((original_sound_format%8) != 0) 
    686. 

  686. 	    {
    687. 

  687. 	      /* weird sizes are legal --
    688. 

  688. 	       * these samples are left-justified (and zero padded on the right), so
    689. 

  689. 	       * we can handle any bit size by rounding up to the nearest byte.
    690. 

  690. 	       */
    691. 

  691. 	      original_sound_format=8*(1+(original_sound_format>>3));
    692. 

  692. 	    }
    693. 

  693. 	  if (original_sound_format == 8) sound_format = snd_8_linear;
    694. 

  694. 	  else if (original_sound_format == 16) sound_format = snd_16_linear;
    695. 

  695. 	  else if (original_sound_format == 24) sound_format = snd_24_linear;
    696. 

  696. 	  else if (original_sound_format == 32) sound_format = snd_32_linear;
    697. 

  697. 	  else sound_format = snd_unsupported;
    698. 

  698. 	  data_size = (frames*c_snd_datum_size(sound_format)*chans);
    699. 

  699. 	  srate = (int)ieee_80_to_double((unsigned char *)(hdrbuf+16));
    700. 

  700. 	  /* if AIFC, compression type over-rides (possibly bogus) original_sound_format */
    701. 

  701. 	  if (type_specifier == (*(int *)I_AIFC))
    702. 

  702. 	    {
    703. 

  703. 	      /* some aifc files assume the compression field is a new and very weird chunk!! -- surely a bug? */
    704. 

  704. 	      /* AIFF spec says COMM size is always 18, but this is amended in the newer AIFC spec */
    705. 

  705. 	      if (chunksize == 18) chunksize += (5+((int)hdrbuf[30])); /* 5=chunk header length in this case */
    706. 

  706. 	      if (!(match_four_chars((unsigned char *)(hdrbuf+26),I_NONE)))
    707. 

  707. 		{
    708. 

  708. 		  original_sound_format = (*(int *)(hdrbuf+26));
    709. 

  709. 		  if (match_four_chars((unsigned char *)(hdrbuf+26),I_ALAW)) sound_format = snd_8_alaw;
    710. 

  710. 		  else if ((match_four_chars((unsigned char *)(hdrbuf+26),I_ULAW)) ||
    711. 

  711. 			   (match_four_chars((unsigned char *)(hdrbuf+26),I_ulaw)))
    712. 

  712. 		    sound_format = snd_8_mulaw;
    713. 

  713. 		  else 
    714. 

  714. 		    {
    715. 

  715. 		      if (match_four_chars((unsigned char *)(hdrbuf+26),I_ima4))
    716. 

  716. 			{
    717. 

  717. 			  block_align = 34;
    718. 

  718. 			  original_sound_format = AIFF_IMA_ADPCM;
    719. 

  719. 			}
    720. 

  720. 		      sound_format = snd_unsupported;
    721. 

  721. 		    }
    722. 

  722. 		}
    723. 

  723. 	    }
    724. 

  724. 	}
    725. 

  725.       else
    726. 

  726. 	{
    727. 

  727. 	  if (match_four_chars((unsigned char *)hdrbuf,I_SSND))
    728. 

  728. 	    {
    729. 

  729. 	      update_ssnd_location = offset+4;
    730. 

  730. 	      data_location = big_endian_int((*(int *)(hdrbuf+8))) + offset + 16; /* Baroque! */
    731. 

  731. 	      /* offset is where the hdrbuf is positioned in the file, the sound data offset itself is at loc+8 and the */
    732. 

  732. 	      /* 0-based location of the sound data is at the end of the chunk = 16 (8=header+4=offset+4=blocksize) */
    733. 

  733. 	      /* the next int can be the block size if the data is block-aligned */
    734. 

  734. 	      /* only one SSND per AIFF is allowed */
    735. 

  735. 	    }
    736. 

  736. 	  else
    737. 

  737. 	    {
    738. 

  738. 	      if ((match_four_chars((unsigned char *)hdrbuf,I_ANNO)) || (match_four_chars((unsigned char *)hdrbuf,I_COMT)))
    739. 

  739. 		{
    740. 

  740. 		  j=0;
    741. 

  741. 		  for (i=0;i<AUX_COMMENTS;i++) if (aux_comment_start[i] == 0) {j=i; break;}
    742. 

  742. 		  if (j >= AUX_COMMENTS) {clm_printf("ran out of auxiliary comment space"); j=0;}
    743. 

  743. 		  aux_comment_start[j] = offset+8;
    744. 

  744. 		  if (match_four_chars((unsigned char *)hdrbuf,I_COMT)) aux_comment_start[j] += 8; /* skip time stamp and markerId (not ID, I assume!) */
    745. 

  745. 		  aux_comment_end[j] = offset+7+chunksize;
    746. 

  746. 		}
    747. 

  747. 	      else
    748. 

  748. 		{
    749. 

  749. 		  if (match_four_chars((unsigned char *)hdrbuf,I_APPL))
    750. 

  750. 		    {
    751. 

  751. 		      if (match_four_chars((unsigned char *)(hdrbuf+8),I_CLM_))
    752. 

  752. 			{
    753. 

  753. 			  /* my own chunk has the arbitrary length comment I use (actually the ASCII    */
    754. 

  754. 			  /* representation of a lisp program evaluated in the CLM package) to handle mix et al. */
    755. 

  755. 			  /* It is nothing more than the actual string -- remember to pad to even length here. */
    756. 

  756. 			  comment_start = offset + 12;
    757. 

  757. 			  comment_end = comment_start + chunksize - 5;
    758. 

  758. 			}
    759. 

  759. 		    }
    760. 

  760. 		  else
    761. 

  761. 		    {
    762. 

  762. 		      if (match_four_chars((unsigned char *)hdrbuf,I_INST))
    763. 

  763. 			{
    764. 

  764. 			  base_note = hdrbuf[8];
    765. 

  765. 			  base_detune = hdrbuf[9];
    766. 

  766. 			  loop_modes[0] = big_endian_short((*(short *)(hdrbuf+16)));
    767. 

  767. 			  loop_starts[0] = big_endian_short((*(short *)(hdrbuf+18)));
    768. 

  768. 			  loop_ends[0] = big_endian_short((*(short *)(hdrbuf+20)));
    769. 

  769. 			  loop_modes[1] = big_endian_short((*(short *)(hdrbuf+22)));
    770. 

  770. 			  loop_starts[1] = big_endian_short((*(short *)(hdrbuf+24)));
    771. 

  771. 			  loop_ends[1] = big_endian_short((*(short *)(hdrbuf+26)));
    772. 

  772. 			  /* these are mark numbers */
    773. 

  773. 			}
    774. 

  774. 		      else
    775. 

  775. 			{
    776. 

  776. 			  if (match_four_chars((unsigned char *)hdrbuf,I_MARK))
    777. 

  777. 			    {
    778. 

  778. 			      /* unsigned short #marks, each mark: id pos name (pstring damn it) */
    779. 

  779. 			      num_marks = big_endian_unsigned_short(*(unsigned short *)(hdrbuf+8));
    780. 

  780. 			      if (num_marks > markers)
    781. 

  781. 				{
    782. 

  782. 				  if (markers > 0) {if (marker_ids) FREE(marker_ids); if (marker_positions) FREE(marker_positions);}
    783. 

  783. 				  markers = num_marks;
    784. 

  784. 				  marker_ids = (int *)CALLOC(markers,sizeof(int));
    785. 

  785. 				  marker_positions = (int *)CALLOC(markers,sizeof(int));
    786. 

  786. 				}
    787. 

  787. 			      moff = 10;
    788. 

  788. 			      for (m=0;m<num_marks;m++)
    789. 

  789. 				{
    790. 

  790. 				  msize = read_aiff_marker(m,moff,(unsigned char *)hdrbuf);
    791. 

  791. 				  moff += msize;
    792. 

  792. 				}
    793. 

  793. 			    }
    794. 

  794. 			}
    795. 

  795. 		    }
    796. 

  796. 		}
    797. 

  797. 	    }
    798. 

  798. 	}
    799. 

  799.       chunkloc = (8+chunksize);
    800. 

  800.       if (chunksize&1) chunkloc++; /* extra null appended to odd-length chunks */
    801. 

  801.       if ((offset+chunkloc) >= update_form_size) happy=0;
    802. 

  802.     }
    803. 

  803.   if (true_file_length < data_size) data_size = true_file_length - data_location;
    804. 

  804.   data_size = c_snd_samples(sound_format,data_size);
    805. 

  805. }
    806. 

  806. 

  807. static void write_aiff_header (int chan, int srate, int chans, int siz, int format, char *comment, int len)
    808. 

  808. {
    809. 

  809.   /* we write the simplest possible AIFF header: AIFF | COMM | APPL-CLM_ if needed | SSND eof. */
    810. 

  810.   /* the assumption being that we're going to be appending sound data once the header is out   */
    811. 

  811.   /* INST and MARK chunks added Jul-95 for various programs that expect them (MixView).        */
    812. 

  812.   int i,j,lenhdr,curend,extra,aifc;
    813. 

  813.   char *str;
    814. 

  814.   lenhdr=0;
    815. 

  815.   extra=0;
    816. 

  816.   curend=0;
    817. 

  817.   if ((format == snd_8_mulaw) || (format == snd_8_alaw)) aifc=1; else aifc=0;
    818. 

  818.   if (len != 0) 
    819. 

  819.     {
    820. 

  820.       lenhdr = 12;
    821. 

  821.       if ((len % 4) != 0)
    822. 

  822. 	extra = (4 - (len % 4));
    823. 

  823.     }
    824. 

  824.   write_four_chars((unsigned char *)hdrbuf,I_FORM);
    825. 

  825.   if (aifc==1) (*(int *)(hdrbuf+4)) = big_endian_int(len+30+16+38+siz+lenhdr+extra+12+10);
    826. 

  826.   else (*(int *)(hdrbuf+4)) = big_endian_int(len+30+16+38+siz+lenhdr+extra);
    827. 

  827.   /* 
    828. 

  828.    * comment length + 4 for AIFF 18+8 for I_COMM info + 16 for I_SSND info + 38 for INST and MARK +
    829. 

  829.    * siz for data + 12 for comment header if any + padding == total size - 8 (i.e. FORM header).   
    830. 

  830.    * INST+MARK (38) added 3-Jul-95 for Notam software compatibility 
    831. 

  831.    *
    832. 

  832.    * if necessary, AIFC is used instead with the FVER and compression-name info: 12 for FVER, 10 for xLAW+size+xLAW+nul
    833. 

  833.    */
    834. 

  834.   if (aifc==1) 
    835. 

  835.     {
    836. 

  836.       write_four_chars((unsigned char *)(hdrbuf+8),I_AIFC); 
    837. 

  837.       write(chan,hdrbuf,12);
    838. 

  838.       curend=12;
    839. 

  839.       write_four_chars((unsigned char *)hdrbuf,I_FVER);
    840. 

  840.       (*(int *)(hdrbuf+4)) = big_endian_int(4);
    841. 

  841.       (*(int *)(hdrbuf+8)) = big_endian_int(0xA2805140);
    842. 

  842.     }
    843. 

  843.   else write_four_chars((unsigned char *)(hdrbuf+8),I_AIFF);
    844. 

  844.   write_four_chars((unsigned char *)(hdrbuf+12),I_COMM);
    845. 

  845.   if (aifc==1) (*(int *)(hdrbuf+16)) = big_endian_int(18+10); else (*(int *)(hdrbuf+16)) = big_endian_int(18);
    846. 

  846.   (*(short *)(hdrbuf+20)) = big_endian_short((short)chans);
    847. 

  847.   (*(int *)(hdrbuf+22)) = big_endian_int((int)(siz / (chans*c_snd_datum_size(format))));
    848. 

  848.   switch (format)
    849. 

  849.     {
    850. 

  850.     case snd_16_linear: (*(short *)(hdrbuf+26)) = big_endian_short(16); break;
    851. 

  851.     case snd_24_linear: (*(short *)(hdrbuf+26)) = big_endian_short(24); break;
    852. 

  852.     case snd_32_linear: (*(short *)(hdrbuf+26)) = big_endian_short(32); break;
    853. 

  853.     case snd_8_linear: (*(short *)(hdrbuf+26)) = big_endian_short(8); break;
    854. 

  854.     case snd_8_mulaw: (*(short *)(hdrbuf+26)) = big_endian_short(8); break;
    855. 

  855.     case snd_8_alaw: (*(short *)(hdrbuf+26)) = big_endian_short(8); break;
    856. 

  856.     default: 
    857. 

  857.       str=(char *)CALLOC(256,sizeof(char));
    858. 

  858.       sprintf(str,"CLM/AIFF unsupported sound data format type: %d\n",format);
    859. 

  859.       clm_printf(str);
    860. 

  860.       FREE(str);
    861. 

  861.       break;
    862. 

  862.     }
    863. 

  863.   double_to_ieee_80((double)srate,(unsigned char *)(hdrbuf+28));
    864. 

  864.   if (aifc==1)
    865. 

  865.     {
    866. 

  866.       if (format == snd_8_mulaw) 
    867. 

  867. 	write_four_chars((unsigned char *)(hdrbuf+38),I_ULAW); 
    868. 

  868.       else write_four_chars((unsigned char *)(hdrbuf+38),I_ALAW);
    869. 

  869.       (*(unsigned char *)(hdrbuf+42)) = 4; /* final pad null not accounted-for */
    870. 

  870.       if (format == snd_8_mulaw) 
    871. 

  871. 	write_four_chars((unsigned char *)(hdrbuf+43),I_ULAW); 
    872. 

  872.       else write_four_chars((unsigned char *)(hdrbuf+43),I_ALAW);
    873. 

  873.       (*(unsigned char *)(hdrbuf+47)) = 0;
    874. 

  874.       i=48;
    875. 

  875.     }
    876. 

  876.   else i = 38;
    877. 

  877.   if (len != 0)
    878. 

  878.     {
    879. 

  879.       if (aifc==1)
    880. 

  880. 	{
    881. 

  881. 	  /* this dumb looking code made necessary by SGI C compiler's stupidity */
    882. 

  882. 	  write_four_chars((unsigned char *)(hdrbuf+48),I_APPL);
    883. 

  883. 	  (*(int *)(hdrbuf+52)) = big_endian_int(len+4+extra);
    884. 

  884. 	  write_four_chars((unsigned char *)(hdrbuf+56),I_CLM_);
    885. 

  885. 	  i = 60;
    886. 

  886. 	}
    887. 

  887.       else
    888. 

  888. 	{
    889. 

  889. 	  write_four_chars((unsigned char *)(hdrbuf+38),I_APPL);
    890. 

  890. 	  (*(int *)(hdrbuf+42)) = big_endian_int(len+4+extra);
    891. 

  891. 	  write_four_chars((unsigned char *)(hdrbuf+46),I_CLM_);
    892. 

  892. 	  i = 50;
    893. 

  893. 	}
    894. 

  894.       for (j=0;j<len;j++)
    895. 

  895. 	{
    896. 

  896. 	  if (i == HDRBUFSIZ)
    897. 

  897. 	    {
    898. 

  898. 	      curend += HDRBUFSIZ;
    899. 

  899. 	      write(chan,hdrbuf,HDRBUFSIZ);
    900. 

  900. 	      i=0;
    901. 

  901. 	    }
    902. 

  902. 	  hdrbuf[i]=comment[j];
    903. 

  903. 	  i++;
    904. 

  904. 	}
    905. 

  905.       if (extra != 0)
    906. 

  906. 	{
    907. 

  907. 	  if ((i+extra) > HDRBUFSIZ)
    908. 

  908. 	    {
    909. 

  909. 	      curend += i;
    910. 

  910. 	      write(chan,hdrbuf,i);
    911. 

  911. 	      i=0;
    912. 

  912. 	    }
    913. 

  913. 	  for (j=0;j<extra;j++)
    914. 

  914. 	    {
    915. 

  915. 	      hdrbuf[i] = 0;
    916. 

  916. 	      i++;
    917. 

  917. 	    }
    918. 

  918. 	}
    919. 

  919.     }
    920. 

  920.   curend += i;
    921. 

  921.   write(chan,hdrbuf,i);
    922. 

  922.   write_four_chars((unsigned char *)hdrbuf,I_MARK);   /* SoundHack includes a blank MARK chunk for some reason */
    923. 

  923.   (*(int *)(hdrbuf+4)) = big_endian_int(2);
    924. 

  924.   (*(short *)(hdrbuf+8)) = 0;
    925. 

  925.   write_four_chars((unsigned char *)(hdrbuf+10),I_INST);
    926. 

  926.   (*(int *)(hdrbuf+14)) = big_endian_int(20);
    927. 

  927.   (*(int *)(hdrbuf+18)) = big_endian_int(0x3c00007f); /* base-note=middle C, detune=0, lownote=0, highnote=0x7f */
    928. 

  928.   (*(int *)(hdrbuf+22)) = big_endian_int(0x017f0000); /* lowvelocity=1, highvelocity=0x7f, gain=0 */
    929. 

  929.   (*(int *)(hdrbuf+26)) = 0;                          /* no loops */
    930. 

  930.   (*(int *)(hdrbuf+30)) = 0; 
    931. 

  931.   (*(int *)(hdrbuf+34)) = 0; 
    932. 

  932.   write_four_chars((unsigned char *)(hdrbuf+38),I_SSND);
    933. 

  933.   (*(int *)(hdrbuf+38+4)) = big_endian_int(siz+8);
    934. 

  934.   (*(int *)(hdrbuf+38+8)) = 0;                        /* "offset" */
    935. 

  935.   (*(int *)(hdrbuf+38+12)) = 0;                       /* "blocksize " */
    936. 

  936.   data_location = 38+16+curend;
    937. 

  937.   write(chan,hdrbuf,38+16);
    938. 

  938. }
    939. 

  939. 

  940. 

  941. static void update_aiff_header (int chan, int siz)
    942. 

  942. {
    943. 

  943.   /* we apparently have to make sure the form size and the data size are correct 
    944. 

  944.    * assumed here that we'll only be updating our own AIFF files 
    945. 

  945.    * There are 3 such locations -- the 2nd word of the file which is the overall form size, 
    946. 

  946.    * the frames variable in the COMM chunk, and the chunk-size variable in the SSND chunk 
    947. 

  947.    * an unexpected hassle for CLM is that we can open/close the output file many times if running mix,
    948. 

  948.    * so we have to update the various size fields taking into account the old size 
    949. 

  949.    */
    950. 

  950.   read(chan,hdrbuf,INITIAL_READ_SIZE);
    951. 

  951.   read_aiff_header(chan,0);
    952. 

  952.   lseek(chan,4L,0);
    953. 

  953.   (*(int *)hdrbuf) = big_endian_int(siz+update_form_size-c_snd_bytes(sound_format,data_size));
    954. 

  954.   /* cancel old data_size from previous possible write */
    955. 

  955.   write(chan,hdrbuf,4);
    956. 

  956.   lseek(chan,update_frames_location,0);
    957. 

  957.   (*(int *)hdrbuf) = big_endian_int(siz/(chans*c_snd_datum_size(sound_format)));
    958. 

  958.   write(chan,hdrbuf,4);
    959. 

  959.   lseek(chan,update_ssnd_location,0);
    960. 

  960.   (*(int *)hdrbuf) = big_endian_int(siz+8);
    961. 

  961.   write(chan,hdrbuf,4);
    962. 

  962. }
    963. 

  963. 

  964. static void update_aiff_header_comment (int chan, char *comment, int len)
    965. 

  965. {
    966. 

  966.   /* save-stats in CLM appends a comment after the sound data has been written */
    967. 

  967.   int i,j,true_len,old_len;
    968. 

  968.   if (len&1) true_len = len+1; else true_len=len;
    969. 

  969.   lseek(chan,0L,2);
    970. 

  970.   write_four_chars((unsigned char *)hdrbuf,I_ANNO);
    971. 

  971.   (*(int *)(hdrbuf+4)) = big_endian_int(len);
    972. 

  972.   for (i=0,j=8;i<len;i++,j++) hdrbuf[j]=comment[i];
    973. 

  973.   write(chan,hdrbuf,8+true_len);
    974. 

  974.   lseek(chan,4L,0);
    975. 

  975.   read(chan,hdrbuf,4);
    976. 

  976.   old_len = big_endian_int(*((int *)hdrbuf));
    977. 

  977.   (*(int *)hdrbuf) = big_endian_int(old_len+true_len+8);
    978. 

  978.   lseek(chan,4L,0);
    979. 

  979.   write(chan,hdrbuf,4);
    980. 

  980. }
    981. 

  981. 

  982. 

  983. 

  984. /* ------------------------------------ RIFF (wave) ------------------------------------
    985. 

  985.  *
    986. 

  986.  * see ftp.microsoft.com:/SoftLib/MSLFILES/MDRK.EXE (also MMSYSTEM.H and MMREG.H)
    987. 

  987.  *
    988. 

  988.  *   0: "RIFF" (little-endian) or "RIFX" (big-endian)
    989. 

  989.  *   4: size
    990. 

  990.  *   8: "WAVE"  ("RMID" = midi data, others are AVI, CPPO, ACON etc)
    991. 

  991.  *       AVI chunk can include audio data
    992. 

  992.  *  
    993. 

  993.  *   rest very similar to AIFF (odd-sized chunks are padded)
    994. 

  994.  *
    995. 

  995.  * fmt  0: format code (see below)
    996. 

  996.  *      2: chans
    997. 

  997.  *      4: srate (long)
    998. 

  998.  *      8: average rate "for buffer estimation"
    999. 

  999.  *     12: alignment "block size"
    1000. 

  1000.  *     14: data size (bits per sample) (PCM only)
    1001. 

  1001.  *     16: count (bytes) of extra info in the header (i.e. trailing info added to this basic header)
    1002. 

  1002.  *     20: samples per block (short) in dvi_adpcm
    1003. 

  1003.  *  
    1004. 

  1004.  * formats are: 0: unknown, 1: PCM, 2: ADPCM, 3: IEEE float, 4: VSELP, 5: IBM_CVSD, 6: alaw, 7: mulaw
    1005. 

  1005.  *              0x10: OKI_ADPCM, 0x11: DVI_ADPCM, 0x12: MediaSpace_ADPCM,
    1006. 

  1006.  *              0x13: Sierra_ADPCM, 0x14: G723_ADPCM, 0x15: DIGISTD, 0x16: DIGIFIX, 0x17: Dialogic ADPCM,
    1007. 

  1007.  *              0x18: Mediavision ADPCM, 0x19: HP cu codec, 
    1008. 

  1008.  *              0x20: Yamaha_ADPCM, 0x21: SONARC, 0x22: DSPGroup_TrueSpeech
    1009. 

  1009.  *              0x23: EchoSC1, 0x24: AudioFile_AF36, 0x25: APTX, 0x26: AudioFile_AF10
    1010. 

  1010.  *              0x27: prosody 1612, 0x28: lrc,
    1011. 

  1011.  *              0x30: Dolby_Ac2, 0x31: GSM610, 0x32: MSN audio codec, 0x33: Antext_ADPCM, 0x34: Control_res_vqlpc,
    1012. 

  1012.  *              0x35: DIGIREAL, 0x36: DIGIADPCM, 0x37: Control_res_cr10, 0x38: NMS_VBXADPCM, 0x39:Roland rdac,
    1013. 

  1013.  *              0x3a: echo sc3, 0x3b: Rockwell adpcm, 0x3c: Rockwell digitalk codec, 0x3d: Xebec,
    1014. 

  1014.  *              0x40: G721_ADPCM, 0x41: G728 CELP, 0x42: MS G723, 0x50: MPEG, 
    1015. 

  1015.  *              0x52: RT24, 0x53: PAC, 0x55: Mpeg layer 3, 0x59: Lucent G723, 0x60: Cirrus,
    1016. 

  1016.  *              0x61: ESS Tech pcm, 0x62: voxware (obsolete), 0x63: canopus atrac,
    1017. 

  1017.  *              0x64: G726, 0x65: G722, 0x66: DSAT, 0x67: DSAT display,
    1018. 

  1018.  *              0x69: voxware (obsolete), 0x70: voxware ac8 (obsolete), 0x71: voxware ac10 (obsolete), 
    1019. 

  1019.  *              0x72: voxware ac16 (obsolete), 0x73: voxware ac20 (obsolete), 0x74: voxware rt24, 
    1020. 

  1020.  *              0x75: voxware rt29, 0x76: voxware rt29hw (obsolete), 0x77: voxware vr12 (obsolete),
    1021. 

  1021.  *              0x78: voxware vr18 (obsolete), 0x79: voxware tq40 (obsolete), 
    1022. 

  1022.  *              0x80: softsound, 0x81: voxware tq60 (obsolete), 0x82: MS RT24, 0x83: G729A,
    1023. 

  1023.  *              0x84: MVI_MVI2, 0x85: DF G726, 0x86: DF GSM610, 0x88: isaudio, 0x89: onlive,
    1024. 

  1024.  *              0x91: sbc24, 0x92: dolby ac3 spdif, 0x97: zyxel adpcm, 0x98: philips lpcbb,
    1025. 

  1025.  *              0x99: packed, 0x100: rhetorex adpcm, 
    1026. 

  1026.  *              0x101: Irat, 0x102: IBM_alaw?, 0x103: IBM_ADPCM?, 
    1027. 

  1027.  *              0x111: vivo G723, 0x112: vivo siren, 0x123: digital g273
    1028. 

  1028.  *              0x200: Creative_ADPCM, 0x202: Creative fastspeech 8, 0x203: Creative fastspeech 10, 
    1029. 

  1029.  *              0x220: quarterdeck, 0x300: FM_TOWNS_SND, 0x400: BTV digital, 0x680: VME vmpcm,
    1030. 

  1030.  *              0x1000: OLIGSM, 0x1001: OLIADPCM, 0x1002: OLICELP, 0x1003: OLISBC, 0x1004: OLIOPR
    1031. 

  1031.  *              0x1100: LH codec, 0x1400: Norris, 0x1401: isaudio, 0x1500: Soundspace musicompression, 0x2000: DVM
    1032. 

  1032.  * (see http://www.microsoft.com/asf/resources/draft-ietf-fleischman-codec-subtree-00.txt)
    1033. 

  1033.  *
    1034. 

  1034.  * RIFF and LIST chunks have nested chunks.  Registered chunk names include:
    1035. 

  1035.  *   LIST with subchunks, one of which can be:
    1036. 

  1036.  *     INFO itself containing:
    1037. 

  1037.  *       IARL: archival location, IART: artist, ICMS: commissioned, ICMT: comment, ICOP: copyright, ICRD: creation date,
    1038. 

  1038.  *       ICRP: uh...cropped, IDIM: dimensions, IDPI: dpi, IENG: engineer, IGNR: genre, IKEY: keywords, ILGT: lightness,
    1039. 

  1039.  *       IMED: medium, INAM: name, IPLT: palette, IPRD: product, ISBJ: subject, ISFT: software, ISHP: sharpness,
    1040. 

  1040.  *       ISRC: source, ISRF: source form, ITCH: technician, ISMP: SMPTE time code, IDIT: digitization time
    1041. 

  1041.  *
    1042. 

  1042.  * data chunk has the samples
    1043. 

  1043.  * other (currently ignored) chunks are wavl = waveform data, fact, cues of some sort, slnt = silence,
    1044. 

  1044.  *     plst = playlist, adtl = associated data list, labl = cue label, note = cue comments,
    1045. 

  1045.  *     ltxt = text associated with data segment (cue), file, DISP = displayable object,
    1046. 

  1046.  *     JUNK = outdated info, PAD = padding, etc
    1047. 

  1047.  * fact chunk generally has number of samples (used in compressed files)
    1048. 

  1048.  */
    1049. 

  1049. 

  1050. static void read_riff_header (int chan)
    1051. 

  1051. {
    1052. 

  1052.   /* we know we have checked for RIFF xxxx WAVE when we arrive here */
    1053. 

  1053.   int chunksize,offset,chunkloc,happy,little;
    1054. 

  1054.   little = 1;
    1055. 

  1055.   if (match_four_chars((unsigned char *)hdrbuf,I_RIFX)) little=0; /* big-endian data in this case, but I've never seen one */
    1056. 

  1056.   type_specifier = (*((int *)(hdrbuf+8)));
    1057. 

  1057.   chunkloc = 12;
    1058. 

  1058.   offset = 0;
    1059. 

  1059.   comment_start = 0;
    1060. 

  1060.   comment_end = 0;
    1061. 

  1061.   header_distributed = 1;
    1062. 

  1062.   sound_format = snd_unsupported;
    1063. 

  1063.   srate = 0;
    1064. 

  1064.   chans = 0;
    1065. 

  1065.   happy = 1;
    1066. 

  1066.   data_size = 0;
    1067. 

  1067.   fact_samples = 0;
    1068. 

  1068.   bits_per_sample = 0;
    1069. 

  1069.   true_file_length = lseek(chan,0L,2);
    1070. 

  1070.   update_form_size = big_or_little_endian_int((*(int *)(hdrbuf+4)),little);
    1071. 

  1071.   while (happy)
    1072. 

  1072.     {
    1073. 

  1073.       offset += chunkloc;
    1074. 

  1074.       if (seek_and_read(chan,(unsigned char *)hdrbuf,offset,32) <= 0)
    1075. 

  1075. 	{
    1076. 

  1076. 	  clm_printf("error reading header");
    1077. 

  1077. 	  return;
    1078. 

  1078. 	}
    1079. 

  1079.       chunksize = big_or_little_endian_int((*(int *)(hdrbuf+4)),little);
    1080. 

  1080.       if (match_four_chars((unsigned char *)hdrbuf,I_fmt_))
    1081. 

  1081. 	{
    1082. 

  1082. 	  /*
    1083. 

  1083. 	   * 8:  short format code        --1=PCM for example
    1084. 

  1084. 	   * 10: short chans              --1
    1085. 

  1085. 	   * 12: long rate                --48000 (0xbb80)
    1086. 

  1086. 	   * 16: long ave rate            --65655 (0x10077)
    1087. 

  1087. 	   * 20: short align              --2
    1088. 

  1088. 	   * 22: short data size (bits)   --16
    1089. 

  1089. 	   * 24: bytes of extra
    1090. 

  1090. 	   * ... some extra data dependent on format
    1091. 

  1091. 	   *
    1092. 

  1092. 	   *  R I  F F  # #  # #  W A  V E  f m  t sp
    1093. 

  1093. 	   *  5249 4646 f851 0500 5741 5645 666d 7420
    1094. 

  1094. 	   *  e40f 0000 0100 0100 80bb 0000 0077 0100
    1095. 

  1095. 	   *  0200 1000 0000 0000 0000 0000 0000 0000
    1096. 

  1096. 	   *  
    1097. 

  1097. 	   *  #x000551f8 = 348664 = size in bytes - 8
    1098. 

  1098. 	   *  #x00000fe4 = 4068 [fmt_ chunk size?]
    1099. 

  1099. 	   */
    1100. 

  1100. 	  original_sound_format = big_or_little_endian_short(((*(short *)(hdrbuf+8))),little);
    1101. 

  1101. 	  chans = big_or_little_endian_short((*(short *)(hdrbuf+10)),little);
    1102. 

  1102. 	  srate = big_or_little_endian_int((*(int *)(hdrbuf+12)),little);
    1103. 

  1103. 	  block_align = big_or_little_endian_short((*(short *)(hdrbuf+20)),little);
    1104. 

  1104. 	  bits_per_sample = big_or_little_endian_short((*(short *)(hdrbuf+22)),little);
    1105. 

  1105. 	  if (bits_per_sample == 16) 
    1106. 

  1106. 	    {
    1107. 

  1107. 	      if (little) sound_format = snd_16_linear_little_endian; else sound_format = snd_16_linear;
    1108. 

  1108. 	    }
    1109. 

  1109. 	  else
    1110. 

  1110. 	    if ((original_sound_format == 6) && (bits_per_sample == 8)) sound_format = snd_8_alaw; else
    1111. 

  1111. 	      if ((original_sound_format == 7) && (bits_per_sample == 8)) sound_format = snd_8_mulaw; else
    1112. 

  1112. 		if (original_sound_format == 1)
    1113. 

  1113. 		    {
    1114. 

  1114. 		      if (bits_per_sample == 8) sound_format = snd_8_unsigned; else
    1115. 

  1115. 			if (bits_per_sample == 32) 
    1116. 

  1116. 			  {
    1117. 

  1117. 			    if (little) sound_format = snd_32_linear_little_endian; else sound_format = snd_32_linear;
    1118. 

  1118. 			  }
    1119. 

  1119. 		    }
    1120. 

  1120. 		else
    1121. 

  1121. 		  /* IBM mulaw follows G711 specs like other versions (this info direct from IBM) */
    1122. 

  1122. 		  if (original_sound_format == 0x102) sound_format = snd_8_alaw; else
    1123. 

  1123. 		    if (original_sound_format == 0x101) sound_format = snd_8_mulaw;
    1124. 

  1124. 	}
    1125. 

  1125.       else
    1126. 

  1126. 	{
    1127. 

  1127. 	  if (match_four_chars((unsigned char *)hdrbuf,I_data))
    1128. 

  1128. 	    {
    1129. 

  1129. 	      update_ssnd_location = offset+4;
    1130. 

  1130. 	      data_location = offset + 8;
    1131. 

  1131. 	      data_size = big_or_little_endian_int((*(int *)(hdrbuf+4)),little);
    1132. 

  1132. 	      happy = 0;
    1133. 

  1133. 	    }
    1134. 

  1134. 	  else
    1135. 

  1135. 	    {
    1136. 

  1136. 	      if (match_four_chars((unsigned char *)hdrbuf,I_fact))
    1137. 

  1137. 		{
    1138. 

  1138. 		  fact_samples = big_or_little_endian_int((*(int *)(hdrbuf+8)),little);
    1139. 

  1139. 		}
    1140. 

  1140. 	      else
    1141. 

  1141. 		{
    1142. 

  1142. 		  if (match_four_chars((unsigned char *)hdrbuf,I_inst))
    1143. 

  1143. 		    {
    1144. 

  1144. 		      base_note = hdrbuf[8];
    1145. 

  1145. 		      base_detune = hdrbuf[9];
    1146. 

  1146. 		      /* rest is gain low-note high-note low-velocity high-velocity */
    1147. 

  1147. 		    }
    1148. 

  1148. 		  else
    1149. 

  1149. 		    {
    1150. 

  1150. 		      if (match_four_chars((unsigned char *)hdrbuf,I_clm_))
    1151. 

  1151. 			{
    1152. 

  1152. 			  comment_start = offset + 8;
    1153. 

  1153. 			  comment_end = comment_start + chunksize - 1; /* end of comment not start of next chunk */
    1154. 

  1154. 			}
    1155. 

  1155. 		    }
    1156. 

  1156. 		}
    1157. 

  1157. 	    }
    1158. 

  1158. 	}
    1159. 

  1159.       chunkloc = (8+chunksize);
    1160. 

  1160.       if (chunksize&1) chunkloc++; /* extra null appended to odd-length chunks */
    1161. 

  1161.     }
    1162. 

  1162.   if (true_file_length < data_size) data_size = true_file_length - data_location;
    1163. 

  1163.   data_size = c_snd_samples(sound_format,data_size);
    1164. 

  1164. }
    1165. 

  1165. 

  1166. static void write_riff_header (int chan, int srate, int chans, int siz, int format, char *comment, int len)
    1167. 

  1167. {
    1168. 

  1168.   int offset,i,j,lenhdr,extra,curend;
    1169. 

  1169.   char *str;
    1170. 

  1170.   lenhdr=0;
    1171. 

  1171.   extra=0;
    1172. 

  1172.   if (len != 0) 
    1173. 

  1173.     {
    1174. 

  1174.       lenhdr = 12;
    1175. 

  1175.       if ((len % 4) != 0)
    1176. 

  1176. 	extra = (4 - (len % 4));
    1177. 

  1177.     }
    1178. 

  1178.   write_four_chars((unsigned char *)hdrbuf,I_RIFF);
    1179. 

  1179.   (*(int *)(hdrbuf+4)) = little_endian_int(len+36+siz+lenhdr+extra);
    1180. 

  1180.   write_four_chars((unsigned char *)(hdrbuf+8),I_WAVE);
    1181. 

  1181.   write_four_chars((unsigned char *)(hdrbuf+12),I_fmt_);
    1182. 

  1182.   (*(int *)(hdrbuf+16)) = little_endian_int(24-8);
    1183. 

  1183.   switch (format)
    1184. 

  1184.     {
    1185. 

  1185.     case snd_8_mulaw: (*(short *)(hdrbuf+20)) = little_endian_short(7); (*(short *)(hdrbuf+34)) = little_endian_short(8); break;
    1186. 

  1186.     case snd_8_alaw: (*(short *)(hdrbuf+20)) = little_endian_short(6); (*(short *)(hdrbuf+34)) = little_endian_short(8); break;
    1187. 

  1187.     case snd_8_unsigned: (*(short *)(hdrbuf+20)) = little_endian_short(1); (*(short *)(hdrbuf+34)) = little_endian_short(8); break;
    1188. 

  1188.     case snd_16_linear_little_endian: (*(short *)(hdrbuf+20)) = little_endian_short(1); (*(short *)(hdrbuf+34)) = little_endian_short(16); break;
    1189. 

  1189.     case snd_32_linear_little_endian: (*(short *)(hdrbuf+20)) = little_endian_short(1); (*(short *)(hdrbuf+34)) = little_endian_short(32); break;
    1190. 

  1190.     default: 
    1191. 

  1191.       str=(char *)CALLOC(256,sizeof(char));
    1192. 

  1192.       sprintf(str,"CLM/RIFF unsupported sound data format type: %d\n",format);
    1193. 

  1193.       clm_printf(str);
    1194. 

  1194.       FREE(str);
    1195. 

  1195.       break;
    1196. 

  1196.     }
    1197. 

  1197.   (*(short *)(hdrbuf+22)) = little_endian_short((short)chans);
    1198. 

  1198.   (*(int *)(hdrbuf+24)) = little_endian_int(srate);
    1199. 

  1199.   (*(int *)(hdrbuf+28)) = little_endian_int(srate * c_snd_datum_size(format));
    1200. 

  1200.   (*(short *)(hdrbuf+32)) = little_endian_short(c_snd_datum_size(format));
    1201. 

  1201. 

  1202.   offset = 36;
    1203. 

  1203.   i = 36;
    1204. 

  1204.   curend = 0;
    1205. 

  1205.   if (len != 0)
    1206. 

  1206.     {
    1207. 

  1207.       offset += len+12;
    1208. 

  1208.       write_four_chars((unsigned char *)(hdrbuf+36),I_clm_);
    1209. 

  1209.       (*(int *)(hdrbuf+40)) = little_endian_int(len+extra);
    1210. 

  1210.       i = 44;
    1211. 

  1211.       for (j=0;j<len;j++)
    1212. 

  1212. 	{
    1213. 

  1213. 	  if (i == HDRBUFSIZ)
    1214. 

  1214. 	    {
    1215. 

  1215. 	      curend += HDRBUFSIZ;
    1216. 

  1216. 	      write(chan,hdrbuf,HDRBUFSIZ);
    1217. 

  1217. 	      i=0;
    1218. 

  1218. 	    }
    1219. 

  1219. 	  hdrbuf[i]=comment[j];
    1220. 

  1220. 	  i++;
    1221. 

  1221. 	}
    1222. 

  1222.       if (extra != 0)
    1223. 

  1223. 	{
    1224. 

  1224. 	  if ((i+extra) > HDRBUFSIZ)
    1225. 

  1225. 	    {
    1226. 

  1226. 	      curend += i;
    1227. 

  1227. 	      write(chan,hdrbuf,i);
    1228. 

  1228. 	      i=0;
    1229. 

  1229. 	    }
    1230. 

  1230. 	  for (j=0;j<extra;j++)
    1231. 

  1231. 	    {
    1232. 

  1232. 	      hdrbuf[i] = 0;
    1233. 

  1233. 	      i++;
    1234. 

  1234. 	    }
    1235. 

  1235. 	}
    1236. 

  1236.     }
    1237. 

  1237.   curend += i;
    1238. 

  1238.   write(chan,hdrbuf,i);
    1239. 

  1239.   write_four_chars((unsigned char *)hdrbuf,I_data);
    1240. 

  1240.   (*(int *)(hdrbuf+4)) = little_endian_int(siz);
    1241. 

  1241.   data_location = 8+curend;
    1242. 

  1242.   write(chan,hdrbuf,8);
    1243. 

  1243. }
    1244. 

  1244. 

  1245. 

  1246. static void update_riff_header (int chan, int siz)
    1247. 

  1247. {
    1248. 

  1248.   read(chan,hdrbuf,INITIAL_READ_SIZE);
    1249. 

  1249.   read_riff_header(chan);
    1250. 

  1250.   lseek(chan,4L,0);
    1251. 

  1251.   (*(int *)hdrbuf) = little_endian_int((siz+update_form_size-c_snd_bytes(sound_format,data_size))); 
    1252. 

  1252.   /* see update_aiff_header for explanation */
    1253. 

  1253.   write(chan,hdrbuf,4);
    1254. 

  1254.   lseek(chan,update_ssnd_location,0);
    1255. 

  1255.   (*(int *)hdrbuf) = little_endian_int(siz);
    1256. 

  1256.   write(chan,hdrbuf,4);
    1257. 

  1257. }
    1258. 

  1258. 

  1259. 

  1260. static void update_riff_header_comment (int chan, char *comment, int len)
    1261. 

  1261. {
    1262. 

  1262.   /* save-stats in CLM appends a comment after the sound data has been written */
    1263. 

  1263.   int i,j,true_len,old_len;
    1264. 

  1264.   if (len&1) true_len = len+1; else true_len=len;
    1265. 

  1265.   lseek(chan,0L,2);
    1266. 

  1266.   write_four_chars((unsigned char *)hdrbuf,I_INFO);
    1267. 

  1267.   (*(int *)(hdrbuf+4)) = little_endian_int(len);
    1268. 

  1268.   for (i=0,j=8;i<len;i++,j++) hdrbuf[j]=comment[i];
    1269. 

  1269.   write(chan,hdrbuf,8+true_len);
    1270. 

  1270.   lseek(chan,4L,0);
    1271. 

  1271.   read(chan,hdrbuf,4);
    1272. 

  1272.   old_len = little_endian_int(*((int *)hdrbuf));
    1273. 

  1273.   (*(int *)hdrbuf) = little_endian_int(old_len+true_len+8);
    1274. 

  1274.   lseek(chan,4L,0);
    1275. 

  1275.   write(chan,hdrbuf,4);
    1276. 

  1276. }
    1277. 

  1277. 

  1278. 

  1279. /* ------------------------------------ AVI ------------------------------------
    1280. 

  1280.  * actually a video format, but it sometimes contains embedded 'wave' data
    1281. 

  1281.  *
    1282. 

  1282.  * RIFF xxx AVI 
    1283. 

  1283.  *   <various LISTs>
    1284. 

  1284.  *   LIST xxxx hdr1 LIST strl(?) strh | strf | strn etc
    1285. 

  1285.  *     strf is the WAVE header starting with the sound format
    1286. 

  1286.  *   LIST xxxx movi ##db|##wb -- wb subblocks have the audio data (these need to be collected as a single stream)
    1287. 

  1287.  * there are many complications that we make no effort to handle here
    1288. 

  1288.  *
    1289. 

  1289.  * described in http://www.rahul.net/jfm/avi.html
    1290. 

  1290.  */
    1291. 

  1291. 

  1292. static void read_avi_header (int chan)
    1293. 

  1293. {
    1294. 

  1294.   /* we know we have checked for RIFF xxxx AVI  when we arrive here */
    1295. 

  1295.   int chunksize,offset,chunkloc,happy,cksize,rdsize,ckoff,cktotal;
    1296. 

  1296.   int cksizer,ckoffr,cktotalr,bits;
    1297. 

  1297.   type_specifier = (*((int *)(hdrbuf+8)));
    1298. 

  1298.   chunkloc = 12;
    1299. 

  1299.   offset = 0;
    1300. 

  1300.   comment_start = 0;
    1301. 

  1301.   comment_end = 0;
    1302. 

  1302.   header_distributed = 1;
    1303. 

  1303.   sound_format = snd_unsupported;
    1304. 

  1304.   srate = 0;
    1305. 

  1305.   chans = 1;
    1306. 

  1306.   happy = 1;
    1307. 

  1307.   data_size = 0;
    1308. 

  1308.   data_location = 0;
    1309. 

  1309.   true_file_length = lseek(chan,0L,2);
    1310. 

  1310.   while (happy)
    1311. 

  1311.     {
    1312. 

  1312.       offset += chunkloc;
    1313. 

  1313.       if (seek_and_read(chan,(unsigned char *)hdrbuf,offset,32) <= 0)
    1314. 

  1314. 	{
    1315. 

  1315. 	  clm_printf("error reading header");
    1316. 

  1316. 	  return;
    1317. 

  1317. 	}
    1318. 

  1318.       chunksize = little_endian_int((*(int *)(hdrbuf+4)));
    1319. 

  1319.       if (match_four_chars((unsigned char *)hdrbuf,I_LIST))
    1320. 

  1320. 	{
    1321. 

  1321. 	  ckoff = offset+12;
    1322. 

  1322. 	  cktotal = 12;
    1323. 

  1323. 	  if (match_four_chars((unsigned char *)(hdrbuf+8),I_movi))
    1324. 

  1324. 	    {
    1325. 

  1325. 	      while (cktotal < chunksize)
    1326. 

  1326. 		{
    1327. 

  1327. 		  lseek(chan,ckoff,0L);
    1328. 

  1328. 		  read(chan,hdrbuf,8);
    1329. 

  1329. 		  cksize = little_endian_int((*(int *)(hdrbuf+4)));
    1330. 

  1330. 		  if ((hdrbuf[2] == 'w') && (hdrbuf[3] == 'b'))
    1331. 

  1331. 		    {
    1332. 

  1332. 		      data_location = ckoff;
    1333. 

  1333. 		      if (srate != 0) happy=0;
    1334. 

  1334. 		      break;
    1335. 

  1335. 		    }
    1336. 

  1336. 		  ckoff += (8+cksize);
    1337. 

  1337. 		  cktotal += (8+cksize);
    1338. 

  1338. 		}
    1339. 

  1339. 	    }
    1340. 

  1340. 	  else
    1341. 

  1341. 	    {
    1342. 

  1342. 	      while (cktotal < chunksize)
    1343. 

  1343. 		{
    1344. 

  1344. 		  lseek(chan,ckoff,0L);
    1345. 

  1345. 		  read(chan,hdrbuf,8);
    1346. 

  1346. 		  cksize = little_endian_int((*(int *)(hdrbuf+4)));
    1347. 

  1347. 		  ckoff += (8+cksize);
    1348. 

  1348. 		  cktotal += (8+cksize);
    1349. 

  1349. 		  if (match_four_chars((unsigned char *)hdrbuf,I_LIST))
    1350. 

  1350. 		    {
    1351. 

  1351. 		      ckoffr = ckoff+12;
    1352. 

  1352. 		      cktotalr = 12;
    1353. 

  1353. 		      while (cktotalr < cksize)
    1354. 

  1354. 			{
    1355. 

  1355. 			  lseek(chan,ckoffr,0L);
    1356. 

  1356. 			  read(chan,hdrbuf,8);
    1357. 

  1357. 			  cksizer = little_endian_int((*(int *)(hdrbuf+4)));
    1358. 

  1358. 			  ckoffr += (8+cksizer);
    1359. 

  1359. 			  cktotalr += (8+cksizer);
    1360. 

  1360. 			  if (match_four_chars((unsigned char *)hdrbuf,I_strf))
    1361. 

  1361. 			    {
    1362. 

  1362. 			      if (cksizer < HDRBUFSIZ) rdsize = cksizer; else rdsize = HDRBUFSIZ;
    1363. 

  1363. 			      read(chan,hdrbuf,rdsize);
    1364. 

  1364. 			      original_sound_format = little_endian_short((*(short *)(hdrbuf+0)));
    1365. 

  1365. 			      chans	= little_endian_short((*(short *)(hdrbuf+2)));
    1366. 

  1366. 			      srate = little_endian_int((*(int *)(hdrbuf+4)));
    1367. 

  1367. 			      /* block_align = little_endian_short((*(short *)(hdrbuf+12))); */
    1368. 

  1368. 			      bits = little_endian_short((*(short *)(hdrbuf+14)));
    1369. 

  1369. 			      /* only 16 bit linear little endian for now */
    1370. 

  1370. 			      if ((bits == 16) && (original_sound_format == 1))
    1371. 

  1371. 				original_sound_format = snd_16_linear_little_endian;
    1372. 

  1372. 			      if (data_location != 0) happy = 0;
    1373. 

  1373. 			      break;
    1374. 

  1374. 			    }
    1375. 

  1375. 			}
    1376. 

  1376. 		    }
    1377. 

  1377. 		}
    1378. 

  1378. 	    }
    1379. 

  1379. 	}
    1380. 

  1380.       chunkloc = (8+chunksize);
    1381. 

  1381.       if (chunksize&1) chunkloc++; /* extra null appended to odd-length chunks */
    1382. 

  1382.     }
    1383. 

  1383. }
    1384. 

  1384. 

  1385. 

  1386. 

  1387. /* ------------------------------------ SoundFont 2.0 ------------------------------------
    1388. 

  1388.  *
    1389. 

  1389.  * Emu's SoundFont(tm) format uses RIFF -- at ftp.creaf.com:/pub/emu/sf2_00a.ps)
    1390. 

  1390.  *
    1391. 

  1391.  * RIFF xxxx sfbk followed by
    1392. 

  1392.  *   LIST xxxx INFO chunk (nothing of interest -- icmt subchunk might have comments)
    1393. 

  1393.  *   LIST xxxx sdta chunk = data
    1394. 

  1394.  *     smpl chunk (16 bit linear little-endian)
    1395. 

  1395.  *   LIST xxxx pdta list chunk 
    1396. 

  1396.  *     shdr subchunk has srate at 40 (int), samples at 28
    1397. 

  1397.  */
    1398. 

  1398. 

  1399. static void read_soundfont_header (int chan)
    1400. 

  1400. {
    1401. 

  1401.   /* we know we have checked for RIFF xxxx sfbk when we arrive here */
    1402. 

  1402.   int chunksize,offset,chunkloc,happy,type,cksize,rdsize,ckoff;
    1403. 

  1403.   char *str;
    1404. 

  1404.   type_specifier = (*((int *)(hdrbuf+8)));
    1405. 

  1405.   chunkloc = 12;
    1406. 

  1406.   offset = 0;
    1407. 

  1407.   comment_start = 0;
    1408. 

  1408.   comment_end = 0;
    1409. 

  1409.   header_distributed = 1;
    1410. 

  1410.   sound_format = snd_16_linear_little_endian;
    1411. 

  1411.   srate = 0;
    1412. 

  1412.   chans = 1; /* to hell with soundfont stereo */
    1413. 

  1413.   happy = 1;
    1414. 

  1414.   data_size = 0;
    1415. 

  1415.   data_location = 0;
    1416. 

  1416.   true_file_length = lseek(chan,0L,2);
    1417. 

  1417.   while (happy)
    1418. 

  1418.     {
    1419. 

  1419.       offset += chunkloc;
    1420. 

  1420.       if (seek_and_read(chan,(unsigned char *)hdrbuf,offset,32) <= 0)
    1421. 

  1421. 	{
    1422. 

  1422. 	  clm_printf("error reading header");
    1423. 

  1423. 	  return;
    1424. 

  1424. 	}
    1425. 

  1425.       chunksize = little_endian_int((*(int *)(hdrbuf+4)));
    1426. 

  1426.       if (match_four_chars((unsigned char *)hdrbuf,I_LIST))
    1427. 

  1427. 	{
    1428. 

  1428. 	  /* everything is squirreled away in LIST chunks in this format */
    1429. 

  1429. 	  if (match_four_chars((unsigned char *)(hdrbuf+8),I_pdta))
    1430. 

  1430. 	    {
    1431. 

  1431. 	      /* go searching for I_shdr -- headers this complicated should be illegal. */
    1432. 

  1432. 	      ckoff = offset+12;
    1433. 

  1433. 	      lseek(chan,ckoff,0L);
    1434. 

  1434. 	      while (!srate)
    1435. 

  1435. 		{
    1436. 

  1436. 		  read(chan,hdrbuf,8);
    1437. 

  1437. 		  cksize = little_endian_int((*(int *)(hdrbuf+4)));
    1438. 

  1438. 		  ckoff += (8+cksize);
    1439. 

  1439. 		  /* here we need to jump over subchunks! -- 4-Aug-97 */
    1440. 

  1440. 		  if (match_four_chars((unsigned char *)hdrbuf,I_shdr))
    1441. 

  1441. 		    {
    1442. 

  1442. 		      if (cksize < HDRBUFSIZ) rdsize = cksize; else rdsize = HDRBUFSIZ;
    1443. 

  1443. 		      read(chan,hdrbuf,rdsize);
    1444. 

  1444. 		      data_size = 2 * little_endian_int(*(int *)(hdrbuf+24));
    1445. 

  1445. 		      srate = little_endian_int(*(int *)(hdrbuf+36));
    1446. 

  1446.                       type = little_endian_short(*(int *)(hdrbuf+44));
    1447. 

  1447. 		      if (type != 1) 
    1448. 

  1448. 			{
    1449. 

  1449. 			  str = (char *)CALLOC(64,sizeof(char));
    1450. 

  1450. 			  sprintf(str,"can't handle this SoundFont data type: %x",type);
    1451. 

  1451. 			  clm_printf(str);
    1452. 

  1452. 			  FREE(str);
    1453. 

  1453. 			  return;
    1454. 

  1454. 			}
    1455. 

  1455. 		      happy = (!data_location);
    1456. 

  1456. 		    }
    1457. 

  1457. 		  else lseek(chan,ckoff,0L);
    1458. 

  1458. 		}
    1459. 

  1459. 	    }
    1460. 

  1460. 	  else
    1461. 

  1461. 	    {
    1462. 

  1462. 	      if (match_four_chars((unsigned char *)(hdrbuf+8),I_sdta))
    1463. 

  1463. 		{
    1464. 

  1464. 		  /* assume smpl follows + subchunk size */
    1465. 

  1465. 		  /* Convert 1.4 appears to create a separate smpl chunk */
    1466. 

  1466. 		  data_location = offset+20; /* LIST xxxx sdta smpl xxxx ... */
    1467. 

  1467. 		  happy = (!srate);
    1468. 

  1468. 		}
    1469. 

  1469. 	    }
    1470. 

  1470. 	}
    1471. 

  1471.       chunkloc = (8+chunksize);
    1472. 

  1472.       if (chunksize&1) chunkloc++; /* extra null appended to odd-length chunks */
    1473. 

  1473.     }
    1474. 

  1474.   if (true_file_length < data_size) data_size = true_file_length - data_location;
    1475. 

  1475.   data_size = c_snd_samples(sound_format,data_size);
    1476. 

  1476. }
    1477. 

  1477. 

  1478. 

  1479. 

  1480. 

  1481. /* ------------------------------------ NIST ------------------------------------ 
    1482. 

  1482.  *
    1483. 

  1483.  * code available in ogitools-v1.0.tar.gz at svr-ftp.eng.cam.ac.uk:comp.speech/sources
    1484. 

  1484.  * 
    1485. 

  1485.  *   0: "NIST_1A"
    1486. 

  1486.  *   8: data_location as ASCII representation of integer (apparently always "   1024")
    1487. 

  1487.  *  16: start of complicated header -- see below for details
    1488. 

  1488.  *
    1489. 

  1489.  *  The most recent version of the SPHERE package is available
    1490. 

  1490.  *  via anonymous ftp from jaguar.ncsl.nist.gov [129.6.48.157] in the pub directory
    1491. 

  1491.  *  in compressed tar form as "sphere-v.tar.Z" (where "v" is the version
    1492. 

  1492.  *  code 2.6a last I looked).  shortpack is also at this site.
    1493. 

  1493.  *
    1494. 

  1494.  *  here's an example:
    1495. 

  1495.  *
    1496. 

  1496.  *  NIST_1A
    1497. 

  1497.  *     1024
    1498. 

  1498.  *  database_id -s5 TIMIT
    1499. 

  1499.  *  database_version -s3 1.0
    1500. 

  1500.  *  utterance_id -s8 aks0_sa1
    1501. 

  1501.  *  channel_count -i 1
    1502. 

  1502.  *  sample_count -i 63488
    1503. 

  1503.  *  sample_rate -i 16000
    1504. 

  1504.  *  sample_min -i -6967
    1505. 

  1505.  *  sample_max -i 7710
    1506. 

  1506.  *  sample_n_bytes -i 2
    1507. 

  1507.  *  sample_byte_format -s2 01
    1508. 

  1508.  *  sample_sig_bits -i 16
    1509. 

  1509.  *  end_head
    1510. 

  1510.  *
    1511. 

  1511.  * the sample_byte_format can be "10"=big-endian or "01"=little-endian, or "shortpack-v0"=compressed via shortpack
    1512. 

  1512.  * other formats are wavpack and shorten.
    1513. 

  1513.  *
    1514. 

  1514.  * another field is 'sample_coding' which can be pcm (i.e. linear), 'pcm,embedded-shorten-v1.09', mu-law, ulaw, pculaw etc --
    1515. 

  1515.  *   so unpredictable as to be totally useless. This means we sometimes try to decode shorten-encoded files because
    1516. 

  1516.  *   we ignore this field.  And worse, there's a 'channels_interleaved' field that (apparently) can be FALSE.  Tough.
    1517. 

  1517.  */
    1518. 

  1518. 

  1519. static int decode_nist_value (char *str,int base,int end)
    1520. 

  1520. {
    1521. 

  1521.   /* can be -i -r or -snnn where nnn=ascii rep of integer = len of string (!) */
    1522. 

  1522.   /* we'll deal only with integer fields (and well-behaved string fields) */
    1523. 

  1523.   int i,j;
    1524. 

  1524.   char value[80];
    1525. 

  1525.   i=base;
    1526. 

  1526.   while ((i<end) && (str[i] != '-')) i++; /* look for -i or whatever */
    1527. 

  1527.   while ((i<end) && (str[i] != ' ')) i++; /* look for space after it */
    1528. 

  1528.   i++;
    1529. 

  1529.   for (j=0;i<end;j++,i++)
    1530. 

  1530.     value[j]=str[i];
    1531. 

  1531.   value[j]=0;
    1532. 

  1532.   if (value[0]=='s') return(NIST_shortpack);
    1533. 

  1533.   sscanf(value,"%d",&i);
    1534. 

  1534.   return(i);
    1535. 

  1535. }
    1536. 

  1536. 

  1537. static void read_nist_header (int chan)
    1538. 

  1538. {
    1539. 

  1539.   char str[80],name[80];
    1540. 

  1540.   int happy = 1;
    1541. 

  1541.   int k,hend,curbase,j,n,nm,samples,bytes,byte_format;
    1542. 

  1542.   type_specifier = (*((int *)(hdrbuf))); /* the actual id is "NIST_1A" */
    1543. 

  1543.   for (k=8;k<16;k++) str[k-8]=hdrbuf[k];
    1544. 

  1544.   sscanf(str,"%d",&data_location);       /* always "1024" */
    1545. 

  1545.   n = 16;
    1546. 

  1546.   hend = INITIAL_READ_SIZE;
    1547. 

  1547.   k=0;
    1548. 

  1548.   curbase = 0;
    1549. 

  1549.   samples = 0;
    1550. 

  1550.   bytes = 0;
    1551. 

  1551.   srate = 0;
    1552. 

  1552.   chans = 0;
    1553. 

  1553.   comment_start = 16;
    1554. 

  1554.   comment_end = 16;
    1555. 

  1555.   byte_format = 10;
    1556. 

  1556.   for (j=0;j<80;j++) str[j]=' ';  
    1557. 

  1557.   while (happy) 
    1558. 

  1558.     {
    1559. 

  1559.       /* much as in xIFF files, march through the file looking for the data we're after */
    1560. 

  1560.       /* in this case we munch a character at a time... */
    1561. 

  1561.       str[k] = hdrbuf[n];
    1562. 

  1562.       if ((((str[k] == '\0') || (str[k] == '\n')) || ((curbase+n+1) >= data_location)) || (k == 79))
    1563. 

  1563. 	{
    1564. 

  1564. 	  /* got a complete record (assuming no embedded newlines, of course) */
    1565. 

  1565. 	  /* now look for a record we care about and decode it */
    1566. 

  1566. 	  nm = 0;
    1567. 

  1567. 	  while (str[nm] != ' ')
    1568. 

  1568. 	    {
    1569. 

  1569. 	      name[nm] = str[nm];
    1570. 

  1570. 	      nm++;
    1571. 

  1571. 	    }
    1572. 

  1572. 	  name[nm]=0;
    1573. 

  1573. 	  if (strcmp(name,"sample_rate") == 0) srate = decode_nist_value(str,nm,k); else
    1574. 

  1574. 	    if (strcmp(name,"channel_count") == 0) chans = decode_nist_value(str,nm,k); else
    1575. 

  1575. 	      if (strcmp(name,"end_head") == 0) {happy = 0; comment_end=curbase+n-1;} else
    1576. 

  1576. 		if (strcmp(name,"sample_count") == 0) samples = decode_nist_value(str,nm,k); else
    1577. 

  1577. 		  if ((bytes == 0) && (strcmp(name,"sample_n_bytes") == 0)) bytes = decode_nist_value(str,nm,k); else
    1578. 

  1578. 		    if ((bytes == 0) && (strcmp(name,"sample_sig_bits") == 0)) {bytes = decode_nist_value(str,nm,k); bytes = (bytes>>3);} else
    1579. 

  1579. 		      if (strcmp(name,"sample_byte_format") == 0) byte_format = decode_nist_value(str,nm,k); else
    1580. 

  1580. 			if (strcmp(name,"end_head") == 0) happy = 0;
    1581. 

  1581. 	  for (j=0;j<=k;j++) str[j]=' ';
    1582. 

  1582. 	  k=0;
    1583. 

  1583. 	  if ((curbase+n+1) > 1024) happy=0;
    1584. 

  1584. 	}
    1585. 

  1585.       else
    1586. 

  1586. 	k++;
    1587. 

  1587.       n++;
    1588. 

  1588.       if (n >= hend)
    1589. 

  1589. 	{
    1590. 

  1590. 	  curbase += hend;
    1591. 

  1591. 	  n = 0;
    1592. 

  1592. 	  read(chan,hdrbuf,HDRBUFSIZ);
    1593. 

  1593. 	  hend = HDRBUFSIZ;
    1594. 

  1594. 	}
    1595. 

  1595.     }
    1596. 

  1596.   data_size = samples*bytes;
    1597. 

  1597.   if (byte_format == NIST_shortpack)
    1598. 

  1598.     {
    1599. 

  1599.       sound_format = snd_unsupported;
    1600. 

  1600.       original_sound_format = NIST_shortpack;
    1601. 

  1601.     }
    1602. 

  1602.   else
    1603. 

  1603.     {
    1604. 

  1604.       if (bytes == 2) 
    1605. 

  1605. 	{
    1606. 

  1606. 	  if (byte_format == 10) 
    1607. 

  1607. 	    sound_format = snd_16_linear;
    1608. 

  1608. 	  else sound_format = snd_16_linear_little_endian;
    1609. 

  1609. 	}
    1610. 

  1610.       else sound_format = snd_8_mulaw;
    1611. 

  1611.     }
    1612. 

  1612.   data_size = c_snd_samples(sound_format,data_size);
    1613. 

  1613.   header_distributed = 1;
    1614. 

  1614. }
    1615. 

  1615. 

  1616. 

  1617. 

  1618. /* ------------------------------------ BICSF ------------------------------------ 
    1619. 

  1619.  * (actually, this is EBICSF and the old BICSF is called IRCAM below)
    1620. 

  1620.  *
    1621. 

  1621.  * 0-28: NeXT-compatible header, read by read_next_header above.
    1622. 

  1622.  *   28: bicsf magic number (
    1623.