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

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

mpeg/mp3

开发平台：

C/C++

dyn_cross.c：源码内容
  1. /**********************************************************************
  2.  * ISO MPEG Audio Subgroup Software Simulation Group (1996)
  3.  * ISO 13818-3 MPEG-2 Audio Multichannel Encoder
  4.  *
  5.  * $Id: dyn_cross.c 1.3 1996/02/12 07:13:35 rowlands Exp $
  6.  *
  7.  * $Log: dyn_cross.c $
  8.  * Revision 1.3  1996/02/12 07:13:35  rowlands
  9.  * Release following Munich meeting
  10.  *
  11.  **********************************************************************/
  13. #include "common.h"
  14. #include "encoder.h"
  16. /************************************************************************
  17.  *
  18.  * take_dyn_cross
  19.  *
  20.  * Version 1.0     94/10/24 Andreas Silzle, IRT
  21.  *
  22.  * Copy the sums, scf, scfsi, if required, in the normal positions.
  23.  *
  24.  ************************************************************************/
  27. /* #define LOW_SBGR 5 original value 960619 FdB */
  28. #define LOW_SBGR 0   /* lowest subbandgroup, in which dyn_cross is done.*/
  29.     /* All sb-groups under that boarder are not        */
  30.     /* affected by dyn_cross        */
  32. void take_dyn_cross (
  33. int dyn_cr,
  34. frame_params *fr_ps,       
  35.     /* out: int fr_ps->header->dyn_cross_on, 
  36.      *     int fr_ps->header->dyn_cross_LR, 
  37.           *     int fr_ps->header->dyn_cross[SBGRS],     
  38.      */     
  39. double sb_sample_sum[5][3][SCALE_BLOCK][SBLIMIT],      
  40.     /* in, T23, T24, T34, T234, T56 */
  41. unsigned int scalar_sum[][3][SBLIMIT],  /* in */ 
  42. unsigned int scfsi_sum[][SBLIMIT],   /* in */
  43. unsigned int scfsi_dyn[][SBLIMIT],   /* in */
  44. double sb_sample[CHANMAX3][3][SCALE_BLOCK][SBLIMIT], /* out */
  45. unsigned int scalar[][3][SBLIMIT],  /* out */ 
  46. unsigned int scfsi[][SBLIMIT])  /* out */
  47. {
  48.     int     sbgr, sb, sufr, smp, dyn_second_stereo = 0;
  49.     layer *info  = fr_ps->header;
  50.     int center   = info->center;
  51.     int surround = info->surround;
  53.     fr_ps->header->dyn_cross_on = 0;
  54.     if (fr_ps->header->dyn_cross_LR && (fr_ps->config == 302 || fr_ps->config == 202 || fr_ps->config == 102))
  55. dyn_second_stereo = 1;
  57. /*    printf ("dyn_cr: %2dn", dyn_cr); */
  59.     for (sbgr = LOW_SBGR; sbgr < SBGRS; sbgr++)
  60.     {
  61. /* signalization */
  62. if (dyn_cr == 0 && dyn_second_stereo == 0)
  63. {
  64.     fr_ps->header->dyn_cross[sbgr] = 0;
  65.     fr_ps->header->dyn_second_stereo[sbgr] = 0;
  66. }
  67. else
  68. {
  69.     fr_ps->header->dyn_cross_on = 1;
  70.     /* original value 960619 FdB */ 
  71.     /* fr_ps->header->dyn_cross[sbgr] = dyn_cr; */
  72.     /* systematic variation of dynamic crosstalk over all subbands */
  73.     if (dyn_cr == -1)
  74.     {
  75. switch (fr_ps->config)
  76. {
  77.     case 320: fr_ps->header->dyn_cross[sbgr] = rand () % 15;
  78. break;
  79.     case 310:
  80.     case 220: fr_ps->header->dyn_cross[sbgr] = rand () % 5;
  81. break;
  82.     case 300:
  83.     case 302:
  84.     case 210: fr_ps->header->dyn_cross[sbgr] = rand () % 2;
  85. break;
  86.     default: fr_ps->header->dyn_cross[sbgr] = 0;
  87. break;
  88. }
  89.     }
  90.     else
  91. fr_ps->header->dyn_cross[sbgr] = dyn_cr;
  93.     fr_ps->header->dyn_second_stereo[sbgr] = dyn_second_stereo;
  94. /*
  95.             printf ("sbgr: %2d dyn_cr: %2d dyn_2nd_st: %2dn",
  96.          sbgr, fr_ps->header->dyn_cross[sbgr],
  97.     fr_ps->header->dyn_second_stereo[sbgr]);
  98. */
  99.     /* copying sums, scf, scfsi */
  100.     
  101.     /* 960627 FdB DynX dependent on configuration */
  102.     if (fr_ps->config == 320)
  103.     {
  104. /* 3/2 */
  105. if(fr_ps->header->dyn_cross[sbgr] == 9 || fr_ps->header->dyn_cross[sbgr] == 11) {
  106.     T3from[sbgr] = T2[sbgr];
  107.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  108.     sb<=sb_groups[sbgr]; sb++) {
  109. scfsi[T2[sbgr]][sb] = scfsi_sum[T23][sb];
  110. for(sufr = 0; sufr<3; ++sufr) {
  111.     scalar[T2[sbgr]][sufr][sb] = scalar_sum[T23][sufr][sb];
  112.     for(smp = 0; smp<SCALE_BLOCK; ++smp) {
  113. sb_sample[T2[sbgr]][sufr][smp][sb] = 
  114.     sb_sample_sum[T23][sufr][smp][sb];
  115.     }   /* for(smp..) */
  116. }     /* for(sufr.). */
  117.     }     /* for(sb..) */
  118. } 
  119. else if(fr_ps->header->dyn_cross[sbgr] == 10 || fr_ps->header->dyn_cross[sbgr] == 12) {
  120.     T4from[sbgr] = T2[sbgr];
  121.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  122.     sb<=sb_groups[sbgr]; sb++) {
  123. scfsi[T2[sbgr]][sb] = scfsi_sum[T24][sb];
  124. for(sufr = 0; sufr<3; ++sufr) {
  125.     scalar[T2[sbgr]][sufr][sb] = scalar_sum[T24][sufr][sb];
  126.     for(smp = 0; smp<SCALE_BLOCK; ++smp) {
  127. sb_sample[T2[sbgr]][sufr][smp][sb] = 
  128.     sb_sample_sum[T24][sufr][smp][sb];
  129.     }   /* for(smp..) */
  130. }     /* for(sufr..) */
  131.     }     /* for(sb..) */
  132. } 
  133. else if(fr_ps->header->dyn_cross[sbgr] == 8 || fr_ps->header->dyn_cross[sbgr] == 13) {
  134.     T4from[sbgr] = T3[sbgr];
  135.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  136.     sb<=sb_groups[sbgr]; sb++) {
  137. scfsi[T3[sbgr]][sb] = scfsi_sum[T34][sb];
  138. for(sufr = 0; sufr<3; ++sufr) {
  139.     scalar[T3[sbgr]][sufr][sb] = scalar_sum[T34][sufr][sb];
  140.     for(smp = 0; smp<SCALE_BLOCK; ++smp) {
  141. sb_sample[T3[sbgr]][sufr][smp][sb] = 
  142.     sb_sample_sum[T34][sufr][smp][sb];
  143.     }   /* for(smp..) */
  144. }     /* for(sufr..) */
  145.     }     /* for(sb..) */
  146. } 
  147. else if(fr_ps->header->dyn_cross[sbgr] == 14) {
  148.     T3from[sbgr] = T4from[sbgr] = T2[sbgr];
  149.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  150.     sb<=sb_groups[sbgr]; sb++) {
  151. scfsi[T2[sbgr]][sb] = scfsi_sum[T234][sb];
  152. for(sufr = 0; sufr<3; ++sufr) {
  153.     scalar[T2[sbgr]][sufr][sb] = scalar_sum[T234][sufr][sb];
  154.     for(smp = 0; smp<SCALE_BLOCK; ++smp) {
  155. sb_sample[T2[sbgr]][sufr][smp][sb] = 
  156.     sb_sample_sum[T234][sufr][smp][sb];
  157.     }   /* for(smp..) */
  158. }     /* for(sufr..) */
  159.     }     /* for(sb..) */
  160. }     /* if(dyncr_do[sbgr]..) */
  162. /* scfsi_dyn in scfsi of L0 and R0 */
  163. /* T2 */
  164. switch(fr_ps->header->dyn_cross[sbgr]) {
  165.       case 3: case 5: case 6: case 7: case 13:
  166.     T2from[sbgr] = T2outof[sbgr];
  167.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  168.     sb<=sb_groups[sbgr]; sb++) 
  169. scfsi[T2outof[sbgr]][sb] = scfsi_dyn[T2outof[sbgr]][sb];
  170.     break;     
  171. } /* switch(dyncr_do[sbgr]) */
  172. /* T3 */
  173. switch(fr_ps->header->dyn_cross[sbgr]) {
  174.       case 2: case 4: case 6: case 7: case 12:
  175.     T3from[sbgr] = T3outof[sbgr];
  176.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  177.     sb<=sb_groups[sbgr]; sb++) 
  178. scfsi[L0][sb] = scfsi_dyn[L0][sb];
  179.     break;     
  180. } /* switch(dyncr_do[sbgr]) */
  181. /* T4 */
  182. switch(fr_ps->header->dyn_cross[sbgr]) {
  183.       case 1: case 4: case 5: case 7: case 11:
  184.     T4from[sbgr] = T4outof[sbgr];
  185.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  186.     sb<=sb_groups[sbgr]; sb++) 
  187. scfsi[R0][sb] = scfsi_dyn[R0][sb];
  188.     break;     
  189. } /* switch(fr_ps->header->dyn_cross[sbgr]) */
  190.     }
  191.     else if (fr_ps->config == 310 || fr_ps->config == 220)
  192.     {
  193. /* 3/1 and 2/2 */
  194. if(fr_ps->header->dyn_cross[sbgr] == 4) {
  195.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  196.     sb<=sb_groups[sbgr]; sb++) {
  197. scfsi[T2[sbgr]][sb] = scfsi_sum[T23][sb];
  198. for(sufr = 0; sufr<3; ++sufr) {
  199.     scalar[T2[sbgr]][sufr][sb] = scalar_sum[T23][sufr][sb];
  200.     for(smp = 0; smp<SCALE_BLOCK; ++smp) {
  201. sb_sample[T2[sbgr]][sufr][smp][sb] = 
  202.     sb_sample_sum[T23][sufr][smp][sb];
  203.     }   /* for(smp..) */
  204. }     /* for(sufr.). */
  205.     }     /* for(sb..) */
  206. } 
  207.     
  208. /* scfsi_dyn in scfsi of L0 and R0 */
  209. /* T2 */
  210. switch(fr_ps->header->dyn_cross[sbgr]) {
  211.       case 2: case 3:
  212.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  213.     sb<=sb_groups[sbgr]; sb++) 
  214. scfsi[T2outof[sbgr]][sb] = scfsi_dyn[T2outof[sbgr]][sb];
  215.     break;     
  216. } /* switch(dyncr_do[sbgr]) */
  217. /* T3 */
  218. switch(fr_ps->header->dyn_cross[sbgr]) {
  219.       case 1: case 3:
  220.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  221.     sb<=sb_groups[sbgr]; sb++) 
  222. scfsi[T3outof[sbgr]][sb] = scfsi_dyn[T3outof[sbgr]][sb];
  223.     break;     
  224. } /* switch(dyncr_do[sbgr]) */
  225.     }
  226.     else if (fr_ps->config == 300 || fr_ps->config == 302 || fr_ps->config == 210)
  227.     {
  228. /* 3/0 (+2/0) and 2/1 */
  229. /* scfsi_dyn in scfsi of L0 and R0 */
  230. /* T2 */
  231. switch(fr_ps->header->dyn_cross[sbgr]) {
  232.       case 1:
  233.     for(sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  234.     sb<=sb_groups[sbgr]; sb++) 
  235. scfsi[T2outof[sbgr]][sb] = scfsi_dyn[T2outof[sbgr]][sb];
  236.     break;     
  237. } /* switch(dyncr_do[sbgr]) */
  238.     
  239. if (fr_ps->header->dyn_second_stereo[sbgr])
  240.     for (sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); sb<=sb_groups[sbgr]; sb++)
  241.     {
  242. scfsi[T3[sbgr]][sb] = scfsi_sum[T23][sb];
  243. for (sufr = 0; sufr<3; ++sufr)
  244. {
  245.     scalar[T3[sbgr]][sufr][sb] = scalar_sum[T23][sufr][sb];
  246.     for (smp = 0; smp<SCALE_BLOCK; ++smp)
  247. sb_sample[T3[sbgr]][sufr][smp][sb] = sb_sample_sum[T23][sufr][smp][sb];
  248. }     /* for(sufr..) */
  249.     }     /* for(sb..) */
  250.     }
  251.     else if (fr_ps->config == 202)
  252.     {
  253. if (fr_ps->header->dyn_second_stereo[sbgr])
  254.     for (sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); sb<=sb_groups[sbgr]; sb++)
  255.     {
  256. scfsi[T2[sbgr]][sb] = scfsi_sum[T23][sb];
  257. for (sufr = 0; sufr<3; ++sufr)
  258. {
  259.     scalar[T2[sbgr]][sufr][sb] = scalar_sum[T23][sufr][sb];
  260.     for (smp = 0; smp<SCALE_BLOCK; ++smp)
  261. sb_sample[T2[sbgr]][sufr][smp][sb] = sb_sample_sum[T23][sufr][smp][sb];
  262. }     /* for(sufr.). */
  263.     }     /* for(sb..) */
  264.     }
  265.     else if (fr_ps->config == 102)
  266.     {
  267. if (fr_ps->header->dyn_second_stereo[sbgr])
  268.     for (sb=((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); sb<=sb_groups[sbgr]; sb++)
  269.     {
  270. scfsi[1][sb] = scfsi_sum[T23][sb];
  271. for (sufr = 0; sufr<3; ++sufr)
  272. {
  273.     scalar[1][sufr][sb] = scalar_sum[T23][sufr][sb];
  274.     for (smp = 0; smp<SCALE_BLOCK; ++smp)
  275. sb_sample[1][sufr][smp][sb] = sb_sample_sum[T23][sufr][smp][sb];
  276. }     /* for(sufr.). */
  277.     }     /* for(sb..) */
  278.     }
  279. } /* if(fr_ps->header->dyn_cross[sbgr] == 0) */
  280.     } /* for(sbgr=0.. */
  281. }
  283. #ifdef Augmentation_7ch
  284. void take_dyn_cross_aug (
  285. int aug_dyn_cr,
  286. frame_params *fr_ps,       
  287.     /* out: int fr_ps->header->dyn_cross_on, 
  288.      *     int fr_ps->header->dyn_cross_LR, 
  289.           *     int fr_ps->header->dyn_cross[SBGRS],     
  290.      */     
  291. double sb_sample_sum[5][3][SCALE_BLOCK][SBLIMIT],      
  292.     /* in, T23, T24, T34, T234, T56 */
  293. unsigned int scalar_sum[][3][SBLIMIT],  /* in */ 
  294. unsigned int scfsi_sum[][SBLIMIT],   /* in */
  295. unsigned int scfsi_dyn[][SBLIMIT],   /* in */
  296. double sb_sample[CHANMAX3][3][SCALE_BLOCK][SBLIMIT], /* out */
  297. unsigned int scalar[][3][SBLIMIT],  /* out */ 
  298. unsigned int scfsi[][SBLIMIT])  /* out */
  299. {
  300.     int     sbgr, sb, sufr, smp;
  301.     layer *info  = fr_ps->header;
  302.     int center   = info->center;
  303.     int surround = info->surround;
  305.     fr_ps->header->aug_dyn_cross_on = 1;
  307.     for (sbgr = LOW_SBGR; sbgr < SBGRS; sbgr++)
  308.     {
  309. if (aug_dyn_cr == -1)
  310.     fr_ps->header->aug_dyn_cross[sbgr] = rand () % 19;
  311. else
  312.     fr_ps->header->aug_dyn_cross[sbgr] = aug_dyn_cr;
  314. /* copying sums, scf, scfsi */
  316. if (fr_ps->header->aug_dyn_cross[sbgr] == 4)
  317. {
  318.     for (sb = ((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  319.     sb <= sb_groups[sbgr]; sb++)
  320.     {
  321. scfsi[T5[sbgr]][sb] = scfsi_sum[T56][sb];
  322. for (sufr = 0; sufr < 3; ++sufr)
  323. {
  324.     scalar[T5[sbgr]][sufr][sb] = scalar_sum[T56][sufr][sb];
  325.     for (smp = 0; smp < SCALE_BLOCK; ++smp)
  326. sb_sample[T5[sbgr]][sufr][smp][sb] = 
  327.     sb_sample_sum[T56][sufr][smp][sb];
  328. }
  329.     }
  330. }
  332. /* scfsi_dyn in scfsi of MPEG2 channels */
  333. /* L0 */
  334. switch (fr_ps->header->aug_dyn_cross[sbgr])
  335. {
  336. case 5: case 6: case 7: case 8: case 9:
  337.       for (sb = ((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  338.       sb <= sb_groups[sbgr]; sb++) 
  339.   scfsi[L0][sb] = scfsi_dyn[L0][sb];
  340.       break;     
  341. }
  342. /* R0 */
  343. switch (fr_ps->header->aug_dyn_cross[sbgr])
  344. {
  345. case 1: case 6: case 11: case 15:
  346.       for (sb = ((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  347.       sb <= sb_groups[sbgr]; sb++) 
  348.   scfsi[R0][sb] = scfsi_dyn[R0][sb];
  349.       break;     
  350. }
  351. /* T2 */
  352. switch (fr_ps->header->aug_dyn_cross[sbgr])
  353. {
  354. case 2: case 7: case 10: case 11: case 12: case 13: case 16:
  355.       for (sb = ((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  356.       sb <= sb_groups[sbgr]; sb++) 
  357.   scfsi[T2[sbgr]][sb] = scfsi_dyn[T2[sbgr]][sb];
  358.       break;     
  359. }
  360. /* T3 */
  361. switch (fr_ps->header->aug_dyn_cross[sbgr])
  362. {
  363. case 14: case 15: case 16: case 17: case 18:
  364.       for (sb = ((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  365.       sb <= sb_groups[sbgr]; sb++) 
  366.   scfsi[T3[sbgr]][sb] = scfsi_dyn[T3[sbgr]][sb];
  367.       break;     
  368. }
  369. /* T4 */
  370. switch (fr_ps->header->aug_dyn_cross[sbgr])
  371. {
  372. case 3: case 8: case 13: case 17:
  373.       for (sb = ((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  374.       sb <= sb_groups[sbgr]; sb++) 
  375.   scfsi[T4[sbgr]][sb] = scfsi_dyn[T4[sbgr]][sb];
  376.       break;     
  377. }
  378.     }
  379. }
  380. #endif
  382. /************************************************************************
  383.  *
  384.  * trans_chan
  385.  *
  386.  * Version 1.0     94/06/27 Andreas Silzle, IRT
  387.  * Version 1.1     94/10/28 Andreas Silzle, IRT
  388.  *
  389.  * Which channels are in the transmission channels 
  390.  * T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof{SBGRS] per subband group.
  391.  * T2outof[] can be changed later by fr_ps->header->dyn_cross_LR.
  392.  *
  393.  ************************************************************************/
  395. void trans_chan (frame_params *fr_ps)      
  396.     /* in:  int fr_ps->header->tc_alloc[SBGRS], 
  397.           *     int fr_ps->numchan,     
  398.      *     int fr_ps->header->matrix,     0 normal -, 3 no matricing 
  399.      *     int fr_ps->header->dyn_cross_LR  0 out of L0, 1 out of R0
  400.      */     
  401. /*  global parameters
  402.  *  out:    T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS], T3outof[SBGRS], T4outof[SBGRS]
  403.  */
  404. {  
  405.     int sbgr;
  407.     for (sbgr = 0; sbgr < SBGRS; sbgr++)
  408.     {
  409. /* 960627 FdB tca dependent on configuration */
  410. if (fr_ps->config == 320)
  411. {
  412.     /* 3/2 */
  413.     switch(fr_ps->header->tc_alloc[sbgr]) {
  414.   case 0:
  415. T2[sbgr] = C; T3[sbgr] = LS; T4[sbgr] = RS;
  416. if(fr_ps->header->dyn_cross_LR == 0)
  417.     T2outof[sbgr] = L0;
  418. else
  419.     T2outof[sbgr] = R0;
  420. T3outof[sbgr] = L0;
  421. T4outof[sbgr] = R0;
  422. break;
  423.   case 1:
  424. T2[sbgr] = L; T3[sbgr] = LS; T4[sbgr] = RS;
  425. T2outof[sbgr] = L0;
  426. T3outof[sbgr] = L0;
  427. T4outof[sbgr] = R0;
  428. break;
  429.   case 2:
  430. T2[sbgr] = R; T3[sbgr] = LS; T4[sbgr] = RS;
  431. T2outof[sbgr] = R0;
  432. T3outof[sbgr] = L0;
  433. T4outof[sbgr] = R0;
  434. break;
  435.   case 3:
  436. T2[sbgr] = C; T3[sbgr] = L; T4[sbgr] = RS;
  437. if(fr_ps->header->dyn_cross_LR == 0)
  438.     T2outof[sbgr] = L0;
  439. else
  440.     T2outof[sbgr] = R0;
  441. T3outof[sbgr] = L0;
  442. T4outof[sbgr] = R0;
  443. break;
  444.   case 4:
  445. T2[sbgr] = C; T3[sbgr] = LS; T4[sbgr] = R;
  446. if(fr_ps->header->dyn_cross_LR == 0)
  447.     T2outof[sbgr] = L0;
  448. else
  449.     T2outof[sbgr] = R0;
  450. T3outof[sbgr] = L0;
  451. T4outof[sbgr] = R0;
  452. break;
  453.   case 5:
  454. T2[sbgr] = C; T3[sbgr] = L; T4[sbgr] = R;
  455. if(fr_ps->header->dyn_cross_LR == 0)
  456.     T2outof[sbgr] = L0;
  457. else
  458.     T2outof[sbgr] = R0;
  459. T3outof[sbgr] = L0;
  460. T4outof[sbgr] = R0;
  461. break;
  462.   case 6:
  463. T2[sbgr] = R; T3[sbgr] = L; T4[sbgr] = RS;
  464. T2outof[sbgr] = R0;
  465. T3outof[sbgr] = L0;
  466. T4outof[sbgr] = R0;
  467. break;
  468.   case 7:
  469. T2[sbgr] = L; T3[sbgr] = LS; T4[sbgr] = R;
  470. T2outof[sbgr] = L0;
  471. T3outof[sbgr] = L0;
  472. T4outof[sbgr] = R0;
  473. break;
  474.     } /* switch() */
  475. }
  476. else if (fr_ps->config == 310)
  477. {
  478.     /* 3/1 */
  479.     switch(fr_ps->header->tc_alloc[sbgr]) {
  480.   case 0:
  481. T2[sbgr] = 2;
  482. T3[sbgr] = 3;
  483. if(fr_ps->header->dyn_cross_LR == 0)
  484.     T2outof[sbgr] = T3outof[sbgr] = L0;
  485. else
  486.     T2outof[sbgr] = T3outof[sbgr] = R0;
  487. break;
  488.   case 1:
  489. T2[sbgr] = L;
  490. T3[sbgr] = 3;
  491. T2outof[sbgr] = L0;
  492. if(fr_ps->header->dyn_cross_LR == 0)
  493.     T3outof[sbgr] = L0;
  494. else
  495.     T3outof[sbgr] = R0;
  496. break;
  497.   case 2:
  498. T2[sbgr] = R;
  499. T3[sbgr] = 3;
  500. T2outof[sbgr] = R0;
  501. if(fr_ps->header->dyn_cross_LR == 0)
  502.     T3outof[sbgr] = L0;
  503. else
  504.     T3outof[sbgr] = R0;
  505. break;
  506.   case 3:
  507. T2[sbgr] = 2;
  508. T3[sbgr] = L;
  509. if(fr_ps->header->dyn_cross_LR == 0)
  510.     T2outof[sbgr] = L0;
  511. else
  512.     T2outof[sbgr] = R0;
  513. T3outof[sbgr] = L0;
  514. break;
  515.   case 4:
  516. T2[sbgr] = 2;
  517. T3[sbgr] = R;
  518. if(fr_ps->header->dyn_cross_LR == 0)
  519.     T2outof[sbgr] = L0;
  520. else
  521.     T2outof[sbgr] = R0;
  522. T3outof[sbgr] = R0;
  523. break;
  524.   case 5:
  525. T2[sbgr] = L;
  526. T3[sbgr] = R;
  527. T2outof[sbgr] = L0;
  528. T3outof[sbgr] = R0;
  529. break;
  530.     } /* switch() */
  531. }
  532. else if (fr_ps->config == 220)
  533. {
  534.     /* 2/2 */
  535.     switch(fr_ps->header->tc_alloc[sbgr]) {
  536.   case 0:
  537. T2[sbgr] = 2; T3[sbgr] = 3;
  538. break;
  539.   case 1:
  540. T2[sbgr] = L; T3[sbgr] = 3;
  541. break;
  542.   case 2:
  543. T2[sbgr] = 2; T3[sbgr] = R;
  544. break;
  545.   case 3:
  546. T2[sbgr] = L; T3[sbgr] = R;
  547. break;
  548.     } /* switch() */
  549.     T2outof[sbgr] = L0;
  550.     T3outof[sbgr] = R0;
  551. }
  552. else if (fr_ps->config == 300 || fr_ps->config == 302)
  553. {
  554.     /* 3/0 (+ 2/0) */
  555.     switch(fr_ps->header->tc_alloc[sbgr]) {
  556.   case 0:
  557. T2[sbgr] = 2;
  558. if(fr_ps->header->dyn_cross_LR == 0)
  559.     T2outof[sbgr] = L0;
  560. else
  561.     T2outof[sbgr] = R0;
  562. break;
  563.   case 1:
  564. T2[sbgr] = L;
  565. T2outof[sbgr] = L0;
  566. break;
  567.   case 2:
  568. T2[sbgr] = R;
  569. T2outof[sbgr] = R0;
  570. break;
  571.     } /* switch() */
  572. }
  573. else if (fr_ps->config == 210)
  574. {
  575.     /* 2/1 */
  576.     switch(fr_ps->header->tc_alloc[sbgr]) {
  577.   case 0:
  578. T2[sbgr] = 2;
  579. if(fr_ps->header->dyn_cross_LR == 0)
  580.     T2outof[sbgr] = L0;
  581. else
  582.     T2outof[sbgr] = R0;
  583. break;
  584.   case 1:
  585. T2[sbgr] = L;
  586. T2outof[sbgr] = L0;
  587. break;
  588.   case 2:
  589. T2[sbgr] = R;
  590. T2outof[sbgr] = R0;
  591. break;
  592.     } /* switch() */
  593. }
  594. if (fr_ps->config == 302)
  595. {
  596.     /* 3/0 + 2/0 */
  597.     T3[sbgr] = 3; 
  598.     T4[sbgr] = 4; 
  599.     T4outof[sbgr] = 3;
  600. }
  601. else if (fr_ps->config == 202)
  602. {
  603.     /* 2/0 + 2/0 */
  604.     T2[sbgr] = 2; 
  605.     T3[sbgr] = 3; 
  606.     T3outof[sbgr] = 2;
  607. }
  608. else if (fr_ps->config == 102)
  609. {
  610.     /* 1/0 + 2/0 */
  611.     T2[sbgr] = 2; 
  612.     T2outof[sbgr] = 1;
  613. }
  614.     } /* for(sbgr.. */
  615. }
  617. #ifdef Augmentation_7ch
  618. void trans_chan_aug (frame_params *fr_ps)      
  619.     /* in:  int fr_ps->header->tc_alloc[SBGRS], 
  620.           *     int fr_ps->numchan,     
  621.      *     int fr_ps->header->matrix,     0 normal -, 3 no matricing 
  622.      *     int fr_ps->header->dyn_cross_LR  0 out of L0, 1 out of R0
  623.      */     
  624. /*  global parameters
  625.  *  out:    T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS], T3outof[SBGRS], T4outof[SBGRS]
  626.  */
  627. {  
  628.     int sbgr;
  630.     for (sbgr = 0; sbgr < SBGRS; sbgr++)
  631.     {
  632. /* 5/2 */
  633. switch (fr_ps->header->aug_tc_alloc[sbgr])
  634. {
  635. case 0:
  636.       T5[sbgr] = LC;
  637.       T6[sbgr] = RC;
  638.       break;
  639. case 1:
  640.       T5[sbgr] = L7;
  641.       T6[sbgr] = RC;
  642.       break;
  643. case 2:
  644.       T5[sbgr] = LC;
  645.       T6[sbgr] = R7;
  646.       break;
  647. case 3:
  648.       T5[sbgr] = L7;
  649.       T6[sbgr] = R7;
  650.       break;
  651. case 4:
  652.       T5[sbgr] = LC;
  653.       T6[sbgr] = C7;
  654.       break;
  655. case 5:
  656.       T5[sbgr] = L7;
  657.       T6[sbgr] = C7;
  658.       break;
  659. case 6:
  660.       T5[sbgr] = C7;
  661.       T6[sbgr] = RC;
  662.       break;
  663. case 7:
  664.       T5[sbgr] = C7;
  665.       T6[sbgr] = R7;
  666.       break;
  667. } /* switch() */
  668.     }
  669. }
  670. #endif
  672. /************************************************************************
  673.  *
  674.  * combine
  675.  *
  676.  * Version 1.0     94/06/27 Andreas Silzle, IRT
  677.  *
  678.  * Add two channels into a mono channel to use it in dynamic crosstalk.
  679.  *
  680.  ************************************************************************/
  682. void combine ( 
  683. frame_params *fr_ps,      
  684.     /* in:  int fr_ps->header->tc_alloc[SBGRS], 
  685.      *     int fr_ps->sblimit,
  686.      */
  687. double sb_sample[CHANMAX3][3][SCALE_BLOCK][SBLIMIT], /* in */
  688. double sb_sample_sum[5][3][SCALE_BLOCK][SBLIMIT]) 
  689.     /* out; T23, T24, T34, T234, T56 */
  690. {  
  691. /*  global parameters
  692.  *  in: T2[SBGRS], T3[SBGRS], T4[SBGRS]
  693.  *      sb_groups[SBGRS]
  694.  */
  695.     int sb, sbgr, smp, sufr;
  697.     for (sbgr=0; sbgr < SBGRS; sbgr++)
  698.     {
  699. for (sb = ((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  700. sb <= sb_groups[sbgr]; sb++)
  701. {
  702.     for (smp = 0; smp < SCALE_BLOCK; smp++)
  703.     {
  704. for (sufr = 0; sufr < 3; ++sufr)
  705. {
  706.     if (fr_ps->config == 320 || fr_ps->config == 310 || fr_ps->config == 220 || fr_ps->config == 202)
  707. sb_sample_sum[T23][sufr][smp][sb] = 
  708.     .5 * (sb_sample[T2[sbgr]][sufr][smp][sb]
  709. + sb_sample[T3[sbgr]][sufr][smp][sb]);
  710.     else if (fr_ps->config == 102)
  711. sb_sample_sum[T23][sufr][smp][sb] = 
  712.     .5 * (sb_sample[1       ][sufr][smp][sb]
  713. + sb_sample[T2[sbgr]][sufr][smp][sb]);
  714.     else if (fr_ps->config == 302)
  715. sb_sample_sum[T23][sufr][smp][sb] = 
  716.     .5 * (sb_sample[T3[sbgr]][sufr][smp][sb]
  717. + sb_sample[T4[sbgr]][sufr][smp][sb]);
  718.     if (fr_ps->config == 320)
  719.     {
  720. sb_sample_sum[T24][sufr][smp][sb] = 
  721.     .5 * (sb_sample[T2[sbgr]][sufr][smp][sb]
  722. + sb_sample[T4[sbgr]][sufr][smp][sb]);
  723. sb_sample_sum[T34][sufr][smp][sb] = 
  724.     .5 * (sb_sample[T3[sbgr]][sufr][smp][sb]
  725. + sb_sample[T4[sbgr]][sufr][smp][sb]);
  726. sb_sample_sum[T234][sufr][smp][sb] = 
  727.     .333333 * (sb_sample[T2[sbgr]][sufr][smp][sb]
  728. + sb_sample[T3[sbgr]][sufr][smp][sb]
  729. + sb_sample[T4[sbgr]][sufr][smp][sb]);
  730.     }
  731. }   /* for(sufr.. */
  732.     }     /* for(smp.. */
  733. }     /* for(sb.. */
  734.     }     /* for(sbgr.. */
  735. }
  737. #ifdef Augmentation_7ch
  738. void combine_aug ( 
  739. frame_params *fr_ps,      
  740.     /* in:  int fr_ps->header->tc_alloc[SBGRS], 
  741.      *     int fr_ps->sblimit,
  742.      */
  743. double sb_sample[CHANMAX3][3][SCALE_BLOCK][SBLIMIT], /* in */
  744. double sb_sample_sum[5][3][SCALE_BLOCK][SBLIMIT]) 
  745.     /* out; T23, T24, T34, T234, T56 */
  746. {  
  747. /*  global parameters
  748.  *  in: T2[SBGRS], T3[SBGRS], T4[SBGRS]
  749.  *      sb_groups[SBGRS]
  750.  */
  751.     int sb, sbgr, smp, sufr;
  753.     for (sbgr = 0; sbgr < SBGRS; sbgr++)
  754.     {
  755. for (sb = ((sbgr==0) ? 0:(sb_groups[sbgr-1]+1)); 
  756. sb <= sb_groups[sbgr]; sb++)
  757. {
  758.     for (smp = 0; smp < SCALE_BLOCK; smp++)
  759.     {
  760. for (sufr = 0; sufr < 3; ++sufr)
  761. {
  762.     sb_sample_sum[T56][sufr][smp][sb] = 
  763. .5 * (sb_sample[T5[sbgr]][sufr][smp][sb]
  764.     + sb_sample[T6[sbgr]][sufr][smp][sb]);
  765. }   /* for (sufr.. */
  766.     }     /* for (smp.. */
  767. }     /* for (sb.. */
  768.     }     /* for (sbgr.. */
  769. }
  770. #endif
  772. /****************************************************************************
  773.  *
  774.  *  void dyn_bal
  775.  *
  776.  *  Add the bits for scf and scfsi of the channel with dynamic crosstalk
  777.  *  in the case of min_ch is L0 and R0.
  778.  *
  779.  *  07/94 Susanne Ritscher
  780.  *  94/10/28 Andreas Silzle     little remake
  781.  *
  782.  *****************************************************************************/
  784. void dyn_bal (
  785. unsigned int scfsi[CHANMAX3][SBLIMIT],   /* in */ 
  786. int sbgr,     /* in */
  787. frame_params *fr_ps,
  788.     /* in:  fr_ps->header->dyn_cross[sbgr] */
  789. int min_ch,     /* in */
  790. int min_sb,     /* in */
  791. int *seli,     /* in, out */
  792. int *scale)     /* in, out */
  793. {
  794. /*  global parameters
  795.  *  in: T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS], T3outof[SBGRS], T4outof[SBGRS]
  796.  */
  797.     static int sfsPerScfsi[] = { 3,2,1,2 };    /* lookup # sfs per scfsi */
  798.     layer *info  = fr_ps->header;
  799.     int center   = info->center;
  800.     int surround = info->surround;
  802.     /* 960627 FdB DynX dependent on configuration */
  803.     if (fr_ps->config == 320)
  804.     {
  805. /* 3/2 */
  806. switch (fr_ps->header->dyn_cross[sbgr]) {
  807.       case 0:
  808.     break;     /* no additional scf and scfsi */
  809.       case 1:  
  810.     if (min_ch == R0) {
  811. *seli += 2;
  812. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  813.     }
  814.     break;
  815.       case 2:  
  816.     if (min_ch == L0) {
  817. *seli += 2;
  818. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  819.     }
  820.     break;
  821.       case 3: 
  822.     if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
  823. *seli += 2;
  824. *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  825.     }
  826.     break;
  827.       case 4: 
  828.     if (min_ch == L0) {
  829. *seli += 2;
  830. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  831.     }
  832.     if (min_ch == R0) {
  833. *seli += 2;
  834. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  835.     }
  836.     break;
  837.       case 5:  
  838.     if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
  839. *seli += 2;
  840. *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  841.     }
  842.     if (min_ch == R0) {
  843. *seli += 2;
  844. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  845.     }
  846.     break;
  847.       case 6: 
  848.     if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
  849. *seli += 2;
  850. *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  851.     }
  852.     if (min_ch == L0) {
  853. *seli += 2;
  854. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  855.     }
  856.     break;
  857.       case 7: 
  858.     if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
  859. *seli += 2;
  860. *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  861.     }
  862.     if (min_ch == L0) {
  863. *seli += 2;
  864. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  865.     }
  866.     if (min_ch == R0) {
  867. *seli += 2;
  868. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  869.     }
  870.     break;
  871.       case 8:
  872.     if (min_ch == T3[sbgr]) {
  873. *seli += 2;
  874. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  875.     }
  876.     break;
  877.       case 9:  
  878.     if (min_ch == T2[sbgr]) {
  879. *seli += 2;
  880. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  881.     }
  882.     break;
  883.       case 10:  
  884.     if (min_ch == T2[sbgr]) {
  885. *seli += 2;
  886. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  887.     }
  888.     break;
  889.       case 11:  
  890.     if (min_ch == T2[sbgr]) {
  891. *seli += 2;
  892. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  893.     }
  894.     if (min_ch == R0) {
  895. *seli += 2;
  896. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  897.     }
  898.     break;
  899.       case 12:  
  900.     if (min_ch == T2[sbgr]) {
  901. *seli += 2;
  902. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  903.     }
  904.     if (min_ch == L0) {
  905. *seli += 2;
  906. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  907.     }
  908.     break;
  909.       case 13:  
  910.     if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
  911. *seli += 2;
  912. *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  913.     }
  914.     if (min_ch == T3[sbgr]) {
  915. *seli += 2;
  916. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  917.     }
  918.     break;
  919.       case 14:  
  920.     if (min_ch == T2[sbgr]) {
  921. *seli += 4;
  922. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  923. *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  924.     }
  925.     break;
  926.       case 15: 
  927.     fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!n");
  928.     fflush(stderr);
  929.     exit(0);
  930.     break;
  931. }     /* switch.. */
  932.     }
  933.     else if (fr_ps->config == 310 || fr_ps->config == 220)
  934.     {
  935. /* 3/1 and 2/2 */
  936. switch (fr_ps->header->dyn_cross[sbgr]) {
  937.       case 0:
  938.     break;     /* no additional scf and scfsi */
  939.       case 1:  
  940.     if (min_ch == T3outof[sbgr]) {
  941. *seli += 2;
  942. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  943.     }
  944.     break;
  945.       case 2:  
  946.     if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
  947. *seli += 2;
  948. *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  949.     }
  950.     break;
  951.       case 3: 
  952.     if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
  953. *seli += 2;
  954. *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  955.     }
  956.     if (min_ch == T3outof[sbgr]) {
  957. *seli += 2;
  958. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  959.     }
  960.     break;
  961.       case 4:  
  962.     if (min_ch == T2[sbgr]) {
  963. *seli += 2;
  964. *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  965.     }
  966.     break;
  967.       default: 
  968.     fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!n");
  969.     fflush(stderr);
  970.     exit(0);
  971.     break;
  972. }     /* switch.. */
  973.     }
  974.     else if (fr_ps->config == 300 || fr_ps->config == 302 || fr_ps->config == 210)
  975.     {
  976. /* 3/0 (+2/0) and 2/1 */
  977. switch(fr_ps->header->dyn_cross[sbgr]) {
  978.       case 0:
  979.     break;     /* no additional scf and scfsi */
  980.       case 1:  
  981.     if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
  982. *seli += 2;
  983. *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  984.     }
  985.     break;
  986.       default: 
  987.     fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!n");
  988.     fflush(stderr);
  989.     exit(0);
  990.     break;
  991. }     /* switch.. */
  992.     
  993. if (fr_ps->config == 302 && info->dyn_second_stereo[sbgr] && min_ch == T4outof[sbgr])
  994. {
  995.     *seli += 2;
  996.     *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
  997. }
  998.     }
  999.     else if (fr_ps->config == 202 && info->dyn_second_stereo[sbgr] && min_ch == T3outof[sbgr])
  1000.     {
  1001.     *seli += 2;
  1002.     *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
  1003.     }
  1004.     else if (fr_ps->config == 102 && info->dyn_second_stereo[sbgr] && min_ch == T2outof[sbgr])
  1005.     {
  1006.     *seli += 2;
  1007.     *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
  1008.     }
  1009. }
  1012. #ifdef Augmentation_7ch
  1013. void dyn_bal_aug (
  1014. unsigned int scfsi[CHANMAX3][SBLIMIT],   /* in */ 
  1015. int sbgr,     /* in */
  1016. frame_params *fr_ps,     /* in:  fr_ps->header->dyn_cross[sbgr] */
  1017. int min_ch,     /* in */
  1018. int min_sb,     /* in */
  1019. int *seli,     /* in, out */
  1020. int *scale)     /* in, out */
  1021. {
  1022. /*  global parameters
  1023.  *  in: T2[SBGRS], T3[SBGRS], T4[SBGRS], T5[SBGRS]
  1024.  */
  1025.     static int sfsPerScfsi[] = { 3,2,1,2 };    /* lookup # sfs per scfsi */
  1026.     int dynx_T2 = !dyn_ch (fr_ps, sbgr, 2);
  1027.     int dynx_T3 = !dyn_ch (fr_ps, sbgr, 3);
  1028.     int dynx_T4 = !dyn_ch (fr_ps, sbgr, 4);
  1029.     int T5T0 = L0, T6T0 = L0, T6T1 = R0;
  1030.     
  1031.     if (fr_ps->header->aug_tc_alloc[sbgr] == 4 || fr_ps->header->aug_tc_alloc[sbgr] == 5)
  1032.      if (fr_ps->header->dyn_cross_LR == 0)
  1033.     T6T1 = L0;
  1034. else
  1035.     T6T0 = R0;
  1036.     else if (fr_ps->header->aug_tc_alloc[sbgr] == 6 || fr_ps->header->aug_tc_alloc[sbgr] == 7)
  1037.         if (fr_ps->header->dyn_cross_LR)
  1038.     T5T0 = R0;
  1040.     /* 5/2 */
  1041.     switch (fr_ps->header->aug_dyn_cross[sbgr])
  1042.     {
  1043.     case  0:
  1044. break;     /* no additional scf and scfsi */
  1045.     case  1:
  1046. if (min_ch == T6T1)
  1047. {
  1048.     *seli += 2;
  1049.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1050. }
  1051. break;
  1052.     case  2:
  1053. if (min_ch == T2[sbgr] || (dynx_T2 && min_ch == T2from[sbgr]))
  1054. {
  1055.     *seli += 2;
  1056.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1057. }
  1058. break;
  1059.     case  3:
  1060. if (min_ch == T4[sbgr] || (dynx_T4 && min_ch == T4from[sbgr]))
  1061. {
  1062.     *seli += 2;
  1063.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1064. }
  1065. break;
  1066.     case  4:
  1067. if (min_ch == T5[sbgr])
  1068. {
  1069.     *seli += 2;
  1070.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1071. }
  1072. break;
  1073.     case  5:
  1074. if (min_ch == T5T0)
  1075. {
  1076.     *seli += 2;
  1077.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1078. }
  1079. break;
  1080.     case  6:
  1081. if (min_ch == T5T0)
  1082. {
  1083.     *seli += 2;
  1084.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1085. }
  1086. else if (min_ch == T6T1)
  1087. {
  1088.     *seli += 2;
  1089.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1090. }
  1091. break;
  1092.     case  7:
  1093. if (min_ch == T5T0)
  1094. {
  1095.     *seli += 2;
  1096.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1097. }
  1098. if (min_ch == T2[sbgr] || (dynx_T2 && min_ch == T2from[sbgr]))
  1099. {
  1100.     *seli += 2;
  1101.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1102. }
  1103. break;
  1104.     case  8:
  1105. if (min_ch == T5T0)
  1106. {
  1107.     *seli += 2;
  1108.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1109. }
  1110. if (min_ch == T4[sbgr] || (dynx_T4 && min_ch == T4from[sbgr]))
  1111. {
  1112.     *seli += 2;
  1113.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1114. }
  1115. break;
  1116.     case  9:
  1117. if (min_ch == T5T0)
  1118. {
  1119.     *seli += 2;
  1120.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1121. }
  1122. if (min_ch == T6T0)
  1123. {
  1124.     *seli += 2;
  1125.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1126. }
  1127. break;
  1128.     case 10:
  1129. if (min_ch == T2[sbgr] || (dynx_T2 && min_ch == T2from[sbgr]))
  1130. {
  1131.     *seli += 2;
  1132.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1133. }
  1134. break;
  1135.     case 11:
  1136. if (min_ch == T2[sbgr] || (dynx_T2 && min_ch == T2from[sbgr]))
  1137. {
  1138.     *seli += 2;
  1139.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1140. }
  1141. if (min_ch == T6T1)
  1142. {
  1143.     *seli += 2;
  1144.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1145. }
  1146. break;
  1147.     case 12:
  1148. if (min_ch == T2[sbgr] || (dynx_T2 && min_ch == T2from[sbgr]))
  1149. {
  1150.     *seli += 4;
  1151.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1152.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1153. }
  1154. break;
  1155.     case 13:
  1156. if (min_ch == T2[sbgr] || (dynx_T2 && min_ch == T2from[sbgr]))
  1157. {
  1158.     *seli += 2;
  1159.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1160. }
  1161. if (min_ch == T4[sbgr] || (dynx_T4 && min_ch == T4from[sbgr]))
  1162. {
  1163.     *seli += 2;
  1164.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1165. }
  1166. break;
  1167.     case 14:
  1168. if (min_ch == T3[sbgr] || (dynx_T3 && min_ch == T3from[sbgr]))
  1169. {
  1170.     *seli += 2;
  1171.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1172. }
  1173. break;
  1174.     case 15:
  1175. if (min_ch == T3[sbgr] || (dynx_T3 && min_ch == T3from[sbgr]))
  1176. {
  1177.     *seli += 2;
  1178.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1179. }
  1180. if (min_ch == T6T1)
  1181. {
  1182.     *seli += 2;
  1183.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1184. }
  1185. break;
  1186.     case 16:
  1187. if (min_ch == T3[sbgr] || (dynx_T3 && min_ch == T3from[sbgr]))
  1188. {
  1189.     *seli += 2;
  1190.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1191. }
  1192. if (min_ch == T2[sbgr] || (dynx_T2 && min_ch == T2from[sbgr]))
  1193. {
  1194.     *seli += 2;
  1195.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1196. }
  1197. break;
  1198.     case 17:
  1199. if (min_ch == T3[sbgr] || (dynx_T3 && min_ch == T3from[sbgr]))
  1200. {
  1201.     *seli += 2;
  1202.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1203. }
  1204. if (min_ch == T4[sbgr] || (dynx_T4 && min_ch == T4from[sbgr]))
  1205. {
  1206.     *seli += 2;
  1207.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1208. }
  1209. break;
  1210.     case 18:
  1211. if (min_ch == T3[sbgr] || (dynx_T3 && min_ch == T3from[sbgr]))
  1212. {
  1213.     *seli += 4;
  1214.     *scale += 6 * sfsPerScfsi[scfsi[T5[sbgr]][min_sb]];
  1215.     *scale += 6 * sfsPerScfsi[scfsi[T6[sbgr]][min_sb]];
  1216. }
  1217. break;
  1218.   default: 
  1219. fprintf (stderr, "FORBIDDEN AUG_DYN_CROSS!!!!!n");
  1220. fflush (stderr);
  1221. exit (1);
  1222. break;
  1223.     }
  1224. }
  1225. #endif
  1228. /****************************************************************************
  1229.  *
  1230.  *  void choose_dyn
  1231.  *
  1232.  *  bit_alloc of the dynamic crosstalk channels must be have a value; 
  1233.  *  only for sending scf in datastream.
  1234.  *
  1235.  *  07/94 Susanne Ritscher
  1236.  *  94/10/31 Andreas Silzle     little remake
  1237.  *  94/12/30 Andreas Silzle     
  1238.  *     fill only up to that subband of the basic channel
  1239.  *     which is unequal zero.
  1240.  *
  1241.  *****************************************************************************/
  1243. void choose_dyn (
  1244. frame_params *fr_ps, 
  1245.     /* in:  fr_ps->header->dyn_cross[sbgr] 
  1246.      *     fr_ps->alloc
  1247.      */
  1248. int min_ch, /* in */
  1249. int min_sb, /* in */
  1250. int sbgr,  /* in */
  1251. unsigned int bit_alloc[CHANMAX3][SBLIMIT]) /* out */
  1252. {
  1253. /*  global parameters
  1254.  *  in: T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS]
  1255.  */
  1256.     layer *info  = fr_ps->header;
  1257.     int center   = info->center;
  1258.     int surround = info->surround;
  1260. /* 960627 FdB DynX dependent on configuration */
  1261. if (fr_ps->config == 320)
  1262. {
  1263.     /* 3/2 */
  1264.     switch(fr_ps->header->dyn_cross[sbgr]) {
  1265.   case 0:
  1266. break;
  1267.   case 1: 
  1268. if(min_ch == R0 && bit_alloc[R0][min_sb] != 0)
  1269.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1270. break;
  1271.   case 2: 
  1272. if(min_ch == L0 && bit_alloc[L0][min_sb] != 0)
  1273.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1274. break;
  1275.   case 3: 
  1276. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
  1277.        bit_alloc[T2[sbgr]][min_sb] = 1;
  1278. break;
  1279.   case 4: 
  1280. if(min_ch == R0 && bit_alloc[R0][min_sb] != 0)
  1281.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1282. if(min_ch == L0 && bit_alloc[L0][min_sb] != 0)
  1283.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1284. break;
  1285.   case 5: 
  1286. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0) 
  1287.     bit_alloc[T2[sbgr]][min_sb] = 1;
  1288. if(min_ch == R0 && bit_alloc[R0][min_sb] != 0) 
  1289.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1290. break;
  1291.   case 6: 
  1292. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0) 
  1293.     bit_alloc[T2[sbgr]][min_sb] = 1;
  1294. if(min_ch == L0 && bit_alloc[L0][min_sb] != 0) 
  1295.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1296. break;
  1297.   case 7: 
  1298. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0) 
  1299.     bit_alloc[T2[sbgr]][min_sb] = 1;
  1300. if(min_ch == L0 && bit_alloc[L0][min_sb] != 0) 
  1301.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1302. if(min_ch == R0 && bit_alloc[R0][min_sb] != 0) 
  1303.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1304. break;
  1305.   case 8: 
  1306. if(min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0)
  1307.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1308. break;
  1309.   case 9: 
  1310. if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
  1311.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1312. break;
  1313.  case 10: 
  1314. if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
  1315.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1316. break;
  1317.  case 11: 
  1318. if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
  1319.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1320. if(min_ch == R0 && bit_alloc[R0][min_sb] != 0)
  1321.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1322. break;
  1323.  case 12: 
  1324. if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
  1325.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1326. if(min_ch == L0 && bit_alloc[L0][min_sb] != 0)
  1327.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1328. break;
  1329.  case 13: 
  1330. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0) 
  1331.     bit_alloc[T2[sbgr]][min_sb] = 1;
  1332. if(min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0)
  1333.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1334. break;
  1335.  case 14: 
  1336. if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) {
  1337.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1338.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1339. }
  1340. break;
  1341.  case 15: 
  1342. fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!n");
  1343. fflush(stderr);
  1344. exit(0);
  1345. break;
  1346.     }     /* switch.. */
  1347. }
  1348. else if (fr_ps->config == 310 || fr_ps->config == 220)
  1349. {
  1350.     /* 3/1 and 2/2 */
  1351.     switch(fr_ps->header->dyn_cross[sbgr]) {
  1352.   case 0:
  1353. break;
  1354.   case 1: 
  1355. if(min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0)
  1356.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1357. break;
  1358.   case 2: 
  1359. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
  1360.     bit_alloc[T2[sbgr]][min_sb] = 1;
  1361. break;
  1362.   case 3: 
  1363. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0) 
  1364.     bit_alloc[T2[sbgr]][min_sb] = 1;
  1365. if(min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0) 
  1366.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1367. break;
  1368.   case 4: 
  1369. if(min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
  1370.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1371. break;
  1372.  default: 
  1373. fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!n");
  1374. fflush(stderr);
  1375. exit(0);
  1376. break;
  1377.     }     /* switch.. */
  1378. }
  1379. else if (fr_ps->config == 300 || fr_ps->config == 302 || fr_ps->config == 210)
  1380. {
  1381.     /* 3/0 (+2/0) and 2/1 */
  1382.     switch(fr_ps->header->dyn_cross[sbgr]) {
  1383.   case 0:
  1384. break;
  1385.   case 1: 
  1386. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
  1387.     bit_alloc[T2[sbgr]][min_sb] = 1;
  1388. break;
  1389.  default: 
  1390. fprintf(stderr, "FORBIDDEN DYN_CROSS!!!!!n");
  1391. fflush(stderr);
  1392. exit(0);
  1393. break;
  1394.     }     /* switch.. */
  1395.     if (fr_ps->header->dyn_second_stereo[sbgr])
  1396. if(min_ch == T4outof[sbgr] && bit_alloc[T4outof[sbgr]][min_sb] != 0)
  1397.     bit_alloc[T4[sbgr]][min_sb] = 1;
  1398. }
  1399. else if (fr_ps->config == 202)
  1400. {
  1401.     if (fr_ps->header->dyn_second_stereo[sbgr])
  1402. if(min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0)
  1403.     bit_alloc[T3[sbgr]][min_sb] = 1;
  1404. }
  1405. else if (fr_ps->config == 102)
  1406. {
  1407.     if (fr_ps->header->dyn_second_stereo[sbgr])
  1408. if(min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
  1409.     bit_alloc[T2[sbgr]][min_sb] = 1;
  1410. }
  1411. }
  1413. #ifdef Augmentation_7ch
  1414. void choose_dyn_aug (
  1415. frame_params *fr_ps, 
  1416.     /* in:  fr_ps->header->dyn_cross[sbgr] 
  1417.      *     fr_ps->alloc
  1418.      */
  1419. int min_ch, /* in */
  1420. int min_sb, /* in */
  1421. int sbgr,  /* in */
  1422. unsigned int bit_alloc[CHANMAX3][SBLIMIT]) /* out */
  1423. {
  1424. /*  global parameters
  1425.  *  in: T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS]
  1426.  */
  1427.     layer *info  = fr_ps->header;
  1428.     int dynx_T2 = !dyn_ch (fr_ps, sbgr, 2);
  1429.     int dynx_T3 = !dyn_ch (fr_ps, sbgr, 3);
  1430.     int dynx_T4 = !dyn_ch (fr_ps, sbgr, 4);
  1431.     int T5T0 = L0, T6T0 = L0, T6T1 = R0;
  1432.     
  1433.     if (info->aug_tc_alloc[sbgr] == 4 || info->aug_tc_alloc[sbgr] == 5)
  1434.      if (fr_ps->header->dyn_cross_LR == 0)
  1435.     T6T1 = L0;
  1436. else
  1437.     T6T0 = R0;
  1438.     else if (info->aug_tc_alloc[sbgr] == 6 || info->aug_tc_alloc[sbgr] == 7)
  1439.         if (info->dyn_cross_LR)
  1440.     T5T0 = R0;
  1442.     /* 5/2 */
  1443.     switch (fr_ps->header->aug_dyn_cross[sbgr])
  1444.     {
  1445.     case 0:
  1446.   break;
  1447.     case 1: 
  1448.   if (min_ch == T6T1 && bit_alloc[T6T1][min_sb] != 0)
  1449.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1450.   break;
  1451.     case 2: 
  1452.   if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
  1453.       (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
  1454.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1455.   break;
  1456.     case 3: 
  1457.   if ((min_ch == T4[sbgr] && bit_alloc[T4[sbgr]][min_sb] != 0) ||
  1458.       (dynx_T4 && min_ch == T4from[sbgr] && bit_alloc[T4from[sbgr]][min_sb] != 0))
  1459.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1460.   break;
  1461.     case 4: 
  1462.   if (min_ch == T5[sbgr] && bit_alloc[T5[sbgr]][min_sb] != 0)
  1463.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1464.   break;
  1465.     case 5: 
  1466.   if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0) 
  1467.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1468.   break;
  1469.     case 6: 
  1470.   if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0) 
  1471.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1472.   if (min_ch == T6T1 && bit_alloc[T6T1][min_sb] != 0) 
  1473.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1474.   break;
  1475.     case 7: 
  1476.   if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0) 
  1477.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1478.   if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
  1479.       (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
  1480.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1481.   break;
  1482.     case 8: 
  1483.   if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0) 
  1484.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1485.   if ((min_ch == T4[sbgr] && bit_alloc[T4[sbgr]][min_sb] != 0) ||
  1486.       (dynx_T4 && min_ch == T4from[sbgr] && bit_alloc[T4from[sbgr]][min_sb] != 0))
  1487.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1488.   break;
  1489.     case 9: 
  1490.   if (min_ch == T5T0 && bit_alloc[T5T0][min_sb] != 0)
  1491.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1492.   if (min_ch == T6T0 && bit_alloc[T6T0][min_sb] != 0)
  1493.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1494.   break;
  1495.    case 10: 
  1496.   if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
  1497.       (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
  1498.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1499.   break;
  1500.    case 11: 
  1501.   if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
  1502.       (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
  1503.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1504.   if (min_ch == T6T1 && bit_alloc[T6T1][min_sb] != 0)
  1505.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1506.   break;
  1507.    case 12: 
  1508.   if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
  1509.       (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
  1510.       bit_alloc[T5[sbgr]][min_sb] = bit_alloc[T6[sbgr]][min_sb] = 1;
  1511.   break;
  1512.    case 13: 
  1513.   if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
  1514.       (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
  1515.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1516.   if ((min_ch == T4[sbgr] && bit_alloc[T4[sbgr]][min_sb] != 0) ||
  1517.       (dynx_T4 && min_ch == T4from[sbgr] && bit_alloc[T4from[sbgr]][min_sb] != 0))
  1518.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1519.   break;
  1520.    case 14: 
  1521.   if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
  1522.       (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
  1523.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1524.   break;
  1525.    case 15: 
  1526.   if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
  1527.       (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
  1528.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1529.   if (min_ch == T6T1 && bit_alloc[T6T1][min_sb] != 0)
  1530.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1531.   break;
  1532.    case 16: 
  1533.   if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
  1534.       (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
  1535.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1536.   if ((min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) ||
  1537.       (dynx_T2 && min_ch == T2from[sbgr] && bit_alloc[T2from[sbgr]][min_sb] != 0))
  1538.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1539.   break;
  1540.    case 17: 
  1541.   if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
  1542.       (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
  1543.       bit_alloc[T5[sbgr]][min_sb] = 1;
  1544.   if ((min_ch == T4[sbgr] && bit_alloc[T4[sbgr]][min_sb] != 0) ||
  1545.       (dynx_T4 && min_ch == T4from[sbgr] && bit_alloc[T4from[sbgr]][min_sb] != 0))
  1546.       bit_alloc[T6[sbgr]][min_sb] = 1;
  1547.   break;
  1548.    case 18:
  1549.   if ((min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0) ||
  1550.       (dynx_T3 && min_ch == T3from[sbgr] && bit_alloc[T3from[sbgr]][min_sb] != 0))
  1551.       bit_alloc[T5[sbgr]][min_sb] = bit_alloc[T6[sbgr]][min_sb] = 1;
  1552.   break;
  1553.    default: 
  1554.   fprintf (stderr, "FORBIDDEN AUG_DYN_CROSS!!!!!n");
  1555.   fflush (stderr);
  1556.   exit (1);
  1557.   break;
  1558.     }
  1559. }
  1560. #endif
  1563. /************************************************************************
  1564.  *
  1565.  * scfsi_calc_dyn    
  1566.  *
  1567.  * Version 1.0     94/07/07 Andreas Silzle, IRT
  1568.  *
  1569.  * Calculating the scale factor select information of one channel 
  1570.  * without changing the scale factors.
  1571.  *
  1572.  ************************************************************************/
  1574. void scfsi_calc_dyn (
  1575. unsigned int scalar_dyn[][3][SBLIMIT],   /* in/out */
  1576. int ch,      /* in */
  1577. int sblimit,     /* in */ 
  1578. unsigned int scfsi_dyn[][SBLIMIT])      /* out */
  1579. {
  1580.     int     sb;
  1581.     
  1582.     for (sb = 0; sb < sblimit; sb++)
  1583.     {
  1584. /* If the subbands are coded only with SCF's, they must be accurate. */
  1585. /* 1993-02-19 and 1994-03-17 shn */
  1586. /* 4 patterns are possible: 0: ABC, 1: AAB, 2: AAA, 3: ABB */
  1587. if ((scalar_dyn[ch][0][sb] != scalar_dyn[ch][1][sb]) &&
  1588.     (scalar_dyn[ch][1][sb] != scalar_dyn[ch][2][sb]))
  1589.     scfsi_dyn[ch][sb] = 0;
  1590. else
  1591. if ((scalar_dyn[ch][0][sb] == scalar_dyn[ch][1][sb]) &&
  1592.     (scalar_dyn[ch][1][sb] != scalar_dyn[ch][2][sb]))
  1593.     scfsi_dyn[ch][sb] = 1;
  1594. else
  1595. if ((scalar_dyn[ch][0][sb] == scalar_dyn[ch][1][sb]) &&
  1596.     (scalar_dyn[ch][1][sb] == scalar_dyn[ch][2][sb]))
  1597.     scfsi_dyn[ch][sb] = 2;
  1598. else
  1599.     scfsi_dyn[ch][sb] = 3;
  1600.     } /* for (sb.. */
  1601. }
  1603. /************************************************************************
  1604.  *
  1605.  * scfsi_calc    
  1606.  *
  1607.  * Version 1.0     94/07/07 Andreas Silzle, IRT
  1608.  *
  1609.  * Calculating the scale factor select information of one channel. 
  1610.  *
  1611.  * route: II_transmission_pattern (Layer II only)
  1612.  *
  1613.  * PURPOSE:For a given subband, determines whether to send 1, 2, or
  1614.  * all 3 of the scalefactors, and fills in the scalefactor
  1615.  * select information accordingly
  1616.  *
  1617.  * SEMANTICS:  The subbands and channels are classified based on how much
  1618.  * the scalefactors changes over its three values (corresponding
  1619.  * to the 3 sets of 12 samples per subband).  The classification
  1620.  * will send 1 or 2 scalefactors instead of three if the scalefactors
  1621.  * do not change much.  The scalefactor select information,
  1622.  * #scfsi#, is filled in accordingly.
  1623.  *
  1624.  ************************************************************************/
  1626. void scfsi_calc (
  1627. unsigned int scalar[][3][SBLIMIT],  /* in/out */
  1628. int ch,  /* in */
  1629. int sblimit, /* in */ 
  1630. unsigned int scfsi[][SBLIMIT])  /* out */
  1631. {
  1632.     int dscf[2];
  1633.     int class[2], sb, j;
  1634.     static int pattern[5][5] = {
  1635. 0x123, 0x122, 0x122, 0x133, 0x123,
  1636. 0x113, 0x111, 0x111, 0x444, 0x113,
  1637. 0x111, 0x111, 0x111, 0x333, 0x113,
  1638. 0x222, 0x222, 0x222, 0x333, 0x123,
  1639. 0x123, 0x122, 0x122, 0x133, 0x123    };
  1641.     for (sb = 0; sb < sblimit; sb++)
  1642.     {
  1643. dscf[0] = (scalar[ch][0][sb] - scalar[ch][1][sb]);
  1644. dscf[1] = (scalar[ch][1][sb] - scalar[ch][2][sb]);
  1645. for (j=0; j<2; j++)
  1646. {
  1647.     if (dscf[j] <= -3)
  1648. class[j] = 0;
  1649.     else if (dscf[j] > -3 && dscf[j] < 0)
  1650. class[j] = 1;
  1651.     else if (dscf[j] == 0)
  1652. class[j] = 2;
  1653.     else if (dscf[j] > 0 && dscf[j] < 3)
  1654. class[j] = 3;
  1655.     else 
  1656. class[j] = 4;
  1657. }
  1658. switch (pattern[class[0]][class[1]])
  1659. {
  1660. case 0x123 :
  1661.     scfsi[ch][sb] = 0;
  1662.     break;
  1663. case 0x122 :
  1664.     scfsi[ch][sb] = 3;
  1665.     scalar[ch][2][sb] = scalar[ch][1][sb];
  1666.     break;
  1667. case 0x133 :
  1668.     scfsi[ch][sb] = 3;
  1669.     scalar[ch][1][sb] = scalar[ch][2][sb];
  1670.     break;
  1671. case 0x113 :
  1672.     scfsi[ch][sb] = 1;
  1673.     scalar[ch][1][sb] = scalar[ch][0][sb];
  1674.     break;
  1675. case 0x111 :
  1676.     scfsi[ch][sb] = 2;
  1677.     scalar[ch][1][sb] = scalar[ch][2][sb] = scalar[ch][0][sb];
  1678.     break;
  1679. case 0x222 :
  1680.     scfsi[ch][sb] = 2;
  1681.     scalar[ch][0][sb] = scalar[ch][2][sb] = scalar[ch][1][sb];
  1682.     break;
  1683. case 0x333 :
  1684.     scfsi[ch][sb] = 2;
  1685.     scalar[ch][0][sb] = scalar[ch][1][sb] = scalar[ch][2][sb];
  1686.     break;
  1687. case 0x444 :
  1688.     scfsi[ch][sb] = 2;
  1689.     if (scalar[ch][0][sb] > scalar[ch][2][sb])
  1690. scalar[ch][0][sb] = scalar[ch][2][sb];
  1691.     scalar[ch][1][sb] = scalar[ch][2][sb] = scalar[ch][0][sb];
  1692. } /* switch */
  1693.     } /* for (sb.. */
  1694. }
  1696. /************************************************************************
  1697.  *
  1698.  * scf_calc    
  1699.  *
  1700.  * Calculating the scale factor for one channel.
  1701.  *
  1702.  * Version 1.0     94/07/07 Andreas Silzle, IRT
  1703.  *
  1704.  * route: II_scale_factor_calc() 
  1705.  *
  1706.  * PURPOSE:For each subband, calculate the scale factor for each set
  1707.  * of the 12 subband samples
  1708.  *
  1709.  * SEMANTICS:  Pick the scalefactor #multiple[]# just larger than the
  1710.  * absolute value of the peak subband sample of 12 samples,
  1711.  * and store the corresponding scalefactor index in #scalar#.
  1712.  *
  1713.  * Layer II has three sets of 12-subband samples for a given
  1714.  * subband.
  1715.  *
  1716.  ************************************************************************/
  1718. void scf_calc (
  1719. double sample[][3][SCALE_BLOCK][SBLIMIT], /* in */
  1720. int sblimit, /* in */
  1721. int ch, /* in */
  1722. unsigned int scf[][3][SBLIMIT]) /* out */ 
  1723. {
  1724. /* global variables: 
  1725.  * double multiple[64] 
  1726.  */
  1727.     int     sb, smp, sufr, r;
  1728.     double  s[SBLIMIT];
  1730.     for (sufr=0; sufr<3; sufr++)
  1731.     {
  1732. for (sb=0; sb<sblimit; sb++)
  1733.     for (smp=1, s[sb] = mod(sample[ch][sufr][0][sb]); 
  1734.     smp<SCALE_BLOCK; smp++)
  1735. if (mod(sample[ch][sufr][smp][sb]) > s[sb])
  1736.     s[sb] = mod(sample[ch][sufr][smp][sb]);
  1738. for (sb=0; sb<sblimit; sb++)
  1739.     for (r=SCALE_RANGE-1, scf[ch][sufr][sb]=0; r>=0; r--)
  1740. if (s[sb] < multiple[r])
  1741. {                       /* <= changed to <, 1992-11-06 shn*/
  1742.     scf[ch][sufr][sb] = r;
  1743.     break;
  1744. }
  1745.     }   /* for (sufr.. */
  1746. }