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