0d2c4a62f61b4e724cdc570b7dd939b3c91cedd5
[ffmpeg.git] / libavcodec / ac3dec.c
1 /*
2  * AC-3 Audio Decoder
3  * This code was developed as part of Google Summer of Code 2006.
4  * E-AC-3 support was added as part of Google Summer of Code 2007.
5  *
6  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).
7  * Copyright (c) 2007-2008 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
8  * Copyright (c) 2007 Justin Ruggles <justin.ruggles@gmail.com>
9  *
10  * Portions of this code are derived from liba52
11  * http://liba52.sourceforge.net
12  * Copyright (C) 2000-2003 Michel Lespinasse <walken@zoy.org>
13  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
14  *
15  * This file is part of FFmpeg.
16  *
17  * FFmpeg is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public
19  * License as published by the Free Software Foundation; either
20  * version 2 of the License, or (at your option) any later version.
21  *
22  * FFmpeg is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public
28  * License along with FFmpeg; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #include <stdio.h>
33 #include <stddef.h>
34 #include <math.h>
35 #include <string.h>
36
37 #include "libavutil/crc.h"
38 #include "ac3_parser.h"
39 #include "ac3dec.h"
40 #include "ac3dec_data.h"
41
42 /** Large enough for maximum possible frame size when the specification limit is ignored */
43 #define AC3_FRAME_BUFFER_SIZE 32768
44
45 /**
46  * table for ungrouping 3 values in 7 bits.
47  * used for exponents and bap=2 mantissas
48  */
49 static uint8_t ungroup_3_in_7_bits_tab[128][3];
50
51
52 /** tables for ungrouping mantissas */
53 static int b1_mantissas[32][3];
54 static int b2_mantissas[128][3];
55 static int b3_mantissas[8];
56 static int b4_mantissas[128][2];
57 static int b5_mantissas[16];
58
59 /**
60  * Quantization table: levels for symmetric. bits for asymmetric.
61  * reference: Table 7.18 Mapping of bap to Quantizer
62  */
63 static const uint8_t quantization_tab[16] = {
64     0, 3, 5, 7, 11, 15,
65     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
66 };
67
68 /** dynamic range table. converts codes to scale factors. */
69 static float dynamic_range_tab[256];
70
71 /** Adjustments in dB gain */
72 #define LEVEL_PLUS_3DB          1.4142135623730950
73 #define LEVEL_PLUS_1POINT5DB    1.1892071150027209
74 #define LEVEL_MINUS_1POINT5DB   0.8408964152537145
75 #define LEVEL_MINUS_3DB         0.7071067811865476
76 #define LEVEL_MINUS_4POINT5DB   0.5946035575013605
77 #define LEVEL_MINUS_6DB         0.5000000000000000
78 #define LEVEL_MINUS_9DB         0.3535533905932738
79 #define LEVEL_ZERO              0.0000000000000000
80 #define LEVEL_ONE               1.0000000000000000
81
82 static const float gain_levels[9] = {
83     LEVEL_PLUS_3DB,
84     LEVEL_PLUS_1POINT5DB,
85     LEVEL_ONE,
86     LEVEL_MINUS_1POINT5DB,
87     LEVEL_MINUS_3DB,
88     LEVEL_MINUS_4POINT5DB,
89     LEVEL_MINUS_6DB,
90     LEVEL_ZERO,
91     LEVEL_MINUS_9DB
92 };
93
94 /**
95  * Table for center mix levels
96  * reference: Section 5.4.2.4 cmixlev
97  */
98 static const uint8_t center_levels[4] = { 4, 5, 6, 5 };
99
100 /**
101  * Table for surround mix levels
102  * reference: Section 5.4.2.5 surmixlev
103  */
104 static const uint8_t surround_levels[4] = { 4, 6, 7, 6 };
105
106 /**
107  * Table for default stereo downmixing coefficients
108  * reference: Section 7.8.2 Downmixing Into Two Channels
109  */
110 static const uint8_t ac3_default_coeffs[8][5][2] = {
111     { { 2, 7 }, { 7, 2 },                               },
112     { { 4, 4 },                                         },
113     { { 2, 7 }, { 7, 2 },                               },
114     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
115     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
116     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
117     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
118     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
119 };
120
121 /**
122  * Symmetrical Dequantization
123  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
124  *            Tables 7.19 to 7.23
125  */
126 static inline int
127 symmetric_dequant(int code, int levels)
128 {
129     return ((code - (levels >> 1)) << 24) / levels;
130 }
131
132 /*
133  * Initialize tables at runtime.
134  */
135 static av_cold void ac3_tables_init(void)
136 {
137     int i;
138
139     /* generate table for ungrouping 3 values in 7 bits
140        reference: Section 7.1.3 Exponent Decoding */
141     for(i=0; i<128; i++) {
142         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
143         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
144         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
145     }
146
147     /* generate grouped mantissa tables
148        reference: Section 7.3.5 Ungrouping of Mantissas */
149     for(i=0; i<32; i++) {
150         /* bap=1 mantissas */
151         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
152         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
153         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
154     }
155     for(i=0; i<128; i++) {
156         /* bap=2 mantissas */
157         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
158         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
159         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
160
161         /* bap=4 mantissas */
162         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
163         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
164     }
165     /* generate ungrouped mantissa tables
166        reference: Tables 7.21 and 7.23 */
167     for(i=0; i<7; i++) {
168         /* bap=3 mantissas */
169         b3_mantissas[i] = symmetric_dequant(i, 7);
170     }
171     for(i=0; i<15; i++) {
172         /* bap=5 mantissas */
173         b5_mantissas[i] = symmetric_dequant(i, 15);
174     }
175
176     /* generate dynamic range table
177        reference: Section 7.7.1 Dynamic Range Control */
178     for(i=0; i<256; i++) {
179         int v = (i >> 5) - ((i >> 7) << 3) - 5;
180         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
181     }
182 }
183
184
185 /**
186  * AVCodec initialization
187  */
188 static av_cold int ac3_decode_init(AVCodecContext *avctx)
189 {
190     AC3DecodeContext *s = avctx->priv_data;
191     s->avctx = avctx;
192
193     ac3_common_init();
194     ac3_tables_init();
195     ff_mdct_init(&s->imdct_256, 8, 1);
196     ff_mdct_init(&s->imdct_512, 9, 1);
197     ff_kbd_window_init(s->window, 5.0, 256);
198     dsputil_init(&s->dsp, avctx);
199     av_lfg_init(&s->dith_state, 0);
200
201     /* set bias values for float to int16 conversion */
202     if(s->dsp.float_to_int16_interleave == ff_float_to_int16_interleave_c) {
203         s->add_bias = 385.0f;
204         s->mul_bias = 1.0f;
205     } else {
206         s->add_bias = 0.0f;
207         s->mul_bias = 32767.0f;
208     }
209
210     /* allow downmixing to stereo or mono */
211     if (avctx->channels > 0 && avctx->request_channels > 0 &&
212             avctx->request_channels < avctx->channels &&
213             avctx->request_channels <= 2) {
214         avctx->channels = avctx->request_channels;
215     }
216     s->downmixed = 1;
217
218     /* allocate context input buffer */
219     if (avctx->error_resilience >= FF_ER_CAREFUL) {
220         s->input_buffer = av_mallocz(AC3_FRAME_BUFFER_SIZE + FF_INPUT_BUFFER_PADDING_SIZE);
221         if (!s->input_buffer)
222             return AVERROR_NOMEM;
223     }
224
225     avctx->sample_fmt = SAMPLE_FMT_S16;
226     return 0;
227 }
228
229 /**
230  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
231  * GetBitContext within AC3DecodeContext must point to
232  * the start of the synchronized AC-3 bitstream.
233  */
234 static int ac3_parse_header(AC3DecodeContext *s)
235 {
236     GetBitContext *gbc = &s->gbc;
237     int i;
238
239     /* read the rest of the bsi. read twice for dual mono mode. */
240     i = !(s->channel_mode);
241     do {
242         skip_bits(gbc, 5); // skip dialog normalization
243         if (get_bits1(gbc))
244             skip_bits(gbc, 8); //skip compression
245         if (get_bits1(gbc))
246             skip_bits(gbc, 8); //skip language code
247         if (get_bits1(gbc))
248             skip_bits(gbc, 7); //skip audio production information
249     } while (i--);
250
251     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
252
253     /* skip the timecodes (or extra bitstream information for Alternate Syntax)
254        TODO: read & use the xbsi1 downmix levels */
255     if (get_bits1(gbc))
256         skip_bits(gbc, 14); //skip timecode1 / xbsi1
257     if (get_bits1(gbc))
258         skip_bits(gbc, 14); //skip timecode2 / xbsi2
259
260     /* skip additional bitstream info */
261     if (get_bits1(gbc)) {
262         i = get_bits(gbc, 6);
263         do {
264             skip_bits(gbc, 8);
265         } while(i--);
266     }
267
268     return 0;
269 }
270
271 /**
272  * Common function to parse AC-3 or E-AC-3 frame header
273  */
274 static int parse_frame_header(AC3DecodeContext *s)
275 {
276     AC3HeaderInfo hdr;
277     int err;
278
279     err = ff_ac3_parse_header(&s->gbc, &hdr);
280     if(err)
281         return err;
282
283     /* get decoding parameters from header info */
284     s->bit_alloc_params.sr_code     = hdr.sr_code;
285     s->channel_mode                 = hdr.channel_mode;
286     s->lfe_on                       = hdr.lfe_on;
287     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
288     s->sample_rate                  = hdr.sample_rate;
289     s->bit_rate                     = hdr.bit_rate;
290     s->channels                     = hdr.channels;
291     s->fbw_channels                 = s->channels - s->lfe_on;
292     s->lfe_ch                       = s->fbw_channels + 1;
293     s->frame_size                   = hdr.frame_size;
294     s->center_mix_level             = hdr.center_mix_level;
295     s->surround_mix_level           = hdr.surround_mix_level;
296     s->num_blocks                   = hdr.num_blocks;
297     s->frame_type                   = hdr.frame_type;
298     s->substreamid                  = hdr.substreamid;
299
300     if(s->lfe_on) {
301         s->start_freq[s->lfe_ch] = 0;
302         s->end_freq[s->lfe_ch] = 7;
303         s->num_exp_groups[s->lfe_ch] = 2;
304         s->channel_in_cpl[s->lfe_ch] = 0;
305     }
306
307     if (hdr.bitstream_id <= 10) {
308         s->eac3                  = 0;
309         s->snr_offset_strategy   = 2;
310         s->block_switch_syntax   = 1;
311         s->dither_flag_syntax    = 1;
312         s->bit_allocation_syntax = 1;
313         s->fast_gain_syntax      = 0;
314         s->first_cpl_leak        = 0;
315         s->dba_syntax            = 1;
316         s->skip_syntax           = 1;
317         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
318         return ac3_parse_header(s);
319     } else {
320         /*s->eac3 = 1;
321         return ff_eac3_parse_header(s);*/
322         return AC3_PARSE_ERROR_BSID;
323     }
324 }
325
326 /**
327  * Set stereo downmixing coefficients based on frame header info.
328  * reference: Section 7.8.2 Downmixing Into Two Channels
329  */
330 static void set_downmix_coeffs(AC3DecodeContext *s)
331 {
332     int i;
333     float cmix = gain_levels[center_levels[s->center_mix_level]];
334     float smix = gain_levels[surround_levels[s->surround_mix_level]];
335     float norm0, norm1;
336
337     for(i=0; i<s->fbw_channels; i++) {
338         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
339         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
340     }
341     if(s->channel_mode > 1 && s->channel_mode & 1) {
342         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
343     }
344     if(s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
345         int nf = s->channel_mode - 2;
346         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
347     }
348     if(s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
349         int nf = s->channel_mode - 4;
350         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
351     }
352
353     /* renormalize */
354     norm0 = norm1 = 0.0;
355     for(i=0; i<s->fbw_channels; i++) {
356         norm0 += s->downmix_coeffs[i][0];
357         norm1 += s->downmix_coeffs[i][1];
358     }
359     norm0 = 1.0f / norm0;
360     norm1 = 1.0f / norm1;
361     for(i=0; i<s->fbw_channels; i++) {
362         s->downmix_coeffs[i][0] *= norm0;
363         s->downmix_coeffs[i][1] *= norm1;
364     }
365
366     if(s->output_mode == AC3_CHMODE_MONO) {
367         for(i=0; i<s->fbw_channels; i++)
368             s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] + s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
369     }
370 }
371
372 /**
373  * Decode the grouped exponents according to exponent strategy.
374  * reference: Section 7.1.3 Exponent Decoding
375  */
376 static void decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
377                              uint8_t absexp, int8_t *dexps)
378 {
379     int i, j, grp, group_size;
380     int dexp[256];
381     int expacc, prevexp;
382
383     /* unpack groups */
384     group_size = exp_strategy + (exp_strategy == EXP_D45);
385     for(grp=0,i=0; grp<ngrps; grp++) {
386         expacc = get_bits(gbc, 7);
387         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
388         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
389         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
390     }
391
392     /* convert to absolute exps and expand groups */
393     prevexp = absexp;
394     for(i=0; i<ngrps*3; i++) {
395         prevexp = av_clip(prevexp + dexp[i]-2, 0, 24);
396         for(j=0; j<group_size; j++) {
397             dexps[(i*group_size)+j] = prevexp;
398         }
399     }
400 }
401
402 /**
403  * Generate transform coefficients for each coupled channel in the coupling
404  * range using the coupling coefficients and coupling coordinates.
405  * reference: Section 7.4.3 Coupling Coordinate Format
406  */
407 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
408 {
409     int i, j, ch, bnd, subbnd;
410
411     subbnd = -1;
412     i = s->start_freq[CPL_CH];
413     for(bnd=0; bnd<s->num_cpl_bands; bnd++) {
414         do {
415             subbnd++;
416             for(j=0; j<12; j++) {
417                 for(ch=1; ch<=s->fbw_channels; ch++) {
418                     if(s->channel_in_cpl[ch]) {
419                         s->fixed_coeffs[ch][i] = ((int64_t)s->fixed_coeffs[CPL_CH][i] * (int64_t)s->cpl_coords[ch][bnd]) >> 23;
420                         if (ch == 2 && s->phase_flags[bnd])
421                             s->fixed_coeffs[ch][i] = -s->fixed_coeffs[ch][i];
422                     }
423                 }
424                 i++;
425             }
426         } while(s->cpl_band_struct[subbnd]);
427     }
428 }
429
430 /**
431  * Grouped mantissas for 3-level 5-level and 11-level quantization
432  */
433 typedef struct {
434     int b1_mant[3];
435     int b2_mant[3];
436     int b4_mant[2];
437     int b1ptr;
438     int b2ptr;
439     int b4ptr;
440 } mant_groups;
441
442 /**
443  * Get the transform coefficients for a particular channel
444  * reference: Section 7.3 Quantization and Decoding of Mantissas
445  */
446 static void get_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
447 {
448     GetBitContext *gbc = &s->gbc;
449     int i, gcode, tbap, start, end;
450     uint8_t *exps;
451     uint8_t *bap;
452     int *coeffs;
453
454     exps = s->dexps[ch_index];
455     bap = s->bap[ch_index];
456     coeffs = s->fixed_coeffs[ch_index];
457     start = s->start_freq[ch_index];
458     end = s->end_freq[ch_index];
459
460     for (i = start; i < end; i++) {
461         tbap = bap[i];
462         switch (tbap) {
463             case 0:
464                 coeffs[i] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
465                 break;
466
467             case 1:
468                 if(m->b1ptr > 2) {
469                     gcode = get_bits(gbc, 5);
470                     m->b1_mant[0] = b1_mantissas[gcode][0];
471                     m->b1_mant[1] = b1_mantissas[gcode][1];
472                     m->b1_mant[2] = b1_mantissas[gcode][2];
473                     m->b1ptr = 0;
474                 }
475                 coeffs[i] = m->b1_mant[m->b1ptr++];
476                 break;
477
478             case 2:
479                 if(m->b2ptr > 2) {
480                     gcode = get_bits(gbc, 7);
481                     m->b2_mant[0] = b2_mantissas[gcode][0];
482                     m->b2_mant[1] = b2_mantissas[gcode][1];
483                     m->b2_mant[2] = b2_mantissas[gcode][2];
484                     m->b2ptr = 0;
485                 }
486                 coeffs[i] = m->b2_mant[m->b2ptr++];
487                 break;
488
489             case 3:
490                 coeffs[i] = b3_mantissas[get_bits(gbc, 3)];
491                 break;
492
493             case 4:
494                 if(m->b4ptr > 1) {
495                     gcode = get_bits(gbc, 7);
496                     m->b4_mant[0] = b4_mantissas[gcode][0];
497                     m->b4_mant[1] = b4_mantissas[gcode][1];
498                     m->b4ptr = 0;
499                 }
500                 coeffs[i] = m->b4_mant[m->b4ptr++];
501                 break;
502
503             case 5:
504                 coeffs[i] = b5_mantissas[get_bits(gbc, 4)];
505                 break;
506
507             default: {
508                 /* asymmetric dequantization */
509                 int qlevel = quantization_tab[tbap];
510                 coeffs[i] = get_sbits(gbc, qlevel) << (24 - qlevel);
511                 break;
512             }
513         }
514         coeffs[i] >>= exps[i];
515     }
516 }
517
518 /**
519  * Remove random dithering from coefficients with zero-bit mantissas
520  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
521  */
522 static void remove_dithering(AC3DecodeContext *s) {
523     int ch, i;
524     int end=0;
525     int *coeffs;
526     uint8_t *bap;
527
528     for(ch=1; ch<=s->fbw_channels; ch++) {
529         if(!s->dither_flag[ch]) {
530             coeffs = s->fixed_coeffs[ch];
531             bap = s->bap[ch];
532             if(s->channel_in_cpl[ch])
533                 end = s->start_freq[CPL_CH];
534             else
535                 end = s->end_freq[ch];
536             for(i=0; i<end; i++) {
537                 if(!bap[i])
538                     coeffs[i] = 0;
539             }
540             if(s->channel_in_cpl[ch]) {
541                 bap = s->bap[CPL_CH];
542                 for(; i<s->end_freq[CPL_CH]; i++) {
543                     if(!bap[i])
544                         coeffs[i] = 0;
545                 }
546             }
547         }
548     }
549 }
550
551 #if 0
552 static void get_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
553                                     mant_groups *m)
554 {
555     if (!s->channel_uses_aht[ch]) {
556         ac3_get_transform_coeffs_ch(s, ch, m);
557     } else {
558         /* if AHT is used, mantissas for all blocks are encoded in the first
559            block of the frame. */
560         int bin;
561         if (!blk)
562             ff_eac3_get_transform_coeffs_aht_ch(s, ch);
563         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
564             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
565         }
566     }
567 }
568 #endif
569
570 /**
571  * Get the transform coefficients.
572  */
573 static void get_transform_coeffs(AC3DecodeContext *s)
574 {
575     int ch, end;
576     int got_cplchan = 0;
577     mant_groups m;
578
579     m.b1ptr = m.b2ptr = m.b4ptr = 3;
580
581     for (ch = 1; ch <= s->channels; ch++) {
582         /* transform coefficients for full-bandwidth channel */
583         get_transform_coeffs_ch(s, ch, &m);
584         /* tranform coefficients for coupling channel come right after the
585            coefficients for the first coupled channel*/
586         if (s->channel_in_cpl[ch])  {
587             if (!got_cplchan) {
588                 get_transform_coeffs_ch(s, CPL_CH, &m);
589                 calc_transform_coeffs_cpl(s);
590                 got_cplchan = 1;
591             }
592             end = s->end_freq[CPL_CH];
593         } else {
594             end = s->end_freq[ch];
595         }
596         do
597             s->fixed_coeffs[ch][end] = 0;
598         while(++end < 256);
599     }
600
601     /* if any channel doesn't use dithering, zero appropriate coefficients */
602     if(!s->dither_all)
603         remove_dithering(s);
604 }
605
606 /**
607  * Stereo rematrixing.
608  * reference: Section 7.5.4 Rematrixing : Decoding Technique
609  */
610 static void do_rematrixing(AC3DecodeContext *s)
611 {
612     int bnd, i;
613     int end, bndend;
614     int tmp0, tmp1;
615
616     end = FFMIN(s->end_freq[1], s->end_freq[2]);
617
618     for(bnd=0; bnd<s->num_rematrixing_bands; bnd++) {
619         if(s->rematrixing_flags[bnd]) {
620             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd+1]);
621             for(i=ff_ac3_rematrix_band_tab[bnd]; i<bndend; i++) {
622                 tmp0 = s->fixed_coeffs[1][i];
623                 tmp1 = s->fixed_coeffs[2][i];
624                 s->fixed_coeffs[1][i] = tmp0 + tmp1;
625                 s->fixed_coeffs[2][i] = tmp0 - tmp1;
626             }
627         }
628     }
629 }
630
631 /**
632  * Inverse MDCT Transform.
633  * Convert frequency domain coefficients to time-domain audio samples.
634  * reference: Section 7.9.4 Transformation Equations
635  */
636 static inline void do_imdct(AC3DecodeContext *s, int channels)
637 {
638     int ch;
639     float add_bias = s->add_bias;
640     if(s->out_channels==1 && channels>1)
641         add_bias *= LEVEL_MINUS_3DB; // compensate for the gain in downmix
642
643     for (ch=1; ch<=channels; ch++) {
644         if (s->block_switch[ch]) {
645             int i;
646             float *x = s->tmp_output+128;
647             for(i=0; i<128; i++)
648                 x[i] = s->transform_coeffs[ch][2*i];
649             ff_imdct_half(&s->imdct_256, s->tmp_output, x);
650             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
651             for(i=0; i<128; i++)
652                 x[i] = s->transform_coeffs[ch][2*i+1];
653             ff_imdct_half(&s->imdct_256, s->delay[ch-1], x);
654         } else {
655             ff_imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
656             s->dsp.vector_fmul_window(s->output[ch-1], s->delay[ch-1], s->tmp_output, s->window, add_bias, 128);
657             memcpy(s->delay[ch-1], s->tmp_output+128, 128*sizeof(float));
658         }
659     }
660 }
661
662 /**
663  * Downmix the output to mono or stereo.
664  */
665 void ff_ac3_downmix_c(float (*samples)[256], float (*matrix)[2], int out_ch, int in_ch, int len)
666 {
667     int i, j;
668     float v0, v1;
669     if(out_ch == 2) {
670         for(i=0; i<len; i++) {
671             v0 = v1 = 0.0f;
672             for(j=0; j<in_ch; j++) {
673                 v0 += samples[j][i] * matrix[j][0];
674                 v1 += samples[j][i] * matrix[j][1];
675             }
676             samples[0][i] = v0;
677             samples[1][i] = v1;
678         }
679     } else if(out_ch == 1) {
680         for(i=0; i<len; i++) {
681             v0 = 0.0f;
682             for(j=0; j<in_ch; j++)
683                 v0 += samples[j][i] * matrix[j][0];
684             samples[0][i] = v0;
685         }
686     }
687 }
688
689 /**
690  * Upmix delay samples from stereo to original channel layout.
691  */
692 static void ac3_upmix_delay(AC3DecodeContext *s)
693 {
694     int channel_data_size = sizeof(s->delay[0]);
695     switch(s->channel_mode) {
696         case AC3_CHMODE_DUALMONO:
697         case AC3_CHMODE_STEREO:
698             /* upmix mono to stereo */
699             memcpy(s->delay[1], s->delay[0], channel_data_size);
700             break;
701         case AC3_CHMODE_2F2R:
702             memset(s->delay[3], 0, channel_data_size);
703         case AC3_CHMODE_2F1R:
704             memset(s->delay[2], 0, channel_data_size);
705             break;
706         case AC3_CHMODE_3F2R:
707             memset(s->delay[4], 0, channel_data_size);
708         case AC3_CHMODE_3F1R:
709             memset(s->delay[3], 0, channel_data_size);
710         case AC3_CHMODE_3F:
711             memcpy(s->delay[2], s->delay[1], channel_data_size);
712             memset(s->delay[1], 0, channel_data_size);
713             break;
714     }
715 }
716
717 /**
718  * Decode a single audio block from the AC-3 bitstream.
719  */
720 static int decode_audio_block(AC3DecodeContext *s, int blk)
721 {
722     int fbw_channels = s->fbw_channels;
723     int channel_mode = s->channel_mode;
724     int i, bnd, seg, ch;
725     int different_transforms;
726     int downmix_output;
727     int cpl_in_use;
728     GetBitContext *gbc = &s->gbc;
729     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS];
730
731     memset(bit_alloc_stages, 0, AC3_MAX_CHANNELS);
732
733     /* block switch flags */
734     different_transforms = 0;
735     if (s->block_switch_syntax) {
736         for (ch = 1; ch <= fbw_channels; ch++) {
737             s->block_switch[ch] = get_bits1(gbc);
738             if(ch > 1 && s->block_switch[ch] != s->block_switch[1])
739                 different_transforms = 1;
740         }
741     }
742
743     /* dithering flags */
744     if (s->dither_flag_syntax) {
745         s->dither_all = 1;
746         for (ch = 1; ch <= fbw_channels; ch++) {
747             s->dither_flag[ch] = get_bits1(gbc);
748             if(!s->dither_flag[ch])
749                 s->dither_all = 0;
750         }
751     }
752
753     /* dynamic range */
754     i = !(s->channel_mode);
755     do {
756         if(get_bits1(gbc)) {
757             s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)]-1.0) *
758                                   s->avctx->drc_scale)+1.0;
759         } else if(blk == 0) {
760             s->dynamic_range[i] = 1.0f;
761         }
762     } while(i--);
763
764     /* coupling strategy */
765     if (get_bits1(gbc)) {
766         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
767         s->cpl_in_use[blk] = get_bits1(gbc);
768         if (s->cpl_in_use[blk]) {
769             /* coupling in use */
770             int cpl_begin_freq, cpl_end_freq;
771
772             if (channel_mode < AC3_CHMODE_STEREO) {
773                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
774                 return -1;
775             }
776
777             /* determine which channels are coupled */
778             for (ch = 1; ch <= fbw_channels; ch++)
779                 s->channel_in_cpl[ch] = get_bits1(gbc);
780
781             /* phase flags in use */
782             if (channel_mode == AC3_CHMODE_STEREO)
783                 s->phase_flags_in_use = get_bits1(gbc);
784
785             /* coupling frequency range and band structure */
786             cpl_begin_freq = get_bits(gbc, 4);
787             cpl_end_freq = get_bits(gbc, 4);
788             if (3 + cpl_end_freq - cpl_begin_freq < 0) {
789                 av_log(s->avctx, AV_LOG_ERROR, "3+cplendf = %d < cplbegf = %d\n", 3+cpl_end_freq, cpl_begin_freq);
790                 return -1;
791             }
792             s->num_cpl_bands = s->num_cpl_subbands = 3 + cpl_end_freq - cpl_begin_freq;
793             s->start_freq[CPL_CH] = cpl_begin_freq * 12 + 37;
794             s->end_freq[CPL_CH] = cpl_end_freq * 12 + 73;
795             for (bnd = 0; bnd < s->num_cpl_subbands - 1; bnd++) {
796                 if (get_bits1(gbc)) {
797                     s->cpl_band_struct[bnd] = 1;
798                     s->num_cpl_bands--;
799                 }
800             }
801             s->cpl_band_struct[s->num_cpl_subbands-1] = 0;
802         } else {
803             /* coupling not in use */
804             for (ch = 1; ch <= fbw_channels; ch++)
805                 s->channel_in_cpl[ch] = 0;
806         }
807     } else if (!blk) {
808         av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must be present in block 0\n");
809         return -1;
810     } else {
811         s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
812     }
813     cpl_in_use = s->cpl_in_use[blk];
814
815     /* coupling coordinates */
816     if (cpl_in_use) {
817         int cpl_coords_exist = 0;
818
819         for (ch = 1; ch <= fbw_channels; ch++) {
820             if (s->channel_in_cpl[ch]) {
821                 if (get_bits1(gbc)) {
822                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
823                     cpl_coords_exist = 1;
824                     master_cpl_coord = 3 * get_bits(gbc, 2);
825                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
826                         cpl_coord_exp = get_bits(gbc, 4);
827                         cpl_coord_mant = get_bits(gbc, 4);
828                         if (cpl_coord_exp == 15)
829                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
830                         else
831                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
832                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
833                     }
834                 } else if (!blk) {
835                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must be present in block 0\n");
836                     return -1;
837                 }
838             }
839         }
840         /* phase flags */
841         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
842             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
843                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
844             }
845         }
846     }
847
848     /* stereo rematrixing strategy and band structure */
849     if (channel_mode == AC3_CHMODE_STEREO) {
850         if (get_bits1(gbc)) {
851             s->num_rematrixing_bands = 4;
852             if(cpl_in_use && s->start_freq[CPL_CH] <= 61)
853                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
854             for(bnd=0; bnd<s->num_rematrixing_bands; bnd++)
855                 s->rematrixing_flags[bnd] = get_bits1(gbc);
856         } else if (!blk) {
857             av_log(s->avctx, AV_LOG_ERROR, "new rematrixing strategy must be present in block 0\n");
858             return -1;
859         }
860     }
861
862     /* exponent strategies for each channel */
863     s->exp_strategy[blk][CPL_CH] = EXP_REUSE;
864     s->exp_strategy[blk][s->lfe_ch] = EXP_REUSE;
865     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
866         s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
867         if(s->exp_strategy[blk][ch] != EXP_REUSE)
868             bit_alloc_stages[ch] = 3;
869     }
870
871     /* channel bandwidth */
872     for (ch = 1; ch <= fbw_channels; ch++) {
873         s->start_freq[ch] = 0;
874         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
875             int group_size;
876             int prev = s->end_freq[ch];
877             if (s->channel_in_cpl[ch])
878                 s->end_freq[ch] = s->start_freq[CPL_CH];
879             else {
880                 int bandwidth_code = get_bits(gbc, 6);
881                 if (bandwidth_code > 60) {
882                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60", bandwidth_code);
883                     return -1;
884                 }
885                 s->end_freq[ch] = bandwidth_code * 3 + 73;
886             }
887             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
888             s->num_exp_groups[ch] = (s->end_freq[ch]+group_size-4) / group_size;
889             if(blk > 0 && s->end_freq[ch] != prev)
890                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
891         }
892     }
893     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
894         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
895                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
896     }
897
898     /* decode exponents for each channel */
899     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
900         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
901             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
902             decode_exponents(gbc, s->exp_strategy[blk][ch],
903                              s->num_exp_groups[ch], s->dexps[ch][0],
904                              &s->dexps[ch][s->start_freq[ch]+!!ch]);
905             if(ch != CPL_CH && ch != s->lfe_ch)
906                 skip_bits(gbc, 2); /* skip gainrng */
907         }
908     }
909
910     /* bit allocation information */
911     if (s->bit_allocation_syntax) {
912         if (get_bits1(gbc)) {
913             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
914             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
915             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
916             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
917             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
918             for(ch=!cpl_in_use; ch<=s->channels; ch++)
919                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
920         } else if (!blk) {
921             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must be present in block 0\n");
922             return -1;
923         }
924     }
925
926     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
927     if (get_bits1(gbc)) {
928         int csnr;
929         csnr = (get_bits(gbc, 6) - 15) << 4;
930         for (ch = !cpl_in_use; ch <= s->channels; ch++) { /* snr offset and fast gain */
931             s->snr_offset[ch] = (csnr + get_bits(gbc, 4)) << 2;
932             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
933         }
934         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
935     } else if (!blk) {
936         av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
937         return -1;
938     }
939
940     /* coupling leak information */
941     if (cpl_in_use) {
942         if (get_bits1(gbc)) {
943             s->bit_alloc_params.cpl_fast_leak = get_bits(gbc, 3);
944             s->bit_alloc_params.cpl_slow_leak = get_bits(gbc, 3);
945             bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
946         } else if (!blk) {
947             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must be present in block 0\n");
948             return -1;
949         }
950     }
951
952     /* delta bit allocation information */
953     if (s->dba_syntax && get_bits1(gbc)) {
954         /* delta bit allocation exists (strategy) */
955         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
956             s->dba_mode[ch] = get_bits(gbc, 2);
957             if (s->dba_mode[ch] == DBA_RESERVED) {
958                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
959                 return -1;
960             }
961             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
962         }
963         /* channel delta offset, len and bit allocation */
964         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
965             if (s->dba_mode[ch] == DBA_NEW) {
966                 s->dba_nsegs[ch] = get_bits(gbc, 3);
967                 for (seg = 0; seg <= s->dba_nsegs[ch]; seg++) {
968                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
969                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
970                     s->dba_values[ch][seg] = get_bits(gbc, 3);
971                 }
972                 /* run last 2 bit allocation stages if new dba values */
973                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
974             }
975         }
976     } else if(blk == 0) {
977         for(ch=0; ch<=s->channels; ch++) {
978             s->dba_mode[ch] = DBA_NONE;
979         }
980     }
981
982     /* Bit allocation */
983     for(ch=!cpl_in_use; ch<=s->channels; ch++) {
984         if(bit_alloc_stages[ch] > 2) {
985             /* Exponent mapping into PSD and PSD integration */
986             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
987                                       s->start_freq[ch], s->end_freq[ch],
988                                       s->psd[ch], s->band_psd[ch]);
989         }
990         if(bit_alloc_stages[ch] > 1) {
991             /* Compute excitation function, Compute masking curve, and
992                Apply delta bit allocation */
993             ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
994                                        s->start_freq[ch], s->end_freq[ch],
995                                        s->fast_gain[ch], (ch == s->lfe_ch),
996                                        s->dba_mode[ch], s->dba_nsegs[ch],
997                                        s->dba_offsets[ch], s->dba_lengths[ch],
998                                        s->dba_values[ch], s->mask[ch]);
999         }
1000         if(bit_alloc_stages[ch] > 0) {
1001             /* Compute bit allocation */
1002             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1003                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1004             ff_ac3_bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1005                                       s->start_freq[ch], s->end_freq[ch],
1006                                       s->snr_offset[ch],
1007                                       s->bit_alloc_params.floor,
1008                                       bap_tab, s->bap[ch]);
1009         }
1010     }
1011
1012     /* unused dummy data */
1013     if (s->skip_syntax && get_bits1(gbc)) {
1014         int skipl = get_bits(gbc, 9);
1015         while(skipl--)
1016             skip_bits(gbc, 8);
1017     }
1018
1019     /* unpack the transform coefficients
1020        this also uncouples channels if coupling is in use. */
1021     get_transform_coeffs(s);
1022
1023     /* TODO: generate enhanced coupling coordinates and uncouple */
1024
1025     /* TODO: apply spectral extension */
1026
1027     /* recover coefficients if rematrixing is in use */
1028     if(s->channel_mode == AC3_CHMODE_STEREO)
1029         do_rematrixing(s);
1030
1031     /* apply scaling to coefficients (headroom, dynrng) */
1032     for(ch=1; ch<=s->channels; ch++) {
1033         float gain = s->mul_bias / 4194304.0f;
1034         if(s->channel_mode == AC3_CHMODE_DUALMONO) {
1035             gain *= s->dynamic_range[ch-1];
1036         } else {
1037             gain *= s->dynamic_range[0];
1038         }
1039         s->dsp.int32_to_float_fmul_scalar(s->transform_coeffs[ch], s->fixed_coeffs[ch], gain, 256);
1040     }
1041
1042     /* downmix and MDCT. order depends on whether block switching is used for
1043        any channel in this block. this is because coefficients for the long
1044        and short transforms cannot be mixed. */
1045     downmix_output = s->channels != s->out_channels &&
1046                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1047                      s->fbw_channels == s->out_channels);
1048     if(different_transforms) {
1049         /* the delay samples have already been downmixed, so we upmix the delay
1050            samples in order to reconstruct all channels before downmixing. */
1051         if(s->downmixed) {
1052             s->downmixed = 0;
1053             ac3_upmix_delay(s);
1054         }
1055
1056         do_imdct(s, s->channels);
1057
1058         if(downmix_output) {
1059             s->dsp.ac3_downmix(s->output, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1060         }
1061     } else {
1062         if(downmix_output) {
1063             s->dsp.ac3_downmix(s->transform_coeffs+1, s->downmix_coeffs, s->out_channels, s->fbw_channels, 256);
1064         }
1065
1066         if(downmix_output && !s->downmixed) {
1067             s->downmixed = 1;
1068             s->dsp.ac3_downmix(s->delay, s->downmix_coeffs, s->out_channels, s->fbw_channels, 128);
1069         }
1070
1071         do_imdct(s, s->out_channels);
1072     }
1073
1074     return 0;
1075 }
1076
1077 /**
1078  * Decode a single AC-3 frame.
1079  */
1080 static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size,
1081                             const uint8_t *buf, int buf_size)
1082 {
1083     AC3DecodeContext *s = avctx->priv_data;
1084     int16_t *out_samples = (int16_t *)data;
1085     int blk, ch, err;
1086
1087     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1088     if (s->input_buffer) {
1089         /* copy input buffer to decoder context to avoid reading past the end
1090            of the buffer, which can be caused by a damaged input stream. */
1091         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1092         init_get_bits(&s->gbc, s->input_buffer, buf_size * 8);
1093     } else {
1094         init_get_bits(&s->gbc, buf, buf_size * 8);
1095     }
1096
1097     /* parse the syncinfo */
1098     *data_size = 0;
1099     err = parse_frame_header(s);
1100
1101     /* check that reported frame size fits in input buffer */
1102     if(s->frame_size > buf_size) {
1103         av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1104         err = AC3_PARSE_ERROR_FRAME_SIZE;
1105     }
1106
1107     /* check for crc mismatch */
1108     if(err != AC3_PARSE_ERROR_FRAME_SIZE && avctx->error_resilience >= FF_ER_CAREFUL) {
1109         if(av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2], s->frame_size-2)) {
1110             av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1111             err = AC3_PARSE_ERROR_CRC;
1112         }
1113     }
1114
1115     if(err && err != AC3_PARSE_ERROR_CRC) {
1116         switch(err) {
1117             case AC3_PARSE_ERROR_SYNC:
1118                 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1119                 return -1;
1120             case AC3_PARSE_ERROR_BSID:
1121                 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1122                 break;
1123             case AC3_PARSE_ERROR_SAMPLE_RATE:
1124                 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1125                 break;
1126             case AC3_PARSE_ERROR_FRAME_SIZE:
1127                 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1128                 break;
1129             case AC3_PARSE_ERROR_FRAME_TYPE:
1130                 /* skip frame if CRC is ok. otherwise use error concealment. */
1131                 /* TODO: add support for substreams and dependent frames */
1132                 if(s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1133                     av_log(avctx, AV_LOG_ERROR, "unsupported frame type : skipping frame\n");
1134                     return s->frame_size;
1135                 } else {
1136                     av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1137                 }
1138                 break;
1139             default:
1140                 av_log(avctx, AV_LOG_ERROR, "invalid header\n");
1141                 break;
1142         }
1143     }
1144
1145     /* if frame is ok, set audio parameters */
1146     if (!err) {
1147         avctx->sample_rate = s->sample_rate;
1148         avctx->bit_rate = s->bit_rate;
1149
1150         /* channel config */
1151         s->out_channels = s->channels;
1152         s->output_mode = s->channel_mode;
1153         if(s->lfe_on)
1154             s->output_mode |= AC3_OUTPUT_LFEON;
1155         if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&
1156                 avctx->request_channels < s->channels) {
1157             s->out_channels = avctx->request_channels;
1158             s->output_mode  = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1159         }
1160         avctx->channels = s->out_channels;
1161
1162         /* set downmixing coefficients if needed */
1163         if(s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1164                 s->fbw_channels == s->out_channels)) {
1165             set_downmix_coeffs(s);
1166         }
1167     } else if (!s->out_channels) {
1168         s->out_channels = avctx->channels;
1169         if(s->out_channels < s->channels)
1170             s->output_mode  = s->out_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;
1171     }
1172
1173     /* decode the audio blocks */
1174     for (blk = 0; blk < s->num_blocks; blk++) {
1175         const float *output[s->out_channels];
1176         if (!err && decode_audio_block(s, blk)) {
1177             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1178         }
1179         for (ch = 0; ch < s->out_channels; ch++)
1180             output[ch] = s->output[ch];
1181         s->dsp.float_to_int16_interleave(out_samples, output, 256, s->out_channels);
1182         out_samples += 256 * s->out_channels;
1183     }
1184     *data_size = s->num_blocks * 256 * avctx->channels * sizeof (int16_t);
1185     return s->frame_size;
1186 }
1187
1188 /**
1189  * Uninitialize the AC-3 decoder.
1190  */
1191 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1192 {
1193     AC3DecodeContext *s = avctx->priv_data;
1194     ff_mdct_end(&s->imdct_512);
1195     ff_mdct_end(&s->imdct_256);
1196
1197     av_freep(&s->input_buffer);
1198
1199     return 0;
1200 }
1201
1202 AVCodec ac3_decoder = {
1203     .name = "ac3",
1204     .type = CODEC_TYPE_AUDIO,
1205     .id = CODEC_ID_AC3,
1206     .priv_data_size = sizeof (AC3DecodeContext),
1207     .init = ac3_decode_init,
1208     .close = ac3_decode_end,
1209     .decode = ac3_decode_frame,
1210     .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52 (AC-3, E-AC-3)"),
1211 };