Revision d802d7ca libavcodec/ac3dec.c

View differences:

libavcodec/ac3dec.c
291 291
 */
292 292
static int ac3_decode_init(AVCodecContext *avctx)
293 293
{
294
    AC3DecodeContext *ctx = avctx->priv_data;
295
    ctx->avctx = avctx;
294
    AC3DecodeContext *s = avctx->priv_data;
295
    s->avctx = avctx;
296 296

  
297 297
    ac3_common_init();
298 298
    ac3_tables_init();
299
    ff_mdct_init(&ctx->imdct_256, 8, 1);
300
    ff_mdct_init(&ctx->imdct_512, 9, 1);
301
    ac3_window_init(ctx->window);
302
    dsputil_init(&ctx->dsp, avctx);
303
    av_init_random(0, &ctx->dith_state);
299
    ff_mdct_init(&s->imdct_256, 8, 1);
300
    ff_mdct_init(&s->imdct_512, 9, 1);
301
    ac3_window_init(s->window);
302
    dsputil_init(&s->dsp, avctx);
303
    av_init_random(0, &s->dith_state);
304 304

  
305 305
    /* set bias values for float to int16 conversion */
306
    if(ctx->dsp.float_to_int16 == ff_float_to_int16_c) {
307
        ctx->add_bias = 385.0f;
308
        ctx->mul_bias = 1.0f;
306
    if(s->dsp.float_to_int16 == ff_float_to_int16_c) {
307
        s->add_bias = 385.0f;
308
        s->mul_bias = 1.0f;
309 309
    } else {
310
        ctx->add_bias = 0.0f;
311
        ctx->mul_bias = 32767.0f;
310
        s->add_bias = 0.0f;
311
        s->mul_bias = 32767.0f;
312 312
    }
313 313

  
314 314
    return 0;
......
319 319
 * GetBitContext within AC3DecodeContext must point to
320 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 324
    AC3HeaderInfo hdr;
325
    GetBitContext *gbc = &ctx->gbc;
325
    GetBitContext *gbc = &s->gbc;
326 326
    float center_mix_level, surround_mix_level;
327 327
    int err, i;
328 328

  
......
331 331
        return err;
332 332

  
333 333
    /* get decoding parameters from header info */
334
    ctx->bit_alloc_params.sr_code     = hdr.sr_code;
335
    ctx->channel_mode                 = hdr.channel_mode;
334
    s->bit_alloc_params.sr_code     = hdr.sr_code;
335
    s->channel_mode                 = hdr.channel_mode;
336 336
    center_mix_level                  = gain_levels[center_levels[hdr.center_mix_level]];
337 337
    surround_mix_level                = gain_levels[surround_levels[hdr.surround_mix_level]];
338
    ctx->lfe_on                        = hdr.lfe_on;
339
    ctx->bit_alloc_params.sr_shift    = hdr.sr_shift;
340
    ctx->sampling_rate                = hdr.sample_rate;
341
    ctx->bit_rate                     = hdr.bit_rate;
342
    ctx->channels                     = hdr.channels;
343
    ctx->fbw_channels                 = ctx->channels - ctx->lfe_on;
344
    ctx->lfe_ch                       = ctx->fbw_channels + 1;
345
    ctx->frame_size                   = hdr.frame_size;
338
    s->lfe_on                        = hdr.lfe_on;
339
    s->bit_alloc_params.sr_shift    = hdr.sr_shift;
340
    s->sampling_rate                = hdr.sample_rate;
341
    s->bit_rate                     = hdr.bit_rate;
342
    s->channels                     = hdr.channels;
343
    s->fbw_channels                 = s->channels - s->lfe_on;
344
    s->lfe_ch                       = s->fbw_channels + 1;
345
    s->frame_size                   = hdr.frame_size;
346 346

  
347 347
    /* set default output to all source channels */
348
    ctx->out_channels = ctx->channels;
349
    ctx->output_mode = ctx->channel_mode;
350
    if(ctx->lfe_on)
351
        ctx->output_mode |= AC3_OUTPUT_LFEON;
348
    s->out_channels = s->channels;
349
    s->output_mode = s->channel_mode;
350
    if(s->lfe_on)
351
        s->output_mode |= AC3_OUTPUT_LFEON;
352 352

  
353 353
    /* skip over portion of header which has already been read */
354 354
    skip_bits(gbc, 16); // skip the sync_word
355 355
    skip_bits(gbc, 16); // skip crc1
356 356
    skip_bits(gbc, 8);  // skip fscod and frmsizecod
357 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 359
        skip_bits(gbc, 2); // skip dsurmod
360 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 362
            skip_bits(gbc, 2); // skip cmixlev
363
        if(ctx->channel_mode & 4)
363
        if(s->channel_mode & 4)
364 364
            skip_bits(gbc, 2); // skip surmixlev
365 365
    }
366 366
    skip_bits1(gbc); // skip lfeon
367 367

  
368 368
    /* read the rest of the bsi. read twice for dual mono mode. */
369
    i = !(ctx->channel_mode);
369
    i = !(s->channel_mode);
370 370
    do {
371 371
        skip_bits(gbc, 5); // skip dialog normalization
372 372
        if (get_bits1(gbc))
......
396 396

  
397 397
    /* set stereo downmixing coefficients
398 398
       reference: Section 7.8.2 Downmixing Into Two Channels */
399
    for(i=0; i<ctx->fbw_channels; i++) {
400
        ctx->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[ctx->channel_mode][i][0]];
401
        ctx->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[ctx->channel_mode][i][1]];
399
    for(i=0; i<s->fbw_channels; i++) {
400
        s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
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) {
404
        ctx->downmix_coeffs[1][0] = ctx->downmix_coeffs[1][1] = center_mix_level;
403
    if(s->channel_mode > 1 && s->channel_mode & 1) {
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) {
407
        int nf = ctx->channel_mode - 2;
408
        ctx->downmix_coeffs[nf][0] = ctx->downmix_coeffs[nf][1] = surround_mix_level * LEVEL_MINUS_3DB;
406
    if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
407
        int nf = s->channel_mode - 2;
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) {
411
        int nf = ctx->channel_mode - 4;
412
        ctx->downmix_coeffs[nf][0] = ctx->downmix_coeffs[nf+1][1] = surround_mix_level;
410
    if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
411
        int nf = s->channel_mode - 4;
412
        s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = surround_mix_level;
413 413
    }
414 414

  
415 415
    return 0;
......
450 450
 * range using the coupling coefficients and coupling coordinates.
451 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 455
    int i, j, ch, bnd, subbnd;
456 456

  
457 457
    subbnd = -1;
458
    i = ctx->start_freq[CPL_CH];
459
    for(bnd=0; bnd<ctx->num_cpl_bands; bnd++) {
458
    i = s->start_freq[CPL_CH];
459
    for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
460 460
        do {
461 461
            subbnd++;
462 462
            for(j=0; j<12; j++) {
463
                for(ch=1; ch<=ctx->fbw_channels; ch++) {
464
                    if(ctx->channel_in_cpl[ch])
465
                        ctx->transform_coeffs[ch][i] = ctx->transform_coeffs[CPL_CH][i] * ctx->cpl_coords[ch][bnd] * 8.0f;
463
                for(ch=1; ch<=s->fbw_channels; ch++) {
464
                    if(s->channel_in_cpl[ch])
465
                        s->transform_coeffs[ch][i] = s->transform_coeffs[CPL_CH][i] * s->cpl_coords[ch][bnd] * 8.0f;
466 466
                }
467 467
                i++;
468 468
            }
469
        } while(ctx->cpl_band_struct[subbnd]);
469
        } while(s->cpl_band_struct[subbnd]);
470 470
    }
471 471
}
472 472

  
......
486 486
 * Get the transform coefficients for a particular channel
487 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 492
    int i, gcode, tbap, start, end;
493 493
    uint8_t *exps;
494 494
    uint8_t *bap;
495 495
    float *coeffs;
496 496

  
497
    exps = ctx->dexps[ch_index];
498
    bap = ctx->bap[ch_index];
499
    coeffs = ctx->transform_coeffs[ch_index];
500
    start = ctx->start_freq[ch_index];
501
    end = ctx->end_freq[ch_index];
497
    exps = s->dexps[ch_index];
498
    bap = s->bap[ch_index];
499
    coeffs = s->transform_coeffs[ch_index];
500
    start = s->start_freq[ch_index];
501
    end = s->end_freq[ch_index];
502 502

  
503 503
    for (i = start; i < end; i++) {
504 504
        tbap = bap[i];
505 505
        switch (tbap) {
506 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 508
                break;
509 509

  
510 510
            case 1:
......
562 562
 * Remove random dithering from coefficients with zero-bit mantissas
563 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 566
    int ch, i;
567 567
    int end=0;
568 568
    float *coeffs;
569 569
    uint8_t *bap;
570 570

  
571
    for(ch=1; ch<=ctx->fbw_channels; ch++) {
572
        if(!ctx->dither_flag[ch]) {
573
            coeffs = ctx->transform_coeffs[ch];
574
            bap = ctx->bap[ch];
575
            if(ctx->channel_in_cpl[ch])
576
                end = ctx->start_freq[CPL_CH];
571
    for(ch=1; ch<=s->fbw_channels; ch++) {
572
        if(!s->dither_flag[ch]) {
573
            coeffs = s->transform_coeffs[ch];
574
            bap = s->bap[ch];
575
            if(s->channel_in_cpl[ch])
576
                end = s->start_freq[CPL_CH];
577 577
            else
578
                end = ctx->end_freq[ch];
578
                end = s->end_freq[ch];
579 579
            for(i=0; i<end; i++) {
580 580
                if(bap[i] == 0)
581 581
                    coeffs[i] = 0.0f;
582 582
            }
583
            if(ctx->channel_in_cpl[ch]) {
584
                bap = ctx->bap[CPL_CH];
585
                for(; i<ctx->end_freq[CPL_CH]; i++) {
583
            if(s->channel_in_cpl[ch]) {
584
                bap = s->bap[CPL_CH];
585
                for(; i<s->end_freq[CPL_CH]; i++) {
586 586
                    if(bap[i] == 0)
587 587
                        coeffs[i] = 0.0f;
588 588
                }
......
594 594
/**
595 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 599
    int ch, end;
600 600
    int got_cplchan = 0;
......
602 602

  
603 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 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 608
            return -1;
609 609
        /* tranform coefficients for coupling channel come right after the
610 610
           coefficients for the first coupled channel*/
611
        if (ctx->channel_in_cpl[ch])  {
611
        if (s->channel_in_cpl[ch])  {
612 612
            if (!got_cplchan) {
613
                if (get_transform_coeffs_ch(ctx, CPL_CH, &m)) {
614
                    av_log(ctx->avctx, AV_LOG_ERROR, "error in decoupling channels\n");
613
                if (get_transform_coeffs_ch(s, CPL_CH, &m)) {
614
                    av_log(s->avctx, AV_LOG_ERROR, "error in decoupling channels\n");
615 615
                    return -1;
616 616
                }
617
                uncouple_channels(ctx);
617
                uncouple_channels(s);
618 618
                got_cplchan = 1;
619 619
            }
620
            end = ctx->end_freq[CPL_CH];
620
            end = s->end_freq[CPL_CH];
621 621
        } else {
622
            end = ctx->end_freq[ch];
622
            end = s->end_freq[ch];
623 623
        }
624 624
        do
625
            ctx->transform_coeffs[ch][end] = 0;
625
            s->transform_coeffs[ch][end] = 0;
626 626
        while(++end < 256);
627 627
    }
628 628

  
629 629
    /* if any channel doesn't use dithering, zero appropriate coefficients */
630
    if(!ctx->dither_all)
631
        remove_dithering(ctx);
630
    if(!s->dither_all)
631
        remove_dithering(s);
632 632

  
633 633
    return 0;
634 634
}
......
637 637
 * Stereo rematrixing.
638 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 642
    int bnd, i;
643 643
    int end, bndend;
644 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++) {
649
        if(ctx->rematrixing_flags[bnd]) {
648
    for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
649
        if(s->rematrixing_flags[bnd]) {
650 650
            bndend = FFMIN(end, rematrix_band_tab[bnd+1]);
651 651
            for(i=rematrix_band_tab[bnd]; i<bndend; i++) {
652
                tmp0 = ctx->transform_coeffs[1][i];
653
                tmp1 = ctx->transform_coeffs[2][i];
654
                ctx->transform_coeffs[1][i] = tmp0 + tmp1;
655
                ctx->transform_coeffs[2][i] = tmp0 - tmp1;
652
                tmp0 = s->transform_coeffs[1][i];
653
                tmp1 = s->transform_coeffs[2][i];
654
                s->transform_coeffs[1][i] = tmp0 + tmp1;
655
                s->transform_coeffs[2][i] = tmp0 - tmp1;
656 656
            }
657 657
        }
658 658
    }
......
661 661
/**
662 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 666
    int i, k;
667 667
    DECLARE_ALIGNED_16(float, x[128]);
668 668
    FFTComplex z[2][64];
669
    float *o_ptr = ctx->tmp_output;
669
    float *o_ptr = s->tmp_output;
670 670

  
671 671
    for(i=0; i<2; i++) {
672 672
        /* de-interleave coefficients */
673 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 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 680
        /* reverse the post-rotation & reordering from standard IMDCT */
681 681
        for(k=0; k<32; k++) {
......
704 704
 * Convert frequency domain coefficients to time-domain audio samples.
705 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 709
    int ch;
710 710
    int channels;
711 711

  
712 712
    /* Don't perform the IMDCT on the LFE channel unless it's used in the output */
713
    channels = ctx->fbw_channels;
714
    if(ctx->output_mode & AC3_OUTPUT_LFEON)
713
    channels = s->fbw_channels;
714
    if(s->output_mode & AC3_OUTPUT_LFEON)
715 715
        channels++;
716 716

  
717 717
    for (ch=1; ch<=channels; ch++) {
718
        if (ctx->block_switch[ch]) {
719
            do_imdct_256(ctx, ch);
718
        if (s->block_switch[ch]) {
719
            do_imdct_256(s, ch);
720 720
        } else {
721
            ctx->imdct_512.fft.imdct_calc(&ctx->imdct_512, ctx->tmp_output,
722
                                          ctx->transform_coeffs[ch],
723
                                          ctx->tmp_imdct);
721
            s->imdct_512.fft.imdct_calc(&s->imdct_512, s->tmp_output,
722
                                          s->transform_coeffs[ch],
723
                                          s->tmp_imdct);
724 724
        }
725 725
        /* For the first half of the block, apply the window, add the delay
726 726
           from the previous block, and send to output */
727
        ctx->dsp.vector_fmul_add_add(ctx->output[ch-1], ctx->tmp_output,
728
                                     ctx->window, ctx->delay[ch-1], 0, 256, 1);
727
        s->dsp.vector_fmul_add_add(s->output[ch-1], s->tmp_output,
728
                                     s->window, s->delay[ch-1], 0, 256, 1);
729 729
        /* For the second half of the block, apply the window and store the
730 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,
732
                                     ctx->window, 256);
731
        s->dsp.vector_fmul_reverse(s->delay[ch-1], s->tmp_output+256,
732
                                     s->window, 256);
733 733
    }
734 734
}
735 735

  
......
764 764
/**
765 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;
770
    int channel_mode = ctx->channel_mode;
769
    int fbw_channels = s->fbw_channels;
770
    int channel_mode = s->channel_mode;
771 771
    int i, bnd, seg, ch;
772
    GetBitContext *gbc = &ctx->gbc;
772
    GetBitContext *gbc = &s->gbc;
773 773
    uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
774 774

  
775 775
    memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
776 776

  
777 777
    /* block switch flags */
778 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 781
    /* dithering flags */
782
    ctx->dither_all = 1;
782
    s->dither_all = 1;
783 783
    for (ch = 1; ch <= fbw_channels; ch++) {
784
        ctx->dither_flag[ch] = get_bits1(gbc);
785
        if(!ctx->dither_flag[ch])
786
            ctx->dither_all = 0;
784
        s->dither_flag[ch] = get_bits1(gbc);
785
        if(!s->dither_flag[ch])
786
            s->dither_all = 0;
787 787
    }
788 788

  
789 789
    /* dynamic range */
790
    i = !(ctx->channel_mode);
790
    i = !(s->channel_mode);
791 791
    do {
792 792
        if(get_bits1(gbc)) {
793
            ctx->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
794
                                    ctx->avctx->drc_scale)+1.0;
793
            s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
794
                                    s->avctx->drc_scale)+1.0;
795 795
        } else if(blk == 0) {
796
            ctx->dynamic_range[i] = 1.0f;
796
            s->dynamic_range[i] = 1.0f;
797 797
        }
798 798
    } while(i--);
799 799

  
800 800
    /* coupling strategy */
801 801
    if (get_bits1(gbc)) {
802 802
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
803
        ctx->cpl_in_use = get_bits1(gbc);
804
        if (ctx->cpl_in_use) {
803
        s->cpl_in_use = get_bits1(gbc);
804
        if (s->cpl_in_use) {
805 805
            /* coupling in use */
806 806
            int cpl_begin_freq, cpl_end_freq;
807 807

  
808 808
            /* determine which channels are coupled */
809 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 812
            /* phase flags in use */
813 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 816
            /* coupling frequency range and band structure */
817 817
            cpl_begin_freq = get_bits(gbc, 4);
818 818
            cpl_end_freq = get_bits(gbc, 4);
819 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 821
                return -1;
822 822
            }
823
            ctx->num_cpl_bands = ctx->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
824
            ctx->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
825
            ctx->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
826
            for (bnd = 0; bnd < ctx->num_cpl_subbands - 1; bnd++) {
823
            s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
824
            s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
825
            s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
826
            for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
827 827
                if (get_bits1(gbc)) {
828
                    ctx->cpl_band_struct[bnd] = 1;
829
                    ctx->num_cpl_bands--;
828
                    s->cpl_band_struct[bnd] = 1;
829
                    s->num_cpl_bands--;
830 830
                }
831 831
            }
832 832
        } else {
833 833
            /* coupling not in use */
834 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 839
    /* coupling coordinates */
840
    if (ctx->cpl_in_use) {
840
    if (s->cpl_in_use) {
841 841
        int cpl_coords_exist = 0;
842 842

  
843 843
        for (ch = 1; ch <= fbw_channels; ch++) {
844
            if (ctx->channel_in_cpl[ch]) {
844
            if (s->channel_in_cpl[ch]) {
845 845
                if (get_bits1(gbc)) {
846 846
                    int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
847 847
                    cpl_coords_exist = 1;
848 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 850
                        cpl_coord_exp = get_bits(gbc, 4);
851 851
                        cpl_coord_mant = get_bits(gbc, 4);
852 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 854
                        else
855
                            ctx->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];
855
                            s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16.0f) / 32.0f;
856
                        s->cpl_coords[ch][bnd] *= scale_factors[cpl_coord_exp + master_cpl_coord];
857 857
                    }
858 858
                }
859 859
            }
860 860
        }
861 861
        /* phase flags */
862
        if (channel_mode == AC3_CHMODE_STEREO && ctx->phase_flags_in_use && cpl_coords_exist) {
863
            for (bnd = 0; bnd < ctx->num_cpl_bands; bnd++) {
862
        if (channel_mode == AC3_CHMODE_STEREO && s->phase_flags_in_use && cpl_coords_exist) {
863
            for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
864 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 870
    /* stereo rematrixing strategy and band structure */
871 871
    if (channel_mode == AC3_CHMODE_STEREO) {
872
        ctx->rematrixing_strategy = get_bits1(gbc);
873
        if (ctx->rematrixing_strategy) {
874
            ctx->num_rematrixing_bands = 4;
875
            if(ctx->cpl_in_use && ctx->start_freq[CPL_CH] <= 61)
876
                ctx->num_rematrixing_bands -= 1 + (ctx->start_freq[CPL_CH] == 37);
877
            for(bnd=0; bnd<ctx->num_rematrixing_bands; bnd++)
878
                ctx->rematrixing_flags[bnd] = get_bits1(gbc);
872
        s->rematrixing_strategy = get_bits1(gbc);
873
        if (s->rematrixing_strategy) {
874
            s->num_rematrixing_bands = 4;
875
            if(s->cpl_in_use && s->start_freq[CPL_CH] <= 61)
876
                s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
877
            for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
878
                s->rematrixing_flags[bnd] = get_bits1(gbc);
879 879
        }
880 880
    }
881 881

  
882 882
    /* exponent strategies for each channel */
883
    ctx->exp_strategy[CPL_CH] = EXP_REUSE;
884
    ctx->exp_strategy[ctx->lfe_ch] = EXP_REUSE;
885
    for (ch = !ctx->cpl_in_use; ch <= ctx->channels; ch++) {
886
        if(ch == ctx->lfe_ch)
887
            ctx->exp_strategy[ch] = get_bits(gbc, 1);
883
    s->exp_strategy[CPL_CH] = EXP_REUSE;
884
    s->exp_strategy[s->lfe_ch] = EXP_REUSE;
885
    for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
886
        if(ch == s->lfe_ch)
887
            s->exp_strategy[ch] = get_bits(gbc, 1);
888 888
        else
889
            ctx->exp_strategy[ch] = get_bits(gbc, 2);
890
        if(ctx->exp_strategy[ch] != EXP_REUSE)
889
            s->exp_strategy[ch] = get_bits(gbc, 2);
890
        if(s->exp_strategy[ch] != EXP_REUSE)
891 891
            bit_alloc_stages[ch] = 3;
892 892
    }
893 893

  
894 894
    /* channel bandwidth */
895 895
    for (ch = 1; ch <= fbw_channels; ch++) {
896
        ctx->start_freq[ch] = 0;
897
        if (ctx->exp_strategy[ch] != EXP_REUSE) {
898
            int prev = ctx->end_freq[ch];
899
            if (ctx->channel_in_cpl[ch])
900
                ctx->end_freq[ch] = ctx->start_freq[CPL_CH];
896
        s->start_freq[ch] = 0;
897
        if (s->exp_strategy[ch] != EXP_REUSE) {
898
            int prev = s->end_freq[ch];
899
            if (s->channel_in_cpl[ch])
900
                s->end_freq[ch] = s->start_freq[CPL_CH];
901 901
            else {
902 902
                int bandwidth_code = get_bits(gbc, 6);
903 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 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 910
                memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
911 911
        }
912 912
    }
913
    ctx->start_freq[ctx->lfe_ch] = 0;
914
    ctx->end_freq[ctx->lfe_ch] = 7;
913
    s->start_freq[s->lfe_ch] = 0;
914
    s->end_freq[s->lfe_ch] = 7;
915 915

  
916 916
    /* decode exponents for each channel */
917
    for (ch = !ctx->cpl_in_use; ch <= ctx->channels; ch++) {
918
        if (ctx->exp_strategy[ch] != EXP_REUSE) {
917
    for (ch = !s->cpl_in_use; ch <= s->channels; ch++) {
918
        if (s->exp_strategy[ch] != EXP_REUSE) {
919 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 921
            if(ch == CPL_CH)
922
                num_groups = (ctx->end_freq[ch] - ctx->start_freq[ch]) / group_size;
923
            else if(ch == ctx->lfe_ch)
922
                num_groups = (s->end_freq[ch] - s->start_freq[ch]) / group_size;
923
            else if(ch == s->lfe_ch)
924 924
                num_groups = 2;
925 925
            else
926
                num_groups = (ctx->end_freq[ch] + group_size - 4) / group_size;
927
            ctx->dexps[ch][0] = get_bits(gbc, 4) << !ch;
928
            decode_exponents(gbc, ctx->exp_strategy[ch], num_groups, ctx->dexps[ch][0],
929
                             &ctx->dexps[ch][ctx->start_freq[ch]+!!ch]);
930
            if(ch != CPL_CH && ch != ctx->lfe_ch)
926
                num_groups = (s->end_freq[ch] + group_size - 4) / group_size;
927
            s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
928
            decode_exponents(gbc, s->exp_strategy[ch], num_groups, s->dexps[ch][0],
929
                             &s->dexps[ch][s->start_freq[ch]+!!ch]);
930
            if(ch != CPL_CH && ch != s->lfe_ch)
931 931
                skip_bits(gbc, 2); /* skip gainrng */
932 932
        }
933 933
    }
934 934

  
935 935
    /* bit allocation information */
936 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;
938
        ctx->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> ctx->bit_alloc_params.sr_shift;
939
        ctx->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)];
941
        ctx->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
942
        for(ch=!ctx->cpl_in_use; ch<=ctx->channels; ch++) {
937
        s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->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
        s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
940
        s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
941
        s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
942
        for(ch=!s->cpl_in_use; ch<=s->channels; ch++) {
943 943
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
944 944
        }
945 945
    }
......
948 948
    if (get_bits1(gbc)) {
949 949
        int csnr;
950 950
        csnr = (get_bits(gbc, 6) - 15) << 4;
951
        for (ch = !ctx->cpl_in_use; ch <= ctx->channels; ch++) { /* snr offset and fast gain */
952
            ctx->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
953
            ctx->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
951
        for (ch = !s->cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
952
            s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
953
            s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
954 954
        }
955 955
        memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
956 956
    }
957 957

  
958 958
    /* coupling leak information */
959
    if (ctx->cpl_in_use && get_bits1(gbc)) {
960
        ctx->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
961
        ctx->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
959
    if (s->cpl_in_use && get_bits1(gbc)) {
960
        s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
961
        s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
962 962
        bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
963 963
    }
964 964

  
965 965
    /* delta bit allocation information */
966 966
    if (get_bits1(gbc)) {
967 967
        /* delta bit allocation exists (strategy) */
968
        for (ch = !ctx->cpl_in_use; ch <= fbw_channels; ch++) {
969
            ctx->dba_mode[ch] = get_bits(gbc, 2);
970
            if (ctx->dba_mode[ch] == DBA_RESERVED) {
971
                av_log(ctx->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
968
        for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
969
            s->dba_mode[ch] = get_bits(gbc, 2);
970
            if (s->dba_mode[ch] == DBA_RESERVED) {
971
                av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
972 972
                return -1;
973 973
            }
974 974
            bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
975 975
        }
976 976
        /* channel delta offset, len and bit allocation */
977
        for (ch = !ctx->cpl_in_use; ch <= fbw_channels; ch++) {
978
            if (ctx->dba_mode[ch] == DBA_NEW) {
979
                ctx->dba_nsegs[ch] = get_bits(gbc, 3);
980
                for (seg = 0; seg <= ctx->dba_nsegs[ch]; seg++) {
981
                    ctx->dba_offsets[ch][seg] = get_bits(gbc, 5);
982
                    ctx->dba_lengths[ch][seg] = get_bits(gbc, 4);
983
                    ctx->dba_values[ch][seg] = get_bits(gbc, 3);
977
        for (ch = !s->cpl_in_use; ch <= fbw_channels; ch++) {
978
            if (s->dba_mode[ch] == DBA_NEW) {
979
                s->dba_nsegs[ch] = get_bits(gbc, 3);
980
                for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
981
                    s->dba_offsets[ch][seg] = get_bits(gbc, 5);
982
                    s->dba_lengths[ch][seg] = get_bits(gbc, 4);
983
                    s->dba_values[ch][seg] = get_bits(gbc, 3);
984 984
                }
985 985
            }
986 986
        }
987 987
    } else if(blk == 0) {
988
        for(ch=0; ch<=ctx->channels; ch++) {
989
            ctx->dba_mode[ch] = DBA_NONE;
988
        for(ch=0; ch<=s->channels; ch++) {
989
            s->dba_mode[ch] = DBA_NONE;
990 990
        }
991 991
    }
992 992

  
993 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 995
        if(bit_alloc_stages[ch] > 2) {
996 996
            /* Exponent mapping into PSD and PSD integration */
997
            ff_ac3_bit_alloc_calc_psd(ctx->dexps[ch],
998
                                      ctx->start_freq[ch], ctx->end_freq[ch],
999
                                      ctx->psd[ch], ctx->band_psd[ch]);
997
            ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
998
                                      s->start_freq[ch], s->end_freq[ch],
999
                                      s->psd[ch], s->band_psd[ch]);
1000 1000
        }
1001 1001
        if(bit_alloc_stages[ch] > 1) {
1002 1002
            /* Compute excitation function, Compute masking curve, and
1003 1003
               Apply delta bit allocation */
1004
            ff_ac3_bit_alloc_calc_mask(&ctx->bit_alloc_params, ctx->band_psd[ch],
1005
                                       ctx->start_freq[ch], ctx->end_freq[ch],
1006
                                       ctx->fast_gain[ch], (ch == ctx->lfe_ch),
1007
                                       ctx->dba_mode[ch], ctx->dba_nsegs[ch],
1008
                                       ctx->dba_offsets[ch], ctx->dba_lengths[ch],
1009
                                       ctx->dba_values[ch], ctx->mask[ch]);
1004
            ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1005
                                       s->start_freq[ch], s->end_freq[ch],
1006
                                       s->fast_gain[ch], (ch == s->lfe_ch),
1007
                                       s->dba_mode[ch], s->dba_nsegs[ch],
1008
                                       s->dba_offsets[ch], s->dba_lengths[ch],
1009
                                       s->dba_values[ch], s->mask[ch]);
1010 1010
        }
1011 1011
        if(bit_alloc_stages[ch] > 0) {
1012 1012
            /* Compute bit allocation */
1013
            ff_ac3_bit_alloc_calc_bap(ctx->mask[ch], ctx->psd[ch],
1014
                                      ctx->start_freq[ch], ctx->end_freq[ch],
1015
                                      ctx->snr_offset[ch],
1016
                                      ctx->bit_alloc_params.floor,
1017
                                      ctx->bap[ch]);
1013
            ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1014
                                      s->start_freq[ch], s->end_freq[ch],
1015
                                      s->snr_offset[ch],
1016
                                      s->bit_alloc_params.floor,
1017
                                      s->bap[ch]);
1018 1018
        }
1019 1019
    }
1020 1020

  
......
1027 1027

  
1028 1028
    /* unpack the transform coefficients
1029 1029
       this also uncouples channels if coupling is in use. */
1030
    if (get_transform_coeffs(ctx)) {
1031
        av_log(ctx->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");
1030
    if (get_transform_coeffs(s)) {
1031
        av_log(s->avctx, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");
1032 1032
        return -1;
1033 1033
    }
1034 1034

  
1035 1035
    /* recover coefficients if rematrixing is in use */
1036
    if(ctx->channel_mode == AC3_CHMODE_STEREO)
1037
        do_rematrixing(ctx);
1036
    if(s->channel_mode == AC3_CHMODE_STEREO)
1037
        do_rematrixing(s);
1038 1038

  
1039 1039
    /* apply scaling to coefficients (headroom, dynrng) */
1040
    for(ch=1; ch<=ctx->channels; ch++) {
1041
        float gain = 2.0f * ctx->mul_bias;
1042
        if(ctx->channel_mode == AC3_CHMODE_DUALMONO) {
1043
            gain *= ctx->dynamic_range[ch-1];
1040
    for(ch=1; ch<=s->channels; ch++) {
1041
        float gain = 2.0f * s->mul_bias;
1042
        if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1043
            gain *= s->dynamic_range[ch-1];
1044 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++) {
1048
            ctx->transform_coeffs[ch][i] *= gain;
1047
        for(i=0; i<s->end_freq[ch]; i++) {
1048
            s->transform_coeffs[ch][i] *= gain;
1049 1049
        }
1050 1050
    }
1051 1051

  
1052
    do_imdct(ctx);
1052
    do_imdct(s);
1053 1053

  
1054 1054
    /* downmix output if needed */
1055
    if(ctx->channels != ctx->out_channels && !((ctx->output_mode & AC3_OUTPUT_LFEON) &&
1056
            ctx->fbw_channels == ctx->out_channels)) {
1057
        ac3_downmix(ctx->output, ctx->fbw_channels, ctx->output_mode,
1058
                    ctx->downmix_coeffs);
1055
    if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1056
            s->fbw_channels == s->out_channels)) {
1057
        ac3_downmix(s->output, s->fbw_channels, s->output_mode,
1058
                    s->downmix_coeffs);
1059 1059
    }
1060 1060

  
1061 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 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 1069
    return 0;
......
1074 1074
 */
1075 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 1078
    int16_t *out_samples = (int16_t *)data;
1079 1079
    int i, blk, ch, err;
1080 1080

  
1081 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 1084
    /* parse the syncinfo */
1085
    err = ac3_parse_header(ctx);
1085
    err = ac3_parse_header(s);
1086 1086
    if(err) {
1087 1087
        switch(err) {
1088 1088
            case AC3_PARSE_ERROR_SYNC:
......
1104 1104
        return -1;
1105 1105
    }
1106 1106

  
1107
    avctx->sample_rate = ctx->sampling_rate;
1108
    avctx->bit_rate = ctx->bit_rate;
1107
    avctx->sample_rate = s->sampling_rate;
1108
    avctx->bit_rate = s->bit_rate;
1109 1109

  
1110 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 1112
        av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1113 1113
        return -1;
1114 1114
    }
1115 1115

  
1116 1116
    /* channel config */
1117
    ctx->out_channels = ctx->channels;
1117
    s->out_channels = s->channels;
1118 1118
    if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1119
        avctx->request_channels < ctx->channels) {
1120
        ctx->out_channels = avctx->request_channels;
1121
        ctx->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1119
        avctx->request_channels < s->channels) {
1120
        s->out_channels = avctx->request_channels;
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 1125
    /* parse the audio blocks */
1126 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 1128
            av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");
1129 1129
            *data_size = 0;
1130
            return ctx->frame_size;
1130
            return s->frame_size;
1131 1131
        }
1132 1132
        for (i = 0; i < 256; i++)
1133
            for (ch = 0; ch < ctx->out_channels; ch++)
1134
                *(out_samples++) = ctx->int_output[ch][i];
1133
            for (ch = 0; ch < s->out_channels; ch++)
1134
                *(out_samples++) = s->int_output[ch][i];
1135 1135
    }
1136 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
/**
......
1142 1142
 */
1143 1143
static int ac3_decode_end(AVCodecContext *avctx)
1144 1144
{
1145
    AC3DecodeContext *ctx = (AC3DecodeContext *)avctx->priv_data;
1146
    ff_mdct_end(&ctx->imdct_512);
1147
    ff_mdct_end(&ctx->imdct_256);
1145
    AC3DecodeContext *s = (AC3DecodeContext *)avctx->priv_data;
1146
    ff_mdct_end(&s->imdct_512);
1147
    ff_mdct_end(&s->imdct_256);
1148 1148

  
1149 1149
    return 0;
1150 1150
}

Also available in: Unified diff