Mercurial > libavcodec.hg

comparison ac3dec.c @ 5456:2335f18d1b47 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use floating-point mantissa dequantization tables
author jbr
date Sat, 04 Aug 2007 03:21:17 +0000
parents 5afadd8cad2a
children 0a5849a4858b
comparison
equal deleted inserted replaced
5455:5afadd8cad2a 5456:2335f18d1b47
50 static float scale_factors[25]; 50 static float scale_factors[25];
51 51
52 /** table for grouping exponents */ 52 /** table for grouping exponents */
53 static uint8_t exp_ungroup_tbl[128][3]; 53 static uint8_t exp_ungroup_tbl[128][3];
54 54
55 static int16_t l3_quantizers_1[32]; 55
56 static int16_t l3_quantizers_2[32]; 56 /** tables for ungrouping mantissas */
57 static int16_t l3_quantizers_3[32]; 57 static float b1_mantissas[32][3];
58 58 static float b2_mantissas[128][3];
59 static int16_t l5_quantizers_1[128]; 59 static float b3_mantissas[8];
60 static int16_t l5_quantizers_2[128]; 60 static float b4_mantissas[128][2];
61 static int16_t l5_quantizers_3[128]; 61 static float b5_mantissas[16];
62 62
63 static int16_t l7_quantizers[7]; 63 /**
64 64 * Quantization table: levels for symmetric. bits for asymmetric.
65 static int16_t l11_quantizers_1[128]; 65 * reference: Table 7.18 Mapping of bap to Quantizer
66 static int16_t l11_quantizers_2[128]; 66 */
67 67 static const uint8_t qntztab[16] = {
68 static int16_t l15_quantizers[15]; 68 0, 3, 5, 7, 11, 15,
69 69 5, 6, 7, 8, 9, 10, 11, 12, 14, 16
70 static const uint8_t qntztab[16] = { 0, 5, 7, 3, 7, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16 }; 70 };
71 71
72 /* Adjustmens in dB gain */ 72 /* Adjustmens in dB gain */
73 #define LEVEL_MINUS_3DB 0.7071067811865476 73 #define LEVEL_MINUS_3DB 0.7071067811865476
74 #define LEVEL_MINUS_4POINT5DB 0.5946035575013605 74 #define LEVEL_MINUS_4POINT5DB 0.5946035575013605
75 #define LEVEL_MINUS_6DB 0.5000000000000000 75 #define LEVEL_MINUS_6DB 0.5000000000000000
191 sum++; 191 sum++;
192 for (i = 0; i < 256; i++) 192 for (i = 0; i < 256; i++)
193 window[i] = sqrt(local_window[i] / sum); 193 window[i] = sqrt(local_window[i] / sum);
194 } 194 }
195 195
196 /* 196 static inline float
197 * Generate quantizer tables. 197 symmetric_dequant(int code, int levels)
198 */ 198 {
199 static void generate_quantizers_table(int16_t quantizers[], int level, int length) 199 return (code - (levels >> 1)) * (2.0f / levels);
200 {
201 int i;
202
203 for (i = 0; i < length; i++)
204 quantizers[i] = ((2 * i - level + 1) << 15) / level;
205 }
206
207 static void generate_quantizers_table_1(int16_t quantizers[], int level, int length1, int length2, int size)
208 {
209 int i, j;
210 int16_t v;
211
212 for (i = 0; i < length1; i++) {
213 v = ((2 * i - level + 1) << 15) / level;
214 for (j = 0; j < length2; j++)
215 quantizers[i * length2 + j] = v;
216 }
217
218 for (i = length1 * length2; i < size; i++)
219 quantizers[i] = 0;
220 }
221
222 static void generate_quantizers_table_2(int16_t quantizers[], int level, int length1, int length2, int size)
223 {
224 int i, j;
225 int16_t v;
226
227 for (i = 0; i < length1; i++) {
228 v = ((2 * (i % level) - level + 1) << 15) / level;
229 for (j = 0; j < length2; j++)
230 quantizers[i * length2 + j] = v;
231 }
232
233 for (i = length1 * length2; i < size; i++)
234 quantizers[i] = 0;
235
236 }
237
238 static void generate_quantizers_table_3(int16_t quantizers[], int level, int length1, int length2, int size)
239 {
240 int i, j;
241
242 for (i = 0; i < length1; i++)
243 for (j = 0; j < length2; j++)
244 quantizers[i * length2 + j] = ((2 * (j % level) - level + 1) << 15) / level;
245
246 for (i = length1 * length2; i < size; i++)
247 quantizers[i] = 0;
248 } 200 }
249 201
250 /* 202 /*
251 * Initialize tables at runtime. 203 * Initialize tables at runtime.
252 */ 204 */
253 static void ac3_tables_init(void) 205 static void ac3_tables_init(void)
254 { 206 {
255 int i; 207 int i;
256 208
257 /* Quantizer ungrouping tables. */ 209 /* generate grouped mantissa tables
258 // for level-3 quantizers 210 reference: Section 7.3.5 Ungrouping of Mantissas */
259 generate_quantizers_table_1(l3_quantizers_1, 3, 3, 9, 32); 211 for(i=0; i<32; i++) {
260 generate_quantizers_table_2(l3_quantizers_2, 3, 9, 3, 32); 212 /* bap=1 mantissas */
261 generate_quantizers_table_3(l3_quantizers_3, 3, 9, 3, 32); 213 b1_mantissas[i][0] = symmetric_dequant( i / 9 , 3);
262 214 b1_mantissas[i][1] = symmetric_dequant((i % 9) / 3, 3);
263 //for level-5 quantizers 215 b1_mantissas[i][2] = symmetric_dequant((i % 9) % 3, 3);
264 generate_quantizers_table_1(l5_quantizers_1, 5, 5, 25, 128); 216 }
265 generate_quantizers_table_2(l5_quantizers_2, 5, 25, 5, 128); 217 for(i=0; i<128; i++) {
266 generate_quantizers_table_3(l5_quantizers_3, 5, 25, 5, 128); 218 /* bap=2 mantissas */
267 219 b2_mantissas[i][0] = symmetric_dequant( i / 25 , 5);
268 //for level-7 quantizers 220 b2_mantissas[i][1] = symmetric_dequant((i % 25) / 5, 5);
269 generate_quantizers_table(l7_quantizers, 7, 7); 221 b2_mantissas[i][2] = symmetric_dequant((i % 25) % 5, 5);
270 222
271 //for level-4 quantizers 223 /* bap=4 mantissas */
272 generate_quantizers_table_2(l11_quantizers_1, 11, 11, 11, 128); 224 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
273 generate_quantizers_table_3(l11_quantizers_2, 11, 11, 11, 128); 225 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
274 226 }
275 //for level-15 quantizers 227 /* generate ungrouped mantissa tables
276 generate_quantizers_table(l15_quantizers, 15, 15); 228 reference: Tables 7.21 and 7.23 */
277 /* End Quantizer ungrouping tables. */ 229 for(i=0; i<7; i++) {
230 /* bap=3 mantissas */
231 b3_mantissas[i] = symmetric_dequant(i, 7);
232 }
233 for(i=0; i<15; i++) {
234 /* bap=5 mantissas */
235 b5_mantissas[i] = symmetric_dequant(i, 15);
236 }
278 237
279 //generate scale factors 238 //generate scale factors
280 for (i = 0; i < 25; i++) 239 for (i = 0; i < 25; i++)
281 scale_factors[i] = pow(2.0, -(i + 15)); 240 scale_factors[i] = pow(2.0, -i);
282 241
283 /* generate exponent tables 242 /* generate exponent tables
284 reference: Section 7.1.3 Exponent Decoding */ 243 reference: Section 7.1.3 Exponent Decoding */
285 for(i=0; i<128; i++) { 244 for(i=0; i<128; i++) {
286 exp_ungroup_tbl[i][0] = i / 25; 245 exp_ungroup_tbl[i][0] = i / 25;
438 do { 397 do {
439 subbnd++; 398 subbnd++;
440 for(j=0; j<12; j++) { 399 for(j=0; j<12; j++) {
441 for(ch=1; ch<=ctx->nfchans; ch++) { 400 for(ch=1; ch<=ctx->nfchans; ch++) {
442 if(ctx->chincpl[ch-1]) 401 if(ctx->chincpl[ch-1])
443 ctx->transform_coeffs[ch][i] = ctx->transform_coeffs_cpl[i] * ctx->cplco[ch-1][bnd]; 402 ctx->transform_coeffs[ch][i] = ctx->transform_coeffs_cpl[i] * ctx->cplco[ch-1][bnd] * 8.0f;
444 } 403 }
445 i++; 404 i++;
446 } 405 }
447 } while((ctx->cplbndstrc >> subbnd) & 1); 406 } while((ctx->cplbndstrc >> subbnd) & 1);
448 } 407 }
449 } 408 }
450 409
451 typedef struct { /* grouped mantissas for 3-level 5-leve and 11-level quantization */ 410 typedef struct { /* grouped mantissas for 3-level 5-leve and 11-level quantization */
452 int16_t l3_quantizers[3]; 411 float b1_mant[3];
453 int16_t l5_quantizers[3]; 412 float b2_mant[3];
454 int16_t l11_quantizers[2]; 413 float b4_mant[2];
455 int l3ptr; 414 int b1ptr;
456 int l5ptr; 415 int b2ptr;
457 int l11ptr; 416 int b4ptr;
458 } mant_groups; 417 } mant_groups;
459 418
460 /* Get the transform coefficients for particular channel */ 419 /* Get the transform coefficients for particular channel */
461 static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_groups *m) 420 static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_groups *m)
462 { 421 {
489 448
490 for (i = start; i < end; i++) { 449 for (i = start; i < end; i++) {
491 tbap = bap[i]; 450 tbap = bap[i];
492 switch (tbap) { 451 switch (tbap) {
493 case 0: 452 case 0:
494 coeffs[i] = (av_random(&ctx->dith_state) & 0xFFFF) * LEVEL_MINUS_3DB; 453 coeffs[i] = ((av_random(&ctx->dith_state) & 0xFFFF) * LEVEL_MINUS_3DB) / 32768.0f;
495 break; 454 break;
496 455
497 case 1: 456 case 1:
498 if (m->l3ptr > 2) { 457 if(m->b1ptr > 2) {
499 gcode = get_bits(gb, 5); 458 gcode = get_bits(gb, 5);
500 m->l3_quantizers[0] = l3_quantizers_1[gcode]; 459 m->b1_mant[0] = b1_mantissas[gcode][0];
501 m->l3_quantizers[1] = l3_quantizers_2[gcode]; 460 m->b1_mant[1] = b1_mantissas[gcode][1];
502 m->l3_quantizers[2] = l3_quantizers_3[gcode]; 461 m->b1_mant[2] = b1_mantissas[gcode][2];
503 m->l3ptr = 0; 462 m->b1ptr = 0;
504 } 463 }
505 coeffs[i] = m->l3_quantizers[m->l3ptr++]; 464 coeffs[i] = m->b1_mant[m->b1ptr++];
506 break; 465 break;
507 466
508 case 2: 467 case 2:
509 if (m->l5ptr > 2) { 468 if(m->b2ptr > 2) {
510 gcode = get_bits(gb, 7); 469 gcode = get_bits(gb, 7);
511 m->l5_quantizers[0] = l5_quantizers_1[gcode]; 470 m->b2_mant[0] = b2_mantissas[gcode][0];
512 m->l5_quantizers[1] = l5_quantizers_2[gcode]; 471 m->b2_mant[1] = b2_mantissas[gcode][1];
513 m->l5_quantizers[2] = l5_quantizers_3[gcode]; 472 m->b2_mant[2] = b2_mantissas[gcode][2];
514 m->l5ptr = 0; 473 m->b2ptr = 0;
515 } 474 }
516 coeffs[i] = m->l5_quantizers[m->l5ptr++]; 475 coeffs[i] = m->b2_mant[m->b2ptr++];
517 break; 476 break;
518 477
519 case 3: 478 case 3:
520 coeffs[i] = l7_quantizers[get_bits(gb, 3)]; 479 coeffs[i] = b3_mantissas[get_bits(gb, 3)];
521 break; 480 break;
522 481
523 case 4: 482 case 4:
524 if (m->l11ptr > 1) { 483 if(m->b4ptr > 1) {
525 gcode = get_bits(gb, 7); 484 gcode = get_bits(gb, 7);
526 m->l11_quantizers[0] = l11_quantizers_1[gcode]; 485 m->b4_mant[0] = b4_mantissas[gcode][0];
527 m->l11_quantizers[1] = l11_quantizers_2[gcode]; 486 m->b4_mant[1] = b4_mantissas[gcode][1];
528 m->l11ptr = 0; 487 m->b4ptr = 0;
529 } 488 }
530 coeffs[i] = m->l11_quantizers[m->l11ptr++]; 489 coeffs[i] = m->b4_mant[m->b4ptr++];
531 break; 490 break;
532 491
533 case 5: 492 case 5:
534 coeffs[i] = l15_quantizers[get_bits(gb, 4)]; 493 coeffs[i] = b5_mantissas[get_bits(gb, 4)];
535 break; 494 break;
536 495
537 default: 496 default:
538 coeffs[i] = get_sbits(gb, qntztab[tbap]) << (16 - qntztab[tbap]); 497 coeffs[i] = get_sbits(gb, qntztab[tbap]) * scale_factors[qntztab[tbap]-1];
539 break; 498 break;
540 } 499 }
541 coeffs[i] *= scale_factors[exps[i]]; 500 coeffs[i] *= scale_factors[exps[i]];
542 } 501 }
543 502
585 { 544 {
586 int i, end; 545 int i, end;
587 int got_cplchan = 0; 546 int got_cplchan = 0;
588 mant_groups m; 547 mant_groups m;
589 548
590 m.l3ptr = m.l5ptr = m.l11ptr = 3; 549 m.b1ptr = m.b2ptr = m.b4ptr = 3;
591 550
592 for (i = 0; i < ctx->nfchans; i++) { 551 for (i = 0; i < ctx->nfchans; i++) {
593 /* transform coefficients for individual channel */ 552 /* transform coefficients for individual channel */
594 if (get_transform_coeffs_ch(ctx, i, &m)) 553 if (get_transform_coeffs_ch(ctx, i, &m))
595 return -1; 554 return -1;
745 ctx->dither_all = 0; 704 ctx->dither_all = 0;
746 } 705 }
747 706
748 if (get_bits1(gb)) { /* dynamic range */ 707 if (get_bits1(gb)) { /* dynamic range */
749 dynrng = get_sbits(gb, 8); 708 dynrng = get_sbits(gb, 8);
750 ctx->dynrng = ((((dynrng & 0x1f) | 0x20) << 13) * scale_factors[3 - (dynrng >> 5)]); 709 ctx->dynrng = (((dynrng & 0x1f) | 0x20) << 13) * pow(2.0, -(18 - (dynrng >> 5)));
751 } else if(blk == 0) { 710 } else if(blk == 0) {
752 ctx->dynrng = 1.0; 711 ctx->dynrng = 1.0;
753 } 712 }
754 713
755 if(acmod == AC3_ACMOD_DUALMONO) { /* dynamic range 1+1 mode */ 714 if(acmod == AC3_ACMOD_DUALMONO) { /* dynamic range 1+1 mode */
756 if(get_bits1(gb)) { 715 if(get_bits1(gb)) {
757 dynrng = get_sbits(gb, 8); 716 dynrng = get_sbits(gb, 8);
758 ctx->dynrng2 = ((((dynrng & 0x1f) | 0x20) << 13) * scale_factors[3 - (dynrng >> 5)]); 717 ctx->dynrng2 = (((dynrng & 0x1f) | 0x20) << 13) * pow(2.0, -(18 - (dynrng >> 5)));
759 } else if(blk == 0) { 718 } else if(blk == 0) {
760 ctx->dynrng2 = 1.0; 719 ctx->dynrng2 = 1.0;
761 } 720 }
762 } 721 }
763 722
805 mstrcplco = 3 * get_bits(gb, 2); 764 mstrcplco = 3 * get_bits(gb, 2);
806 for (bnd = 0; bnd < ctx->ncplbnd; bnd++) { 765 for (bnd = 0; bnd < ctx->ncplbnd; bnd++) {
807 cplcoexp = get_bits(gb, 4); 766 cplcoexp = get_bits(gb, 4);
808 cplcomant = get_bits(gb, 4); 767 cplcomant = get_bits(gb, 4);
809 if (cplcoexp == 15) 768 if (cplcoexp == 15)
810 cplcomant <<= 14; 769 ctx->cplco[i][bnd] = cplcomant / 16.0f;
811 else 770 else
812 cplcomant = (cplcomant | 0x10) << 13; 771 ctx->cplco[i][bnd] = (cplcomant + 16.0f) / 32.0f;
813 ctx->cplco[i][bnd] = cplcomant * scale_factors[cplcoexp + mstrcplco]; 772 ctx->cplco[i][bnd] *= scale_factors[cplcoexp + mstrcplco];
814 } 773 }
815 } 774 }
816 775
817 if (acmod == AC3_ACMOD_STEREO && ctx->phsflginu && (ctx->cplcoe & 1 || ctx->cplcoe & 2)) 776 if (acmod == AC3_ACMOD_STEREO && ctx->phsflginu && (ctx->cplcoe & 1 || ctx->cplcoe & 2))
818 for (bnd = 0; bnd < ctx->ncplbnd; bnd++) 777 for (bnd = 0; bnd < ctx->ncplbnd; bnd++)