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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > mpeg/mp3 > 查看源码
COMMON.C
资源名称：mpeg.zip　[点击查看]
上传用户：njqiyou
上传日期：2007-01-08
资源大小：574k
文件大小：62k
源码类别：

mpeg/mp3

开发平台：

C/C++

COMMON.C：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Multichannel Encoder
  4.  *
  5.  * $Id: common.c 1.8 1996/02/12 07:13:35 rowlands Exp $
  6.  *
  7.  * $Log: common.c $
  8.  * Revision 1.8  1996/02/12 07:13:35  rowlands
  9.  * Release following Munich meeting
  10.  *
  11.  * Revision 1.5.2.1  1995/11/06  04:19:12  rowlands
  12.  * Received from Uwe Felderhoff (IRT)
  13.  *
  14.  * Revision 1.6.1  1995/08/14  07:49:33  tenkate
  15.  * ML-LSF added Warner ten Kate 7/8/95 (Philips)
  16.  * allocation table alloc_4 read to allocml
  17.  *
  18.  * Revision 1.6  1995/07/31  07:44:27  tenkate
  19.  * void hdr_to_frps updated for phantom coding, 25/07/95 WtK
  20.  *
  21.  * Revision 1.3.2.1  1995/06/16  03:46:42  rowlands
  22.  * Input from Susanne Ritscher (IRT)
  23.  *
  24.  * Revision 1.3.3.1  1995/06/16  08:25:11  rowlands
  25.  * Input from Sang Wook Kim (Samsung AIT)
  26.  *
  27.  **********************************************************************/
  29. /**********************************************************************
  30.  *   date   programmers         comment                               *
  31.  * 2/25/91  Doulas Wong,        start of version 1.0 records          *
  32.  *          Davis Pan                                                 *
  33.  * 5/10/91  W. Joseph Carter    Created this file for all common      *
  34.  *                              functions and global variables.       *
  35.  *                              Ported to Macintosh and Unix.         *
  36.  *                              Added Jean-Georges Fritsch's          *
  37.  *                              "bitstream.c" package.                *
  38.  *                              Added routines to handle AIFF PCM     *
  39.  *                              sound files.                          *
  40.  *                              Added "mem_alloc()" and "mem_free()"  *
  41.  *                              routines for memory allocation        *
  42.  *                              portability.                          *
  43.  *                              Added routines to convert between     *
  44.  *                              Apple SANE extended floating point    *
  45.  *                              format and IEEE double precision      *
  46.  *                              floating point format.  For AIFF.     *
  47.  * 02jul91 dpwe (Aware Inc)     Moved allocation table input here;    *
  48.  *                              Tables read from subdir TABLES_PATH.  *
  49.  *                              Added some debug printout fns (Write*)*
  50.  * 7/10/91 Earle Jennings       replacement of the one float by FLOAT *
  51.  *                              port to MsDos from MacIntosh version  *
  52.  * 8/ 5/91 Jean-Georges Fritsch fixed bug in open_bit_stream_r()      *
  53.  *10/ 1/91 S.I. Sudharsanan,    Ported to IBM AIX platform.           *
  54.  *         Don H. Lee,                                                *
  55.  *         Peter W. Farrett                                           *
  56.  *10/3/91  Don H. Lee           implemented CRC-16 error protection   *
  57.  *                              newly introduced functions are        *
  58.  *                              I_CRC_calc, II_CRC_calc and           *
  59.  *                              update_CRC. Additions and revisions   *
  60.  *                              are marked with dhl for clarity       *
  61.  *10/18/91 Jean-Georges Fritsch fixed bug in update_CRC(),            *
  62.  *                              II_CRC_calc() and I_CRC_calc()        *
  63.  * 2/11/92  W. Joseph Carter    Ported new code to Macintosh.  Most   *
  64.  *                              important fixes involved changing     *
  65.  *                              16-bit ints to long or unsigned in    *
  66.  *                              bit alloc routines for quant of 65535 *
  67.  *                              and passing proper function args.     *
  68.  *                              Removed "Other Joint Stereo" option   *
  69.  *                              and made bitrate be total channel     *
  70.  *                              bitrate, irrespective of the mode.    *
  71.  *                              Fixed many small bugs & reorganized.  *
  72.  *3/20/92 Jean-Georges Fritsch  fixed bug in start-of-frame search    *
  73.  *  8jul92 Susanne Ritscher     MS-DOS, MSC 6.0 port fixes.           *
  74.  * 19aug92 Soren H. Nielsen     Fixed bug in I_CRC_calc and in        *
  75.  *                              II_CRC_calc. Added function: new_ext  *
  76.  *          for better MS-DOS compatability       *
  77.  *26nov92 Susanne Ritscher    AIFF for MS-DOS        *
  78.  **********************************************************************
  79.  *                                                                    *
  80.  *                                                                    *
  81.  *  MPEG/audio Phase 2 coding/decoding multichannel                   *
  82.  *                                                                    *
  83.  *  7/27/93        Susanne Ritscher,  IRT Munich                      *
  84.  *                                                                    *
  85.  *  8/27/93        Susanne Ritscher, IRT Munich                       *
  86.  *                 Channel-Switching is working                       *
  87.  *  9/1/93         Susanne Ritscher,  IRT Munich                      *
  88.  *                 all channels normalized                            *
  89.  *  9/20/93        channel-switching is only performed at a           *
  90.  *                 certain limit of TC_ALLOC dB, which is included    *
  91.  *                 in encoder.h                                       *
  92.  *                                                                    *
  93.  *  Version 1.0                                                       *
  94.  *                                                                    *
  95.  *  07/12/94       Susanne Ritscher,  IRT Munich                      *
  96.  *                                                                    *
  97.  *  Version 1.1                                                       *
  98.  *                                                                    *
  99.  *  02/23/95    Susanne Ritscher,  IRT Munich                      *
  100.  *                 corrected some bugs                                *
  101.  *                 extension bitstream is working                     *
  102.  *                                                                    *
  103.  *  Version 2.0                                                       *
  104.  *                                                                    *
  105.  *  01/28/97       Frans de Bont, Philips Sound & Vision, Eindhoven   *
  106.  *     - dynamic crosstalk working for all configurations*
  107.  *     - prediction working for all configurations       *
  108.  *     - extension bitstream fixed       *
  109.  *     - fully compliant to DIS 13818-3.2                *
  110.  *                                                                    *       *     
  111.  **********************************************************************/
  112. /***********************************************************************
  113.  *                                                                    *
  114.  *  06/06/95    Sang Wook Kim,  Samsung AIT                        *
  115.  *                 corrected some bugs                                *
  116.  *                                                                    *
  117.  **********************************************************************/
  118. /***********************************************************************
  119. *
  120. *  Global Include Files
  121. *
  122. ***********************************************************************/
  124. #include        "common.h"
  126. /*
  127. #undef PrintCRCDebug
  128. #undef PrintBitDebug
  129. */
  130. #ifdef  MACINTOSH
  132. #include        <SANE.h>
  133. #include        <pascal.h>
  135. #endif
  137. #include <ctype.h>
  139. /***********************************************************************
  140. *
  141. *  Global Variable Definitions
  142. *
  143. ***********************************************************************/
  145. char *mode_names[4] = { "stereo", "j-stereo", "dual-ch", "single-ch" };
  146. char *layer_names[3] = { "I", "II", "III" };
  148. double  s_freq[4] = {44.1, 48, 32, 0};
  150. int   bitrate[3][16] = {
  151.  {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0},
  152.  {0,32,48,56,64,80,96,112,128,160,192,224,256,320,384,0},
  153.  {0,32,40,48,56,64,80,96,112,128,160,192,224,256,320,0}
  154.         };
  156. double /*far*/ multiple[64] = {
  157. 2.00000000000000, 1.58740105196820, 1.25992104989487,
  158. 1.00000000000000, 0.79370052598410, 0.62996052494744, 0.50000000000000,
  159. 0.39685026299205, 0.31498026247372, 0.25000000000000, 0.19842513149602,
  160. 0.15749013123686, 0.12500000000000, 0.09921256574801, 0.07874506561843,
  161. 0.06250000000000, 0.04960628287401, 0.03937253280921, 0.03125000000000,
  162. 0.02480314143700, 0.01968626640461, 0.01562500000000, 0.01240157071850,
  163. 0.00984313320230, 0.00781250000000, 0.00620078535925, 0.00492156660115,
  164. 0.00390625000000, 0.00310039267963, 0.00246078330058, 0.00195312500000,
  165. 0.00155019633981, 0.00123039165029, 0.00097656250000, 0.00077509816991,
  166. 0.00061519582514, 0.00048828125000, 0.00038754908495, 0.00030759791257,
  167. 0.00024414062500, 0.00019377454248, 0.00015379895629, 0.00012207031250,
  168. 0.00009688727124, 0.00007689947814, 0.00006103515625, 0.00004844363562,
  169. 0.00003844973907, 0.00003051757813, 0.00002422181781, 0.00001922486954,
  170. 0.00001525878906, 0.00001211090890, 0.00000961243477, 0.00000762939453,
  171. 0.00000605545445, 0.00000480621738, 0.00000381469727, 0.00000302772723,
  172. 0.00000240310869, 0.00000190734863, 0.00000151386361, 0.00000120155435,
  173. 1E-20
  174. };
  176. int sbgrp[32] = { 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 10, 10,
  177.  11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11};
  178. int sb_groups[12] = { 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 15, 26 /*31*/};
  181. int transmission_channel7[8][2] = { /* for 5/2 config */
  182. {10, 11}, 
  183. { 7, 11}, 
  184. {10,  8}, 
  185. { 7,  8}, 
  186. {10,  9}, 
  187. { 7,  9}, 
  188. { 9, 11}, 
  189. { 9,  8}, 
  190. };    
  192. int transmission_channel5[8][5] = { /* for 3/2 config */
  193.                    {0, 1, 2, 3, 4}, 
  194.    {0, 1, 5, 3, 4}, 
  195.    {0, 1, 6, 3, 4}, 
  196.    {0, 1, 2, 5, 4}, 
  197.    {0, 1, 2, 3, 6}, 
  198.    {0, 1, 2, 5, 6}, 
  199.    {0, 1, 6, 5, 4}, 
  200.    {0, 1, 5, 3, 6}, 
  201.    };
  203. int transmission_channel4a[6][4] = { /* for 3/1 config */
  204.                    {0, 1, 2, 3}, 
  205.    {0, 1, 5, 3}, 
  206.    {0, 1, 6, 3}, 
  207.    {0, 1, 2, 5}, 
  208.    {0, 1, 2, 6}, 
  209.    {0, 1, 5, 6}, 
  210.    };
  212. int transmission_channel4b[4][4] = { /* for 2/2 config */
  213.                    {0, 1, 2, 3}, 
  214.    {0, 1, 5, 3}, 
  215.    {0, 1, 2, 6}, 
  216.    {0, 1, 5, 6}, 
  217.    };
  219. int transmission_channel3[3][5] = { /* for 3/0 (+ 2/0) and 2/1 config's */
  220.                    {0, 1, 2, 3, 4}, 
  221.    {0, 1, 5, 3, 4}, 
  222.    {0, 1, 6, 3, 4}, 
  223.    };
  225. int no_channel[8][2] = {
  226. {5, 6}, 
  227. {2, 6}, 
  228. {5, 2}, 
  229. {3, 6}, 
  230. {5, 4}, 
  231. {3, 4}, 
  232. {3, 2}, 
  233. {2, 4}, 
  234. };    
  237. int n_pred_coef[16]; 
  238. int n_pred_coef4[16]  = { 6, 4, 4, 4, 2, 2, 2, 0, 2, 2, 2, 0, 0, 0, 0, 0 }; 
  239. int n_pred_coef3[16] = { 4, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 
  240. int n_pred_coef1[16] = { 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 
  242. int dyn_bbal5[19][12] = { /* for 5/2 config */
  243.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
  244.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  245.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  246.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  247.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  248.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  249.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  250.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  251.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  252.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  253.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  254.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  255.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  256.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  257.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  258.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  259.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  260.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  261.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  262.     };
  263. int dyn_bbal4[15][12] = { /* for 3/2 config */
  264.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
  265.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  266.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  267.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  268.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  269.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  270.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  271.     {12, 12, 12, 12, 12, 12, 12, 12, 24, 21, 36, 87},     
  272.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  273.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  274.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  275.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  276.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  277.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  278.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  279.     };
  280. int dyn_bbal4PhC[15][12] = { /* for 3/2 config in case of Phantom center coding */
  281.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
  282.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  283.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  284.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 0, 0},     
  285.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  286.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 12, 29},         
  287.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 12, 29},         
  288.     {12, 12, 12, 12, 12, 12, 12, 12, 24, 21, 24, 58},     
  289.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  290.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  291.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  292.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  293.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  294.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 12, 29},         
  295.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  296.     };
  297. int dyn_bbal3[5][12] = { /* for 3/1 and 2/2 config */
  298.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
  299.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  300.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  301.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 24, 58},         
  302.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  303.     };
  304. int dyn_bbal3PhC[5][12] = { /* for 3/1 config in case of Phantom center coding */
  305.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
  306.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  307.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 0, 0},     
  308.     {8, 8, 8, 8, 8, 8, 8, 8, 16, 14, 12, 29},         
  309.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  310.     };
  311. int dyn_bbal1[2][12] = { /* for 3/0 (+2/0) and 2/1 config */
  312.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
  313.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 12, 29},     
  314.     };
  315. int dyn_bbal1PhC[2][12] = { /* for 3/0 (+2/0) config in case of Phantom center coding */
  316.     {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 
  317.     {4, 4, 4, 4, 4, 4, 4, 4, 8, 7, 0, 0},     
  318.     };
  321. int dyn_ch5[19][2] = { /* for 5/2 config */
  322.     {1, 1}, 
  323.     {1, 0}, 
  324.     {1, 0}, 
  325.     {1, 0}, 
  326.     {1, 0}, 
  327.     {0, 1}, 
  328.     {0, 0}, 
  329.     {0, 0}, 
  330.     {0, 0}, 
  331.     {0, 0}, 
  332.     {0, 1}, 
  333.     {0, 0}, 
  334.     {0, 0}, 
  335.     {0, 0}, 
  336.     {0, 1}, 
  337.     {0, 0}, 
  338.     {0, 0}, 
  339.     {0, 0}, 
  340.     {0, 0}, 
  341.    };    
  342.  
  343. int dyn_ch4[15][3] = { /* for 3/2 config */
  344.     {1, 1, 1}, 
  345.     {1, 1, 0}, 
  346.     {1, 0, 1}, 
  347.     {0, 1, 1}, 
  348.     {1, 0, 0}, 
  349.     {0, 1, 0}, 
  350.     {0, 0, 1}, 
  351.     {0, 0, 0}, 
  352.     {1, 1, 0}, 
  353.     {1, 0, 1}, 
  354.     {1, 1, 0}, 
  355.     {1, 0, 0}, 
  356.     {1, 0, 0}, 
  357.     {0, 1, 0}, 
  358.     {1, 0, 0}, 
  359.    };    
  360.  
  361. int dyn_ch3[5][2] = { /* for 3/1 and 2/2 config */
  362.     {1, 1}, 
  363.     {1, 0}, 
  364.     {0, 1}, 
  365.     {0, 0}, 
  366.     {1, 0}, 
  367.    };    
  368.  
  369. int dyn_ch1[2][3] = { /* for 3/0 (+2/0) and 2/1 config */
  370.     {1, 1, 1}, 
  371.     {0, 1, 1}, 
  372.    };    
  373.  
  374. int T2[12], T3[12], T4[12], T5[12], T6[12];
  375. int T2outof[12], T3outof[12], T4outof[12]; /* L0 or R0 */
  376. int T2from[12], T3from[12], T4from[12];
  379. /***********************************************************************
  380. *
  381. *  Global Function Definitions
  382. *
  383. ***********************************************************************/
  385. void program_information(void)
  386. {
  387.  printf("ISO MPEG Audio Subgroup Software Simulation Group (1996)n");
  388.  printf("ISO 13818-3 MPEG-2 Audio Multichannel Encodern");
  389.  printf("%sn", VERSION);
  390. }
  392. /* The system uses a variety of data files.  By opening them via this
  393.    function, we can accommodate various locations. */
  395. FILE *OpenTableFile(char *name)
  396. {
  397. char fulname[80];
  398. char *envdir;
  399. FILE *f;
  401.      fulname[0] = '';
  403. #ifdef TABLES_PATH
  404.        strcpy(fulname, TABLES_PATH);   /* default relative path for tables */
  405. #endif /* TABLES_PATH */          /* (includes terminal path seperator */
  407. #ifdef UNIX                       /* envir. variables for UNIX only */
  408.        {
  409.         char *getenv(const char *);
  411.         envdir = getenv(MPEGTABENV);   /* check for environment */
  412.         if(envdir != NULL)
  413.             strcpy(fulname, envdir);
  414.         strcat(fulname, PATH_SEPARATOR);  /* add a "/" on the end */
  415.       }
  416. #endif /* UNIX */
  418.     strcat(fulname, name);
  419.     if( (f=fopen(fulname,"r"))==NULL ) {
  420.         fprintf(stderr,"OpenTable: could not find %sn", fulname);
  422. #ifdef UNIX
  423.           if(envdir != NULL)
  424.             fprintf(stderr,"Check %s directory '%s'n",MPEGTABENV, envdir);
  425.           else
  426.             fprintf(stderr,"Check local directory './%s' or setenv %sn",
  427.                     TABLES_PATH, MPEGTABENV);
  428. #else /* not unix : no environment variables */
  430. #ifdef TABLES_PATH
  431.             fprintf(stderr,"Check local directory './%s'n",TABLES_PATH);
  432. #endif /* TABLES_PATH */
  434. #endif /* UNIX */
  436.     }
  437.     return f;
  438. }
  440. /***********************************************************************
  441. /*
  442. /* Read one of the data files ("alloc_*") specifying the bit allocation/
  443. /* quatization parameters for each subband in layer II encoding
  444. /*
  445. /**********************************************************************/
  447. int read_bit_alloc(int table, al_table (*alloc))        /* read in table, return # subbands */
  448.           
  449.                 
  450. {
  451.         long a, b, c, d, i, j;
  452.         FILE *fp;
  453.         char name[16], t[80];
  454.         int sblim;
  456.         strcpy(name, "alloc_0");
  458.         switch (table) {
  459.                 case 0 : name[6] = '0';         break;
  460.                 case 1 : name[6] = '1';         break;
  461.                 case 2 : name[6] = '2';         break;
  462.                 case 3 : name[6] = '3';         break;
  463.                 case 4 : name[6] = '4';         break; /* for MultiLingual LSF , WtK 7/8/95 */
  464.                 default : name[6] = '0';
  465.         }
  467.         if (!(fp = OpenTableFile(name))) {
  468.                 printf("Please check bit allocation table %sn", name);
  469.                 exit(0);
  470.         }
  472. #ifdef PrintBitDebug
  473. printf("using bit allocation table %sn", name);
  474. #endif
  476.         fgets(t, 80, fp);
  477.         sscanf(t, "%dn", &sblim);
  478.         while (!feof(fp)) {
  479.                 fgets(t, 80, fp);
  480.                 sscanf(t, "%ld %ld %ld %ld %ld %ldn", &i, &j, &a, &b, &c, &d);
  481.                         (*alloc)[i][j].steps = a;
  482.                         (*alloc)[i][j].bits  = b;
  483.                         (*alloc)[i][j].group = c;
  484.                         (*alloc)[i][j].quant = d;
  485.         }
  486.         fclose(fp);
  487.         return sblim;
  488. }
  490. /***********************************************************************
  491. /*
  492. /* Using the decoded info the appropriate possible quantization per
  493. /* subband table is loaded
  494. /*
  495. /**********************************************************************/
  497. int pick_table (frame_params *fr_ps) /* choose table, load if necess, return # sb's */
  498. {
  499.     int table, tableml, lay, ws, bsp, br_per_ch, sfrq;
  500.     int sblim = fr_ps->sblimit;     /* return current value if no load */
  502.     lay = fr_ps->header->lay - 1;
  503.     bsp = fr_ps->header->bitrate_index;
  505.     /* Bug corrected by SWKim060695 */
  506.     br_per_ch = bitrate[lay][bsp] / (fr_ps->stereo /* + fr_ps->stereomc */);
  507.     ws = fr_ps->header->sampling_frequency;
  508.     sfrq = s_freq[ws];
  510.     /* decision rules refer to per-channel bitrates (kbits/sec/chan) */
  511.     if ((sfrq == 48 && br_per_ch >= 56) ||
  512. (br_per_ch >= 56 && br_per_ch <= 80))
  513. table = 0;
  514.     else if (sfrq != 48 && br_per_ch >= 96)
  515. table = 1;
  516.     else if (sfrq != 32 && br_per_ch <= 48)
  517. table = 2;
  518.     else
  519. table = 3;
  521.     if (fr_ps->tab_num != table)
  522.     {
  523. if (fr_ps->tab_num >= 0)
  524.     mem_free ((void **) &(fr_ps->alloc));
  525. fr_ps->alloc = (al_table *) mem_alloc (sizeof (al_table), "alloc");
  526. sblim = read_bit_alloc (fr_ps->tab_num = table, fr_ps->alloc);
  527.     }
  529.     if (verbosity >= 2)
  530. printf("sblim = %d,  table = %d,  br_per_ch = %dn", sblim, table, br_per_ch);
  532.     return (sblim);
  533. }
  535. /* choose MC and ML tables, load if necess, return # sb's */
  536. void mc_pick_table (frame_params *fr_ps)   
  537. {
  538.    int tablemc, tableml, ws, sfrq;
  540.    /* BUG corrected SWKim060695 */
  541.    ws = fr_ps->header->sampling_frequency;
  542.    sfrq = s_freq[ws];
  544.    /* decision rules refer to sampling frequency */
  545.    if (sfrq == 48)
  546.       tablemc = 0;
  547.    else
  548.       tablemc = 1;
  550.    if (fr_ps->tab_num_mc != tablemc)
  551.    {
  552.       if (fr_ps->tab_num >= 0)
  553.  mem_free ((void **)& (fr_ps->alloc_mc));
  554.       fr_ps->alloc_mc = (al_table *) mem_alloc (sizeof(al_table), "alloc_mc");
  555.       fr_ps->sblimit_mc = read_bit_alloc (fr_ps->tab_num_mc = tablemc, fr_ps->alloc_mc);
  556.    }
  559.     if (fr_ps->header->multiling_ch > 0)
  560.     {
  561. /* LSF MultiLingual 7/8/95 WtK */
  562. if (fr_ps->header->multiling_fs == 0)
  563. {
  564.     fr_ps->tab_num_ml = fr_ps->tab_num_mc;
  565.     fr_ps->alloc_ml   = fr_ps->alloc_mc;
  566.     fr_ps->sblimit_ml = fr_ps->sblimit_mc;
  567. }
  568. else
  569. {
  570.     tableml = 4;
  571.     if (fr_ps->tab_num_ml != tableml)
  572.     {
  573. if (fr_ps->tab_num_ml >= 0)
  574.     mem_free ((void **) &(fr_ps->alloc_ml));
  575. fr_ps->alloc_ml = (al_table *) mem_alloc (sizeof (al_table), "alloc_ml");
  576. fr_ps->sblimit_ml = read_bit_alloc (fr_ps->tab_num_ml = tableml, fr_ps->alloc_ml);
  577.     }
  578. } /* ml_fs==0 */
  579.     } /* ml_ch>0 */
  581.     if (verbosity >= 2)
  582.     {
  583. printf("Multchannel uses : sblim = %d,  table = %dn", fr_ps->sblimit_mc, fr_ps->tab_num_mc);
  584. if (fr_ps->header->multiling_ch > 0) 
  585.     printf ("Multilingual uses : sblim = %d, table = %dn", fr_ps->sblimit_ml, fr_ps->tab_num_ml);
  586.     }
  587. }
  589. int js_bound (int lay, int m_ext)
  590. {
  591.     static int jsb_table[3][4] =  { { 4, 8, 12, 16 }, { 4, 8, 12, 16},
  592.     { 0, 4, 8, 16} };  /* lay+m_e -> jsbound */
  594.     if (lay < 1 || lay > 3 || m_ext < 0 || m_ext > 3)
  595.     {
  596.         fprintf (stderr, "js_bound bad layer/modext (%d/%d)n", lay, m_ext);
  597.         exit (1);
  598.     }
  600.     return (jsb_table[lay-1][m_ext]);
  601. }
  603. void hdr_to_frps (frame_params *fr_ps) /* interpret data in hdr str to fields in fr_ps */
  604. {
  605.     layer *hdr = fr_ps->header;     /* (or pass in as arg?) */
  607.     fr_ps->actual_mode = hdr->mode;
  608.     if (hdr->mode != MPG_MD_NONE)
  609. fr_ps->stereo = (hdr->mode == MPG_MD_MONO) ? 1 : 2;
  610.     else
  611.      fr_ps->stereo = 0;
  613.     if (verbosity >= 2)
  614.         printf ("stereo = %d stereomc = %d stereoaug = %dn",
  615. fr_ps->stereo, fr_ps->stereomc, fr_ps->stereoaug);
  617.     if (hdr->lay == 2)
  618. fr_ps->sblimit = pick_table (fr_ps);
  619.     else
  620. fr_ps->sblimit = SBLIMIT;
  622.     if (hdr->mode == MPG_MD_JOINT_STEREO)
  623. fr_ps->jsbound = js_bound (hdr->lay, hdr->mode_ext);
  624.     else
  625. fr_ps->jsbound = fr_ps->sblimit;
  627.     if (hdr->multiling_ch > 0 && hdr->multiling_lay > 0)
  628.     {
  629. fprintf (stderr, "MultiLingual not in Layer 2!n exit.n");
  630. exit (1);
  631.     }
  633.     if (fr_ps->stereomc > 0 || hdr->lfe || hdr->multiling_ch > 0)
  634. mc_pick_table (fr_ps);
  635. }
  637. int BitrateIndex(int layr, int bRate)   /* convert bitrate in kbps to index */
  638.                         /* 1 or 2 */
  639.                         /* legal rates from 32 to 448 */
  640. {
  641. int     index = 0;
  642. int     found = 0;
  644.     while(!found && index<15)   {
  645.         if(bitrate[layr-1][index] == bRate)
  646.             found = 1;
  647.         else
  648.             ++index;
  649.     }
  650.     if(found)
  651.         return(index);
  652.     else {
  653.         fprintf(stderr, "BitrateIndex: %d (layer %d) is not a legal bitraten",
  654.                 bRate, layr);
  655.         return(-1);     /* Error! */
  656.     }
  657. }
  659. int SmpFrqIndex(long int sRate)  /* convert samp frq in Hz to index */
  660. /* for MultiLingual LSF                                                       */
  661. /* Note this function differs from the one called upon MPEG2 Audio-LSF coding */
  662. /* The value '16' is used to detect half sample rate of ML wrt. MC            */
  663. /* 7/8/95 WtK                                                                 */
  664. {
  665.     switch (sRate) {
  666.       case    44100    :   return( 0);     break;
  667.       case    48000    :   return( 1);     break;
  668.       case    32000    :   return( 2);     break;
  669.       case    22050    :   return(16);     break;
  670.       case    24000    :   return(17);     break;
  671.       case    16000    :   return(18);     break;
  672.       default          :   fprintf(stderr, "SmpFrqIndex: %ld is not a legal sample raten", sRate);
  673.                            return(-1);     /* Error! */
  674.     }
  675. }
  677. /*******************************************************************************
  678. *
  679. *  Allocate number of bytes of memory equal to "block".
  680. *
  681. *******************************************************************************/
  683. void *mem_alloc (long unsigned int block, char *item)
  684. {
  685. #ifndef MSDOS
  686.     void *ptr;
  687. #else
  688.     void _far *ptr;
  689. #endif
  691. #ifdef MACINTOSH
  692.     ptr = NewPtr (block);
  693. #endif
  695. #ifdef MSDOS
  696.     ptr = (void _far *) _fmalloc ((unsigned int) block); /* far memory, 92-07-08 sr */
  697. #endif
  699. #if ! defined (MACINTOSH) && ! defined (MSDOS)
  700.     ptr = (void *) malloc (block);
  701. #endif
  703.     if (ptr != NULL)
  704.     {
  705. #ifdef MSDOS
  706. _fmemset (ptr, 0, (unsigned int) block); /* far memory, 92-07-08 sr */
  707. #else
  708.         memset (ptr, 0, block);
  709. #endif
  710.     }
  711.     else
  712.     {
  713.         printf ("Unable to allocate %sn", item);
  714.         exit (1);
  715.     }
  717.     return (ptr);
  718. }
  720. /****************************************************************************
  721. *
  722. *  Free memory pointed to by "*ptr_addr".
  723. *
  724. *****************************************************************************/
  726. void    mem_free (void **ptr_addr)
  727. {
  728.     if (*ptr_addr != NULL)
  729.     {
  730. #ifdef  MACINTOSH
  731. DisposPtr (*ptr_addr);
  732. #else
  733. free (*ptr_addr);
  734. #endif
  735. *ptr_addr = NULL;
  736.     }
  737. }
  739. /****************************************************************************
  740. *
  741. *  Routines to convert between the Apple SANE extended floating point format
  742. *  and the IEEE double precision floating point format.  These routines are
  743. *  called from within the Audio Interchange File Format (AIFF) routines.
  744. *
  745. *****************************************************************************/
  747. /*
  748. *** Apple's 80-bit SANE extended has the following format:
  750.  1       15      1            63
  751. +-+-------------+-+-----------------------------+
  752. |s|       e     |i|            f                |
  753. +-+-------------+-+-----------------------------+
  754.   msb        lsb   msb                       lsb
  756. The value v of the number is determined by these fields as follows:
  757. If 0 <= e < 32767,              then v = (-1)^s * 2^(e-16383) * (i.f).
  758. If e == 32767 and f == 0,       then v = (-1)^s * (infinity), regardless of i.
  759. If e == 32767 and f != 0,       then v is a NaN, regardless of i.
  761. *** IEEE Draft Standard 754 Double Precision has the following format:
  763. MSB
  764. +-+---------+-----------------------------+
  765. |1| 11 Bits |           52 Bits           |
  766. +-+---------+-----------------------------+
  767.  ^     ^                ^
  768.  |     |                |
  769.  Sign  Exponent         Mantissa
  770. */
  772. /*****************************************************************************
  773. *
  774. *  double_to_extended()
  775. *
  776. *  Purpose:     Convert from IEEE double precision format to SANE extended
  777. *               format.
  778. *
  779. *  Passed:      Pointer to the double precision number and a pointer to what
  780. *               will hold the Apple SANE extended format value.
  781. *
  782. *  Outputs:     The SANE extended format pointer will be filled with the
  783. *               converted value.
  784. *
  785. *  Returned:    Nothing.
  786. *
  787. *****************************************************************************/
  790. void    double_to_extended(double *pd, char *ps)
  791. {
  793. #ifdef  MACINTOSH
  795.         x96tox80(pd, (extended *) ps);
  797. #else
  799. /* fixed bus alignment error, HP 27-may-93 */
  801. register unsigned long  top2bits;
  803. register unsigned short *ps2;
  804. register IEEE_DBL       *p_dbl;
  805. register SANE_EXT       *p_ext;
  806. SANE_EXT ext_align;
  807. char *c_align;
  808. int i;
  810.    p_dbl = (IEEE_DBL *) pd;
  811.    p_ext = &ext_align;
  812.    top2bits = p_dbl->hi & 0xc0000000;
  813.    p_ext->l1 = ((p_dbl->hi >> 4) & 0x3ff0000) | top2bits;
  814.    p_ext->l1 |= ((p_dbl->hi >> 5) & 0x7fff) | 0x8000;
  815.    p_ext->l2 = (p_dbl->hi << 27) & 0xf8000000;
  816.    p_ext->l2 |= ((p_dbl->lo >> 5) & 0x07ffffff);
  817.    ps2 = (unsigned short *) & (p_dbl->lo);
  818.    ps2++;
  819.    p_ext->s1 = (*ps2 << 11) & 0xf800;
  821.    c_align = (char *) p_ext;
  822.    for (i=0;i<10;i++)
  823.      ps[i] = c_align[i];
  825. #endif
  827. }
  830. /*****************************************************************************
  831. *
  832. *  extended_to_double()
  833. *
  834. *  Purpose:     Convert from SANE extended format to IEEE double precision
  835. *               format.
  836. *
  837. *  Passed:      Pointer to the Apple SANE extended format value and a pointer
  838. *               to what will hold the the IEEE double precision number.
  839. *
  840. *  Outputs:     The IEEE double precision format pointer will be filled with
  841. *               the converted value.
  842. *
  843. *  Returned:    Nothing.
  844. *
  845. *****************************************************************************/
  847. void    extended_to_double(char *ps, double *pd)
  848. {
  850. #ifdef  MACINTOSH
  852.    x80tox96((extended *) ps, pd);
  854. #else
  856. /* fixed bus alignment error, HP 27-may-93 */
  858. register unsigned long  top2bits;
  860. register IEEE_DBL       *p_dbl;
  861. register SANE_EXT       *p_ext;
  862. SANE_EXT ext_align;
  863. char *c_align;
  864. int i;
  866.    p_dbl = (IEEE_DBL *) pd;
  867.    p_ext = &ext_align;
  869.    c_align = (char *) p_ext;
  870.    for (i=0;i<10;i++)
  871.      c_align[i] = ps[i];
  873.    top2bits = p_ext->l1 & 0xc0000000;
  874.    p_dbl->hi = ((p_ext->l1 << 4) & 0x3ff00000) | top2bits;
  875.    p_dbl->hi |= (p_ext->l1 << 5) & 0xffff0;
  876.    p_dbl->hi |= (p_ext->l2 >> 27) & 0x1f;
  877.    p_dbl->lo = (p_ext->l2 << 5) & 0xffffffe0;
  878.    p_dbl->lo |= (unsigned long) ((p_ext->s1 >> 11) & 0x1f);
  880. #endif
  882. }
  884. /*****************************************************************************
  885. *
  886. *  Read Audio Interchange File Format (AIFF) headers.
  887. *
  888. *****************************************************************************/
  890. int aiff_read_headers (FILE *file_ptr, IFF_AIFF *aiff_ptr, int *byte_per_sample)
  891. {
  893.     register char   i;
  894.     register long   seek_offset;
  895.     
  896.     char  temp_sampleRate[10];
  897.     char  *dummy;
  898.     char  holder;
  899.     Chunk           FormChunk;
  900.     CommonChunk     CommChunk;
  901.     SoundDataChunk  SndDChunk;
  902.     identifier  ident;
  904.     if (fseek (file_ptr, 0, SEEK_SET) != 0)
  905. return (-1);
  907.     if (fread (&FormChunk, sizeof (Chunk), 1, file_ptr) != 1)
  908. return (-1);
  910. #ifdef MSDOS
  911.     holder = FormChunk.ckID[0];
  912.     FormChunk.ckID[0] = FormChunk.ckID[3];
  913.     FormChunk.ckID[3] = holder;
  914.     holder = FormChunk.ckID[1];
  915.     FormChunk.ckID[1] = FormChunk.ckID[2];
  916.     FormChunk.ckID[2] = holder;
  917. /* fixed bug in next line, HP 27-may-93 */
  918.     holder = FormChunk.formType[0];
  919.     FormChunk.formType[0] = FormChunk.formType[3];
  920.     FormChunk.formType[3] = holder;
  921.     holder = FormChunk.formType[1];
  922.     FormChunk.formType[1] = FormChunk.formType[2];
  923.     FormChunk.formType[2] = holder;
  924.     FormChunk.ckSize = _lrotl(FormChunk.ckSize, 8);
  925. #endif
  928. /* fixed bug in next line, HP 27-may-93 */
  929.     if (strncmp (FormChunk.ckID, IFF_ID_FORM, 4) != 0 ||
  930. strncmp (FormChunk.formType, IFF_ID_AIFF, 4) != 0)
  931. return (-1);  /* warning: different levels of indirection.7/8/92.sr*/
  933.     if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
  934. return (-1);
  936. #ifdef MSDOS
  937.     holder = ident.name[0];
  938.     ident.name[0] = ident.name[3];
  939.     ident.name[3] = holder;
  940.     holder = ident.name[1];
  941.     ident.name[1] = ident.name[2];
  942.     ident.name[2] = holder;
  943.     ident.ck_length = _lrotl (ident.ck_length, 8);
  944. #endif
  946. /* fixed bug in next line, HP 27-may-93 */
  947.     while (strncmp (ident.name, IFF_ID_COMM, 4) != 0)
  948.     {
  949. dummy = (char *) mem_alloc (ident.ck_length * sizeof (char),  "dummy");
  950. if (fread (dummy, ident.ck_length, 1, file_ptr) != 1)
  951.     return (-1);
  952. mem_free ((void **) &dummy);
  953. /* fixed bug in next line, HP 27-may-93 */
  954. if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
  955.    return (-1);
  957. #ifdef MSDOS
  958. holder = ident.name[0];
  959. ident.name[0] = ident.name[3];
  960. ident.name[3] = holder;
  961. holder = ident.name[1];
  962. ident.name[1] = ident.name[2];
  963. ident.name[2] = holder;
  964. ident.ck_length = _lrotl(ident.ck_length, 8);
  965. #endif
  966.     }
  968.     for (i = 0; i < 4; ++i)
  969. CommChunk.ckID[i] = ident.name[i];
  971.     CommChunk.ckSize = ident.ck_length;
  973.     if (fread (&CommChunk.numChannels, sizeof (short), 1, file_ptr) != 1)
  974. return (-1);
  976.     if (fread (&CommChunk.numSampleFrames, sizeof (unsigned long), 1, file_ptr) != 1)
  977. return (-1);
  979.     if (fread (&CommChunk.sampleSize, sizeof (short), 1, file_ptr) != 1)
  980. return (-1);
  982.     if (fread (CommChunk.sampleRate, sizeof (char[10]), 1, file_ptr) != 1)
  983. return (-1);
  985. #ifdef MSDOS
  986.     CommChunk.sampleSize = _rotl (CommChunk.sampleSize, 8);
  987.     CommChunk.ckSize = _lrotl (CommChunk.ckSize, 8);
  988.     CommChunk.numChannels = _rotl (CommChunk.numChannels, 8);
  989.     CommChunk.numSampleFrames = _lrotl (CommChunk.numSampleFrames, 8);
  990. #endif
  992.     *byte_per_sample = ceil ((double) CommChunk.sampleSize / 8);
  994.     for (i = 0; i < sizeof (char[10]); i++)
  995. temp_sampleRate[i] = CommChunk.sampleRate[i];
  997.     extended_to_double (temp_sampleRate, &aiff_ptr->sampleRate);
  999. /* to start the search again from the beginning, HP 27-may-93 */
  1000.     fseek (file_ptr, sizeof (Chunk), SEEK_SET);
  1002.     if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
  1003. return (-1);
  1005. #ifdef MSDOS
  1006.     holder = ident.name[0];
  1007.     ident.name[0] = ident.name[3];
  1008.     ident.name[3] = holder;
  1009.     holder = ident.name[1];
  1010.     ident.name[1] = ident.name[2];
  1011.     ident.name[2] = holder;
  1012.     ident.ck_length = _lrotl (ident.ck_length, 8);
  1013. #endif
  1015. /* fixed bug in next line, HP 27-may-93 */
  1016.     while (strncmp (ident.name, IFF_ID_SSND, 4) != 0)
  1017.     {
  1018. dummy = (char *) mem_alloc (ident.ck_length * sizeof (char),  "dummy");
  1019. if (fread (dummy, ident.ck_length, 1, file_ptr) != 1)
  1020.     return (-1);
  1021. mem_free ((void **) &dummy);
  1022. if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
  1023.     return (-1);
  1024. /* the following lines are not necessary, HP 27-may-93 */
  1025. /*
  1026. {
  1027. fseek (file_ptr, 0, SEEK_SET);
  1028. if (fread (&ident, sizeof (identifier), 1, file_ptr) != 1)
  1029. return (-1);
  1030. }
  1031. */
  1033. #ifdef MSDOS
  1034. holder = ident.name[0];
  1035. ident.name[0] = ident.name[3];
  1036. ident.name[3] = holder;
  1037. holder = ident.name[1];
  1038. ident.name[1] = ident.name[2];
  1039. ident.name[2] = holder;
  1040. ident.ck_length = _lrotl (ident.ck_length, 8);
  1041. #endif
  1042.     }
  1044.     for (i = 0; i < 4; ++i)
  1045. SndDChunk.ckID[i] = ident.name[i];
  1046.     SndDChunk.ckSize = ident.ck_length;
  1048.     if (fread (&SndDChunk.offset, sizeof (unsigned long), 1, file_ptr) != 1)
  1049. return (-1);
  1051.     if (fread (&SndDChunk.blockSize, sizeof (unsigned long), 1, file_ptr) != 1)
  1052. return (-1);
  1054. #ifdef MSDOS
  1055.     SndDChunk.offset = _lrotl (SndDChunk.offset, 8);
  1056.     SndDChunk.blockSize = _lrotl (SndDChunk.blockSize, 8);
  1057. #endif
  1059. /* why seek behinde the SSND Chunk ????, HP 27-may-93 */
  1060. /*
  1061.     seek_offset = SndDChunk.ckSize - sizeof (SoundDataChunk) + sizeof (ChunkHeader);
  1063.     if (fseek (file_ptr, seek_offset, SEEK_CUR) != 0)
  1064. return (-1);
  1065. */
  1067.     aiff_ptr->numChannels       = CommChunk.numChannels;
  1068.     aiff_ptr->numSampleFrames   = CommChunk.numSampleFrames;
  1069.     aiff_ptr->sampleSize        = CommChunk.sampleSize;
  1070.     aiff_ptr->blkAlgn.offset    = SndDChunk.offset;
  1071.     aiff_ptr->blkAlgn.blockSize = SndDChunk.blockSize;
  1072.     strncpy (aiff_ptr->sampleType, SndDChunk.ckID, 4);
  1073.  
  1074.     return (0);
  1075. }
  1078. /*****************************************************************************
  1079. *
  1080. *  Seek past some Audio Interchange File Format (AIFF) headers to sound data.
  1081. *
  1082. *****************************************************************************/
  1084. int aiff_seek_to_sound_data (FILE *file_ptr)
  1085. {
  1086.     if (fseek (file_ptr, sizeof (Chunk) + sizeof (SoundDataChunk), SEEK_SET) != 0)
  1087. return (-1);
  1088.     else
  1089. return (0);
  1090. }
  1092. /*******************************************************************************
  1093. *
  1094. *  Write Audio Interchange File Format (AIFF) headers.
  1095. *
  1096. *******************************************************************************/
  1098. int aiff_write_headers (FILE *file_ptr, IFF_AIFF *aiff_ptr)
  1099. {
  1100.     register char   i;
  1101.     register long   seek_offset;
  1102.     
  1103.     char            temp_sampleRate[10];
  1104.     
  1105.     Chunk           FormChunk;
  1106.     CommonChunk     CommChunk;
  1107.     SoundDataChunk  SndDChunk;
  1109.     strcpy (FormChunk.ckID, IFF_ID_FORM);
  1110.     strcpy (FormChunk.formType, IFF_ID_AIFF);
  1111.     strcpy (CommChunk.ckID, IFF_ID_COMM);  /*7/7/93,SR,changed FormChunk to CommChunk*/
  1113.     double_to_extended (&aiff_ptr->sampleRate, temp_sampleRate);
  1115.     for (i = 0; i < sizeof (char[10]); i++)
  1116. CommChunk.sampleRate[i] = temp_sampleRate[i];
  1118.     CommChunk.numChannels             = aiff_ptr->numChannels;
  1119.     CommChunk.numSampleFrames         = aiff_ptr->numSampleFrames;
  1120.     CommChunk.sampleSize              = aiff_ptr->sampleSize;
  1121.     SndDChunk.offset                  = aiff_ptr->blkAlgn.offset;
  1122.     SndDChunk.blockSize               = aiff_ptr->blkAlgn.blockSize;
  1123.     strncpy (SndDChunk.ckID, aiff_ptr->sampleType,  4);
  1124.  
  1125.     CommChunk.ckSize = sizeof (CommChunk.numChannels) +
  1126.        sizeof (CommChunk.numSampleFrames) +
  1127.        sizeof (CommChunk.sampleSize) +
  1128.        sizeof (CommChunk.sampleRate);
  1129.  
  1130.     SndDChunk.ckSize = sizeof (SoundDataChunk) - sizeof (ChunkHeader) +
  1131. (CommChunk.sampleSize + BITS_IN_A_BYTE - 1) / BITS_IN_A_BYTE *
  1132. CommChunk.numChannels * CommChunk.numSampleFrames;
  1133.  
  1134.     FormChunk.ckSize = sizeof (Chunk) + SndDChunk.ckSize + sizeof (ChunkHeader) +
  1135. CommChunk.ckSize;
  1136.  
  1137.     if (fseek (file_ptr, 0, SEEK_SET) != 0)
  1138. return (-1);
  1139.  
  1140.     if (fwrite (&FormChunk, sizeof (Chunk), 1, file_ptr) != 1)
  1141. return (-1);
  1142.  
  1143.     if (fwrite (&SndDChunk, sizeof (SoundDataChunk), 1, file_ptr) != 1)
  1144. return (-1);
  1145.  
  1146.     seek_offset = SndDChunk.ckSize - sizeof (SoundDataChunk) + sizeof (ChunkHeader);
  1147.  
  1148.     if (fseek (file_ptr, seek_offset, SEEK_CUR) != 0)
  1149. return (-1);
  1150.  
  1151.     if (fwrite (CommChunk.ckID, sizeof (ID), 1, file_ptr) != 1)
  1152. return (-1);
  1153.  
  1154.     if (fwrite (&CommChunk.ckSize, sizeof (long), 1, file_ptr) != 1)
  1155. return (-1);
  1156.  
  1157.     if (fwrite (&CommChunk.numChannels, sizeof (short), 1, file_ptr) != 1)
  1158. return (-1);
  1159.  
  1160.     if (fwrite (&CommChunk.numSampleFrames, sizeof (unsigned long), 1, file_ptr) != 1)
  1161. return (-1);
  1162.  
  1163.     if (fwrite (&CommChunk.sampleSize, sizeof (short), 1, file_ptr) != 1)
  1164. return (-1);
  1165.  
  1166.     if (fwrite (CommChunk.sampleRate, sizeof (char[10]), 1, file_ptr) != 1)
  1167. return (-1);
  1168.  
  1169.     return (0);
  1170. }
  1172. /*****************************************************************************
  1173. *
  1174. *  bit_stream.c package
  1175. *  Author:  Jean-Georges Fritsch, C-Cube Microsystems
  1176. *
  1177. *****************************************************************************/
  1179. /********************************************************************
  1180.   This package provides functions to write (exclusive or read)
  1181.   information from (exclusive or to) the bit stream.
  1183.   If the bit stream is opened in read mode only the get functions are
  1184.   available. If the bit stream is opened in write mode only the put
  1185.   functions are available.
  1186. ********************************************************************/
  1188. /* refill the buffer from the input device when the buffer becomes empty    */
  1189. int refill_buffer(Bit_stream_struc *bs)
  1190.                         /* bit stream structure */
  1191. {
  1192.    register int i=bs->buf_size-2-bs->buf_byte_idx;
  1193.    register unsigned long n;
  1194.    register int index=0;
  1195.    char val[2];
  1197.    while ((i>=0) && (!bs->eob)) {
  1199.       if (bs->format == BINARY)
  1200.          n = fread(&bs->buf[i--], sizeof(unsigned char), 1, bs->pt);
  1202.       else {
  1203.   while((index < 2) && n) {
  1204. n = fread(&val[index], sizeof(char), 1, bs->pt);
  1205. switch (val[index]) {
  1206. case 0x30:
  1207. case 0x31:
  1208. case 0x32:
  1209. case 0x33:
  1210. case 0x34:
  1211. case 0x35:
  1212. case 0x36:
  1213. case 0x37:
  1214. case 0x38:
  1215. case 0x39:
  1216. case 0x41:
  1217. case 0x42:
  1218. case 0x43:
  1219. case 0x44:
  1220. case 0x45:
  1221. case 0x46:
  1222. index++;
  1223. break;
  1224. default: break;
  1225. }
  1226.    }
  1228.            if (val[0] <= 0x39) bs->buf[i] = (val[0] - 0x30) << 4;
  1229.                  else  bs->buf[i] = (val[0] - 0x37) << 4;
  1230.            if (val[1] <= 0x39) bs->buf[i--] |= (val[1] - 0x30);
  1231.                  else  bs->buf[i--] |= (val[1] - 0x37);
  1232.    index = 0;
  1233.       }
  1235.       if (!n) {
  1236.          bs->eob= i+1;
  1237.       }
  1239.     }
  1240. }
  1242. static char *he = "0123456789ABCDEF";
  1244. /* empty the buffer to the output device when the buffer becomes full */
  1245. void empty_buffer(Bit_stream_struc *bs, int minimum)
  1246.                         /* bit stream structure */
  1247.                         /* end of the buffer to empty */
  1248. {
  1249.    register int i;
  1251. #if BS_FORMAT == BINARY
  1252.    for (i=bs->buf_size-1;i>=minimum;i--)
  1253.       fwrite(&bs->buf[i], sizeof(unsigned char), 1, bs->pt);
  1254. #else
  1255.    for (i=bs->buf_size-1;i>=minimum;i--) {
  1256.        char val[2];
  1257.        val[0] = he[((bs->buf[i] >> 4) & 0x0F)];
  1258.        val[1] = he[(bs->buf[i] & 0x0F)];
  1259.        fwrite(val, sizeof(char), 2, bs->pt);
  1260.    }
  1261. #endif
  1263.    for (i=minimum-1; i>=0; i--)
  1264.        bs->buf[bs->buf_size - minimum + i] = bs->buf[i];
  1266.    bs->buf_byte_idx = bs->buf_size -1 - minimum;
  1267.    bs->buf_bit_idx = 8;
  1268. }
  1270. /* open the device to write the bit stream into it */
  1271. void open_bit_stream_w(Bit_stream_struc *bs, char *bs_filenam, int size)
  1272.                         /* bit stream structure */
  1273.                         /* name of the bit stream file */
  1274.                         /* size of the buffer */
  1275. {
  1276.    if ((bs->pt = fopen(bs_filenam, "w+")) == NULL) {
  1277.       printf("Could not create "%s".n", bs_filenam);
  1278.       exit(0);
  1279.    }
  1280.    alloc_buffer(bs, size);
  1281.    bs->buf_byte_idx = size-1;
  1282.    bs->buf_bit_idx=8;
  1283.    bs->totbit=0;
  1284.    bs->mode = WRITE_MODE;
  1285.    bs->eob = FALSE;
  1286.    bs->eobs = FALSE;
  1287. }
  1289. /* open the device to read the bit stream from it */
  1290. void open_bit_stream_r(Bit_stream_struc *bs, char *bs_filenam, int size)
  1291.                         /* bit stream structure */
  1292.                         /* name of the bit stream file */
  1293.                         /* size of the buffer */
  1294. {
  1295.    register unsigned long n;
  1296.    register int i=0;
  1297.    register unsigned char flag = 1;
  1298.    unsigned char val;
  1300.    if ((bs->pt = fopen(bs_filenam, "rb")) == NULL) {
  1301.       printf("Could not find "%s".n", bs_filenam);
  1302.       exit(0);
  1303.    }
  1305.    do {
  1306.      n = fread(&val, sizeof(unsigned char), 1, bs->pt);
  1307.      switch (val) {
  1308.       case 0x30:
  1309.       case 0x31:
  1310.       case 0x32:
  1311.       case 0x33:
  1312.       case 0x34:
  1313.       case 0x35:
  1314.       case 0x36:
  1315.       case 0x37:
  1316.       case 0x38:
  1317.       case 0x39:
  1318.       case 0x41:
  1319.       case 0x42:
  1320.       case 0x43:
  1321.       case 0x44:
  1322.       case 0x45:
  1323.       case 0x46:
  1324.       case 0xa:  /* n */
  1325.           break;
  1327.       default: /* detection of an binary character */
  1328.           flag--;
  1329.           i = 300;
  1330.           break;
  1331.      }
  1333.    } while (flag & n);
  1335.    if (flag) {
  1336.       if (verbosity >= 2) printf ("the bit stream file %s is an ASCII filen", bs_filenam);
  1337.       bs->format = ASCII;
  1338.    }
  1339.    else {
  1340.       bs->format = BINARY;
  1341.       if (verbosity >= 2) printf ("the bit stream file %s is a BINARY filen", bs_filenam);
  1342.    }
  1344.    fclose(bs->pt);
  1346.    if ((bs->pt = fopen(bs_filenam, "rb")) == NULL) {
  1347.       printf("Could not find "%s".n", bs_filenam);
  1348.       exit(0);
  1349.    }
  1351.    alloc_buffer(bs, size);
  1352.    bs->buf_byte_idx=0;
  1353.    bs->buf_bit_idx=0;
  1354.    bs->totbit=0;
  1355.    bs->mode = READ_MODE;
  1356.    bs->eob = FALSE;
  1357.    bs->eobs = FALSE;
  1358. }
  1360. /* close the device containing the bit stream after a read process */
  1361. void close_bit_stream_r (Bit_stream_struc *bs)
  1362. {
  1363.     fclose (bs->pt);
  1364.     desalloc_buffer (bs);
  1365. }
  1367. /*close the device containing the bit stream after a write process*/
  1368. void close_bit_stream_w (Bit_stream_struc *bs)
  1369. {
  1370.     empty_buffer (bs, bs->buf_byte_idx + 1);
  1371.     fclose (bs->pt);
  1372.     desalloc_buffer (bs);
  1373. }
  1375. /* open and initialize the buffer; */
  1376. void alloc_buffer (Bit_stream_struc *bs, int size)
  1377. {
  1378.     bs->buf = (unsigned char *) mem_alloc (size * sizeof (unsigned char), "buffer");
  1379.     bs->buf_size = size;
  1380. }
  1382. /* empty and close the buffer */
  1383. void desalloc_buffer (Bit_stream_struc *bs)
  1384. {
  1385.    free (bs->buf);
  1386. }
  1388. int putmask[9]={0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff};
  1389. int mask[8]={0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};
  1391. /*read 1 bit from the bit stream */
  1392. unsigned int get1bit(Bit_stream_struc *bs)
  1393.                         /* bit stream structure */
  1394. {
  1395.    unsigned int bit;
  1396.    register int i;
  1398.    bs->totbit++;
  1400.    if (!bs->buf_bit_idx) {
  1401.         bs->buf_bit_idx = 8;
  1402.         bs->buf_byte_idx--;
  1403.         if ((bs->buf_byte_idx < MINIMUM) || (bs->buf_byte_idx < bs->eob)) {
  1404.              if (bs->eob)
  1405.                 bs->eobs = TRUE;
  1406.              else {
  1407.                 for (i=bs->buf_byte_idx; i>=0;i--)
  1408.                   bs->buf[bs->buf_size-1-bs->buf_byte_idx+i] = bs->buf[i];
  1409.                 refill_buffer(bs);
  1410.                 bs->buf_byte_idx = bs->buf_size-1;
  1411.              }
  1412.         }
  1413.    }
  1414.    bit = bs->buf[bs->buf_byte_idx]&mask[bs->buf_bit_idx-1];
  1415.    bit = bit >> (bs->buf_bit_idx-1);
  1416.    bs->buf_bit_idx--;
  1417. #ifdef PrintBitDebug
  1418.    printf ("pos: %5d getbits: %2d code: %4x val: %5dn",
  1419. bs->totbit-1,  1, bit, bit);
  1420.    fflush (stdout);
  1421. #endif
  1422.    return(bit);
  1423. }
  1425. /*write 1 bit from the bit stream */
  1426. void put1bit(Bit_stream_struc *bs, int bit)
  1427.                         /* bit stream structure */
  1428.                         /* bit to write into the buffer */
  1429. {
  1430.    register int i;
  1432. #ifdef PrintBitDebug
  1433.    printf ("pos: %5d putbits: %2d code: %4x val: %5dn",
  1434. bs->totbit,  1, bit, bit);
  1435.    fflush (stdout);
  1436. #endif
  1438.    bs->totbit++;
  1440.    bs->buf[bs->buf_byte_idx] |= (bit&0x1) << (bs->buf_bit_idx-1);
  1441.    bs->buf_bit_idx--;
  1442.    if (!bs->buf_bit_idx) {
  1443.        bs->buf_bit_idx = 8;
  1444.        bs->buf_byte_idx--;
  1445.        if (bs->buf_byte_idx < 0)
  1446.           empty_buffer(bs, MINIMUM);
  1447.        bs->buf[bs->buf_byte_idx] = 0;
  1448.    }
  1449. }
  1451. /*read N bit from the bit stream */
  1452. unsigned long getbits(Bit_stream_struc *bs, int N)
  1453.                         /* bit stream structure */
  1454.                         /* number of bits to read from the bit stream */
  1455. {
  1456.  unsigned long val=0;
  1457.  register int i;
  1458.  register int j = N;
  1459.  register int k, tmp;
  1461.  if (N > MAX_LENGTH)
  1462.     printf("Cannot read or write more than %d bits at a time.n", MAX_LENGTH);
  1464.  bs->totbit += N;
  1465.  while (j > 0) {
  1466.    if (!bs->buf_bit_idx) {
  1467.         bs->buf_bit_idx = 8;
  1468.         bs->buf_byte_idx--;
  1469.         if ((bs->buf_byte_idx < MINIMUM) || (bs->buf_byte_idx < bs->eob)) {
  1470.              if (bs->eob)
  1471.                 bs->eobs = TRUE;
  1472.              else {
  1473.                 for (i=bs->buf_byte_idx; i>=0;i--)
  1474.                    bs->buf[bs->buf_size-1-bs->buf_byte_idx+i] = bs->buf[i];
  1475.                 refill_buffer(bs);
  1476.                 bs->buf_byte_idx = bs->buf_size-1;
  1477.              }
  1478.         }
  1479.    }
  1480.    k = MIN (j, bs->buf_bit_idx);
  1481.    tmp = bs->buf[bs->buf_byte_idx]&putmask[bs->buf_bit_idx];
  1482.    tmp = tmp >> (bs->buf_bit_idx-k);
  1483.    val |= tmp << (j-k);
  1484.    bs->buf_bit_idx -= k;
  1485.    j -= k;
  1486.  }
  1487. #ifdef PrintBitDebug
  1488.  printf ("pos: %5d getbits: %2d code: %4x val: %5dn", 
  1489.  bs->totbit - N,  N, val, val);
  1490.  fflush (stdout);
  1491. #endif
  1492.  return(val);
  1493. }
  1495. /*write N bits into the bit stream */
  1496. void putbits(Bit_stream_struc *bs, unsigned int val, int N)
  1497.                         /* bit stream structure */
  1498.                         /* val to write into the buffer */
  1499.                         /* number of bits of val */
  1500. {
  1501.  register int i;
  1502.  register int j = N;
  1503.  register int k, tmp;
  1505.  if (N > MAX_LENGTH)
  1506.     printf("Cannot read or write more than %d bits at a time.n", MAX_LENGTH);
  1508. #ifdef PrintBitDebug
  1509.  printf ("pos: %5d putbits: %2d code: %4x val: %5dn", 
  1510.  bs->totbit,  N, val, val);
  1511.  fflush (stdout);
  1512. #endif
  1514.  bs->totbit += N;
  1515.  while (j > 0) {
  1516.    k = MIN(j, bs->buf_bit_idx);
  1517.    tmp = val >> (j-k);
  1518.    bs->buf[bs->buf_byte_idx] |= (tmp&putmask[k]) << (bs->buf_bit_idx-k);
  1519.    bs->buf_bit_idx -= k;
  1520.    if (!bs->buf_bit_idx) {
  1521.        bs->buf_bit_idx = 8;
  1522.        bs->buf_byte_idx--;
  1523.        if (bs->buf_byte_idx < 0)
  1524.           empty_buffer(bs, MINIMUM);
  1525.        bs->buf[bs->buf_byte_idx] = 0;
  1526.    }
  1527.    j -= k;
  1528.  }
  1529. }
  1531. /*return the current bit stream length (in bits)*/
  1532. unsigned long sstell(Bit_stream_struc *bs)
  1533.                         /* bit stream structure */
  1534. {
  1535.   return(bs->totbit);
  1536. }
  1538. /*return the status of the bit stream*/
  1539. /* returns 1 if end of bit stream was reached */
  1540. /* returns 0 if end of bit stream was not reached */
  1541. int end_bs(Bit_stream_struc *bs)
  1542.                         /* bit stream structure */
  1543. {
  1544.   return(bs->eobs);
  1545. }
  1547. /*****************************************************************************
  1548. *
  1549. *  End of bit_stream.c package
  1550. *
  1551. *****************************************************************************/
  1553. int transmission_channel (frame_params *fr_ps, int sbgr, int m)
  1554. {
  1555.     int config = fr_ps->config;
  1556.     int tca = fr_ps->header->tc_alloc[sbgr];
  1557. #ifdef Augmentation_7ch
  1558.     int aug_tca = fr_ps->header->aug_tc_alloc[sbgr];
  1559. #endif
  1561.     /* 960627 FdB TCA table dependent on configuration */
  1562.     if (config == 320)
  1563. #ifdef Augmentation_7ch
  1564. if (m >= 5)
  1565.     return (transmission_channel7[aug_tca][m-5]); /* 5/2 */
  1566. else
  1567. #endif
  1568.     return (transmission_channel5[tca][m]); /* 3/2 */
  1569.     else if (config == 310)
  1570. return (transmission_channel4a[tca][m]); /* 3/1 */
  1571.     else if (config == 220)
  1572. return (transmission_channel4b[tca][m]); /* 2/2 */
  1573.     else if (config == 300 || config == 302 || config == 210)
  1574. return (transmission_channel3[tca][m]); /* 3/0 (+2/0) and 2/1 */
  1575.     else
  1576. return (m);
  1577. }
  1579. int dyn_ch (frame_params *fr_ps, int sbgr, int m)
  1580. {
  1581.     int config = fr_ps->config;
  1582.     int dynx = fr_ps->header->dyn_cross[sbgr];
  1583.     int dynx2stereo = fr_ps->header->dyn_second_stereo[sbgr];
  1584. #ifdef Augmentation_7ch
  1585.     int aug_dynx = fr_ps->header->aug_dyn_cross[sbgr];
  1586. #endif
  1587.     /* 960627 FdB Dyn_ch table dependent on configuration */
  1588.     if (config == 320)
  1589. #ifdef Augmentation_7ch
  1590. if (m >= 5)
  1591.     return (dyn_ch5[aug_dynx][m-5]);
  1592. else
  1593. #endif
  1594.     return (dyn_ch4[dynx][m-2]);
  1595.     else if (config == 310 || config == 220)
  1596. return (dyn_ch3[dynx][m-2]);
  1597.     else if (config == 300 || config == 302 || config == 210)
  1598.     {
  1599. if (config == 302 && dynx2stereo && m == 4)
  1600.     return (0);
  1601. else
  1602.     return (dyn_ch1[dynx][m-2]);
  1603.     }
  1604.     else if (config == 202 && dynx2stereo && m == 3)
  1605. return (0);
  1606.     else if (config == 102 && dynx2stereo && m == 2)
  1607. return (0);
  1608.     else
  1609. return (1);
  1610. }
  1612. int dyn_bbal (int config, int center, int dynx, int sbgr)
  1613. {
  1614.     /* 960627 FdB Dyn_ch table dependent on configuration */
  1615.     if (config == 320)
  1616.     {
  1617. if (center == 3)
  1618.     return (dyn_bbal4PhC[dynx][sbgr]);
  1619. else
  1620.     return (dyn_bbal4[dynx][sbgr]);
  1621.     }
  1622.     else if (config == 310 || config == 220)
  1623.     {
  1624. if (center == 3)
  1625.     return (dyn_bbal3PhC[dynx][sbgr]);
  1626. else
  1627.     return (dyn_bbal3[dynx][sbgr]);
  1628.     }
  1629.     else if (config == 300 || config == 302 || config == 210)
  1630.     {
  1631. if (center == 3)
  1632.     return (dyn_bbal1PhC[dynx][sbgr]);
  1633. else
  1634.     return (dyn_bbal1[dynx][sbgr]);
  1635.     }
  1636.     else
  1637. return (0);
  1638. }
  1640. int dyn_bbal_2ndst (int dynx, int sbgr)
  1641. {
  1642.     return (dyn_bbal4[dynx][sbgr]);
  1643. }
  1646. #ifdef Augmentation_7ch
  1647. int dyn_bbal_aug (int aug_dynx, int sbgr)
  1648. {
  1649.     /* 960627 FdB Dyn_ch table dependent on configuration */
  1650.     return (dyn_bbal5[aug_dynx][sbgr]);
  1651. }
  1652. #endif
  1654. void init_mc_pred (frame_params *fr_ps)
  1655. {
  1656.     layer *info = fr_ps->header;
  1657.     int i, j, k;
  1659.     switch (fr_ps->config)
  1660.     {
  1661.     case 320: for (i = 0; i < 16; i++) n_pred_coef[i] = n_pred_coef4[i]; break;
  1662.     case 310:
  1663.     case 220: for (i = 0; i < 16; i++) n_pred_coef[i] = n_pred_coef3[i]; break;
  1664.     case 300:
  1665.     case 302:
  1666.     case 210: for (i = 0; i < 16; i++) n_pred_coef[i] = n_pred_coef1[i]; break;
  1667.     default: for (i = 0; i < 16; i++) n_pred_coef[i] = 0; break;
  1668.     }
  1670.     for (i = 0; i < 8; i++)
  1671.     {
  1672. info->mc_pred[i] = 0;
  1673. for (j = 0; j < 6; j++)
  1674. {
  1675.     info->delay_comp[i][j] = 0;
  1676.     info->predsi[i][j] = 0;
  1677.     for (k = 0; k < 3; k++)
  1678. info->pred_coef[i][j][k] = 127;
  1679. }  
  1680.     }
  1681. }
  1683. void set_mc_pred (frame_params *fr_ps)
  1684. {
  1685.     layer *info = fr_ps->header;
  1686.     int config = fr_ps->config;
  1687.     int dynx;
  1688.     int i, j, k, npred;
  1690.     for (i = 0; i < 8; i++)
  1691.     {
  1692. info->mc_pred[i] = rand () % 2;
  1693. if (info->mc_pred[i])
  1694. {
  1695.     dynx = fr_ps->header->dyn_cross[i];
  1696.     npred = n_pred_coef[dynx];
  1697.     for (j = 0; j < npred; j++)
  1698.     {
  1699. info->predsi[i][j] = rand () % 4;
  1700. if (info->predsi[i][j])
  1701. {
  1702.     info->delay_comp[i][j] = rand () % 8;
  1703.     for (k = 0; k < info->predsi[i][j]; k++)
  1704. info->pred_coef[i][j][k] = rand () % 256;
  1705. }
  1706.     }  
  1707. }
  1708.     }
  1709. }
  1711. /*****************************************************************************
  1712. *
  1713. *  CRC error protection package
  1714. *
  1715. *****************************************************************************/
  1717. void I_CRC_calc (frame_params *fr_ps, unsigned int (*bit_alloc)[32], unsigned int *crc)
  1718. {
  1719.     int i, k;
  1720.     layer *info = fr_ps->header;
  1721.     int stereo  = fr_ps->stereo;
  1722.     int jsbound = fr_ps->jsbound;
  1724.     *crc = 0xffff; /* changed from '0' 92-08-11 shn */
  1725.     update_CRC(info->bitrate_index, 4, crc);
  1726.     update_CRC(info->sampling_frequency, 2, crc);
  1727.     update_CRC(info->padding, 1, crc);
  1728.     update_CRC(info->extension, 1, crc);
  1729.     update_CRC(info->mode, 2, crc);
  1730.     update_CRC(info->mode_ext, 2, crc);
  1731.     update_CRC(info->copyright, 1, crc);
  1732.     update_CRC(info->original, 1, crc);
  1733.     update_CRC(info->emphasis, 2, crc);
  1735.     for (i=0;i<SBLIMIT;i++)
  1736.     for (k=0;k<((i<jsbound)?stereo:1);k++)
  1737.     update_CRC(bit_alloc[k][i], 4, crc);
  1738. }
  1740. void II_CRC_calc (frame_params *fr_ps, unsigned int (*bit_alloc)[32], unsigned int (*scfsi)[32], unsigned int *crc)
  1741. {
  1742.     int i, k;
  1743.     layer *info = fr_ps->header;
  1744.     int stereo  = fr_ps->stereo;
  1745.     int sblimit = fr_ps->sblimit;
  1746.     int jsbound = fr_ps->jsbound;
  1747.     al_table *alloc = fr_ps->alloc;
  1749.     *crc = 0xffff; /* changed from '0' 92-08-11 shn */
  1750.     update_CRC(info->bitrate_index, 4, crc);
  1751.     update_CRC(info->sampling_frequency, 2, crc);
  1752.     update_CRC(info->padding, 1, crc);
  1753.     update_CRC(info->extension, 1, crc);
  1754.     update_CRC(info->mode, 2, crc);
  1755.     update_CRC(info->mode_ext, 2, crc);
  1756.     update_CRC(info->copyright, 1, crc);
  1757.     update_CRC(info->original, 1, crc);
  1758.     update_CRC(info->emphasis, 2, crc);
  1760.     for (i=0;i<sblimit;i++)
  1761.     for (k=0;k<((i<jsbound)?stereo:1);k++)
  1762.     update_CRC(bit_alloc[k][i], (*alloc)[i][0].bits, crc);
  1764.     for (i=0;i<sblimit;i++)
  1765.     for (k=0;k<stereo;k++)
  1766.     if (bit_alloc[k][i])
  1767.     update_CRC(scfsi[k][i], 2, crc);
  1768. }
  1770. void II_CRC_calc_mc (frame_params *fr_ps, unsigned int (*bit_alloc)[32], unsigned int lfe_alloc, unsigned int (*scfsi)[32], unsigned int *crc)
  1771. {
  1772.     int i, k, m, l;
  1773.     layer *info  = fr_ps->header;
  1774.     int nr_tc    = fr_ps->stereo + fr_ps->stereomc;
  1775.     int center   = info->center;
  1776.     int surround = info->surround;
  1777.     int sblimit  = fr_ps->sblimit_mc;
  1778.     al_table *alloc = fr_ps->alloc_mc;
  1779.     
  1780.     *crc = 0xffff; /* changed from '0' 92-08-11 shn */
  1781.     update_CRC(info->ext_bit_stream_present, 1, crc);
  1782.     if(info->ext_bit_stream_present == 1)
  1783.         update_CRC(info->n_ad_bytes, 8, crc);
  1784.     update_CRC(center, 2, crc);
  1785.     update_CRC(surround, 2, crc);
  1786.     update_CRC(info->lfe, 1, crc);
  1787.     update_CRC(info->audio_mix, 1, crc);
  1788.     update_CRC(info->matrix, 2, crc);
  1789.     update_CRC(info->multiling_ch, 3, crc);
  1790.     update_CRC(info->multiling_fs, 1, crc);
  1791.     update_CRC(info->multiling_lay, 1, crc);
  1792.     update_CRC(info->copy_ident_bit, 1, crc);
  1793.     update_CRC(info->copy_ident_start, 1, crc);
  1794.     
  1795.     update_CRC(info->tc_sbgr_select, 1, crc);
  1796.     update_CRC(info->dyn_cross_on, 1, crc);
  1797.     update_CRC(info->mc_prediction_on, 1, crc);
  1798.     /* 960627 FdB tca bits dependent on configuration */
  1799.     if ((center == 1 || center == 3) &&
  1800.         (surround == 1 || surround == 2))
  1801.     {
  1802. /* 3 bits for tca's */
  1803. if(info->tc_sbgr_select == 1)
  1804.     update_CRC(info->tc_allocation, 3, crc);
  1805. else
  1806.     for(i = 0; i < 12; i++)
  1807. update_CRC(info->tc_alloc[i], 3, crc);
  1808.     }
  1809.     else if (center == 1 || center == 3 || surround == 1 || surround == 2)
  1810.     {
  1811. /* 2 bits for tca's */
  1812. if(info->tc_sbgr_select == 1)
  1813.     update_CRC(info->tc_allocation, 2, crc);
  1814. else
  1815.     for(i = 0; i < 12; i++)
  1816. update_CRC(info->tc_alloc[i], 2, crc);
  1817.     }
  1818.     if(info->dyn_cross_on == 1)
  1819.     {
  1820.       update_CRC(info->dyn_cross_LR, 1, crc);
  1821. for(i = 0; i < 12; i++)
  1822. {
  1823.     /* 960627 FdB DynX bits dependent on configuration */
  1824.     if((center == 1 || center == 3) && surround == 2)
  1825. /* 3/2 */
  1826. update_CRC(info->dyn_cross[i], 4, crc);
  1827.     else if(((center == 1 || center == 3) && surround == 1) ||
  1828.     (center == 0 && surround == 2))
  1829. /* 3/1 and 2/2 */
  1830. update_CRC(info->dyn_cross[i], 3, crc);
  1831.     else if(center == 1 || center == 3 || surround == 1)
  1832. /* 3/0 (+2/0) and 2/1 */
  1833. update_CRC(info->dyn_cross[i], 1, crc);
  1834.     if(surround == 3)
  1835. update_CRC(info->dyn_second_stereo[i], 1, crc);
  1836. }   
  1837.     }   
  1839.     if (info->mc_prediction_on == 1)
  1840.     {
  1841. for(i = 0; i < 8; i++)
  1842. {
  1843.     update_CRC (info->mc_pred[i], 1, crc);
  1844.     if (info->mc_pred[i] == 1)
  1845.         for (k = 0; k < n_pred_coef[info->dyn_cross[i]]; k ++)
  1846.     update_CRC (info->predsi[i][k], 2, crc);
  1847. }
  1848.     }
  1849.     
  1850.     if (fr_ps->header->lfe == 1)
  1851.         update_CRC (lfe_alloc, (*alloc)[0][0].bits, crc);     
  1852.     
  1853.     for (i = 0; i < sblimit; i++)
  1854.     {
  1855. l = sbgrp[i];
  1857. for (m = fr_ps->stereo; m < fr_ps->stereo + fr_ps->stereomc; m++)
  1858. {        
  1859.     k = transmission_channel (fr_ps, l, m);
  1861.     if ((i < 12) || (k != 2) || (fr_ps->header->center != 3))
  1862.     {
  1863. /* 960627 FdB DynX dependent on configuration */
  1864. if (dyn_ch (fr_ps, l, m) == 1)
  1865.     update_CRC (bit_alloc[k][i], (*alloc)[i][0].bits, crc);
  1866.     }      
  1867. }
  1868.     }
  1870.     for (i = 0; i < sblimit; i++)
  1871.     {
  1872. l = sbgrp[i];
  1874. for (m = fr_ps->stereo; m < fr_ps->stereo + fr_ps->stereomc; m++)
  1875.         {        
  1876.     k = transmission_channel (fr_ps, l, m);
  1877.  
  1878.     if (bit_alloc[k][i] && (i < 12 || m != 2 || center != 3))
  1879. update_CRC (scfsi[k][i], 2, crc);
  1880. }
  1881.     }
  1882. }
  1884. #ifdef Augmentation_7ch
  1885. void II_CRC_calc_aug (frame_params *fr_ps, unsigned int (*bit_alloc)[32], unsigned int (*scfsi)[32], unsigned int *crc)
  1886. {
  1887.     int i, k, m, l;
  1888.     int aug_future_ext = 0;
  1889.     layer *info  = fr_ps->header;
  1890.     int sblimit  = fr_ps->sblimit_mc;
  1891.     al_table *alloc = fr_ps->alloc_mc;
  1892.     
  1893.     *crc = 0xffff; /* changed from '0' 92-08-11 shn */
  1894.     update_CRC (info->aug_mtx_proc, 2, crc);
  1895.     update_CRC (info->aug_dyn_cross_on, 1, crc);
  1896.     update_CRC (aug_future_ext, 1, crc);
  1897.     /* 960627 FdB aug tca bits dependent on configuration */
  1898.     if (info->aug_mtx_proc == 0)
  1899. for (i = 0; i < 12; i++)
  1900.     update_CRC (info->aug_tc_alloc[i], 3, crc);
  1901.     else if (info->aug_mtx_proc == 1)
  1902. for (i = 0; i < 12; i++)
  1903.     update_CRC (info->aug_tc_alloc[i], 2, crc);
  1904.     if (info->aug_dyn_cross_on == 1)
  1905. for (i = 0; i < 12; i++)
  1906.     update_CRC (info->aug_dyn_cross[i], 5, crc);
  1908.     for (i = 0; i < sblimit; i++)
  1909.     {
  1910. l = sbgrp[i];
  1912. for (m = 5; m < 7; ++m)
  1913. {        
  1914.     k = transmission_channel (fr_ps, l, m);
  1916.     if (dyn_ch (fr_ps, l, m) == 1)
  1917. update_CRC (bit_alloc[k][i], (*alloc)[i][0].bits, crc);
  1918. }
  1919.     }
  1921.     for (i = 0; i < sblimit; i++)
  1922.     {
  1923. l = sbgrp[i];
  1925. for (m = 5; m < 7; ++m)
  1926.         {        
  1927.     k = transmission_channel (fr_ps, l, m);
  1928.  
  1929.     if (bit_alloc[k][i])
  1930. update_CRC (scfsi[k][i], 2, crc);
  1931. }
  1932.     }
  1933. }
  1934. #endif
  1937. void II_CRC_calc_ext (frame_params *fr_ps, unsigned int *z, unsigned int *crc)
  1938. {
  1939.     int i;
  1941.     layer *info = fr_ps->header;
  1942.     *crc = 0xffff; 
  1943.     update_CRC (info->ext_length, 11, crc);
  1944.     update_CRC (info->ext_bit, 1, crc);
  1945.     for (i = 0; i < 14; i++)
  1946.     {
  1947. update_CRC (z[i], 8, crc);
  1948.     }
  1949.     update_CRC (z[14], 4, crc);
  1950. }
  1953. void update_CRC (unsigned int data, unsigned int length, unsigned int *crc)
  1954. {
  1955.     unsigned int  masking, carry;
  1957.     masking = 1 << length;
  1959.     while (masking >>= 1)
  1960.     {
  1961. carry = *crc & 0x8000;
  1962. *crc <<= 1;
  1963. if (!carry ^ !(data & masking))
  1964.     *crc ^= CRC16_POLYNOMIAL;
  1965.     }
  1966.     *crc &= 0xffff;
  1968. #ifdef PrintCRCDebug
  1969. printf ("crc_len: %2d code: %4x crc: %4xn", length, data, *crc);
  1970. fflush (stdout);
  1971. #endif
  1972. }
  1974. /*****************************************************************************
  1975. *
  1976. *  End of CRC error protection package
  1977. *
  1978. *****************************************************************************/
  1980. #ifdef  MACINTOSH
  1981. /*****************************************************************************
  1982. *
  1983. *  Set Macintosh file attributes.
  1984. *
  1985. *****************************************************************************/
  1987. void    set_mac_file_attr(fileName, vRefNum, creator, fileType)
  1988. char    fileName[MAX_NAME_SIZE];
  1989. short   vRefNum;
  1990. OsType  creator;
  1991. OsType  fileType;
  1992. {
  1994. short   theFile;
  1995. char    pascal_fileName[MAX_NAME_SIZE];
  1996. FInfo   fndrInfo;
  1998.         CtoPstr(strcpy(pascal_fileName, fileName));
  2000.         FSOpen(pascal_fileName, vRefNum, &theFile);
  2001.         GetFInfo(pascal_fileName, vRefNum, &fndrInfo);
  2002.         fndrInfo.fdCreator = creator;
  2003.         fndrInfo.fdType = fileType;
  2004.         SetFInfo(pascal_fileName, vRefNum, &fndrInfo);
  2005.         FSClose(theFile);
  2007. }
  2008. #endif