1 #include "common.h"
2 #include "encoder.h"
3 #include "dyn_cross.h"
4
5 /************************************************************************
6 *
7 * take_dyn_cross
8 *
9 * Version 1.0 94/10/24 Andreas Silzle, IRT
10 *
11 * Copy the sums, scf, scfsi, if required, in the normal positions.
12 *
13 ************************************************************************/
14
15
16 /* #define LOW_SBGR 5 original value 960619 FdB */
17 #define LOW_SBGR 0 /* lowest subbandgroup, in which dyn_cross is done. */
18 /* All sb-groups under that boarder are not */
19 /* affected by dyn_cross */
20
take_dyn_cross(int dyn_cr,frame_params * fr_ps,double sb_sample_sum[5][3][SCALE_BLOCK][SBLIMIT],unsigned int scalar_sum[][3][SBLIMIT],unsigned int scfsi_sum[][SBLIMIT],unsigned int scfsi_dyn[][SBLIMIT],double sb_sample[CHANMAX3][3][SCALE_BLOCK][SBLIMIT],unsigned int scalar[][3][SBLIMIT],unsigned int scfsi[][SBLIMIT])21 void take_dyn_cross (int dyn_cr, frame_params * fr_ps,
22 /* out: int fr_ps->header->dyn_cross_on,
23 * int fr_ps->header->dyn_cross_LR,
24 * int fr_ps->header->dyn_cross[SBGRS],
25 */
26 double sb_sample_sum[5][3][SCALE_BLOCK][SBLIMIT],
27 /* in, T23, T24, T34, T234, T56 */
28 unsigned int scalar_sum[][3][SBLIMIT], /* in */
29 unsigned int scfsi_sum[][SBLIMIT], /* in */
30 unsigned int scfsi_dyn[][SBLIMIT], /* in */
31 double sb_sample[CHANMAX3][3][SCALE_BLOCK][SBLIMIT], /* out */
32 unsigned int scalar[][3][SBLIMIT], /* out */
33 unsigned int scfsi[][SBLIMIT])
34 { /* out */
35 int sbgr, sb, sufr, smp, dyn_second_stereo = 0;
36 //MFC layer *info = fr_ps->header;
37 //int center = info->center;
38 //int surround = info->surround;
39
40 fr_ps->header->dyn_cross_on = 0;
41 if (fr_ps->header->dyn_cross_LR
42 && (fr_ps->config == 302 || fr_ps->config == 202 || fr_ps->config == 102))
43 dyn_second_stereo = 1;
44
45 /* printf ("dyn_cr: %2d\n", dyn_cr); */
46
47 for (sbgr = LOW_SBGR; sbgr < SBGRS; sbgr++) {
48 /* signalization */
49 if (dyn_cr == 0 && dyn_second_stereo == 0) {
50 fr_ps->header->dyn_cross[sbgr] = 0;
51 fr_ps->header->dyn_second_stereo[sbgr] = 0;
52 } else {
53 fr_ps->header->dyn_cross_on = 1;
54 /* original value 960619 FdB */
55 /* fr_ps->header->dyn_cross[sbgr] = dyn_cr; */
56 /* systematic variation of dynamic crosstalk over all subbands */
57 if (dyn_cr == -1) {
58 switch (fr_ps->config) {
59 case 320:
60 fr_ps->header->dyn_cross[sbgr] = rand () % 15;
61 break;
62 case 310:
63 case 220:
64 fr_ps->header->dyn_cross[sbgr] = rand () % 5;
65 break;
66 case 300:
67 case 302:
68 case 210:
69 fr_ps->header->dyn_cross[sbgr] = rand () % 2;
70 break;
71 default:
72 fr_ps->header->dyn_cross[sbgr] = 0;
73 break;
74 }
75 } else
76 fr_ps->header->dyn_cross[sbgr] = dyn_cr;
77
78 fr_ps->header->dyn_second_stereo[sbgr] = dyn_second_stereo;
79 /*
80 printf ("sbgr: %2d dyn_cr: %2d dyn_2nd_st: %2d\n",
81 sbgr, fr_ps->header->dyn_cross[sbgr],
82 fr_ps->header->dyn_second_stereo[sbgr]);
83 */
84 /* copying sums, scf, scfsi */
85
86 /* 960627 FdB DynX dependent on configuration */
87 if (fr_ps->config == 320) {
88 /* 3/2 */
89 if (fr_ps->header->dyn_cross[sbgr] == 9
90 || fr_ps->header->dyn_cross[sbgr] == 11) {
91 T3from[sbgr] = T2[sbgr];
92 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
93 sb <= sb_groups[sbgr]; sb++) {
94 scfsi[T2[sbgr]][sb] = scfsi_sum[T23][sb];
95 for (sufr = 0; sufr < 3; ++sufr) {
96 scalar[T2[sbgr]][sufr][sb] = scalar_sum[T23][sufr][sb];
97 for (smp = 0; smp < SCALE_BLOCK; ++smp) {
98 sb_sample[T2[sbgr]][sufr][smp][sb] =
99 sb_sample_sum[T23][sufr][smp][sb];
100 } /* for(smp..) */
101 } /* for(sufr.). */
102 } /* for(sb..) */
103 } else if (fr_ps->header->dyn_cross[sbgr] == 10
104 || fr_ps->header->dyn_cross[sbgr] == 12) {
105 T4from[sbgr] = T2[sbgr];
106 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
107 sb <= sb_groups[sbgr]; sb++) {
108 scfsi[T2[sbgr]][sb] = scfsi_sum[T24][sb];
109 for (sufr = 0; sufr < 3; ++sufr) {
110 scalar[T2[sbgr]][sufr][sb] = scalar_sum[T24][sufr][sb];
111 for (smp = 0; smp < SCALE_BLOCK; ++smp) {
112 sb_sample[T2[sbgr]][sufr][smp][sb] =
113 sb_sample_sum[T24][sufr][smp][sb];
114 } /* for(smp..) */
115 } /* for(sufr..) */
116 } /* for(sb..) */
117 } else if (fr_ps->header->dyn_cross[sbgr] == 8
118 || fr_ps->header->dyn_cross[sbgr] == 13) {
119 T4from[sbgr] = T3[sbgr];
120 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
121 sb <= sb_groups[sbgr]; sb++) {
122 scfsi[T3[sbgr]][sb] = scfsi_sum[T34][sb];
123 for (sufr = 0; sufr < 3; ++sufr) {
124 scalar[T3[sbgr]][sufr][sb] = scalar_sum[T34][sufr][sb];
125 for (smp = 0; smp < SCALE_BLOCK; ++smp) {
126 sb_sample[T3[sbgr]][sufr][smp][sb] =
127 sb_sample_sum[T34][sufr][smp][sb];
128 } /* for(smp..) */
129 } /* for(sufr..) */
130 } /* for(sb..) */
131 } else if (fr_ps->header->dyn_cross[sbgr] == 14) {
132 T3from[sbgr] = T4from[sbgr] = T2[sbgr];
133 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
134 sb <= sb_groups[sbgr]; sb++) {
135 scfsi[T2[sbgr]][sb] = scfsi_sum[T234][sb];
136 for (sufr = 0; sufr < 3; ++sufr) {
137 scalar[T2[sbgr]][sufr][sb] = scalar_sum[T234][sufr][sb];
138 for (smp = 0; smp < SCALE_BLOCK; ++smp) {
139 sb_sample[T2[sbgr]][sufr][smp][sb] =
140 sb_sample_sum[T234][sufr][smp][sb];
141 } /* for(smp..) */
142 } /* for(sufr..) */
143 } /* for(sb..) */
144 }
145
146
147 /* if(dyncr_do[sbgr]..) */
148 /* scfsi_dyn in scfsi of L0 and R0 */
149 /* T2 */
150 switch (fr_ps->header->dyn_cross[sbgr]) {
151 case 3:
152 case 5:
153 case 6:
154 case 7:
155 case 13:
156 T2from[sbgr] = T2outof[sbgr];
157 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
158 sb <= sb_groups[sbgr]; sb++)
159 scfsi[T2outof[sbgr]][sb] = scfsi_dyn[T2outof[sbgr]][sb];
160 break;
161 } /* switch(dyncr_do[sbgr]) */
162 /* T3 */
163 switch (fr_ps->header->dyn_cross[sbgr]) {
164 case 2:
165 case 4:
166 case 6:
167 case 7:
168 case 12:
169 T3from[sbgr] = T3outof[sbgr];
170 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
171 sb <= sb_groups[sbgr]; sb++)
172 scfsi[L0][sb] = scfsi_dyn[L0][sb];
173 break;
174 } /* switch(dyncr_do[sbgr]) */
175 /* T4 */
176 switch (fr_ps->header->dyn_cross[sbgr]) {
177 case 1:
178 case 4:
179 case 5:
180 case 7:
181 case 11:
182 T4from[sbgr] = T4outof[sbgr];
183 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
184 sb <= sb_groups[sbgr]; sb++)
185 scfsi[R0][sb] = scfsi_dyn[R0][sb];
186 break;
187 } /* switch(fr_ps->header->dyn_cross[sbgr]) */
188 } else if (fr_ps->config == 310 || fr_ps->config == 220) {
189 /* 3/1 and 2/2 */
190 if (fr_ps->header->dyn_cross[sbgr] == 4) {
191 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
192 sb <= sb_groups[sbgr]; sb++) {
193 scfsi[T2[sbgr]][sb] = scfsi_sum[T23][sb];
194 for (sufr = 0; sufr < 3; ++sufr) {
195 scalar[T2[sbgr]][sufr][sb] = scalar_sum[T23][sufr][sb];
196 for (smp = 0; smp < SCALE_BLOCK; ++smp) {
197 sb_sample[T2[sbgr]][sufr][smp][sb] =
198 sb_sample_sum[T23][sufr][smp][sb];
199 } /* for(smp..) */
200 } /* for(sufr.). */
201 } /* for(sb..) */
202 }
203
204 /* scfsi_dyn in scfsi of L0 and R0 */
205 /* T2 */
206 switch (fr_ps->header->dyn_cross[sbgr]) {
207 case 2:
208 case 3:
209 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
210 sb <= sb_groups[sbgr]; sb++)
211 scfsi[T2outof[sbgr]][sb] = scfsi_dyn[T2outof[sbgr]][sb];
212 break;
213 } /* switch(dyncr_do[sbgr]) */
214 /* T3 */
215 switch (fr_ps->header->dyn_cross[sbgr]) {
216 case 1:
217 case 3:
218 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
219 sb <= sb_groups[sbgr]; sb++)
220 scfsi[T3outof[sbgr]][sb] = scfsi_dyn[T3outof[sbgr]][sb];
221 break;
222 } /* switch(dyncr_do[sbgr]) */
223 } else if (fr_ps->config == 300 || fr_ps->config == 302
224 || fr_ps->config == 210) {
225 /* 3/0 (+2/0) and 2/1 */
226 /* scfsi_dyn in scfsi of L0 and R0 */
227 /* T2 */
228 switch (fr_ps->header->dyn_cross[sbgr]) {
229 case 1:
230 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
231 sb <= sb_groups[sbgr]; sb++)
232 scfsi[T2outof[sbgr]][sb] = scfsi_dyn[T2outof[sbgr]][sb];
233 break;
234 } /* switch(dyncr_do[sbgr]) */
235
236 if (fr_ps->header->dyn_second_stereo[sbgr])
237 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
238 sb <= sb_groups[sbgr]; sb++) {
239 scfsi[T3[sbgr]][sb] = scfsi_sum[T23][sb];
240 for (sufr = 0; sufr < 3; ++sufr) {
241 scalar[T3[sbgr]][sufr][sb] = scalar_sum[T23][sufr][sb];
242 for (smp = 0; smp < SCALE_BLOCK; ++smp)
243 sb_sample[T3[sbgr]][sufr][smp][sb] =
244 sb_sample_sum[T23][sufr][smp][sb];
245 } /* for(sufr..) */
246 } /* for(sb..) */
247 } else if (fr_ps->config == 202) {
248 if (fr_ps->header->dyn_second_stereo[sbgr])
249 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
250 sb <= sb_groups[sbgr]; sb++) {
251 scfsi[T2[sbgr]][sb] = scfsi_sum[T23][sb];
252 for (sufr = 0; sufr < 3; ++sufr) {
253 scalar[T2[sbgr]][sufr][sb] = scalar_sum[T23][sufr][sb];
254 for (smp = 0; smp < SCALE_BLOCK; ++smp)
255 sb_sample[T2[sbgr]][sufr][smp][sb] =
256 sb_sample_sum[T23][sufr][smp][sb];
257 } /* for(sufr.). */
258 } /* for(sb..) */
259 } else if (fr_ps->config == 102) {
260 if (fr_ps->header->dyn_second_stereo[sbgr])
261 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
262 sb <= sb_groups[sbgr]; sb++) {
263 scfsi[1][sb] = scfsi_sum[T23][sb];
264 for (sufr = 0; sufr < 3; ++sufr) {
265 scalar[1][sufr][sb] = scalar_sum[T23][sufr][sb];
266 for (smp = 0; smp < SCALE_BLOCK; ++smp)
267 sb_sample[1][sufr][smp][sb] = sb_sample_sum[T23][sufr][smp][sb];
268 } /* for(sufr.). */
269 } /* for(sb..) */
270 }
271 } /* if(fr_ps->header->dyn_cross[sbgr] == 0) */
272 } /* for(sbgr=0.. */
273 }
274
275
276 /************************************************************************
277 *
278 * trans_chan
279 *
280 * Version 1.0 94/06/27 Andreas Silzle, IRT
281 * Version 1.1 94/10/28 Andreas Silzle, IRT
282 *
283 * Which channels are in the transmission channels
284 * T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof{SBGRS] per subband group.
285 * T2outof[] can be changed later by fr_ps->header->dyn_cross_LR.
286 *
287 ************************************************************************/
288
trans_chan(frame_params * fr_ps)289 void trans_chan (frame_params * fr_ps)
290 /* in: int fr_ps->header->tc_alloc[SBGRS],
291 * int fr_ps->numchan,
292 * int fr_ps->header->matrix, 0 normal -, 3 no matricing
293 * int fr_ps->header->dyn_cross_LR 0 out of L0, 1 out of R0
294 */
295 /* global parameters
296 * out: T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS], T3outof[SBGRS], T4outof[SBGRS]
297 */
298 {
299 int sbgr;
300
301 for (sbgr = 0; sbgr < SBGRS; sbgr++) {
302 /* 960627 FdB tca dependent on configuration */
303 if (fr_ps->config == 320) {
304 /* 3/2 */
305 switch (fr_ps->header->tc_alloc[sbgr]) {
306 case 0:
307 T2[sbgr] = C;
308 T3[sbgr] = LS;
309 T4[sbgr] = RS;
310 if (fr_ps->header->dyn_cross_LR == 0)
311 T2outof[sbgr] = L0;
312 else
313 T2outof[sbgr] = R0;
314 T3outof[sbgr] = L0;
315 T4outof[sbgr] = R0;
316 break;
317 case 1:
318 T2[sbgr] = L;
319 T3[sbgr] = LS;
320 T4[sbgr] = RS;
321 T2outof[sbgr] = L0;
322 T3outof[sbgr] = L0;
323 T4outof[sbgr] = R0;
324 break;
325 case 2:
326 T2[sbgr] = R;
327 T3[sbgr] = LS;
328 T4[sbgr] = RS;
329 T2outof[sbgr] = R0;
330 T3outof[sbgr] = L0;
331 T4outof[sbgr] = R0;
332 break;
333 case 3:
334 T2[sbgr] = C;
335 T3[sbgr] = L;
336 T4[sbgr] = RS;
337 if (fr_ps->header->dyn_cross_LR == 0)
338 T2outof[sbgr] = L0;
339 else
340 T2outof[sbgr] = R0;
341 T3outof[sbgr] = L0;
342 T4outof[sbgr] = R0;
343 break;
344 case 4:
345 T2[sbgr] = C;
346 T3[sbgr] = LS;
347 T4[sbgr] = R;
348 if (fr_ps->header->dyn_cross_LR == 0)
349 T2outof[sbgr] = L0;
350 else
351 T2outof[sbgr] = R0;
352 T3outof[sbgr] = L0;
353 T4outof[sbgr] = R0;
354 break;
355 case 5:
356 T2[sbgr] = C;
357 T3[sbgr] = L;
358 T4[sbgr] = R;
359 if (fr_ps->header->dyn_cross_LR == 0)
360 T2outof[sbgr] = L0;
361 else
362 T2outof[sbgr] = R0;
363 T3outof[sbgr] = L0;
364 T4outof[sbgr] = R0;
365 break;
366 case 6:
367 T2[sbgr] = R;
368 T3[sbgr] = L;
369 T4[sbgr] = RS;
370 T2outof[sbgr] = R0;
371 T3outof[sbgr] = L0;
372 T4outof[sbgr] = R0;
373 break;
374 case 7:
375 T2[sbgr] = L;
376 T3[sbgr] = LS;
377 T4[sbgr] = R;
378 T2outof[sbgr] = L0;
379 T3outof[sbgr] = L0;
380 T4outof[sbgr] = R0;
381 break;
382 } /* switch() */
383 } else if (fr_ps->config == 310) {
384 /* 3/1 */
385 switch (fr_ps->header->tc_alloc[sbgr]) {
386 case 0:
387 T2[sbgr] = 2;
388 T3[sbgr] = 3;
389 if (fr_ps->header->dyn_cross_LR == 0)
390 T2outof[sbgr] = T3outof[sbgr] = L0;
391 else
392 T2outof[sbgr] = T3outof[sbgr] = R0;
393 break;
394 case 1:
395 T2[sbgr] = L;
396 T3[sbgr] = 3;
397 T2outof[sbgr] = L0;
398 if (fr_ps->header->dyn_cross_LR == 0)
399 T3outof[sbgr] = L0;
400 else
401 T3outof[sbgr] = R0;
402 break;
403 case 2:
404 T2[sbgr] = R;
405 T3[sbgr] = 3;
406 T2outof[sbgr] = R0;
407 if (fr_ps->header->dyn_cross_LR == 0)
408 T3outof[sbgr] = L0;
409 else
410 T3outof[sbgr] = R0;
411 break;
412 case 3:
413 T2[sbgr] = 2;
414 T3[sbgr] = L;
415 if (fr_ps->header->dyn_cross_LR == 0)
416 T2outof[sbgr] = L0;
417 else
418 T2outof[sbgr] = R0;
419 T3outof[sbgr] = L0;
420 break;
421 case 4:
422 T2[sbgr] = 2;
423 T3[sbgr] = R;
424 if (fr_ps->header->dyn_cross_LR == 0)
425 T2outof[sbgr] = L0;
426 else
427 T2outof[sbgr] = R0;
428 T3outof[sbgr] = R0;
429 break;
430 case 5:
431 T2[sbgr] = L;
432 T3[sbgr] = R;
433 T2outof[sbgr] = L0;
434 T3outof[sbgr] = R0;
435 break;
436 } /* switch() */
437 } else if (fr_ps->config == 220) {
438 /* 2/2 */
439 switch (fr_ps->header->tc_alloc[sbgr]) {
440 case 0:
441 T2[sbgr] = 2;
442 T3[sbgr] = 3;
443 break;
444 case 1:
445 T2[sbgr] = L;
446 T3[sbgr] = 3;
447 break;
448 case 2:
449 T2[sbgr] = 2;
450 T3[sbgr] = R;
451 break;
452 case 3:
453 T2[sbgr] = L;
454 T3[sbgr] = R;
455 break;
456 } /* switch() */
457 T2outof[sbgr] = L0;
458 T3outof[sbgr] = R0;
459 } else if (fr_ps->config == 300 || fr_ps->config == 302) {
460 /* 3/0 (+ 2/0) */
461 switch (fr_ps->header->tc_alloc[sbgr]) {
462 case 0:
463 T2[sbgr] = 2;
464 if (fr_ps->header->dyn_cross_LR == 0)
465 T2outof[sbgr] = L0;
466 else
467 T2outof[sbgr] = R0;
468 break;
469 case 1:
470 T2[sbgr] = L;
471 T2outof[sbgr] = L0;
472 break;
473 case 2:
474 T2[sbgr] = R;
475 T2outof[sbgr] = R0;
476 break;
477 } /* switch() */
478 } else if (fr_ps->config == 210) {
479 /* 2/1 */
480 switch (fr_ps->header->tc_alloc[sbgr]) {
481 case 0:
482 T2[sbgr] = 2;
483 if (fr_ps->header->dyn_cross_LR == 0)
484 T2outof[sbgr] = L0;
485 else
486 T2outof[sbgr] = R0;
487 break;
488 case 1:
489 T2[sbgr] = L;
490 T2outof[sbgr] = L0;
491 break;
492 case 2:
493 T2[sbgr] = R;
494 T2outof[sbgr] = R0;
495 break;
496 } /* switch() */
497 }
498 if (fr_ps->config == 302) {
499 /* 3/0 + 2/0 */
500 T3[sbgr] = 3;
501 T4[sbgr] = 4;
502 T4outof[sbgr] = 3;
503 } else if (fr_ps->config == 202) {
504 /* 2/0 + 2/0 */
505 T2[sbgr] = 2;
506 T3[sbgr] = 3;
507 T3outof[sbgr] = 2;
508 } else if (fr_ps->config == 102) {
509 /* 1/0 + 2/0 */
510 T2[sbgr] = 2;
511 T2outof[sbgr] = 1;
512 }
513 } /* for(sbgr.. */
514 }
515
516
517 /************************************************************************
518 *
519 * combine
520 *
521 * Version 1.0 94/06/27 Andreas Silzle, IRT
522 *
523 * Add two channels into a mono channel to use it in dynamic crosstalk.
524 *
525 ************************************************************************/
526
combine(frame_params * fr_ps,double sb_sample[CHANMAX3][3][SCALE_BLOCK][SBLIMIT],double sb_sample_sum[5][3][SCALE_BLOCK][SBLIMIT])527 void combine (frame_params * fr_ps,
528 /* in: int fr_ps->header->tc_alloc[SBGRS],
529 * int fr_ps->sblimit,
530 */
531 double sb_sample[CHANMAX3][3][SCALE_BLOCK][SBLIMIT], /* in */
532 double sb_sample_sum[5][3][SCALE_BLOCK][SBLIMIT])
533 /* out; T23, T24, T34, T234, T56 */
534 {
535 /* global parameters
536 * in: T2[SBGRS], T3[SBGRS], T4[SBGRS]
537 * sb_groups[SBGRS]
538 */
539 int sb, sbgr, smp, sufr;
540
541 for (sbgr = 0; sbgr < SBGRS; sbgr++) {
542 for (sb = ((sbgr == 0) ? 0 : (sb_groups[sbgr - 1] + 1));
543 sb <= sb_groups[sbgr]; sb++) {
544 for (smp = 0; smp < SCALE_BLOCK; smp++) {
545 for (sufr = 0; sufr < 3; ++sufr) {
546 if (fr_ps->config == 320 || fr_ps->config == 310
547 || fr_ps->config == 220 || fr_ps->config == 202)
548 sb_sample_sum[T23][sufr][smp][sb] =
549 .5 * (sb_sample[T2[sbgr]][sufr][smp][sb]
550 + sb_sample[T3[sbgr]][sufr][smp][sb]);
551 else if (fr_ps->config == 102)
552 sb_sample_sum[T23][sufr][smp][sb] =
553 .5 * (sb_sample[1][sufr][smp][sb]
554 + sb_sample[T2[sbgr]][sufr][smp][sb]);
555 else if (fr_ps->config == 302)
556 sb_sample_sum[T23][sufr][smp][sb] =
557 .5 * (sb_sample[T3[sbgr]][sufr][smp][sb]
558 + sb_sample[T4[sbgr]][sufr][smp][sb]);
559 if (fr_ps->config == 320) {
560 sb_sample_sum[T24][sufr][smp][sb] =
561 .5 * (sb_sample[T2[sbgr]][sufr][smp][sb]
562 + sb_sample[T4[sbgr]][sufr][smp][sb]);
563 sb_sample_sum[T34][sufr][smp][sb] =
564 .5 * (sb_sample[T3[sbgr]][sufr][smp][sb]
565 + sb_sample[T4[sbgr]][sufr][smp][sb]);
566 sb_sample_sum[T234][sufr][smp][sb] =
567 .333333 * (sb_sample[T2[sbgr]][sufr][smp][sb]
568 + sb_sample[T3[sbgr]][sufr][smp][sb]
569 + sb_sample[T4[sbgr]][sufr][smp][sb]);
570 }
571 } /* for(sufr.. */
572 } /* for(smp.. */
573 } /* for(sb.. */
574 } /* for(sbgr.. */
575 }
576
577
578 /****************************************************************************
579 *
580 * void dyn_bal
581 *
582 * Add the bits for scf and scfsi of the channel with dynamic crosstalk
583 * in the case of min_ch is L0 and R0.
584 *
585 * 07/94 Susanne Ritscher
586 * 94/10/28 Andreas Silzle little remake
587 *
588 *****************************************************************************/
589
dyn_bal(unsigned int scfsi[CHANMAX3][SBLIMIT],int sbgr,frame_params * fr_ps,int min_ch,int min_sb,int * seli,int * scale)590 void dyn_bal (unsigned int scfsi[CHANMAX3][SBLIMIT], /* in */
591 int sbgr, /* in */
592 frame_params * fr_ps,
593 /* in: fr_ps->header->dyn_cross[sbgr] */
594 int min_ch, /* in */
595 int min_sb, /* in */
596 int *seli, /* in, out */
597 int *scale)
598 { /* in, out */
599 /* global parameters
600 * in: T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS], T3outof[SBGRS], T4outof[SBGRS]
601 */
602 static int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */
603 layer *info = fr_ps->header;
604 int center = info->center;
605 //int surround = info->surround;
606
607 /* 960627 FdB DynX dependent on configuration */
608 if (fr_ps->config == 320) {
609 /* 3/2 */
610 switch (fr_ps->header->dyn_cross[sbgr]) {
611 case 0:
612 break; /* no additional scf and scfsi */
613 case 1:
614 if (min_ch == R0) {
615 *seli += 2;
616 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
617 }
618 break;
619 case 2:
620 if (min_ch == L0) {
621 *seli += 2;
622 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
623 }
624 break;
625 case 3:
626 if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
627 *seli += 2;
628 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
629 }
630 break;
631 case 4:
632 if (min_ch == L0) {
633 *seli += 2;
634 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
635 }
636 if (min_ch == R0) {
637 *seli += 2;
638 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
639 }
640 break;
641 case 5:
642 if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
643 *seli += 2;
644 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
645 }
646 if (min_ch == R0) {
647 *seli += 2;
648 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
649 }
650 break;
651 case 6:
652 if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
653 *seli += 2;
654 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
655 }
656 if (min_ch == L0) {
657 *seli += 2;
658 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
659 }
660 break;
661 case 7:
662 if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
663 *seli += 2;
664 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
665 }
666 if (min_ch == L0) {
667 *seli += 2;
668 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
669 }
670 if (min_ch == R0) {
671 *seli += 2;
672 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
673 }
674 break;
675 case 8:
676 if (min_ch == T3[sbgr]) {
677 *seli += 2;
678 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
679 }
680 break;
681 case 9:
682 if (min_ch == T2[sbgr]) {
683 *seli += 2;
684 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
685 }
686 break;
687 case 10:
688 if (min_ch == T2[sbgr]) {
689 *seli += 2;
690 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
691 }
692 break;
693 case 11:
694 if (min_ch == T2[sbgr]) {
695 *seli += 2;
696 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
697 }
698 if (min_ch == R0) {
699 *seli += 2;
700 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
701 }
702 break;
703 case 12:
704 if (min_ch == T2[sbgr]) {
705 *seli += 2;
706 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
707 }
708 if (min_ch == L0) {
709 *seli += 2;
710 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
711 }
712 break;
713 case 13:
714 if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
715 *seli += 2;
716 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
717 }
718 if (min_ch == T3[sbgr]) {
719 *seli += 2;
720 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
721 }
722 break;
723 case 14:
724 if (min_ch == T2[sbgr]) {
725 *seli += 4;
726 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
727 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
728 }
729 break;
730 case 15:
731 fprintf (stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
732 fflush (stderr);
733 exit (0);
734 break;
735 } /* switch.. */
736 } else if (fr_ps->config == 310 || fr_ps->config == 220) {
737 /* 3/1 and 2/2 */
738 switch (fr_ps->header->dyn_cross[sbgr]) {
739 case 0:
740 break; /* no additional scf and scfsi */
741 case 1:
742 if (min_ch == T3outof[sbgr]) {
743 *seli += 2;
744 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
745 }
746 break;
747 case 2:
748 if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
749 *seli += 2;
750 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
751 }
752 break;
753 case 3:
754 if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
755 *seli += 2;
756 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
757 }
758 if (min_ch == T3outof[sbgr]) {
759 *seli += 2;
760 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
761 }
762 break;
763 case 4:
764 if (min_ch == T2[sbgr]) {
765 *seli += 2;
766 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
767 }
768 break;
769 default:
770 fprintf (stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
771 fflush (stderr);
772 exit (0);
773 break;
774 } /* switch.. */
775 } else if (fr_ps->config == 300 || fr_ps->config == 302
776 || fr_ps->config == 210) {
777 /* 3/0 (+2/0) and 2/1 */
778 switch (fr_ps->header->dyn_cross[sbgr]) {
779 case 0:
780 break; /* no additional scf and scfsi */
781 case 1:
782 if (min_ch == T2outof[sbgr] && (center != 3 || sbgr < 10)) {
783 *seli += 2;
784 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
785 }
786 break;
787 default:
788 fprintf (stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
789 fflush (stderr);
790 exit (0);
791 break;
792 } /* switch.. */
793
794 if (fr_ps->config == 302 && info->dyn_second_stereo[sbgr]
795 && min_ch == T4outof[sbgr]) {
796 *seli += 2;
797 *scale += 6 * sfsPerScfsi[scfsi[T4[sbgr]][min_sb]];
798 }
799 } else if (fr_ps->config == 202 && info->dyn_second_stereo[sbgr]
800 && min_ch == T3outof[sbgr]) {
801 *seli += 2;
802 *scale += 6 * sfsPerScfsi[scfsi[T3[sbgr]][min_sb]];
803 } else if (fr_ps->config == 102 && info->dyn_second_stereo[sbgr]
804 && min_ch == T2outof[sbgr]) {
805 *seli += 2;
806 *scale += 6 * sfsPerScfsi[scfsi[T2[sbgr]][min_sb]];
807 }
808 }
809
810
811
812
813 /****************************************************************************
814 *
815 * void choose_dyn
816 *
817 * bit_alloc of the dynamic crosstalk channels must be have a value;
818 * only for sending scf in datastream.
819 *
820 * 07/94 Susanne Ritscher
821 * 94/10/31 Andreas Silzle little remake
822 * 94/12/30 Andreas Silzle
823 * fill only up to that subband of the basic channel
824 * which is unequal zero.
825 *
826 *****************************************************************************/
827
choose_dyn(frame_params * fr_ps,int min_ch,int min_sb,int sbgr,unsigned int bit_alloc[CHANMAX3][SBLIMIT])828 void choose_dyn (frame_params * fr_ps,
829 /* in: fr_ps->header->dyn_cross[sbgr]
830 * fr_ps->alloc
831 */
832 int min_ch, /* in */
833 int min_sb, /* in */
834 int sbgr, /* in */
835 unsigned int bit_alloc[CHANMAX3][SBLIMIT])
836 { /* out */
837 /* global parameters
838 * in: T2[SBGRS], T3[SBGRS], T4[SBGRS], T2outof[SBGRS]
839 */
840 //MFC layer *info = fr_ps->header;
841 //int center = info->center;
842 //int surround = info->surround;
843
844 /* 960627 FdB DynX dependent on configuration */
845 if (fr_ps->config == 320) {
846 /* 3/2 */
847 switch (fr_ps->header->dyn_cross[sbgr]) {
848 case 0:
849 break;
850 case 1:
851 if (min_ch == R0 && bit_alloc[R0][min_sb] != 0)
852 bit_alloc[T4[sbgr]][min_sb] = 1;
853 break;
854 case 2:
855 if (min_ch == L0 && bit_alloc[L0][min_sb] != 0)
856 bit_alloc[T3[sbgr]][min_sb] = 1;
857 break;
858 case 3:
859 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
860 bit_alloc[T2[sbgr]][min_sb] = 1;
861 break;
862 case 4:
863 if (min_ch == R0 && bit_alloc[R0][min_sb] != 0)
864 bit_alloc[T4[sbgr]][min_sb] = 1;
865 if (min_ch == L0 && bit_alloc[L0][min_sb] != 0)
866 bit_alloc[T3[sbgr]][min_sb] = 1;
867 break;
868 case 5:
869 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
870 bit_alloc[T2[sbgr]][min_sb] = 1;
871 if (min_ch == R0 && bit_alloc[R0][min_sb] != 0)
872 bit_alloc[T4[sbgr]][min_sb] = 1;
873 break;
874 case 6:
875 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
876 bit_alloc[T2[sbgr]][min_sb] = 1;
877 if (min_ch == L0 && bit_alloc[L0][min_sb] != 0)
878 bit_alloc[T3[sbgr]][min_sb] = 1;
879 break;
880 case 7:
881 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
882 bit_alloc[T2[sbgr]][min_sb] = 1;
883 if (min_ch == L0 && bit_alloc[L0][min_sb] != 0)
884 bit_alloc[T3[sbgr]][min_sb] = 1;
885 if (min_ch == R0 && bit_alloc[R0][min_sb] != 0)
886 bit_alloc[T4[sbgr]][min_sb] = 1;
887 break;
888 case 8:
889 if (min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0)
890 bit_alloc[T4[sbgr]][min_sb] = 1;
891 break;
892 case 9:
893 if (min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
894 bit_alloc[T3[sbgr]][min_sb] = 1;
895 break;
896 case 10:
897 if (min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
898 bit_alloc[T4[sbgr]][min_sb] = 1;
899 break;
900 case 11:
901 if (min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
902 bit_alloc[T3[sbgr]][min_sb] = 1;
903 if (min_ch == R0 && bit_alloc[R0][min_sb] != 0)
904 bit_alloc[T4[sbgr]][min_sb] = 1;
905 break;
906 case 12:
907 if (min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
908 bit_alloc[T4[sbgr]][min_sb] = 1;
909 if (min_ch == L0 && bit_alloc[L0][min_sb] != 0)
910 bit_alloc[T3[sbgr]][min_sb] = 1;
911 break;
912 case 13:
913 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
914 bit_alloc[T2[sbgr]][min_sb] = 1;
915 if (min_ch == T3[sbgr] && bit_alloc[T3[sbgr]][min_sb] != 0)
916 bit_alloc[T4[sbgr]][min_sb] = 1;
917 break;
918 case 14:
919 if (min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0) {
920 bit_alloc[T3[sbgr]][min_sb] = 1;
921 bit_alloc[T4[sbgr]][min_sb] = 1;
922 }
923 break;
924 case 15:
925 fprintf (stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
926 fflush (stderr);
927 exit (0);
928 break;
929 } /* switch.. */
930 } else if (fr_ps->config == 310 || fr_ps->config == 220) {
931 /* 3/1 and 2/2 */
932 switch (fr_ps->header->dyn_cross[sbgr]) {
933 case 0:
934 break;
935 case 1:
936 if (min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0)
937 bit_alloc[T3[sbgr]][min_sb] = 1;
938 break;
939 case 2:
940 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
941 bit_alloc[T2[sbgr]][min_sb] = 1;
942 break;
943 case 3:
944 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
945 bit_alloc[T2[sbgr]][min_sb] = 1;
946 if (min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0)
947 bit_alloc[T3[sbgr]][min_sb] = 1;
948 break;
949 case 4:
950 if (min_ch == T2[sbgr] && bit_alloc[T2[sbgr]][min_sb] != 0)
951 bit_alloc[T3[sbgr]][min_sb] = 1;
952 break;
953 default:
954 fprintf (stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
955 fflush (stderr);
956 exit (0);
957 break;
958 } /* switch.. */
959 } else if (fr_ps->config == 300 || fr_ps->config == 302
960 || fr_ps->config == 210) {
961 /* 3/0 (+2/0) and 2/1 */
962 switch (fr_ps->header->dyn_cross[sbgr]) {
963 case 0:
964 break;
965 case 1:
966 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
967 bit_alloc[T2[sbgr]][min_sb] = 1;
968 break;
969 default:
970 fprintf (stderr, "FORBIDDEN DYN_CROSS!!!!!\n");
971 fflush (stderr);
972 exit (0);
973 break;
974 } /* switch.. */
975 if (fr_ps->header->dyn_second_stereo[sbgr])
976 if (min_ch == T4outof[sbgr] && bit_alloc[T4outof[sbgr]][min_sb] != 0)
977 bit_alloc[T4[sbgr]][min_sb] = 1;
978 } else if (fr_ps->config == 202) {
979 if (fr_ps->header->dyn_second_stereo[sbgr])
980 if (min_ch == T3outof[sbgr] && bit_alloc[T3outof[sbgr]][min_sb] != 0)
981 bit_alloc[T3[sbgr]][min_sb] = 1;
982 } else if (fr_ps->config == 102) {
983 if (fr_ps->header->dyn_second_stereo[sbgr])
984 if (min_ch == T2outof[sbgr] && bit_alloc[T2outof[sbgr]][min_sb] != 0)
985 bit_alloc[T2[sbgr]][min_sb] = 1;
986 }
987 }
988
989
990
991 /************************************************************************
992 *
993 * scfsi_calc_dyn
994 *
995 * Version 1.0 94/07/07 Andreas Silzle, IRT
996 *
997 * Calculating the scale factor select information of one channel
998 * without changing the scale factors.
999 *
1000 ************************************************************************/
1001
scfsi_calc_dyn(unsigned int scalar_dyn[][3][SBLIMIT],int ch,int sblimit,unsigned int scfsi_dyn[][SBLIMIT])1002 void scfsi_calc_dyn (unsigned int scalar_dyn[][3][SBLIMIT], /* in/out */
1003 int ch, /* in */
1004 int sblimit, /* in */
1005 unsigned int scfsi_dyn[][SBLIMIT])
1006 { /* out */
1007 int sb;
1008
1009 for (sb = 0; sb < sblimit; sb++) {
1010 /* If the subbands are coded only with SCF's, they must be accurate. */
1011 /* 1993-02-19 and 1994-03-17 shn */
1012 /* 4 patterns are possible: 0: ABC, 1: AAB, 2: AAA, 3: ABB */
1013 if ((scalar_dyn[ch][0][sb] != scalar_dyn[ch][1][sb]) &&
1014 (scalar_dyn[ch][1][sb] != scalar_dyn[ch][2][sb]))
1015 scfsi_dyn[ch][sb] = 0;
1016 else
1017 if ((scalar_dyn[ch][0][sb] == scalar_dyn[ch][1][sb]) &&
1018 (scalar_dyn[ch][1][sb] != scalar_dyn[ch][2][sb]))
1019 scfsi_dyn[ch][sb] = 1;
1020 else
1021 if ((scalar_dyn[ch][0][sb] == scalar_dyn[ch][1][sb]) &&
1022 (scalar_dyn[ch][1][sb] == scalar_dyn[ch][2][sb]))
1023 scfsi_dyn[ch][sb] = 2;
1024 else
1025 scfsi_dyn[ch][sb] = 3;
1026 } /* for (sb.. */
1027 }
1028
1029 /************************************************************************
1030 *
1031 * scfsi_calc
1032 *
1033 * Version 1.0 94/07/07 Andreas Silzle, IRT
1034 *
1035 * Calculating the scale factor select information of one channel.
1036 *
1037 * route: II_transmission_pattern (Layer II only)
1038 *
1039 * PURPOSE:For a given subband, determines whether to send 1, 2, or
1040 * all 3 of the scalefactors, and fills in the scalefactor
1041 * select information accordingly
1042 *
1043 * SEMANTICS: The subbands and channels are classified based on how much
1044 * the scalefactors changes over its three values (corresponding
1045 * to the 3 sets of 12 samples per subband). The classification
1046 * will send 1 or 2 scalefactors instead of three if the scalefactors
1047 * do not change much. The scalefactor select information,
1048 * #scfsi#, is filled in accordingly.
1049 *
1050 ************************************************************************/
1051
scfsi_calc(unsigned int scalar[][3][SBLIMIT],int ch,int sblimit,unsigned int scfsi[][SBLIMIT])1052 void scfsi_calc (unsigned int scalar[][3][SBLIMIT], /* in/out */
1053 int ch, /* in */
1054 int sblimit, /* in */
1055 unsigned int scfsi[][SBLIMIT])
1056 { /* out */
1057 int dscf[2];
1058 int class[2], sb, j;
1059 static int pattern[5][5] = {
1060 { 0x123, 0x122, 0x122, 0x133, 0x123},
1061 { 0x113, 0x111, 0x111, 0x444, 0x113},
1062 { 0x111, 0x111, 0x111, 0x333, 0x113},
1063 { 0x222, 0x222, 0x222, 0x333, 0x123},
1064 { 0x123, 0x122, 0x122, 0x133, 0x123}
1065 };
1066
1067 for (sb = 0; sb < sblimit; sb++) {
1068 dscf[0] = (scalar[ch][0][sb] - scalar[ch][1][sb]);
1069 dscf[1] = (scalar[ch][1][sb] - scalar[ch][2][sb]);
1070 for (j = 0; j < 2; j++) {
1071 if (dscf[j] <= -3)
1072 class[j] = 0;
1073 else if (dscf[j] > -3 && dscf[j] < 0)
1074 class[j] = 1;
1075 else if (dscf[j] == 0)
1076 class[j] = 2;
1077 else if (dscf[j] > 0 && dscf[j] < 3)
1078 class[j] = 3;
1079 else
1080 class[j] = 4;
1081 }
1082 switch (pattern[class[0]][class[1]]) {
1083 case 0x123:
1084 scfsi[ch][sb] = 0;
1085 break;
1086 case 0x122:
1087 scfsi[ch][sb] = 3;
1088 scalar[ch][2][sb] = scalar[ch][1][sb];
1089 break;
1090 case 0x133:
1091 scfsi[ch][sb] = 3;
1092 scalar[ch][1][sb] = scalar[ch][2][sb];
1093 break;
1094 case 0x113:
1095 scfsi[ch][sb] = 1;
1096 scalar[ch][1][sb] = scalar[ch][0][sb];
1097 break;
1098 case 0x111:
1099 scfsi[ch][sb] = 2;
1100 scalar[ch][1][sb] = scalar[ch][2][sb] = scalar[ch][0][sb];
1101 break;
1102 case 0x222:
1103 scfsi[ch][sb] = 2;
1104 scalar[ch][0][sb] = scalar[ch][2][sb] = scalar[ch][1][sb];
1105 break;
1106 case 0x333:
1107 scfsi[ch][sb] = 2;
1108 scalar[ch][0][sb] = scalar[ch][1][sb] = scalar[ch][2][sb];
1109 break;
1110 case 0x444:
1111 scfsi[ch][sb] = 2;
1112 if (scalar[ch][0][sb] > scalar[ch][2][sb])
1113 scalar[ch][0][sb] = scalar[ch][2][sb];
1114 scalar[ch][1][sb] = scalar[ch][2][sb] = scalar[ch][0][sb];
1115 } /* switch */
1116 } /* for (sb.. */
1117 }
1118
1119 /************************************************************************
1120 *
1121 * scf_calc
1122 *
1123 * Calculating the scale factor for one channel.
1124 *
1125 * Version 1.0 94/07/07 Andreas Silzle, IRT
1126 *
1127 * route: II_scale_factor_calc()
1128 *
1129 * PURPOSE:For each subband, calculate the scale factor for each set
1130 * of the 12 subband samples
1131 *
1132 * SEMANTICS: Pick the scalefactor #multiple[]# just larger than the
1133 * absolute value of the peak subband sample of 12 samples,
1134 * and store the corresponding scalefactor index in #scalar#.
1135 *
1136 * Layer II has three sets of 12-subband samples for a given
1137 * subband.
1138 *
1139 ************************************************************************/
1140
scf_calc(double sample[][3][SCALE_BLOCK][SBLIMIT],int sblimit,int ch,unsigned int scf[][3][SBLIMIT])1141 void scf_calc (double sample[][3][SCALE_BLOCK][SBLIMIT], /* in */
1142 int sblimit, /* in */
1143 int ch, /* in */
1144 unsigned int scf[][3][SBLIMIT])
1145 { /* out */
1146 /* global variables:
1147 * double multiple[64]
1148 */
1149 int sb, smp, sufr, r;
1150 double s[SBLIMIT];
1151
1152 for (sufr = 0; sufr < 3; sufr++) {
1153 for (sb = 0; sb < sblimit; sb++)
1154 for (smp = 1, s[sb] = fabs (sample[ch][sufr][0][sb]);
1155 smp < SCALE_BLOCK; smp++)
1156 if (fabs (sample[ch][sufr][smp][sb]) > s[sb])
1157 s[sb] = fabs (sample[ch][sufr][smp][sb]);
1158
1159 for (sb = 0; sb < sblimit; sb++)
1160 for (r = SCALE_RANGE - 1, scf[ch][sufr][sb] = 0; r >= 0; r--)
1161 if (s[sb] < multiple[r]) { /* <= changed to <, 1992-11-06 shn */
1162 scf[ch][sufr][sb] = r;
1163 break;
1164 }
1165 } /* for (sufr.. */
1166 }
1167