1
2
3 /**********************************************************************
4 *
5 * This program computes the predistortion.
6 * The three additional channels are AFTER THE BITALLOCATION
7 * quantized and dequantized. With these dequantized samples
8 * the frontchannels are matriced again in order to dematrice them in a
9 * more exact way. This should improve the quality of matriced signals.
10 *
11 * In case of prediction the whole process of decoding predicted signals
12 * is worked off????
13 *
14 **************************************************************************/
15 #include "common.h"
16 #include "encoder.h"
17 #include "predisto.h"
18
predistortion(double (* sb_sample)[3][12][32],unsigned int (* scalar)[3][32],unsigned int (* bit_alloc)[32],unsigned int (* subband)[3][12][32],frame_params * fr_ps,double (* perm_smr)[32],unsigned int (* scfsi)[32],int * adb,unsigned int (* scfsi_dyn)[32])19 void predistortion (double (*sb_sample)[3][12][32],
20 unsigned int (*scalar)[3][32],
21 unsigned int (*bit_alloc)[32],
22 unsigned int (*subband)[3][12][32], frame_params * fr_ps,
23 double (*perm_smr)[32], unsigned int (*scfsi)[32], int *adb,
24 unsigned int (*scfsi_dyn)[32])
25 {
26 double sbs_sample[7][3][12][SBLIMIT]; /*predistortion */
27 int l, m;
28 int sblimit;
29 //MFC int ch, gr, sb;
30 //MFC int ad;
31 sblimit = fr_ps->sblimit;
32 l = 2;
33 m = 7;
34
35 pre_quant (sbs_sample, l, m, sb_sample, scalar, bit_alloc, subband, fr_ps);
36
37 matri (sbs_sample, fr_ps, sb_sample, scalar, sblimit, scfsi, scfsi_dyn,
38 bit_alloc, subband);
39
40 l = 0;
41 m = 2;
42
43 /*II_scale_factor_calc(sb_sample,scalar,sblimit, l, m); */
44 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
45
46 bit_all (perm_smr, scfsi, bit_alloc, adb, fr_ps);
47 }
48
49
50
51
52
53
54
55
56
57 static double snr[18] = { 0.00, 6.03, 11.80, 15.81, /* 0, 3, 5, 7 */
58 19.03, 23.50, 29.82, 35.99, /* 9,15,31,63 */
59 42.08, 48.13, 54.17, 60.20, /* 127, ... */
60 66.22, 72.25, 78.27, 84.29, /* 2047, ... */
61 90.31, 96.33
62 }; /* 16383, ... */
63
64
65 /* Multilingual TEST 17/03/1995 JMZ */
bit_all(double (* perm_smr)[32],unsigned int (* scfsi)[32],unsigned int (* bit_alloc)[32],int * adb,frame_params * fr_ps)66 int bit_all (double (*perm_smr)[32], unsigned int (*scfsi)[32],
67 unsigned int (*bit_alloc)[32], int *adb, frame_params * fr_ps)
68 /* minimum masking level */
69 /* bit_all() recalculates allocation for compatible signals Lo and Ro */
70 /* which are channels k==0 and k==1. This recalculation is performed */
71 /* because of signal modifications by predistortion. */
72 /* WtK 7/8/95. Information from SR. */
73 {
74 int n_ml_ch = fr_ps->header->multiling_ch; /*JMZ 17/03/95 Multilingual */
75 int i, min_ch, min_sb, k, increment, scale, seli, ba, j, l;
76 //MFC int adb_hlp, adb_hlp1, adb_hlp2;
77 int bspl, bscf, bsel, ad;
78 int bspl_mpg1, bscf_mpg1, bsel_mpg1;
79 double mnr[14][SBLIMIT], small; /*JMZ 17/03/95 Multilingual */
80 char used[14][SBLIMIT]; /*JMZ 17/03/95 Multilingual */
81 int stereo = fr_ps->stereo;
82 int stereomc = fr_ps->stereomc;
83 int stereoaug = fr_ps->stereoaug;
84 int sblimit = fr_ps->sblimit;
85 int sblimit_mc = fr_ps->sblimit_mc;
86 int sblimit_ml = fr_ps->sblimit_ml;
87
88 int jsbound = fr_ps->jsbound;
89 al_table *alloc = fr_ps->alloc;
90 al_table *alloc_mc = fr_ps->alloc_mc;
91 al_table *alloc_ml = fr_ps->alloc_ml;
92
93 // double dynsmr = 0.0; /* border of SMR for dynamic datarate */
94 //static char init = 0;
95 static int banc, berr;
96 int bbal, bancmc, pred, bancext, bbal_mpg1;
97 int pci, adb_mpg1;
98 int bits = 0; /*bits already used for the front-channels */
99 static int sfsPerScfsi[] = { 3, 2, 1, 2 }; /* lookup # sfs per scfsi */
100
101 banc = 32; /* banc: bits for header */ ;
102 /* 960627 FdB reserve extra bits wrt bugs */
103 banc += 200;
104
105 if (fr_ps->header->error_protection)
106 berr = 16;
107 else
108 berr = 0; /* added 92-08-11 shn */
109
110 pred = 0;
111 bancmc = 0;
112 bancext = 0;
113 bbal = 0;
114 bbal_mpg1 = 0;
115 adb_mpg1 = bitrate[fr_ps->header->lay - 1][fr_ps->header->bitrate_index] * 24;
116
117 #ifdef DEBUG
118 if (verbosity >= 3)
119 printf ("stereo+stereomc+stereoaug+n_ml_ch=%d\n",
120 stereo + stereomc + stereoaug + n_ml_ch);
121 #endif
122
123 if (fr_ps->header->mode == MPG_MD_STEREO) {
124 for (i = 0; i < sblimit; ++i)
125 bbal += (stereo) * (*alloc)[i][0].bits;
126 for (i = 0; i < sblimit_mc; ++i)
127 bbal += (stereomc + stereoaug) * (*alloc)[i][0].bits;
128 for (i = 0; i < sblimit_ml; ++i)
129 bbal += (n_ml_ch) * (*alloc_ml)[i][0].bits;
130 }
131 if (fr_ps->header->mode == MPG_MD_JOINT_STEREO) {
132 for (i = 0; i < jsbound; ++i)
133 bbal += (stereo) * (*alloc)[i][0].bits;
134 for (i = jsbound; i < sblimit; ++i)
135 bbal += (stereo - 1) * (*alloc)[i][0].bits;
136 for (i = 0; i < sblimit_mc; ++i)
137 bbal += (stereomc + stereoaug) * (*alloc)[i][0].bits;
138 for (i = 0; i < sblimit_ml; ++i)
139 bbal += (n_ml_ch) * (*alloc_ml)[i][0].bits;
140 }
141
142 if (fr_ps->header->center == 3)
143 bbal -= 41;
144
145 if (fr_ps->header->ext_bit_stream_present == 0)
146 bancmc += 35; /* mc_header + crc + tc_sbgr_select+ dyn_cross_on +
147 mc_prediction_on 01/05/94, SR new! 05/04/94, SR */
148 else {
149 bancmc += 43;
150 bancext = 40;
151 }
152
153 if (fr_ps->header->tc_sbgr_select == 0)
154 bancmc += 36;
155 else
156 bancmc += 3;
157
158 if (fr_ps->header->dyn_cross_on == 1)
159 bancmc += 49; /* now with dyn_cross_LR, 505/04/94, SR */
160
161 if (fr_ps->header->mc_prediction_on == 1) {
162 for (i = 0; i < 8; i++) { /*now only 8 sb_groups, 05/04/94, SR */
163 bancmc += 1;
164 if (fr_ps->header->mc_pred[i] == 1)
165 bancmc += n_pred_coef[fr_ps->header->dyn_cross[i]] * 2;
166 }
167
168 for (i = 0; i < 8; i++)
169 if (fr_ps->header->mc_pred[i] == 1)
170 for (j = 0; j < n_pred_coef[fr_ps->header->dyn_cross[i]]; j++)
171 if (fr_ps->header->predsi[i][j] != 0) {
172 pred += 3;
173 for (pci = 0; pci < fr_ps->header->predsi[i][j]; pci++)
174 pred += 8;
175 }
176 }
177
178
179 for (l = 0; l < sblimit; l++)
180 for (k = 0; k < 2; k++)
181 used[k][l] = 0;
182
183 for (l = 0; l < SBLIMIT; l++) { /* searching for the sb min SMR */
184 i = sbgrp[l];
185
186 for (j = stereo; j < stereo + stereomc + stereoaug; j++)
187 if ((j < stereo && l < sblimit) || (j >= stereo && l < sblimit_mc)) {
188 /* k = transmission_channel5[fr_ps->header->tc_alloc[i]][j]; */
189 k = transmission_channel (fr_ps, i, j);
190
191 if (j < stereo)
192 bits += 12 * ((*alloc)[l][bit_alloc[k][l]].group *
193 (*alloc)[l][bit_alloc[k][l]].bits);
194 else if (j < 7 || n_ml_ch == 0) /* Multichannel */
195 bits += 12 * ((*alloc_mc)[l][bit_alloc[k][l]].group *
196 (*alloc_mc)[l][bit_alloc[k][l]].bits);
197 else /* MultiLingual */
198 bits += 12 * ((*alloc_ml)[l][bit_alloc[k][l]].group *
199 (*alloc_ml)[l][bit_alloc[k][l]].bits);
200
201 if (bit_alloc[k][l] != 0) {
202 bits += 2;
203 switch (scfsi[k][l]) {
204 case 0:
205 bits += 18;
206 break;
207 case 1:
208 bits += 12;
209 break;
210 case 2:
211 bits += 6;
212 break;
213 case 3:
214 bits += 12;
215 break;
216 }
217 }
218 }
219 }
220
221 for (i = 0; i < 12; i++) {
222 if ((fr_ps->header->tc_alloc[i] == 1) || (fr_ps->header->tc_alloc[i] == 7)) {
223 bits += 12 * ((*alloc)[l][bit_alloc[0][l]].group *
224 (*alloc)[l][bit_alloc[0][l]].bits);
225 if (bit_alloc[0][l] != 0) {
226 bits += 2;
227 switch (scfsi[0][l]) {
228 case 0:
229 bits += 18;
230 break;
231 case 1:
232 bits += 12;
233 break;
234 case 2:
235 bits += 6;
236 break;
237 case 3:
238 bits += 12;
239 break;
240 }
241 }
242 used[0][l] = 2;
243 }
244
245 if ((fr_ps->header->tc_alloc[i] == 2) || (fr_ps->header->tc_alloc[i] == 6)) {
246 bits += 12 * ((*alloc)[l][bit_alloc[1][l]].group *
247 (*alloc)[l][bit_alloc[1][l]].bits);
248 if (bit_alloc[1][l] != 0) {
249 bits += 2;
250 switch (scfsi[1][l]) {
251 case 0:
252 bits += 18;
253 break;
254 case 1:
255 bits += 12;
256 break;
257 case 2:
258 bits += 6;
259 break;
260 case 3:
261 bits += 12;
262 break;
263 }
264 }
265 used[1][l] = 2;
266 }
267 }
268
269 if (fr_ps->header->ext_bit_stream_present == 0)
270 *adb -= bbal + berr + banc + bancmc + pred + bits;
271 else {
272 *adb = *adb - bbal - berr - banc - bancmc - pred - bits -
273 bancext - (fr_ps->header->n_ad_bytes * 8);
274 for (i = 0; i < sblimit; ++i)
275 bbal_mpg1 += 2 * (*alloc)[i][0].bits;
276 adb_mpg1 -= bbal_mpg1 + berr + banc + bancmc +
277 (fr_ps->header->n_ad_bytes * 8);
278 }
279 ad = *adb;
280
281 for (l = 0; l < sblimit; l++) {
282 for (k = 0; k < 2; k++) {
283 mnr[k][l] = snr[0] - perm_smr[k][l];
284 if (used[k][l] == 0)
285 bit_alloc[k][l] = 0;
286 }
287 }
288
289 /********************************************************************/
290 /* JMZ 08/03/1995 Multilingual */
291
292 for (i = 0; i < sblimit_ml; i++)
293 for (k = 7; k < 7 + n_ml_ch; k++) {
294 mnr[k][i] = snr[0] - perm_smr[k][i];
295 /* mask-to-noise-level = signal-to-noise-level - minimum-masking- */
296 /* threshold */
297
298 bit_alloc[k][i] = 0;
299 used[k][i] = 0;
300 }
301
302 /* JMZ 08/03/1995 Multilingual */
303 /********************************************************************/
304
305
306
307 bspl = bscf = bsel = bspl_mpg1 = bscf_mpg1 = bsel_mpg1 = 0;
308
309 do {
310 small = 999999.0;
311 min_sb = -1;
312 min_ch = -1;
313
314
315 for (i = 0; i < sblimit; i++) {
316 for (k = 0; k < 2; k++) {
317 if ((used[k][i] != 2) && (small > mnr[k][i])) {
318 small = mnr[k][i];
319 min_sb = i;
320 min_ch = k;
321 }
322 }
323 }
324
325 /******************************************************************/
326 /* Multilingual JMZ 08/03/1995 */
327
328 if (n_ml_ch > 0) {
329 for (i = 0; i < sblimit_ml; i++)
330 for (j = 7; j < (n_ml_ch + 7); ++j) {
331 k = j;
332 if ((used[k][i] != 2) && (small > mnr[k][i])) {
333 small = mnr[k][i];
334 min_sb = i;
335 min_ch = k;
336 }
337 }
338 }
339
340 /* Multilingual JMZ 08/03/1995 */
341 /******************************************************************/
342
343
344 if (min_sb > -1) {
345 if (min_ch < stereo) {
346 increment =
347 12 * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb] + 1].group *
348 (*alloc)[min_sb][bit_alloc[min_ch][min_sb] + 1].bits);
349 /* how many bits are needed */
350 if (used[min_ch][min_sb])
351 increment -= 12 * ((*alloc)[min_sb][bit_alloc[min_ch][min_sb]].group *
352 (*alloc)[min_sb][bit_alloc[min_ch][min_sb]].bits);
353 } else if (min_ch < 7 || n_ml_ch == 0) { /* Multichannel */
354 increment =
355 12 * ((*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb] + 1].group *
356 (*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb] + 1].bits);
357 /* how many bits are needed */
358 if (used[min_ch][min_sb])
359 increment -=
360 12 * ((*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]].group *
361 (*alloc_mc)[min_sb][bit_alloc[min_ch][min_sb]].bits);
362 } else { /* MultiLingual 7/8/95 WtK */
363
364 increment = ((*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb] + 1].group *
365 (*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb] + 1].bits);
366 if (used[min_ch][min_sb])
367 increment -= ((*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]].group *
368 (*alloc_ml)[min_sb][bit_alloc[min_ch][min_sb]].bits);
369 if (fr_ps->header->multiling_fs == 1)
370 increment *= 6;
371 else
372 increment *= 12;
373 }
374
375 /* scale factor bits required for subband [min] */
376 if (used[min_ch][min_sb])
377 scale = seli = 0;
378 else { /* this channel had no bits or scfs before */
379 seli = 2;
380 scale = 6 * sfsPerScfsi[scfsi[min_ch][min_sb]];
381 }
382
383 if (fr_ps->header->ext_bit_stream_present == 1) {
384 if (adb_mpg1 >
385 bspl_mpg1 + bscf_mpg1 + bsel_mpg1 + seli + scale + increment) {
386 bspl_mpg1 += increment; /* bits for subband sample */
387 bscf_mpg1 += scale; /* bits for scale factor */
388 bsel_mpg1 += seli; /* bits for scfsi code */
389 } else
390 used[min_ch][min_sb] = 2; /* can't increase this alloc */
391 }
392
393
394 if ((ad > bspl + bscf + bsel + seli + scale + increment)
395 && (used[min_ch][min_sb] != 2)) {
396 ba = ++bit_alloc[min_ch][min_sb]; /* next up alloc */
397 bspl += increment; /* bits for subband sample */
398 bscf += scale; /* bits for scale factor */
399 bsel += seli; /* bits for scfsi code */
400 used[min_ch][min_sb] = 1; /* subband has bits */
401 if (min_ch < 7)
402 mnr[min_ch][min_sb] = -perm_smr[min_ch][min_sb] +
403 snr[(*alloc)[min_sb][ba].quant + 1];
404 else
405 mnr[min_ch][min_sb] = -perm_smr[min_ch][min_sb] +
406 snr[(*alloc_ml)[min_sb][ba].quant + 1];
407
408 /* Check if subband has been fully allocated max bits */
409 if (min_ch < stereo) {
410 if (ba >= (1 << (*alloc)[min_sb][0].bits) - 1)
411 used[min_ch][min_sb] = 2;
412 } else if (min_ch < 7 || n_ml_ch == 0) { /* Multichannel */
413 if (ba >= (1 << (*alloc_mc)[min_sb][0].bits) - 1)
414 used[min_ch][min_sb] = 2;
415 } else {
416 if (ba >= (1 << (*alloc_ml)[min_sb][0].bits) - 1)
417 used[min_ch][min_sb] = 2;
418 }
419 } else
420 used[min_ch][min_sb] = 2; /* can't increase this alloc */
421
422 } /* end of if-loop if min_sb >-1 */
423 } while (min_sb > -1); /* until could find no channel */
424 /* Calculate the number of bits left */
425
426 ad -= bspl + bscf + bsel;
427 *adb = ad;
428 for (i = sblimit; i < SBLIMIT; i++)
429 for (k = 0; k < 2; k++)
430 bit_alloc[k][i] = 0;
431 for (i = sblimit_ml; i < SBLIMIT; i++)
432 for (k = 7; k < 7 + n_ml_ch; k++)
433 bit_alloc[k][i] = 0;
434
435 //MFC: Should bit_all return something?
436 // Declared to return int, but doesn't... um...
437 return(0);
438
439 }
440
441
matri(double (* sbs_sample)[3][12][32],frame_params * fr_ps,double (* sb_sample)[3][12][32],unsigned int (* scalar)[3][32],int sblimit,unsigned int (* scfsi)[32],unsigned int (* scfsi_dyn)[32],unsigned int (* bit_alloc)[32],unsigned int (* subband)[3][12][32])442 void matri (double (*sbs_sample)[3][12][32], frame_params * fr_ps,
443 double (*sb_sample)[3][12][32], unsigned int (*scalar)[3][32],
444 int sblimit, unsigned int (*scfsi)[32],
445 unsigned int (*scfsi_dyn)[32], unsigned int (*bit_alloc)[32],
446 unsigned int (*subband)[3][12][32])
447 {
448 int i, j, k, l, m, n;
449
450 //MFC layer *info = fr_ps->header;
451
452 for (k = 0; k < 8; k++) {
453 if (fr_ps->header->mc_pred[k] == 0) {
454 switch (fr_ps->header->tc_alloc[k]) {
455 case 0:
456 for (j = 0; j < 3; ++j)
457 for (l = 0; l < 12; l++) {
458 sb_sample[0][j][l][k] =
459 sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
460 sbs_sample[3][j][l][k];
461 sb_sample[1][j][l][k] =
462 sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
463 sbs_sample[4][j][l][k];
464 }
465 m = 0;
466 n = 2;
467 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
468 break;
469 case 1:
470 for (j = 0; j < 3; ++j)
471 for (l = 0; l < 12; l++) {
472 sb_sample[0][j][l][k] =
473 sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] +
474 sbs_sample[3][j][l][k];
475 }
476
477 m = 0;
478 n = 1;
479 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
480 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
481 pre_quant (sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband,
482 fr_ps);
483
484 for (j = 0; j < 3; ++j)
485 for (l = 0; l < 12; l++) {
486 sbs_sample[2][j][l][k] =
487 sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] -
488 sbs_sample[3][j][l][k];
489 sb_sample[1][j][l][k] =
490 sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
491 sbs_sample[4][j][l][k];
492 }
493 m = 1;
494 n = 2;
495 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
496
497 break;
498 case 2:
499 for (j = 0; j < 3; ++j)
500 for (l = 0; l < 12; l++) {
501 sb_sample[1][j][l][k] =
502 sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] +
503 sbs_sample[4][j][l][k];
504 }
505
506 m = 1;
507 n = 2;
508 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
509 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
510 pre_quant (sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband,
511 fr_ps);
512
513 for (j = 0; j < 3; ++j)
514 for (l = 0; l < 12; l++) {
515 sbs_sample[2][j][l][k] =
516 sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] -
517 sbs_sample[4][j][l][k];
518 sb_sample[0][j][l][k] =
519 sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
520 sbs_sample[3][j][l][k];
521 }
522 m = 0;
523 n = 1;
524 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
525
526 break;
527 case 3:
528 for (j = 0; j < 3; ++j)
529 for (l = 0; l < 12; l++) {
530 sb_sample[0][j][l][k] =
531 sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
532 sb_sample[3][j][l][k];
533 sb_sample[1][j][l][k] =
534 sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
535 sbs_sample[4][j][l][k];
536 }
537 m = 0;
538 n = 2;
539 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
540 break;
541 case 4:
542 for (j = 0; j < 3; ++j)
543 for (l = 0; l < 12; l++) {
544 sb_sample[0][j][l][k] =
545 sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
546 sbs_sample[3][j][l][k];
547 sb_sample[1][j][l][k] =
548 sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
549 sb_sample[4][j][l][k];
550 }
551 m = 0;
552 n = 2;
553 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
554 break;
555 case 5:
556 for (j = 0; j < 3; ++j)
557 for (l = 0; l < 12; l++) {
558 sb_sample[0][j][l][k] =
559 sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
560 sb_sample[3][j][l][k];
561 sb_sample[1][j][l][k] =
562 sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
563 sb_sample[4][j][l][k];
564 }
565 m = 0;
566 n = 2;
567 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
568 break;
569 case 6:
570 for (j = 0; j < 3; ++j)
571 for (l = 0; l < 12; l++) {
572 sb_sample[1][j][l][k] =
573 sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] +
574 sbs_sample[4][j][l][k];
575 }
576
577 m = 1;
578 n = 2;
579 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
580 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
581 pre_quant (sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband,
582 fr_ps);
583
584 for (j = 0; j < 3; ++j)
585 for (l = 0; l < 12; l++) {
586 sbs_sample[2][j][l][k] =
587 sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] -
588 sbs_sample[4][j][l][k];
589 sb_sample[0][j][l][k] =
590 sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
591 sb_sample[3][j][l][k];
592 }
593 m = 0;
594 n = 1;
595 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
596
597 break;
598 case 7:
599 for (j = 0; j < 3; ++j)
600 for (l = 0; l < 12; l++) {
601 sb_sample[0][j][l][k] =
602 sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] +
603 sbs_sample[3][j][l][k];
604 }
605
606 m = 0;
607 n = 1;
608 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
609 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
610 pre_quant (sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband,
611 fr_ps);
612
613 for (j = 0; j < 3; ++j)
614 for (l = 0; l < 12; l++) {
615 sbs_sample[2][j][l][k] =
616 sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] -
617 sbs_sample[3][j][l][k];
618 sb_sample[1][j][l][k] =
619 sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
620 sb_sample[4][j][l][k];
621 }
622 m = 1;
623 n = 2;
624 scale_factor_calc (scalar, sblimit, m, n, k, sb_sample);
625
626 break;
627 }
628 }
629 }
630
631 for (i = 8; i < 12; i++) {
632 if (fr_ps->header->mc_pred[k] == 0) {
633 switch (fr_ps->header->tc_alloc[i]) {
634 case 0:
635 for (j = 0; j < 3; ++j)
636 for (l = 0; l < 12; l++)
637 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
638 sb_sample[0][j][l][k] =
639 sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
640 sbs_sample[3][j][l][k];
641 sb_sample[1][j][l][k] =
642 sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
643 sbs_sample[4][j][l][k];
644 }
645 m = 0;
646 n = 2;
647 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
648 break;
649 case 1:
650 for (j = 0; j < 3; ++j)
651 for (l = 0; l < 12; l++)
652 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
653 sb_sample[0][j][l][k] =
654 sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] +
655 sbs_sample[3][j][l][k];
656 }
657
658 m = 0;
659 n = 1;
660 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
661 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
662 pre_quant (sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband,
663 fr_ps);
664
665 for (j = 0; j < 3; ++j)
666 for (l = 0; l < 12; l++)
667 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
668 sbs_sample[2][j][l][k] =
669 sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] -
670 sbs_sample[3][j][l][k];
671 sb_sample[1][j][l][k] =
672 sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
673 sbs_sample[4][j][l][k];
674 }
675 m = 1;
676 n = 2;
677 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
678 break;
679 case 2:
680 for (j = 0; j < 3; ++j)
681 for (l = 0; l < 12; l++)
682 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
683 sb_sample[1][j][l][k] =
684 sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] +
685 sbs_sample[4][j][l][k];
686 }
687
688 m = 1;
689 n = 2;
690 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
691 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
692 pre_quant (sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband,
693 fr_ps);
694
695 for (j = 0; j < 3; ++j)
696 for (l = 0; l < 12; l++)
697 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
698 sbs_sample[2][j][l][k] =
699 sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] -
700 sbs_sample[4][j][l][k];
701 sb_sample[0][j][l][k] =
702 sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
703 sbs_sample[3][j][l][k];
704 }
705 m = 0;
706 n = 1;
707 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
708
709 break;
710 case 3:
711 for (j = 0; j < 3; ++j)
712 for (l = 0; l < 12; l++)
713 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
714 sb_sample[0][j][l][k] =
715 sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
716 sb_sample[3][j][l][k];
717 sb_sample[1][j][l][k] =
718 sb_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
719 sbs_sample[4][j][l][k];
720 }
721 m = 0;
722 n = 2;
723 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
724 break;
725 case 4:
726 for (j = 0; j < 3; ++j)
727 for (l = 0; l < 12; l++)
728 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
729 sb_sample[0][j][l][k] =
730 sb_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
731 sbs_sample[3][j][l][k];
732 sb_sample[1][j][l][k] =
733 sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
734 sb_sample[4][j][l][k];
735 }
736 m = 0;
737 n = 2;
738 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
739 break;
740 case 5:
741 for (j = 0; j < 3; ++j)
742 for (l = 0; l < 12; l++)
743 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
744 sb_sample[0][j][l][k] =
745 sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
746 sb_sample[3][j][l][k];
747 sb_sample[1][j][l][k] =
748 sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
749 sb_sample[4][j][l][k];
750 }
751 m = 0;
752 n = 2;
753 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
754 break;
755 case 6:
756 for (j = 0; j < 3; ++j)
757 for (l = 0; l < 12; l++)
758 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
759 sb_sample[1][j][l][k] =
760 sbs_sample[6][j][l][k] + sb_sample[2][j][l][k] +
761 sbs_sample[4][j][l][k];
762 }
763
764 m = 1;
765 n = 2;
766 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
767 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
768 pre_quant (sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband,
769 fr_ps);
770
771 for (j = 0; j < 3; ++j)
772 for (l = 0; l < 12; l++)
773 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
774 sbs_sample[2][j][l][k] =
775 sbs_sample[1][j][l][k] - sbs_sample[6][j][l][k] -
776 sbs_sample[4][j][l][k];
777 sb_sample[0][j][l][k] =
778 sbs_sample[5][j][l][k] + sbs_sample[2][j][l][k] +
779 sb_sample[3][j][l][k];
780 }
781 m = 0;
782 n = 1;
783 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
784
785 break;
786 case 7:
787 for (j = 0; j < 3; ++j)
788 for (l = 0; l < 12; l++)
789 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
790 sb_sample[0][j][l][k] =
791 sbs_sample[5][j][l][k] + sb_sample[2][j][l][k] +
792 sbs_sample[3][j][l][k];
793 }
794
795 m = 0;
796 n = 1;
797 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
798 trans_pattern (scalar, scfsi, fr_ps, scfsi_dyn);
799 pre_quant (sbs_sample, m, n, sb_sample, scalar, bit_alloc, subband,
800 fr_ps);
801
802 for (j = 0; j < 3; ++j)
803 for (l = 0; l < 12; l++)
804 for (k = sb_groups[i - 1] + 1; k <= sb_groups[i]; k++) {
805 sbs_sample[2][j][l][k] =
806 sbs_sample[0][j][l][k] - sbs_sample[5][j][l][k] -
807 sbs_sample[3][j][l][k];
808 sb_sample[1][j][l][k] =
809 sbs_sample[6][j][l][k] + sbs_sample[2][j][l][k] +
810 sb_sample[4][j][l][k];
811 }
812 m = 1;
813 n = 2;
814 scale_factor_calc (scalar, sblimit, m, n, i, sb_sample);
815
816 break;
817 }
818 }
819 }
820 }
821
822
823
824
buffer_sample(unsigned int (* keep_it)[36][32],unsigned int (* sample)[3][32],unsigned int (* bit_alloc)[32],frame_params * fr_ps,int l,int z,int q)825 void buffer_sample (unsigned int (*keep_it)[36][32], unsigned int (*sample)[3][32],
826 unsigned int (*bit_alloc)[32], frame_params * fr_ps, int l,
827 int z, int q)
828 {
829 int i, j, k, m;
830 int stereo = fr_ps->stereo;
831 int sblimit = fr_ps->sblimit;
832 int jsbound = fr_ps->jsbound;
833 //MFC al_table *alloc = fr_ps->alloc;
834 //MFC unsigned int x;
835
836 for (i = 0; i < sblimit; i++)
837 for (j = l; j < ((i < jsbound) ? z : l + 1); j++) {
838 if (bit_alloc[j][i]) {
839 /* check for grouping in subband */
840 /* if ((*alloc)[i][bit_alloc[j][i]].group==3) */
841 for (m = 0; m < 3; m++) {
842 sample[j][m][i] = keep_it[j][q * 3 + m][i];
843 }
844 } else { /* for no sample transmitted */
845 for (k = 0; k < 3; k++)
846 sample[j][k][i] = 0;
847 }
848 if (stereo == 2 && i >= jsbound) /* joint stereo : copy L to R */
849 for (k = 0; k < 3; k++)
850 sample[1][k][i] = sample[0][k][i];
851 }
852 for (i = sblimit; i < SBLIMIT; i++)
853 for (j = l; j < z; j++)
854 for (k = 0; k < 3; k++)
855 sample[j][k][i] = 0;
856 }
857
858
859
860 static double a[17] = {
861 0.750000000, 0.625000000, 0.875000000, 0.562500000, 0.937500000,
862 0.968750000, 0.984375000, 0.992187500, 0.996093750, 0.998046875,
863 0.999023438, 0.999511719, 0.999755859, 0.999877930, 0.999938965,
864 0.999969482, 0.999984741
865 };
866
867 static double b[17] = {
868 -0.250000000, -0.375000000, -0.125000000, -0.437500000, -0.062500000,
869 -0.031250000, -0.015625000, -0.007812500, -0.003906250, -0.001953125,
870 -0.000976563, -0.000488281, -0.000244141, -0.000122070, -0.000061035,
871 -0.000030518, -0.000015259
872 };
873
874
875
subband_quantization_pre(unsigned int (* scalar)[3][32],double (* sb_samples)[3][12][32],unsigned int (* bit_alloc)[32],unsigned int (* sbband)[3][12][32],frame_params * fr_ps,int ch1,int ch2)876 void subband_quantization_pre (unsigned int (*scalar)[3][32],
877 double (*sb_samples)[3][12][32],
878 unsigned int (*bit_alloc)[32],
879 unsigned int (*sbband)[3][12][32],
880 frame_params * fr_ps, int ch1, int ch2)
881 {
882 int i, j, k, s, n, qnt, sig, z;
883 //MFC int stereo = fr_ps->stereo;
884 //MFC int stereomc = fr_ps->stereomc;
885 int sblimit = fr_ps->sblimit;
886 unsigned int stps;
887 double d;
888 al_table *alloc = fr_ps->alloc;
889
890
891
892 for (s = 0; s < 3; s++)
893 for (j = 0; j < 12; j = j + 3)
894 for (i = 0; i < sblimit; i++)
895 for (k = ch1; k < ch2; k++) {
896 for (z = 0; z < 3; z++) {
897 if (bit_alloc[k][i])
898 d = sb_samples[k][s][j + z][i] / multiple[scalar[k][s][i]];
899 else
900 d = 0;
901
902
903 if (fabs (d) >= 1.0) { /* > changed to >=, 1992-11-06 shn */
904 printf ("In predistortion, not scaled properly, %d %d %d %d\n", k,
905 s, j + z, i);
906 printf ("Value %1.10f\n", sb_samples[k][s][j + z][i]);
907 }
908 qnt = (*alloc)[i][bit_alloc[k][i]].quant;
909 d = d * a[qnt] + b[qnt];
910 /* extract MSB N-1 bits from the floating point sample */
911 if (d >= 0)
912 sig = 1;
913 else {
914 sig = 0;
915 d += 1.0;
916 }
917 n = 0;
918 #ifndef MS_DOS
919 stps = (*alloc)[i][bit_alloc[k][i]].steps;
920 while ((1L << n) < stps)
921 n++;
922 #else
923 while (((unsigned long) (1L << (long) n) <
924 ((unsigned long) ((*alloc)[i][bit_alloc[k][i]].steps)
925 & 0xffff)
926 ) && (n < 16)
927 )
928 n++;
929 #endif
930 n--;
931 sbband[k][s][j + z][i] = (unsigned int) (d * (double) (1L << n));
932 /* tag the inverted sign bit to sbband at position N */
933 /* The bit inversion is a must for grouping with 3,5,9 steps
934 so it is done for all subbands */
935 if (sig)
936 sbband[k][s][j + z][i] |= 1 << n;
937
938 if (!bit_alloc[k][i])
939 sbband[k][s][j + z][i] = 0;
940 }
941
942 /*try try try ! 7/7/94 */
943
944 /* if ((*alloc)[i][bit_alloc[k][i]].group != 3)
945 {
946 y =(*alloc)[i][bit_alloc[k][i]].steps;
947 sbband[k][s][j][i] = sbband[k][s][j][i] +
948 sbband[k][s][j+1][i] * y +
949 sbband[k][s][j+2][i] * y * y;
950 sbband[k][s][j+1][i] = sbband[k][s][j][i];
951 sbband[k][s][j+2][i] = sbband[k][s][j][i];
952 }*/
953
954
955
956 }
957 for (s = 0; s < 3; s++)
958 for (j = sblimit; j < SBLIMIT; j++)
959 for (i = 0; i < 12; i++)
960 for (k = 0; k < 7; k++)
961 sbband[k][s][i][j] = 0;
962 }
963
964
965
966
967
968
trans_pattern(unsigned int (* scalar)[3][32],unsigned int (* scfsi)[32],frame_params * fr_ps,unsigned int (* scfsi_dyn)[32])969 void trans_pattern (unsigned int (*scalar)[3][32], unsigned int (*scfsi)[32],
970 frame_params * fr_ps, unsigned int (*scfsi_dyn)[32])
971 {
972 //MFC int stereo = fr_ps->stereo;
973 //MFC int stereomc = fr_ps->stereomc;
974 int sblimit = fr_ps->sblimit;
975 int dscf[2];
976 int class[2], i, j, k;
977 static int pattern[5][5] = {
978 { 0x123, 0x122, 0x122, 0x133, 0x123},
979 { 0x113, 0x111, 0x111, 0x444, 0x113},
980 { 0x111, 0x111, 0x111, 0x333, 0x113},
981 { 0x222, 0x222, 0x222, 0x333, 0x123},
982 { 0x123, 0x122, 0x122, 0x133, 0x123}
983 };
984
985 for (k = 0; k < 2; k++)
986 for (i = 0; i < sblimit; i++) {
987 dscf[0] = (scalar[k][0][i] - scalar[k][1][i]);
988 dscf[1] = (scalar[k][1][i] - scalar[k][2][i]);
989 for (j = 0; j < 2; j++) {
990 if (dscf[j] <= -3)
991 class[j] = 0;
992 else if (dscf[j] > -3 && dscf[j] < 0)
993 class[j] = 1;
994 else if (dscf[j] == 0)
995 class[j] = 2;
996 else if (dscf[j] > 0 && dscf[j] < 3)
997 class[j] = 3;
998 else
999 class[j] = 4;
1000 }
1001 switch (pattern[class[0]][class[1]]) {
1002 case 0x123:
1003 scfsi[k][i] = 0;
1004 break;
1005 case 0x122:
1006 scfsi[k][i] = 3;
1007 scalar[k][2][i] = scalar[k][1][i];
1008 break;
1009 case 0x133:
1010 scfsi[k][i] = 3;
1011 scalar[k][1][i] = scalar[k][2][i];
1012 break;
1013 case 0x113:
1014 scfsi[k][i] = 1;
1015 scalar[k][1][i] = scalar[k][0][i];
1016 break;
1017 case 0x111:
1018 scfsi[k][i] = 2;
1019 scalar[k][1][i] = scalar[k][2][i] = scalar[k][0][i];
1020 break;
1021 case 0x222:
1022 scfsi[k][i] = 2;
1023 scalar[k][0][i] = scalar[k][2][i] = scalar[k][1][i];
1024 break;
1025 case 0x333:
1026 scfsi[k][i] = 2;
1027 scalar[k][0][i] = scalar[k][1][i] = scalar[k][2][i];
1028 break;
1029 case 0x444:
1030 scfsi[k][i] = 2;
1031 if (scalar[k][0][i] > scalar[k][2][i])
1032 scalar[k][0][i] = scalar[k][2][i];
1033 scalar[k][1][i] = scalar[k][2][i] = scalar[k][0][i];
1034
1035 }
1036 }
1037 }
1038
1039
1040
1041
1042
pre_quant(double (* sbs_sample)[3][12][32],int l,int m,double (* sb_sample)[3][12][32],unsigned int (* scalar)[3][32],unsigned int (* bit_alloc)[32],unsigned int (* subband)[3][12][32],frame_params * fr_ps)1043 void pre_quant (double (*sbs_sample)[3][12][32], int l, int m,
1044 double (*sb_sample)[3][12][32], unsigned int (*scalar)[3][32],
1045 unsigned int (*bit_alloc)[32],
1046 unsigned int (*subband)[3][12][32], frame_params * fr_ps)
1047 {
1048 double sb_pre_sample[7][3][12][SBLIMIT]; /*predistortion */
1049 unsigned int sample[7][3][SBLIMIT];
1050 unsigned int keep_it[7][36][SBLIMIT];
1051 int ch, sb, gr, i;
1052 //MFC int hi, hu;
1053
1054 subband_quantization_pre (scalar, sb_sample, bit_alloc, subband, fr_ps, l, m);
1055
1056
1057 for (ch = l; ch < m; ch++)
1058 for (sb = 0; sb < SBLIMIT; sb++)
1059 for (gr = 0; gr < 3; gr++)
1060 for (i = 0; i < 12; i++)
1061 keep_it[ch][i + gr * 12][sb] = subband[ch][gr][i][sb];
1062
1063 for (i = 0; i < 12; i++) {
1064 buffer_sample (keep_it, sample, bit_alloc, fr_ps, l, m, i);
1065
1066 II_dequantize_sample (sample, bit_alloc, sb_pre_sample, fr_ps, l, m, i);
1067 II_denormalize_sample (sb_pre_sample, scalar, fr_ps, i >> 2, l, m, i);
1068 }
1069
1070 for (ch = l; ch < m; ch++)
1071 for (sb = 0; sb < SBLIMIT; sb++)
1072 for (i = 0; i < 4; i++)
1073 for (gr = 0; gr < 3; gr++)
1074 sbs_sample[ch][0][i * 3 + gr][sb] = sb_pre_sample[ch][gr][i][sb];
1075
1076 for (ch = l; ch < m; ch++)
1077 for (sb = 0; sb < SBLIMIT; sb++)
1078 for (i = 4; i < 8; i++)
1079 for (gr = 0; gr < 3; gr++)
1080 sbs_sample[ch][1][(i - 4) * 3 + gr][sb] =
1081 sb_pre_sample[ch][gr][i][sb];
1082
1083 for (ch = l; ch < m; ch++)
1084 for (sb = 0; sb < SBLIMIT; sb++)
1085 for (i = 8; i < 12; i++)
1086 for (gr = 0; gr < 3; gr++)
1087 sbs_sample[ch][2][(i - 8) * 3 + gr][sb] =
1088 sb_pre_sample[ch][gr][i][sb];
1089
1090
1091 }
1092
1093 /**************************************************************
1094 *
1095 * Restore the compressed sample to a factional number.
1096 * first complement the MSB of the sample
1097 * for Layer II :
1098 * Use the formula s = s' * c + d
1099 *
1100 * taken out of decoder,modified for prediction 9/16/93,SR
1101 *
1102 **************************************************************/
1103
1104 static double c[17] = { 1.33333333333, 1.60000000000, 1.14285714286,
1105 1.77777777777, 1.06666666666, 1.03225806452,
1106 1.01587301587, 1.00787401575, 1.00392156863,
1107 1.00195694716, 1.00097751711, 1.00048851979,
1108 1.00024420024, 1.00012208522, 1.00006103888,
1109 1.00003051851, 1.00001525902
1110 };
1111
1112 static double d[17] = { 0.500000000, 0.500000000, 0.250000000, 0.500000000,
1113 0.125000000, 0.062500000, 0.031250000, 0.015625000,
1114 0.007812500, 0.003906250, 0.001953125, 0.0009765625,
1115 0.00048828125, 0.00024414063, 0.00012207031,
1116 0.00006103516, 0.00003051758
1117 };
1118
1119 /************************** Layer II stuff ************************/
1120
II_dequantize_sample(unsigned int (* sample)[3][32],unsigned int (* bit_alloc)[32],double (* fraction)[3][12][32],frame_params * fr_ps,int l,int m,int z)1121 void II_dequantize_sample (unsigned int (*sample)[3][32],
1122 unsigned int (*bit_alloc)[32],
1123 double (*fraction)[3][12][32], frame_params * fr_ps,
1124 int l, int m, int z)
1125 {
1126 int i, j, k, x;
1127 //MFC int stereo = fr_ps->stereo;
1128 int sblimit = fr_ps->sblimit;
1129 al_table *alloc = fr_ps->alloc;
1130
1131 for (i = 0; i < sblimit; i++)
1132 for (j = 0; j < 3; j++)
1133 for (k = l; k < m; k++)
1134 if (bit_alloc[k][i]) {
1135
1136 /* locate MSB in the sample */
1137 x = 0;
1138 #ifndef MSDOS
1139 while ((1L << x) < (*alloc)[i][bit_alloc[k][i]].steps)
1140 x++;
1141 #else
1142 /* microsoft C thinks an int is a short */
1143 while (((unsigned long) (1L << (long) x) <
1144 (unsigned long) ((*alloc)[i][bit_alloc[k][i]].steps)
1145 ) && (x < 16))
1146 x++;
1147 #endif
1148
1149 /* MSB inversion */
1150 if (((sample[k][j][i] >> (x - 1) ) & 1) == 1) //MFC
1151 fraction[k][j][z][i] = 0.0;
1152 else
1153 fraction[k][j][z][i] = -1.0;
1154
1155 /* Form a 2's complement sample */
1156 fraction[k][j][z][i] +=
1157 (double) (sample[k][j][i] & ((1 << (x - 1) ) - 1)) /
1158 (double) (1L << (x - 1) );
1159
1160 /* Dequantize the sample */
1161 fraction[k][j][z][i] += d[(*alloc)[i][bit_alloc[k][i]].quant];
1162 fraction[k][j][z][i] *= c[(*alloc)[i][bit_alloc[k][i]].quant];
1163 } else
1164 fraction[k][j][z][i] = 0.0;
1165
1166 for (i = sblimit; i < SBLIMIT; i++)
1167 for (j = 0; j < 3; j++)
1168 for (k = l; k < m; k++)
1169 fraction[k][j][z][i] = 0.0;
1170 }
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
II_denormalize_sample(double (* fraction)[3][12][32],unsigned int (* scale_index)[3][32],frame_params * fr_ps,int x,int l,int m,int z)1183 void II_denormalize_sample (double (*fraction)[3][12][32],
1184 unsigned int (*scale_index)[3][32],
1185 frame_params * fr_ps, int x, int l, int m, int z)
1186 /*far */
1187 {
1188 int i, j;
1189 //MFC int stereo = fr_ps->stereo;
1190 int sblimit = fr_ps->sblimit;
1191
1192 for (i = 0; i < sblimit; i++)
1193 for (j = l; j < m; j++) {
1194 fraction[j][0][z][i] *= multiple[scale_index[j][x][i]];
1195 fraction[j][1][z][i] *= multiple[scale_index[j][x][i]];
1196 fraction[j][2][z][i] *= multiple[scale_index[j][x][i]];
1197 }
1198 }
1199
1200
1201
scale_factor_calc(unsigned int (* scalar)[3][32],int sblimit,int l,int m,int z,double (* sb_sample)[3][12][32])1202 void scale_factor_calc (unsigned int (*scalar)[3][32], int sblimit, int l,
1203 int m, int z, double (*sb_sample)[3][12][32])
1204
1205
1206
1207 /* (see above) */
1208 {
1209 int i, j, k, t;
1210 double s[SBLIMIT];
1211
1212 for (k = l; k < m; k++)
1213 for (t = 0; t < 3; t++) {
1214 for (i = ((z == 0) ? 0 : (sb_groups[z - 1] + 1)); i <= sb_groups[z]; i++) {
1215 for (j = 1, s[i] = fabs (sb_sample[k][t][0][i]); j < SCALE_BLOCK; j++)
1216 if (fabs (sb_sample[k][t][j][i]) > s[i])
1217 s[i] = fabs (sb_sample[k][t][j][i]);
1218 }
1219 for (i = ((z == 0) ? 0 : (sb_groups[z - 1] + 1)); i <= sb_groups[z]; i++) {
1220 for (j = SCALE_RANGE - 1, scalar[k][t][i] = 0; j >= 0; j--)
1221 if (s[i] < multiple[j]) { /* <= changed to <, 1992-11-06 shn */
1222 scalar[k][t][i] = j;
1223 break;
1224 }
1225 }
1226 }
1227 }
1228