Mercurial > libavcodec.hg
comparison ac3dec.c @ 6090:b7b19fbc4746 libavcodec
cosmetics: rename all AC3DecodeContext variables from ctx to s
author | jbr |
---|---|
date | Sun, 30 Dec 2007 20:58:50 +0000 |
parents | 12a77958941f |
children | c365f7b83133 |
comparison
equal
deleted
inserted
replaced
6089:12a77958941f | 6090:b7b19fbc4746 |
---|---|
289 /** | 289 /** |
290 * AVCodec initialization | 290 * AVCodec initialization |
291 */ | 291 */ |
292 static int ac3_decode_init(AVCodecContext *avctx) | 292 static int ac3_decode_init(AVCodecContext *avctx) |
293 { | 293 { |
294 AC3DecodeContext *ctx = avctx->priv_data; | 294 AC3DecodeContext *s = avctx->priv_data; |
295 ctx->avctx = avctx; | 295 s->avctx = avctx; |
296 | 296 |
297 ac3_common_init(); | 297 ac3_common_init(); |
298 ac3_tables_init(); | 298 ac3_tables_init(); |
299 ff_mdct_init(&ctx->imdct_256, 8, 1); | 299 ff_mdct_init(&s->imdct_256, 8, 1); |
300 ff_mdct_init(&ctx->imdct_512, 9, 1); | 300 ff_mdct_init(&s->imdct_512, 9, 1); |
301 ac3_window_init(ctx->window); | 301 ac3_window_init(s->window); |
302 dsputil_init(&ctx->dsp, avctx); | 302 dsputil_init(&s->dsp, avctx); |
303 av_init_random(0, &ctx->dith_state); | 303 av_init_random(0, &s->dith_state); |
304 | 304 |
305 /* set bias values for float to int16 conversion */ | 305 /* set bias values for float to int16 conversion */ |
306 if(ctx->dsp.float_to_int16 == ff_float_to_int16_c) { | 306 if(s->dsp.float_to_int16 == ff_float_to_int16_c) { |
307 ctx->add_bias = 385.0f; | 307 s->add_bias = 385.0f; |
308 ctx->mul_bias = 1.0f; | 308 s->mul_bias = 1.0f; |
309 } else { | 309 } else { |
310 ctx->add_bias = 0.0f; | 310 s->add_bias = 0.0f; |
311 ctx->mul_bias = 32767.0f; | 311 s->mul_bias = 32767.0f; |
312 } | 312 } |
313 | 313 |
314 return 0; | 314 return 0; |
315 } | 315 } |
316 | 316 |
317 /** | 317 /** |
318 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream. | 318 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream. |
319 * GetBitContext within AC3DecodeContext must point to | 319 * GetBitContext within AC3DecodeContext must point to |
320 * start of the synchronized ac3 bitstream. | 320 * start of the synchronized ac3 bitstream. |
321 */ | 321 */ |
322 static int ac3_parse_header(AC3DecodeContext *ctx) | 322 static int ac3_parse_header(AC3DecodeContext *s) |
323 { | 323 { |
324 AC3HeaderInfo hdr; | 324 AC3HeaderInfo hdr; |
325 GetBitContext *gbc = &ctx->gbc; | 325 GetBitContext *gbc = &s->gbc; |
326 float center_mix_level, surround_mix_level; | 326 float center_mix_level, surround_mix_level; |
327 int err, i; | 327 int err, i; |
328 | 328 |
329 err = ff_ac3_parse_header(gbc->buffer, &hdr); | 329 err = ff_ac3_parse_header(gbc->buffer, &hdr); |
330 if(err) | 330 if(err) |
331 return err; | 331 return err; |
332 | 332 |
333 /* get decoding parameters from header info */ | 333 /* get decoding parameters from header info */ |
334 ctx->bit_alloc_params.sr_code = hdr.sr_code; | 334 s->bit_alloc_params.sr_code = hdr.sr_code; |
335 ctx->channel_mode = hdr.channel_mode; | 335 s->channel_mode = hdr.channel_mode; |
336 center_mix_level = gain_levels[center_levels[hdr.center_mix_level]]; | 336 center_mix_level = gain_levels[center_levels[hdr.center_mix_level]]; |
337 surround_mix_level = gain_levels[surround_levels[hdr.surround_mix_level]]; | 337 surround_mix_level = gain_levels[surround_levels[hdr.surround_mix_level]]; |
338 ctx->lfe_on = hdr.lfe_on; | 338 s->lfe_on = hdr.lfe_on; |
339 ctx->bit_alloc_params.sr_shift = hdr.sr_shift; | 339 s->bit_alloc_params.sr_shift = hdr.sr_shift; |
340 ctx->sampling_rate = hdr.sample_rate; | 340 s->sampling_rate = hdr.sample_rate; |
341 ctx->bit_rate = hdr.bit_rate; | 341 s->bit_rate = hdr.bit_rate; |
342 ctx->channels = hdr.channels; | 342 s->channels = hdr.channels; |
343 ctx->fbw_channels = ctx->channels - ctx->lfe_on; | 343 s->fbw_channels = s->channels - s->lfe_on; |
344 ctx->lfe_ch = ctx->fbw_channels + 1; | 344 s->lfe_ch = s->fbw_channels + 1; |
345 ctx->frame_size = hdr.frame_size; | 345 s->frame_size = hdr.frame_size; |
346 | 346 |
347 /* set default output to all source channels */ | 347 /* set default output to all source channels */ |
348 ctx->out_channels = ctx->channels; | 348 s->out_channels = s->channels; |
349 ctx->output_mode = ctx->channel_mode; | 349 s->output_mode = s->channel_mode; |
350 if(ctx->lfe_on) | 350 if(s->lfe_on) |
351 ctx->output_mode |= AC3_OUTPUT_LFEON; | 351 s->output_mode |= AC3_OUTPUT_LFEON; |
352 | 352 |
353 /* skip over portion of header which has already been read */ | 353 /* skip over portion of header which has already been read */ |
354 skip_bits(gbc, 16); // skip the sync_word | 354 skip_bits(gbc, 16); // skip the sync_word |
355 skip_bits(gbc, 16); // skip crc1 | 355 skip_bits(gbc, 16); // skip crc1 |
356 skip_bits(gbc, 8); // skip fscod and frmsizecod | 356 skip_bits(gbc, 8); // skip fscod and frmsizecod |
357 skip_bits(gbc, 11); // skip bsid, bsmod, and acmod | 357 skip_bits(gbc, 11); // skip bsid, bsmod, and acmod |
358 if(ctx->channel_mode == AC3_CHMODE_STEREO) { | 358 if(s->channel_mode == AC3_CHMODE_STEREO) { |
359 skip_bits(gbc, 2); // skip dsurmod | 359 skip_bits(gbc, 2); // skip dsurmod |
360 } else { | 360 } else { |
361 if((ctx->channel_mode & 1) && ctx->channel_mode != AC3_CHMODE_MONO) | 361 if((s->channel_mode & 1) && s->channel_mode != AC3_CHMODE_MONO) |
362 skip_bits(gbc, 2); // skip cmixlev | 362 skip_bits(gbc, 2); // skip cmixlev |
363 if(ctx->channel_mode & 4) | 363 if(s->channel_mode & 4) |
364 skip_bits(gbc, 2); // skip surmixlev | 364 skip_bits(gbc, 2); // skip surmixlev |
365 } | 365 } |
366 skip_bits1(gbc); // skip lfeon | 366 skip_bits1(gbc); // skip lfeon |
367 | 367 |
368 /* read the rest of the bsi. read twice for dual mono mode. */ | 368 /* read the rest of the bsi. read twice for dual mono mode. */ |
369 i = !(ctx->channel_mode); | 369 i = !(s->channel_mode); |
370 do { | 370 do { |
371 skip_bits(gbc, 5); // skip dialog normalization | 371 skip_bits(gbc, 5); // skip dialog normalization |
372 if (get_bits1(gbc)) | 372 if (get_bits1(gbc)) |
373 skip_bits(gbc, 8); //skip compression | 373 skip_bits(gbc, 8); //skip compression |
374 if (get_bits1(gbc)) | 374 if (get_bits1(gbc)) |
394 } while(i--); | 394 } while(i--); |
395 } | 395 } |
396 | 396 |
397 /* set stereo downmixing coefficients | 397 /* set stereo downmixing coefficients |
398 reference: Section 7.8.2 Downmixing Into Two Channels */ | 398 reference: Section 7.8.2 Downmixing Into Two Channels */ |
399 for(i=0; i<ctx->fbw_channels; i++) { | 399 for(i=0; i<s->fbw_channels; i++) { |
400 ctx->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[ctx->channel_mode][i][0]]; | 400 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]]; |
401 ctx->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[ctx->channel_mode][i][1]]; | 401 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]]; |
402 } | 402 } |
403 if(ctx->channel_mode > 1 && ctx->channel_mode & 1) { | 403 if(s->channel_mode > 1 && s->channel_mode & 1) { |
404 ctx->downmix_coeffs[1][0] = ctx->downmix_coeffs[1][1] = center_mix_level; | 404 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = center_mix_level; |
405 } | 405 } |
406 if(ctx->channel_mode == AC3_CHMODE_2F1R || ctx->channel_mode == AC3_CHMODE_3F1R) { | 406 if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) { |
407 int nf = ctx->channel_mode - 2; | 407 int nf = s->channel_mode - 2; |
408 ctx->downmix_coeffs[nf][0] = ctx->downmix_coeffs[nf][1] = surround_mix_level * LEVEL_MINUS_3DB; | 408 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = surround_mix_level * LEVEL_MINUS_3DB; |
409 } | 409 } |
410 if(ctx->channel_mode == AC3_CHMODE_2F2R || ctx->channel_mode == AC3_CHMODE_3F2R) { | 410 if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) { |
411 int nf = ctx->channel_mode - 4; | 411 int nf = s->channel_mode - 4; |
412 ctx->downmix_coeffs[nf][0] = ctx->downmix_coeffs[nf+1][1] = surround_mix_level; | 412 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = surround_mix_level; |
413 } | 413 } |
414 | 414 |
415 return 0; | 415 return 0; |
416 } | 416 } |
417 | 417 |
448 /** | 448 /** |
449 * Generate transform coefficients for each coupled channel in the coupling | 449 * Generate transform coefficients for each coupled channel in the coupling |
450 * range using the coupling coefficients and coupling coordinates. | 450 * range using the coupling coefficients and coupling coordinates. |
451 * reference: Section 7.4.3 Coupling Coordinate Format | 451 * reference: Section 7.4.3 Coupling Coordinate Format |
452 */ | 452 */ |
453 static void uncouple_channels(AC3DecodeContext *ctx) | 453 static void uncouple_channels(AC3DecodeContext *s) |
454 { | 454 { |
455 int i, j, ch, bnd, subbnd; | 455 int i, j, ch, bnd, subbnd; |
456 | 456 |
457 subbnd = -1; | 457 subbnd = -1; |
458 i = ctx->start_freq[CPL_CH]; | 458 i = s->start_freq[CPL_CH]; |
459 for(bnd=0; bnd<ctx->num_cpl_bands; bnd++) { | 459 for(bnd=0; bnd<s->num_cpl_bands; bnd++) { |
460 do { | 460 do { |
461 subbnd++; | 461 subbnd++; |
462 for(j=0; j<12; j++) { | 462 for(j=0; j<12; j++) { |
463 for(ch=1; ch<=ctx->fbw_channels; ch++) { | 463 for(ch=1; ch<=s->fbw_channels; ch++) { |
464 if(ctx->channel_in_cpl[ch]) | 464 if(s->channel_in_cpl[ch]) |
465 ctx->transform_coeffs[ch][i] = ctx->transform_coeffs[CPL_CH][i] * ctx->cpl_coords[ch][bnd] * 8.0f; | 465 s->transform_coeffs[ch][i] = s->transform_coeffs[CPL_CH][i] * s->cpl_coords[ch][bnd] * 8.0f; |
466 } | 466 } |
467 i++; | 467 i++; |
468 } | 468 } |
469 } while(ctx->cpl_band_struct[subbnd]); | 469 } while(s->cpl_band_struct[subbnd]); |
470 } | 470 } |
471 } | 471 } |
472 | 472 |
473 /** | 473 /** |
474 * Grouped mantissas for 3-level 5-level and 11-level quantization | 474 * Grouped mantissas for 3-level 5-level and 11-level quantization |
484 | 484 |
485 /** | 485 /** |
486 * Get the transform coefficients for a particular channel | 486 * Get the transform coefficients for a particular channel |
487 * reference: Section 7.3 Quantization and Decoding of Mantissas | 487 * reference: Section 7.3 Quantization and Decoding of Mantissas |
488 */ | 488 */ |
489 static int get_transform_coeffs_ch(AC3DecodeContext *ctx, int ch_index, mant_groups *m) | 489 static int get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m) |
490 { | 490 { |
491 GetBitContext *gbc = &ctx->gbc; | 491 GetBitContext *gbc = &s->gbc; |
492 int i, gcode, tbap, start, end; | 492 int i, gcode, tbap, start, end; |
493 uint8_t *exps; | 493 uint8_t *exps; |
494 uint8_t *bap; | 494 uint8_t *bap; |
495 float *coeffs; | 495 float *coeffs; |
496 | 496 |
497 exps = ctx->dexps[ch_index]; | 497 exps = s->dexps[ch_index]; |
498 bap = ctx->bap[ch_index]; | 498 bap = s->bap[ch_index]; |
499 coeffs = ctx->transform_coeffs[ch_index]; | 499 coeffs = s->transform_coeffs[ch_index]; |
500 start = ctx->start_freq[ch_index]; | 500 start = s->start_freq[ch_index]; |
501 end = ctx->end_freq[ch_index]; | 501 end = s->end_freq[ch_index]; |
502 | 502 |
503 for (i = start; i < end; i++) { | 503 for (i = start; i < end; i++) { |
504 tbap = bap[i]; | 504 tbap = bap[i]; |
505 switch (tbap) { | 505 switch (tbap) { |
506 case 0: | 506 case 0: |
507 coeffs[i] = ((av_random(&ctx->dith_state) & 0xFFFF) / 65535.0f) - 0.5f; | 507 coeffs[i] = ((av_random(&s->dith_state) & 0xFFFF) / 65535.0f) - 0.5f; |
508 break; | 508 break; |
509 | 509 |
510 case 1: | 510 case 1: |
511 if(m->b1ptr > 2) { | 511 if(m->b1ptr > 2) { |
512 gcode = get_bits(gbc, 5); | 512 gcode = get_bits(gbc, 5); |
560 | 560 |
561 /** | 561 /** |
562 * Remove random dithering from coefficients with zero-bit mantissas | 562 * Remove random dithering from coefficients with zero-bit mantissas |
563 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0) | 563 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0) |
564 */ | 564 */ |
565 static void remove_dithering(AC3DecodeContext *ctx) { | 565 static void remove_dithering(AC3DecodeContext *s) { |
566 int ch, i; | 566 int ch, i; |
567 int end=0; | 567 int end=0; |
568 float *coeffs; | 568 float *coeffs; |
569 uint8_t *bap; | 569 uint8_t *bap; |
570 | 570 |
571 for(ch=1; ch<=ctx->fbw_channels; ch++) { | 571 for(ch=1; ch<=s->fbw_channels; ch++) { |
572 if(!ctx->dither_flag[ch]) { | 572 if(!s->dither_flag[ch]) { |
573 coeffs = ctx->transform_coeffs[ch]; | 573 coeffs = s->transform_coeffs[ch]; |
574 bap = ctx->bap[ch]; | 574 bap = s->bap[ch]; |
575 if(ctx->channel_in_cpl[ch]) | 575 if(s->channel_in_cpl[ch]) |
576 end = ctx->start_freq[CPL_CH]; | 576 end = s->start_freq[CPL_CH]; |
577 else | 577 else |
578 end = ctx->end_freq[ch]; | 578 end = s->end_freq[ch]; |
579 for(i=0; i<end; i++) { | 579 for(i=0; i<end; i++) { |
580 if(bap[i] == 0) | 580 if(bap[i] == 0) |
581 coeffs[i] = 0.0f; | 581 coeffs[i] = 0.0f; |
582 } | 582 } |
583 if(ctx->channel_in_cpl[ch]) { | 583 if(s->channel_in_cpl[ch]) { |
584 bap = ctx->bap[CPL_CH]; | 584 bap = s->bap[CPL_CH]; |
585 for(; i<ctx->end_freq[CPL_CH]; i++) { | 585 for(; i<s->end_freq[CPL_CH]; i++) { |
586 if(bap[i] == 0) | 586 if(bap[i] == 0) |
587 coeffs[i] = 0.0f; | 587 coeffs[i] = 0.0f; |
588 } | 588 } |
589 } | 589 } |
590 } | 590 } |
592 } | 592 } |
593 | 593 |
594 /** | 594 /** |
595 * Get the transform coefficients. | 595 * Get the transform coefficients. |
596 */ | 596 */ |
597 static int get_transform_coeffs(AC3DecodeContext * ctx) | 597 static int get_transform_coeffs(AC3DecodeContext *s) |
598 { | 598 { |
599 int ch, end; | 599 int ch, end; |
600 int got_cplchan = 0; | 600 int got_cplchan = 0; |
601 mant_groups m; | 601 mant_groups m; |
602 | 602 |
603 m.b1ptr = m.b2ptr = m.b4ptr = 3; | 603 m.b1ptr = m.b2ptr = m.b4ptr = 3; |
604 | 604 |
605 for (ch = 1; ch <= ctx->channels; ch++) { | 605 for (ch = 1; ch <= s->channels; ch++) { |
606 /* transform coefficients for full-bandwidth channel */ | 606 /* transform coefficients for full-bandwidth channel */ |
607 if (get_transform_coeffs_ch(ctx, ch, &m)) | 607 if (get_transform_coeffs_ch(s, ch, &m)) |
608 return -1; | 608 return -1; |
609 /* tranform coefficients for coupling channel come right after the | 609 /* tranform coefficients for coupling channel come right after the |
610 coefficients for the first coupled channel*/ | 610 coefficients for the first coupled channel*/ |
611 if (ctx->channel_in_cpl[ch]) { | 611 if (s->channel_in_cpl[ch]) { |
612 if (!got_cplchan) { | 612 if (!got_cplchan) { |
613 if (get_transform_coeffs_ch(ctx, CPL_CH, &m)) { | 613 if (get_transform_coeffs_ch(s, CPL_CH, &m)) { |
614 av_log(ctx->avctx, AV_LOG_ERROR, "error in decoupling channels\n"); | 614 av_log(s->avctx, AV_LOG_ERROR, "error in decoupling channels\n"); |
615 return -1; | 615 return -1; |
616 } | 616 } |
617 uncouple_channels(ctx); | 617 uncouple_channels(s); |
618 got_cplchan = 1; | 618 got_cplchan = 1; |
619 } | 619 } |
620 end = ctx->end_freq[CPL_CH]; | 620 end = s->end_freq[CPL_CH]; |
621 } else { | 621 } else { |
622 end = ctx->end_freq[ch]; | 622 end = s->end_freq[ch]; |
623 } | 623 } |
624 do | 624 do |
625 ctx->transform_coeffs[ch][end] = 0; | 625 s->transform_coeffs[ch][end] = 0; |
626 while(++end < 256); | 626 while(++end < 256); |
627 } | 627 } |
628 | 628 |
629 /* if any channel doesn't use dithering, zero appropriate coefficients */ | 629 /* if any channel doesn't use dithering, zero appropriate coefficients */ |
630 if(!ctx->dither_all) | 630 if(!s->dither_all) |
631 remove_dithering(ctx); | 631 remove_dithering(s); |
632 | 632 |
633 return 0; | 633 return 0; |
634 } | 634 } |
635 | 635 |
636 /** | 636 /** |
637 * Stereo rematrixing. | 637 * Stereo rematrixing. |
638 * reference: Section 7.5.4 Rematrixing : Decoding Technique | 638 * reference: Section 7.5.4 Rematrixing : Decoding Technique |
639 */ | 639 */ |
640 static void do_rematrixing(AC3DecodeContext *ctx) | 640 static void do_rematrixing(AC3DecodeContext *s) |
641 { | 641 { |
642 int bnd, i; | 642 int bnd, i; |
643 int end, bndend; | 643 int end, bndend; |
644 float tmp0, tmp1; | 644 float tmp0, tmp1; |
645 | 645 |
646 end = FFMIN(ctx->end_freq[1], ctx->end_freq[2]); | 646 end = FFMIN(s->end_freq[1], s->end_freq[2]); |
647 | 647 |
648 for(bnd=0; bnd<ctx->num_rematrixing_bands; bnd++) { | 648 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) { |
649 if(ctx->rematrixing_flags[bnd]) { | 649 if(s->rematrixing_flags[bnd]) { |
650 bndend = FFMIN(end, rematrix_band_tab[bnd+1]); | 650 bndend = FFMIN(end, rematrix_band_tab[bnd+1]); |
651 for(i=rematrix_band_tab[bnd]; i<bndend; i++) { | 651 for(i=rematrix_band_tab[bnd]; i<bndend; i++) { |
652 tmp0 = ctx->transform_coeffs[1][i]; | 652 tmp0 = s->transform_coeffs[1][i]; |
653 tmp1 = ctx->transform_coeffs[2][i]; | 653 tmp1 = s->transform_coeffs[2][i]; |
654 ctx->transform_coeffs[1][i] = tmp0 + tmp1; | 654 s->transform_coeffs[1][i] = tmp0 + tmp1; |
655 ctx->transform_coeffs[2][i] = tmp0 - tmp1; | 655 s->transform_coeffs[2][i] = tmp0 - tmp1; |
656 } | 656 } |
657 } | 657 } |
658 } | 658 } |
659 } | 659 } |
660 | 660 |
661 /** | 661 /** |
662 * Perform the 256-point IMDCT | 662 * Perform the 256-point IMDCT |
663 */ | 663 */ |
664 static void do_imdct_256(AC3DecodeContext *ctx, int chindex) | 664 static void do_imdct_256(AC3DecodeContext *s, int chindex) |
665 { | 665 { |
666 int i, k; | 666 int i, k; |
667 DECLARE_ALIGNED_16(float, x[128]); | 667 DECLARE_ALIGNED_16(float, x[128]); |
668 FFTComplex z[2][64]; | 668 FFTComplex z[2][64]; |
669 float *o_ptr = ctx->tmp_output; | 669 float *o_ptr = s->tmp_output; |
670 | 670 |
671 for(i=0; i<2; i++) { | 671 for(i=0; i<2; i++) { |
672 /* de-interleave coefficients */ | 672 /* de-interleave coefficients */ |
673 for(k=0; k<128; k++) { | 673 for(k=0; k<128; k++) { |
674 x[k] = ctx->transform_coeffs[chindex][2*k+i]; | 674 x[k] = s->transform_coeffs[chindex][2*k+i]; |
675 } | 675 } |
676 | 676 |
677 /* run standard IMDCT */ | 677 /* run standard IMDCT */ |
678 ctx->imdct_256.fft.imdct_calc(&ctx->imdct_256, o_ptr, x, ctx->tmp_imdct); | 678 s->imdct_256.fft.imdct_calc(&s->imdct_256, o_ptr, x, s->tmp_imdct); |
679 | 679 |
680 /* reverse the post-rotation & reordering from standard IMDCT */ | 680 /* reverse the post-rotation & reordering from standard IMDCT */ |
681 for(k=0; k<32; k++) { | 681 for(k=0; k<32; k++) { |
682 z[i][32+k].re = -o_ptr[128+2*k]; | 682 z[i][32+k].re = -o_ptr[128+2*k]; |
683 z[i][32+k].im = -o_ptr[2*k]; | 683 z[i][32+k].im = -o_ptr[2*k]; |
702 /** | 702 /** |
703 * Inverse MDCT Transform. | 703 * Inverse MDCT Transform. |
704 * Convert frequency domain coefficients to time-domain audio samples. | 704 * Convert frequency domain coefficients to time-domain audio samples. |
705 * reference: Section 7.9.4 Transformation Equations | 705 * reference: Section 7.9.4 Transformation Equations |
706 */ | 706 */ |
707 static inline void do_imdct(AC3DecodeContext *ctx) | 707 static inline void do_imdct(AC3DecodeContext *s) |
708 { | 708 { |
709 int ch; | 709 int ch; |
710 int channels; | 710 int channels; |
711 | 711 |
712 /* Don't perform the IMDCT on the LFE channel unless it's used in the output */ | 712 /* Don't perform the IMDCT on the LFE channel unless it's used in the output */ |
713 channels = ctx->fbw_channels; | 713 channels = s->fbw_channels; |
714 if(ctx->output_mode & AC3_OUTPUT_LFEON) | 714 if(s->output_mode & AC3_OUTPUT_LFEON) |
715 channels++; | 715 channels++; |
716 | 716 |
717 for (ch=1; ch<=channels; ch++) { | 717 for (ch=1; ch<=channels; ch++) { |
718 if (ctx->block_switch[ch]) { | 718 if (s->block_switch[ch]) { |
719 do_imdct_256(ctx, ch); | 719 do_imdct_256(s, ch); |
720 } else { | 720 } else { |
721 ctx->imdct_512.fft.imdct_calc(&ctx->imdct_512, ctx->tmp_output, | 721 s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output, |
722 ctx->transform_coeffs[ch], | 722 s->transform_coeffs[ch], |
723 ctx->tmp_imdct); | 723 s->tmp_imdct); |
724 } | 724 } |
725 /* For the first half of the block, apply the window, add the delay | 725 /* For the first half of the block, apply the window, add the delay |
726 from the previous block, and send to output */ | 726 from the previous block, and send to output */ |
727 ctx->dsp.vector_fmul_add_add(ctx->output[ch-1], ctx->tmp_output, | 727 s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output, |
728 ctx->window, ctx->delay[ch-1], 0, 256, 1); | 728 s->window, s->delay[ch-1], 0, 256, 1); |
729 /* For the second half of the block, apply the window and store the | 729 /* For the second half of the block, apply the window and store the |
730 samples to delay, to be combined with the next block */ | 730 samples to delay, to be combined with the next block */ |
731 ctx->dsp.vector_fmul_reverse(ctx->delay[ch-1], ctx->tmp_output+256, | 731 s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256, |
732 ctx->window, 256); | 732 s->window, 256); |
733 } | 733 } |
734 } | 734 } |
735 | 735 |
736 /** | 736 /** |
737 * Downmix the output to mono or stereo. | 737 * Downmix the output to mono or stereo. |
762 } | 762 } |
763 | 763 |
764 /** | 764 /** |
765 * Parse an audio block from AC-3 bitstream. | 765 * Parse an audio block from AC-3 bitstream. |
766 */ | 766 */ |
767 static int ac3_parse_audio_block(AC3DecodeContext *ctx, int blk) | 767 static int ac3_parse_audio_block(AC3DecodeContext *s, int blk) |
768 { | 768 { |
769 int fbw_channels = ctx->fbw_channels; | 769 int fbw_channels = s->fbw_channels; |
770 int channel_mode = ctx->channel_mode; | 770 int channel_mode = s->channel_mode; |
771 int i, bnd, seg, ch; | 771 int i, bnd, seg, ch; |
772 GetBitContext *gbc = &ctx->gbc; | 772 GetBitContext *gbc = &s->gbc; |
773 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS]; | 773 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS]; |
774 | 774 |
775 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS); | 775 memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS); |
776 | 776 |
777 /* block switch flags */ | 777 /* block switch flags */ |
778 for (ch = 1; ch <= fbw_channels; ch++) | 778 for (ch = 1; ch <= fbw_channels; ch++) |
779 ctx->block_switch[ch] = get_bits1(gbc); | 779 s->block_switch[ch] = get_bits1(gbc); |
780 | 780 |
781 /* dithering flags */ | 781 /* dithering flags */ |
782 ctx->dither_all = 1; | 782 s->dither_all = 1; |
783 for (ch = 1; ch <= fbw_channels; ch++) { | 783 for (ch = 1; ch <= fbw_channels; ch++) { |
784 ctx->dither_flag[ch] = get_bits1(gbc); | 784 s->dither_flag[ch] = get_bits1(gbc); |
785 if(!ctx->dither_flag[ch]) | 785 if(!s->dither_flag[ch]) |
786 ctx->dither_all = 0; | 786 s->dither_all = 0; |
787 } | 787 } |
788 | 788 |
789 /* dynamic range */ | 789 /* dynamic range */ |
790 i = !(ctx->channel_mode); | 790 i = !(s->channel_mode); |
791 do { | 791 do { |
792 if(get_bits1(gbc)) { | 792 if(get_bits1(gbc)) { |
793 ctx->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) * | 793 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) * |
794 ctx->avctx->drc_scale)+1.0; | 794 s->avctx->drc_scale)+1.0; |
795 } else if(blk == 0) { | 795 } else if(blk == 0) { |
796 ctx->dynamic_range[i] = 1.0f; | 796 s->dynamic_range[i] = 1.0f; |
797 } | 797 } |
798 } while(i--); | 798 } while(i--); |
799 | 799 |
800 /* coupling strategy */ | 800 /* coupling strategy */ |
801 if (get_bits1(gbc)) { | 801 if (get_bits1(gbc)) { |
802 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); | 802 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); |
803 ctx->cpl_in_use = get_bits1(gbc); | 803 s->cpl_in_use = get_bits1(gbc); |
804 if (ctx->cpl_in_use) { | 804 if (s->cpl_in_use) { |
805 /* coupling in use */ | 805 /* coupling in use */ |
806 int cpl_begin_freq, cpl_end_freq; | 806 int cpl_begin_freq, cpl_end_freq; |
807 | 807 |
808 /* determine which channels are coupled */ | 808 /* determine which channels are coupled */ |
809 for (ch = 1; ch <= fbw_channels; ch++) | 809 for (ch = 1; ch <= fbw_channels; ch++) |
810 ctx->channel_in_cpl[ch] = get_bits1(gbc); | 810 s->channel_in_cpl[ch] = get_bits1(gbc); |
811 | 811 |
812 /* phase flags in use */ | 812 /* phase flags in use */ |
813 if (channel_mode == AC3_CHMODE_STEREO) | 813 if (channel_mode == AC3_CHMODE_STEREO) |
814 ctx->phase_flags_in_use = get_bits1(gbc); | 814 s->phase_flags_in_use = get_bits1(gbc); |
815 | 815 |
816 /* coupling frequency range and band structure */ | 816 /* coupling frequency range and band structure */ |
817 cpl_begin_freq = get_bits(gbc, 4); | 817 cpl_begin_freq = get_bits(gbc, 4); |
818 cpl_end_freq = get_bits(gbc, 4); | 818 cpl_end_freq = get_bits(gbc, 4); |
819 if (3 + cpl_end_freq - cpl_begin_freq < 0) { | 819 if (3 + cpl_end_freq - cpl_begin_freq < 0) { |
820 av_log(ctx->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq); | 820 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq); |
821 return -1; | 821 return -1; |
822 } | 822 } |
823 ctx->num_cpl_bands = ctx->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq; | 823 s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq; |
824 ctx->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37; | 824 s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37; |
825 ctx->end_freq[CPL_CH] = cpl_end_freq * 12 + 73; | 825 s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73; |
826 for (bnd = 0; bnd < ctx->num_cpl_subbands - 1; bnd++) { | 826 for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) { |
827 if (get_bits1(gbc)) { | 827 if (get_bits1(gbc)) { |
828 ctx->cpl_band_struct[bnd] = 1; | 828 s->cpl_band_struct[bnd] = 1; |
829 ctx->num_cpl_bands--; | 829 s->num_cpl_bands--; |
830 } | 830 } |
831 } | 831 } |
832 } else { | 832 } else { |
833 /* coupling not in use */ | 833 /* coupling not in use */ |
834 for (ch = 1; ch <= fbw_channels; ch++) | 834 for (ch = 1; ch <= fbw_channels; ch++) |
835 ctx->channel_in_cpl[ch] = 0; | 835 s->channel_in_cpl[ch] = 0; |
836 } | 836 } |
837 } | 837 } |
838 | 838 |
839 /* coupling coordinates */ | 839 /* coupling coordinates */ |
840 if (ctx->cpl_in_use) { | 840 if (s->cpl_in_use) { |
841 int cpl_coords_exist = 0; | 841 int cpl_coords_exist = 0; |
842 | 842 |
843 for (ch = 1; ch <= fbw_channels; ch++) { | 843 for (ch = 1; ch <= fbw_channels; ch++) { |
844 if (ctx->channel_in_cpl[ch]) { | 844 if (s->channel_in_cpl[ch]) { |
845 if (get_bits1(gbc)) { | 845 if (get_bits1(gbc)) { |
846 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant; | 846 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant; |
847 cpl_coords_exist = 1; | 847 cpl_coords_exist = 1; |
848 master_cpl_coord = 3 * get_bits(gbc, 2); | 848 master_cpl_coord = 3 * get_bits(gbc, 2); |
849 for (bnd = 0; bnd < ctx->num_cpl_bands; bnd++) { | 849 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { |
850 cpl_coord_exp = get_bits(gbc, 4); | 850 cpl_coord_exp = get_bits(gbc, 4); |
851 cpl_coord_mant = get_bits(gbc, 4); | 851 cpl_coord_mant = get_bits(gbc, 4); |
852 if (cpl_coord_exp == 15) | 852 if (cpl_coord_exp == 15) |
853 ctx->cpl_coords[ch][bnd] = cpl_coord_mant / 16.0f; | 853 s->cpl_coords[ch][bnd] = cpl_coord_mant / 16.0f; |
854 else | 854 else |
855 ctx->cpl_coords[ch][bnd] = (cpl_coord_mant + 16.0f) / 32.0f; | 855 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16.0f) / 32.0f; |
856 ctx->cpl_coords[ch][bnd] *= scale_factors[cpl_coord_exp + master_cpl_coord]; | 856 s->cpl_coords[ch][bnd] *= scale_factors[cpl_coord_exp + master_cpl_coord]; |
857 } | 857 } |
858 } | 858 } |
859 } | 859 } |
860 } | 860 } |
861 /* phase flags */ | 861 /* phase flags */ |
862 if (channel_mode == AC3_CHMODE_STEREO && ctx->phase_flags_in_use && cpl_coords_exist) { | 862 if (channel_mode == AC3_CHMODE_STEREO && s->phase_flags_in_use && cpl_coords_exist) { |
863 for (bnd = 0; bnd < ctx->num_cpl_bands; bnd++) { | 863 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) { |
864 if (get_bits1(gbc)) | 864 if (get_bits1(gbc)) |
865 ctx->cpl_coords[2][bnd] = -ctx->cpl_coords[2][bnd]; | 865 s->cpl_coords[2][bnd] = -s->cpl_coords[2][bnd]; |
866 } | 866 } |
867 } | 867 } |
868 } | 868 } |
869 | 869 |
870 /* stereo rematrixing strategy and band structure */ | 870 /* stereo rematrixing strategy and band structure */ |
871 if (channel_mode == AC3_CHMODE_STEREO) { | 871 if (channel_mode == AC3_CHMODE_STEREO) { |
872 ctx->rematrixing_strategy = get_bits1(gbc); | 872 s->rematrixing_strategy = get_bits1(gbc); |
873 if (ctx->rematrixing_strategy) { | 873 if (s->rematrixing_strategy) { |
874 ctx->num_rematrixing_bands = 4; | 874 s->num_rematrixing_bands = 4; |
875 if(ctx->cpl_in_use && ctx->start_freq[CPL_CH] <= 61) | 875 if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61) |
876 ctx->num_rematrixing_bands -= 1 + (ctx->start_freq[CPL_CH] == 37); | 876 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37); |
877 for(bnd=0; bnd<ctx->num_rematrixing_bands; bnd++) | 877 for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) |
878 ctx->rematrixing_flags[bnd] = get_bits1(gbc); | 878 s->rematrixing_flags[bnd] = get_bits1(gbc); |
879 } | 879 } |
880 } | 880 } |
881 | 881 |
882 /* exponent strategies for each channel */ | 882 /* exponent strategies for each channel */ |
883 ctx->exp_strategy[CPL_CH] = EXP_REUSE; | 883 s->exp_strategy[CPL_CH] = EXP_REUSE; |
884 ctx->exp_strategy[ctx->lfe_ch] = EXP_REUSE; | 884 s->exp_strategy[s->lfe_ch] = EXP_REUSE; |
885 for (ch = !ctx->cpl_in_use; ch <= ctx->channels; ch++) { | 885 for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { |
886 if(ch == ctx->lfe_ch) | 886 if(ch == s->lfe_ch) |
887 ctx->exp_strategy[ch] = get_bits(gbc, 1); | 887 s->exp_strategy[ch] = get_bits(gbc, 1); |
888 else | 888 else |
889 ctx->exp_strategy[ch] = get_bits(gbc, 2); | 889 s->exp_strategy[ch] = get_bits(gbc, 2); |
890 if(ctx->exp_strategy[ch] != EXP_REUSE) | 890 if(s->exp_strategy[ch] != EXP_REUSE) |
891 bit_alloc_stages[ch] = 3; | 891 bit_alloc_stages[ch] = 3; |
892 } | 892 } |
893 | 893 |
894 /* channel bandwidth */ | 894 /* channel bandwidth */ |
895 for (ch = 1; ch <= fbw_channels; ch++) { | 895 for (ch = 1; ch <= fbw_channels; ch++) { |
896 ctx->start_freq[ch] = 0; | 896 s->start_freq[ch] = 0; |
897 if (ctx->exp_strategy[ch] != EXP_REUSE) { | 897 if (s->exp_strategy[ch] != EXP_REUSE) { |
898 int prev = ctx->end_freq[ch]; | 898 int prev = s->end_freq[ch]; |
899 if (ctx->channel_in_cpl[ch]) | 899 if (s->channel_in_cpl[ch]) |
900 ctx->end_freq[ch] = ctx->start_freq[CPL_CH]; | 900 s->end_freq[ch] = s->start_freq[CPL_CH]; |
901 else { | 901 else { |
902 int bandwidth_code = get_bits(gbc, 6); | 902 int bandwidth_code = get_bits(gbc, 6); |
903 if (bandwidth_code > 60) { | 903 if (bandwidth_code > 60) { |
904 av_log(ctx->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code); | 904 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code); |
905 return -1; | 905 return -1; |
906 } | 906 } |
907 ctx->end_freq[ch] = bandwidth_code * 3 + 73; | 907 s->end_freq[ch] = bandwidth_code * 3 + 73; |
908 } | 908 } |
909 if(blk > 0 && ctx->end_freq[ch] != prev) | 909 if(blk > 0 && s->end_freq[ch] != prev) |
910 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); | 910 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); |
911 } | 911 } |
912 } | 912 } |
913 ctx->start_freq[ctx->lfe_ch] = 0; | 913 s->start_freq[s->lfe_ch] = 0; |
914 ctx->end_freq[ctx->lfe_ch] = 7; | 914 s->end_freq[s->lfe_ch] = 7; |
915 | 915 |
916 /* decode exponents for each channel */ | 916 /* decode exponents for each channel */ |
917 for (ch = !ctx->cpl_in_use; ch <= ctx->channels; ch++) { | 917 for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { |
918 if (ctx->exp_strategy[ch] != EXP_REUSE) { | 918 if (s->exp_strategy[ch] != EXP_REUSE) { |
919 int group_size, num_groups; | 919 int group_size, num_groups; |
920 group_size = 3 << (ctx->exp_strategy[ch] - 1); | 920 group_size = 3 << (s->exp_strategy[ch] - 1); |
921 if(ch == CPL_CH) | 921 if(ch == CPL_CH) |
922 num_groups = (ctx->end_freq[ch] - ctx->start_freq[ch]) / group_size; | 922 num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size; |
923 else if(ch == ctx->lfe_ch) | 923 else if(ch == s->lfe_ch) |
924 num_groups = 2; | 924 num_groups = 2; |
925 else | 925 else |
926 num_groups = (ctx->end_freq[ch] + group_size - 4) / group_size; | 926 num_groups = (s->end_freq[ch] + group_size - 4) / group_size; |
927 ctx->dexps[ch][0] = get_bits(gbc, 4) << !ch; | 927 s->dexps[ch][0] = get_bits(gbc, 4) << !ch; |
928 decode_exponents(gbc, ctx->exp_strategy[ch], num_groups, ctx->dexps[ch][0], | 928 decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0], |
929 &ctx->dexps[ch][ctx->start_freq[ch]+!!ch]); | 929 &s->dexps[ch][s->start_freq[ch]+!!ch]); |
930 if(ch != CPL_CH && ch != ctx->lfe_ch) | 930 if(ch != CPL_CH && ch != s->lfe_ch) |
931 skip_bits(gbc, 2); /* skip gainrng */ | 931 skip_bits(gbc, 2); /* skip gainrng */ |
932 } | 932 } |
933 } | 933 } |
934 | 934 |
935 /* bit allocation information */ | 935 /* bit allocation information */ |
936 if (get_bits1(gbc)) { | 936 if (get_bits1(gbc)) { |
937 ctx->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> ctx->bit_alloc_params.sr_shift; | 937 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; |
938 ctx->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> ctx->bit_alloc_params.sr_shift; | 938 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift; |
939 ctx->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)]; | 939 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)]; |
940 ctx->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)]; | 940 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)]; |
941 ctx->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)]; | 941 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)]; |
942 for(ch=!ctx->cpl_in_use; ch<=ctx->channels; ch++) { | 942 for(ch=!s->cpl_in_use; ch<=s->channels; ch++) { |
943 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); | 943 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); |
944 } | 944 } |
945 } | 945 } |
946 | 946 |
947 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */ | 947 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */ |
948 if (get_bits1(gbc)) { | 948 if (get_bits1(gbc)) { |
949 int csnr; | 949 int csnr; |
950 csnr = (get_bits(gbc, 6) - 15) << 4; | 950 csnr = (get_bits(gbc, 6) - 15) << 4; |
951 for (ch = !ctx->cpl_in_use; ch <= ctx->channels; ch++) { /* snr offset and fast gain */ | 951 for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */ |
952 ctx->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2; | 952 s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2; |
953 ctx->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; | 953 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)]; |
954 } | 954 } |
955 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); | 955 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS); |
956 } | 956 } |
957 | 957 |
958 /* coupling leak information */ | 958 /* coupling leak information */ |
959 if (ctx->cpl_in_use && get_bits1(gbc)) { | 959 if (s->cpl_in_use && get_bits1(gbc)) { |
960 ctx->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3); | 960 s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3); |
961 ctx->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3); | 961 s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3); |
962 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2); | 962 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2); |
963 } | 963 } |
964 | 964 |
965 /* delta bit allocation information */ | 965 /* delta bit allocation information */ |
966 if (get_bits1(gbc)) { | 966 if (get_bits1(gbc)) { |
967 /* delta bit allocation exists (strategy) */ | 967 /* delta bit allocation exists (strategy) */ |
968 for (ch = !ctx->cpl_in_use; ch <= fbw_channels; ch++) { | 968 for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) { |
969 ctx->dba_mode[ch] = get_bits(gbc, 2); | 969 s->dba_mode[ch] = get_bits(gbc, 2); |
970 if (ctx->dba_mode[ch] == DBA_RESERVED) { | 970 if (s->dba_mode[ch] == DBA_RESERVED) { |
971 av_log(ctx->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n"); | 971 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n"); |
972 return -1; | 972 return -1; |
973 } | 973 } |
974 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); | 974 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2); |
975 } | 975 } |
976 /* channel delta offset, len and bit allocation */ | 976 /* channel delta offset, len and bit allocation */ |
977 for (ch = !ctx->cpl_in_use; ch <= fbw_channels; ch++) { | 977 for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) { |
978 if (ctx->dba_mode[ch] == DBA_NEW) { | 978 if (s->dba_mode[ch] == DBA_NEW) { |
979 ctx->dba_nsegs[ch] = get_bits(gbc, 3); | 979 s->dba_nsegs[ch] = get_bits(gbc, 3); |
980 for (seg = 0; seg <= ctx->dba_nsegs[ch]; seg++) { | 980 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) { |
981 ctx->dba_offsets[ch][seg] = get_bits(gbc, 5); | 981 s->dba_offsets[ch][seg] = get_bits(gbc, 5); |
982 ctx->dba_lengths[ch][seg] = get_bits(gbc, 4); | 982 s->dba_lengths[ch][seg] = get_bits(gbc, 4); |
983 ctx->dba_values[ch][seg] = get_bits(gbc, 3); | 983 s->dba_values[ch][seg] = get_bits(gbc, 3); |
984 } | 984 } |
985 } | 985 } |
986 } | 986 } |
987 } else if(blk == 0) { | 987 } else if(blk == 0) { |
988 for(ch=0; ch<=ctx->channels; ch++) { | 988 for(ch=0; ch<=s->channels; ch++) { |
989 ctx->dba_mode[ch] = DBA_NONE; | 989 s->dba_mode[ch] = DBA_NONE; |
990 } | 990 } |
991 } | 991 } |
992 | 992 |
993 /* Bit allocation */ | 993 /* Bit allocation */ |
994 for(ch=!ctx->cpl_in_use; ch<=ctx->channels; ch++) { | 994 for(ch=!s->cpl_in_use; ch<=s->channels; ch++) { |
995 if(bit_alloc_stages[ch] > 2) { | 995 if(bit_alloc_stages[ch] > 2) { |
996 /* Exponent mapping into PSD and PSD integration */ | 996 /* Exponent mapping into PSD and PSD integration */ |
997 ff_ac3_bit_alloc_calc_psd(ctx->dexps[ch], | 997 ff_ac3_bit_alloc_calc_psd(s->dexps[ch], |
998 ctx->start_freq[ch], ctx->end_freq[ch], | 998 s->start_freq[ch], s->end_freq[ch], |
999 ctx->psd[ch], ctx->band_psd[ch]); | 999 s->psd[ch], s->band_psd[ch]); |
1000 } | 1000 } |
1001 if(bit_alloc_stages[ch] > 1) { | 1001 if(bit_alloc_stages[ch] > 1) { |
1002 /* Compute excitation function, Compute masking curve, and | 1002 /* Compute excitation function, Compute masking curve, and |
1003 Apply delta bit allocation */ | 1003 Apply delta bit allocation */ |
1004 ff_ac3_bit_alloc_calc_mask(&ctx->bit_alloc_params, ctx->band_psd[ch], | 1004 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch], |
1005 ctx->start_freq[ch], ctx->end_freq[ch], | 1005 s->start_freq[ch], s->end_freq[ch], |
1006 ctx->fast_gain[ch], (ch == ctx->lfe_ch), | 1006 s->fast_gain[ch], (ch == s->lfe_ch), |
1007 ctx->dba_mode[ch], ctx->dba_nsegs[ch], | 1007 s->dba_mode[ch], s->dba_nsegs[ch], |
1008 ctx->dba_offsets[ch], ctx->dba_lengths[ch], | 1008 s->dba_offsets[ch], s->dba_lengths[ch], |
1009 ctx->dba_values[ch], ctx->mask[ch]); | 1009 s->dba_values[ch], s->mask[ch]); |
1010 } | 1010 } |
1011 if(bit_alloc_stages[ch] > 0) { | 1011 if(bit_alloc_stages[ch] > 0) { |
1012 /* Compute bit allocation */ | 1012 /* Compute bit allocation */ |
1013 ff_ac3_bit_alloc_calc_bap(ctx->mask[ch], ctx->psd[ch], | 1013 ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch], |
1014 ctx->start_freq[ch], ctx->end_freq[ch], | 1014 s->start_freq[ch], s->end_freq[ch], |
1015 ctx->snr_offset[ch], | 1015 s->snr_offset[ch], |
1016 ctx->bit_alloc_params.floor, | 1016 s->bit_alloc_params.floor, |
1017 ctx->bap[ch]); | 1017 s->bap[ch]); |
1018 } | 1018 } |
1019 } | 1019 } |
1020 | 1020 |
1021 /* unused dummy data */ | 1021 /* unused dummy data */ |
1022 if (get_bits1(gbc)) { | 1022 if (get_bits1(gbc)) { |
1025 skip_bits(gbc, 8); | 1025 skip_bits(gbc, 8); |
1026 } | 1026 } |
1027 | 1027 |
1028 /* unpack the transform coefficients | 1028 /* unpack the transform coefficients |
1029 this also uncouples channels if coupling is in use. */ | 1029 this also uncouples channels if coupling is in use. */ |
1030 if (get_transform_coeffs(ctx)) { | 1030 if (get_transform_coeffs(s)) { |
1031 av_log(ctx->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n"); | 1031 av_log(s->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n"); |
1032 return -1; | 1032 return -1; |
1033 } | 1033 } |
1034 | 1034 |
1035 /* recover coefficients if rematrixing is in use */ | 1035 /* recover coefficients if rematrixing is in use */ |
1036 if(ctx->channel_mode == AC3_CHMODE_STEREO) | 1036 if(s->channel_mode == AC3_CHMODE_STEREO) |
1037 do_rematrixing(ctx); | 1037 do_rematrixing(s); |
1038 | 1038 |
1039 /* apply scaling to coefficients (headroom, dynrng) */ | 1039 /* apply scaling to coefficients (headroom, dynrng) */ |
1040 for(ch=1; ch<=ctx->channels; ch++) { | 1040 for(ch=1; ch<=s->channels; ch++) { |
1041 float gain = 2.0f * ctx->mul_bias; | 1041 float gain = 2.0f * s->mul_bias; |
1042 if(ctx->channel_mode == AC3_CHMODE_DUALMONO) { | 1042 if(s->channel_mode == AC3_CHMODE_DUALMONO) { |
1043 gain *= ctx->dynamic_range[ch-1]; | 1043 gain *= s->dynamic_range[ch-1]; |
1044 } else { | 1044 } else { |
1045 gain *= ctx->dynamic_range[0]; | 1045 gain *= s->dynamic_range[0]; |
1046 } | 1046 } |
1047 for(i=0; i<ctx->end_freq[ch]; i++) { | 1047 for(i=0; i<s->end_freq[ch]; i++) { |
1048 ctx->transform_coeffs[ch][i] *= gain; | 1048 s->transform_coeffs[ch][i] *= gain; |
1049 } | 1049 } |
1050 } | 1050 } |
1051 | 1051 |
1052 do_imdct(ctx); | 1052 do_imdct(s); |
1053 | 1053 |
1054 /* downmix output if needed */ | 1054 /* downmix output if needed */ |
1055 if(ctx->channels != ctx->out_channels && !((ctx->output_mode & AC3_OUTPUT_LFEON) && | 1055 if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) && |
1056 ctx->fbw_channels == ctx->out_channels)) { | 1056 s->fbw_channels == s->out_channels)) { |
1057 ac3_downmix(ctx->output, ctx->fbw_channels, ctx->output_mode, | 1057 ac3_downmix(s->output, s->fbw_channels, s->output_mode, |
1058 ctx->downmix_coeffs); | 1058 s->downmix_coeffs); |
1059 } | 1059 } |
1060 | 1060 |
1061 /* convert float to 16-bit integer */ | 1061 /* convert float to 16-bit integer */ |
1062 for(ch=0; ch<ctx->out_channels; ch++) { | 1062 for(ch=0; ch<s->out_channels; ch++) { |
1063 for(i=0; i<256; i++) { | 1063 for(i=0; i<256; i++) { |
1064 ctx->output[ch][i] += ctx->add_bias; | 1064 s->output[ch][i] += s->add_bias; |
1065 } | 1065 } |
1066 ctx->dsp.float_to_int16(ctx->int_output[ch], ctx->output[ch], 256); | 1066 s->dsp.float_to_int16(s->int_output[ch], s->output[ch], 256); |
1067 } | 1067 } |
1068 | 1068 |
1069 return 0; | 1069 return 0; |
1070 } | 1070 } |
1071 | 1071 |
1072 /** | 1072 /** |
1073 * Decode a single AC-3 frame. | 1073 * Decode a single AC-3 frame. |
1074 */ | 1074 */ |
1075 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size) | 1075 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size) |
1076 { | 1076 { |
1077 AC3DecodeContext *ctx = (AC3DecodeContext *)avctx->priv_data; | 1077 AC3DecodeContext *s = (AC3DecodeContext *)avctx->priv_data; |
1078 int16_t *out_samples = (int16_t *)data; | 1078 int16_t *out_samples = (int16_t *)data; |
1079 int i, blk, ch, err; | 1079 int i, blk, ch, err; |
1080 | 1080 |
1081 /* initialize the GetBitContext with the start of valid AC-3 Frame */ | 1081 /* initialize the GetBitContext with the start of valid AC-3 Frame */ |
1082 init_get_bits(&ctx->gbc, buf, buf_size * 8); | 1082 init_get_bits(&s->gbc, buf, buf_size * 8); |
1083 | 1083 |
1084 /* parse the syncinfo */ | 1084 /* parse the syncinfo */ |
1085 err = ac3_parse_header(ctx); | 1085 err = ac3_parse_header(s); |
1086 if(err) { | 1086 if(err) { |
1087 switch(err) { | 1087 switch(err) { |
1088 case AC3_PARSE_ERROR_SYNC: | 1088 case AC3_PARSE_ERROR_SYNC: |
1089 av_log(avctx, AV_LOG_ERROR, "frame sync error\n"); | 1089 av_log(avctx, AV_LOG_ERROR, "frame sync error\n"); |
1090 break; | 1090 break; |
1102 break; | 1102 break; |
1103 } | 1103 } |
1104 return -1; | 1104 return -1; |
1105 } | 1105 } |
1106 | 1106 |
1107 avctx->sample_rate = ctx->sampling_rate; | 1107 avctx->sample_rate = s->sampling_rate; |
1108 avctx->bit_rate = ctx->bit_rate; | 1108 avctx->bit_rate = s->bit_rate; |
1109 | 1109 |
1110 /* check that reported frame size fits in input buffer */ | 1110 /* check that reported frame size fits in input buffer */ |
1111 if(ctx->frame_size > buf_size) { | 1111 if(s->frame_size > buf_size) { |
1112 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n"); | 1112 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n"); |
1113 return -1; | 1113 return -1; |
1114 } | 1114 } |
1115 | 1115 |
1116 /* channel config */ | 1116 /* channel config */ |
1117 ctx->out_channels = ctx->channels; | 1117 s->out_channels = s->channels; |
1118 if (avctx->request_channels > 0 && avctx->request_channels <= 2 && | 1118 if (avctx->request_channels > 0 && avctx->request_channels <= 2 && |
1119 avctx->request_channels < ctx->channels) { | 1119 avctx->request_channels < s->channels) { |
1120 ctx->out_channels = avctx->request_channels; | 1120 s->out_channels = avctx->request_channels; |
1121 ctx->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO; | 1121 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO; |
1122 } | 1122 } |
1123 avctx->channels = ctx->out_channels; | 1123 avctx->channels = s->out_channels; |
1124 | 1124 |
1125 /* parse the audio blocks */ | 1125 /* parse the audio blocks */ |
1126 for (blk = 0; blk < NB_BLOCKS; blk++) { | 1126 for (blk = 0; blk < NB_BLOCKS; blk++) { |
1127 if (ac3_parse_audio_block(ctx, blk)) { | 1127 if (ac3_parse_audio_block(s, blk)) { |
1128 av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n"); | 1128 av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n"); |
1129 *data_size = 0; | 1129 *data_size = 0; |
1130 return ctx->frame_size; | 1130 return s->frame_size; |
1131 } | 1131 } |
1132 for (i = 0; i < 256; i++) | 1132 for (i = 0; i < 256; i++) |
1133 for (ch = 0; ch < ctx->out_channels; ch++) | 1133 for (ch = 0; ch < s->out_channels; ch++) |
1134 *(out_samples++) = ctx->int_output[ch][i]; | 1134 *(out_samples++) = s->int_output[ch][i]; |
1135 } | 1135 } |
1136 *data_size = NB_BLOCKS * 256 * avctx->channels * sizeof (int16_t); | 1136 *data_size = NB_BLOCKS * 256 * avctx->channels * sizeof (int16_t); |
1137 return ctx->frame_size; | 1137 return s->frame_size; |
1138 } | 1138 } |
1139 | 1139 |
1140 /** | 1140 /** |
1141 * Uninitialize the AC-3 decoder. | 1141 * Uninitialize the AC-3 decoder. |
1142 */ | 1142 */ |
1143 static int ac3_decode_end(AVCodecContext *avctx) | 1143 static int ac3_decode_end(AVCodecContext *avctx) |
1144 { | 1144 { |
1145 AC3DecodeContext *ctx = (AC3DecodeContext *)avctx->priv_data; | 1145 AC3DecodeContext *s = (AC3DecodeContext *)avctx->priv_data; |
1146 ff_mdct_end(&ctx->imdct_512); | 1146 ff_mdct_end(&s->imdct_512); |
1147 ff_mdct_end(&ctx->imdct_256); | 1147 ff_mdct_end(&s->imdct_256); |
1148 | 1148 |
1149 return 0; | 1149 return 0; |
1150 } | 1150 } |
1151 | 1151 |
1152 AVCodec ac3_decoder = { | 1152 AVCodec ac3_decoder = { |