Merge commit '1f604f96ea70503caa642f68a85be6074a5b3f46'
[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  * This file is part of FFmpeg.
11  *
12  * FFmpeg is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU Lesser General Public
14  * License as published by the Free Software Foundation; either
15  * version 2.1 of the License, or (at your option) any later version.
16  *
17  * FFmpeg is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20  * Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public
23  * License along with FFmpeg; if not, write to the Free Software
24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25  */
26
27 #include <stdio.h>
28 #include <stddef.h>
29 #include <math.h>
30 #include <string.h>
31
32 #include "libavutil/channel_layout.h"
33 #include "libavutil/crc.h"
34 #include "libavutil/opt.h"
35 #include "internal.h"
36 #include "aac_ac3_parser.h"
37 #include "ac3_parser.h"
38 #include "ac3dec.h"
39 #include "ac3dec_data.h"
40 #include "kbdwin.h"
41
42 /**
43  * table for ungrouping 3 values in 7 bits.
44  * used for exponents and bap=2 mantissas
45  */
46 static uint8_t ungroup_3_in_7_bits_tab[128][3];
47
48 /** tables for ungrouping mantissas */
49 static int b1_mantissas[32][3];
50 static int b2_mantissas[128][3];
51 static int b3_mantissas[8];
52 static int b4_mantissas[128][2];
53 static int b5_mantissas[16];
54
55 /**
56  * Quantization table: levels for symmetric. bits for asymmetric.
57  * reference: Table 7.18 Mapping of bap to Quantizer
58  */
59 static const uint8_t quantization_tab[16] = {
60     0, 3, 5, 7, 11, 15,
61     5, 6, 7, 8, 9, 10, 11, 12, 14, 16
62 };
63
64 /** dynamic range table. converts codes to scale factors. */
65 static float dynamic_range_tab[256];
66
67 /** Adjustments in dB gain */
68 static const float gain_levels[9] = {
69     LEVEL_PLUS_3DB,
70     LEVEL_PLUS_1POINT5DB,
71     LEVEL_ONE,
72     LEVEL_MINUS_1POINT5DB,
73     LEVEL_MINUS_3DB,
74     LEVEL_MINUS_4POINT5DB,
75     LEVEL_MINUS_6DB,
76     LEVEL_ZERO,
77     LEVEL_MINUS_9DB
78 };
79
80 /**
81  * Table for default stereo downmixing coefficients
82  * reference: Section 7.8.2 Downmixing Into Two Channels
83  */
84 static const uint8_t ac3_default_coeffs[8][5][2] = {
85     { { 2, 7 }, { 7, 2 },                               },
86     { { 4, 4 },                                         },
87     { { 2, 7 }, { 7, 2 },                               },
88     { { 2, 7 }, { 5, 5 }, { 7, 2 },                     },
89     { { 2, 7 }, { 7, 2 }, { 6, 6 },                     },
90     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 },           },
91     { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 },           },
92     { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },
93 };
94
95 /**
96  * Symmetrical Dequantization
97  * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization
98  *            Tables 7.19 to 7.23
99  */
100 static inline int
101 symmetric_dequant(int code, int levels)
102 {
103     return ((code - (levels >> 1)) << 24) / levels;
104 }
105
106 /*
107  * Initialize tables at runtime.
108  */
109 static av_cold void ac3_tables_init(void)
110 {
111     int i;
112
113     /* generate table for ungrouping 3 values in 7 bits
114        reference: Section 7.1.3 Exponent Decoding */
115     for (i = 0; i < 128; i++) {
116         ungroup_3_in_7_bits_tab[i][0] =  i / 25;
117         ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;
118         ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;
119     }
120
121     /* generate grouped mantissa tables
122        reference: Section 7.3.5 Ungrouping of Mantissas */
123     for (i = 0; i < 32; i++) {
124         /* bap=1 mantissas */
125         b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);
126         b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);
127         b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);
128     }
129     for (i = 0; i < 128; i++) {
130         /* bap=2 mantissas */
131         b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);
132         b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);
133         b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);
134
135         /* bap=4 mantissas */
136         b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);
137         b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);
138     }
139     /* generate ungrouped mantissa tables
140        reference: Tables 7.21 and 7.23 */
141     for (i = 0; i < 7; i++) {
142         /* bap=3 mantissas */
143         b3_mantissas[i] = symmetric_dequant(i, 7);
144     }
145     for (i = 0; i < 15; i++) {
146         /* bap=5 mantissas */
147         b5_mantissas[i] = symmetric_dequant(i, 15);
148     }
149
150     /* generate dynamic range table
151        reference: Section 7.7.1 Dynamic Range Control */
152     for (i = 0; i < 256; i++) {
153         int v = (i >> 5) - ((i >> 7) << 3) - 5;
154         dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);
155     }
156 }
157
158 /**
159  * AVCodec initialization
160  */
161 static av_cold int ac3_decode_init(AVCodecContext *avctx)
162 {
163     AC3DecodeContext *s = avctx->priv_data;
164     int i;
165
166     s->avctx = avctx;
167
168     ff_ac3_common_init();
169     ac3_tables_init();
170     ff_mdct_init(&s->imdct_256, 8, 1, 1.0);
171     ff_mdct_init(&s->imdct_512, 9, 1, 1.0);
172     ff_kbd_window_init(s->window, 5.0, 256);
173     ff_dsputil_init(&s->dsp, avctx);
174     avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);
175     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
176     ff_fmt_convert_init(&s->fmt_conv, avctx);
177     av_lfg_init(&s->dith_state, 0);
178
179     avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
180
181     /* allow downmixing to stereo or mono */
182 #if FF_API_REQUEST_CHANNELS
183 FF_DISABLE_DEPRECATION_WARNINGS
184     if (avctx->request_channels == 1)
185         avctx->request_channel_layout = AV_CH_LAYOUT_MONO;
186     else if (avctx->request_channels == 2)
187         avctx->request_channel_layout = AV_CH_LAYOUT_STEREO;
188 FF_ENABLE_DEPRECATION_WARNINGS
189 #endif
190     if (avctx->channels > 1 &&
191         avctx->request_channel_layout == AV_CH_LAYOUT_MONO)
192         avctx->channels = 1;
193     else if (avctx->channels > 2 &&
194              avctx->request_channel_layout == AV_CH_LAYOUT_STEREO)
195         avctx->channels = 2;
196     s->downmixed = 1;
197
198     for (i = 0; i < AC3_MAX_CHANNELS; i++) {
199         s->xcfptr[i] = s->transform_coeffs[i];
200         s->dlyptr[i] = s->delay[i];
201     }
202
203     return 0;
204 }
205
206 /**
207  * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.
208  * GetBitContext within AC3DecodeContext must point to
209  * the start of the synchronized AC-3 bitstream.
210  */
211 static int ac3_parse_header(AC3DecodeContext *s)
212 {
213     GetBitContext *gbc = &s->gbc;
214     int i;
215
216     /* read the rest of the bsi. read twice for dual mono mode. */
217     i = !s->channel_mode;
218     do {
219         skip_bits(gbc, 5); // skip dialog normalization
220         if (get_bits1(gbc))
221             skip_bits(gbc, 8); //skip compression
222         if (get_bits1(gbc))
223             skip_bits(gbc, 8); //skip language code
224         if (get_bits1(gbc))
225             skip_bits(gbc, 7); //skip audio production information
226     } while (i--);
227
228     skip_bits(gbc, 2); //skip copyright bit and original bitstream bit
229
230     /* skip the timecodes or parse the Alternate Bit Stream Syntax
231        TODO: read & use the xbsi1 downmix levels */
232     if (s->bitstream_id != 6) {
233         if (get_bits1(gbc))
234             skip_bits(gbc, 14); //skip timecode1
235         if (get_bits1(gbc))
236             skip_bits(gbc, 14); //skip timecode2
237     } else {
238         if (get_bits1(gbc))
239             skip_bits(gbc, 14); //skip xbsi1
240         if (get_bits1(gbc)) {
241             s->dolby_surround_ex_mode = get_bits(gbc, 2);
242             s->dolby_headphone_mode   = get_bits(gbc, 2);
243             skip_bits(gbc, 10); // skip adconvtyp (1), xbsi2 (8), encinfo (1)
244         }
245     }
246
247     /* skip additional bitstream info */
248     if (get_bits1(gbc)) {
249         i = get_bits(gbc, 6);
250         do {
251             skip_bits(gbc, 8);
252         } while (i--);
253     }
254
255     return 0;
256 }
257
258 /**
259  * Common function to parse AC-3 or E-AC-3 frame header
260  */
261 static int parse_frame_header(AC3DecodeContext *s)
262 {
263     AC3HeaderInfo hdr;
264     int err;
265
266     err = avpriv_ac3_parse_header(&s->gbc, &hdr);
267     if (err)
268         return err;
269
270     /* get decoding parameters from header info */
271     s->bit_alloc_params.sr_code     = hdr.sr_code;
272     s->bitstream_id                 = hdr.bitstream_id;
273     s->bitstream_mode               = hdr.bitstream_mode;
274     s->channel_mode                 = hdr.channel_mode;
275     s->lfe_on                       = hdr.lfe_on;
276     s->bit_alloc_params.sr_shift    = hdr.sr_shift;
277     s->sample_rate                  = hdr.sample_rate;
278     s->bit_rate                     = hdr.bit_rate;
279     s->channels                     = hdr.channels;
280     s->fbw_channels                 = s->channels - s->lfe_on;
281     s->lfe_ch                       = s->fbw_channels + 1;
282     s->frame_size                   = hdr.frame_size;
283     s->center_mix_level             = hdr.center_mix_level;
284     s->surround_mix_level           = hdr.surround_mix_level;
285     s->num_blocks                   = hdr.num_blocks;
286     s->frame_type                   = hdr.frame_type;
287     s->substreamid                  = hdr.substreamid;
288     s->dolby_surround_mode          = hdr.dolby_surround_mode;
289     s->dolby_surround_ex_mode       = AC3_DSUREXMOD_NOTINDICATED;
290     s->dolby_headphone_mode         = AC3_DHEADPHONMOD_NOTINDICATED;
291
292     if (s->lfe_on) {
293         s->start_freq[s->lfe_ch]     = 0;
294         s->end_freq[s->lfe_ch]       = 7;
295         s->num_exp_groups[s->lfe_ch] = 2;
296         s->channel_in_cpl[s->lfe_ch] = 0;
297     }
298
299     if (s->bitstream_id <= 10) {
300         s->eac3                  = 0;
301         s->snr_offset_strategy   = 2;
302         s->block_switch_syntax   = 1;
303         s->dither_flag_syntax    = 1;
304         s->bit_allocation_syntax = 1;
305         s->fast_gain_syntax      = 0;
306         s->first_cpl_leak        = 0;
307         s->dba_syntax            = 1;
308         s->skip_syntax           = 1;
309         memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
310         return ac3_parse_header(s);
311     } else if (CONFIG_EAC3_DECODER) {
312         s->eac3 = 1;
313         return ff_eac3_parse_header(s);
314     } else {
315         av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");
316         return AVERROR(ENOSYS);
317     }
318 }
319
320 /**
321  * Set stereo downmixing coefficients based on frame header info.
322  * reference: Section 7.8.2 Downmixing Into Two Channels
323  */
324 static void set_downmix_coeffs(AC3DecodeContext *s)
325 {
326     int i;
327     float cmix = gain_levels[s->  center_mix_level];
328     float smix = gain_levels[s->surround_mix_level];
329     float norm0, norm1;
330
331     for (i = 0; i < s->fbw_channels; i++) {
332         s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];
333         s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];
334     }
335     if (s->channel_mode > 1 && s->channel_mode & 1) {
336         s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;
337     }
338     if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {
339         int nf = s->channel_mode - 2;
340         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;
341     }
342     if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {
343         int nf = s->channel_mode - 4;
344         s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;
345     }
346
347     /* renormalize */
348     norm0 = norm1 = 0.0;
349     for (i = 0; i < s->fbw_channels; i++) {
350         norm0 += s->downmix_coeffs[i][0];
351         norm1 += s->downmix_coeffs[i][1];
352     }
353     norm0 = 1.0f / norm0;
354     norm1 = 1.0f / norm1;
355     for (i = 0; i < s->fbw_channels; i++) {
356         s->downmix_coeffs[i][0] *= norm0;
357         s->downmix_coeffs[i][1] *= norm1;
358     }
359
360     if (s->output_mode == AC3_CHMODE_MONO) {
361         for (i = 0; i < s->fbw_channels; i++)
362             s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +
363                                        s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;
364     }
365 }
366
367 /**
368  * Decode the grouped exponents according to exponent strategy.
369  * reference: Section 7.1.3 Exponent Decoding
370  */
371 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,
372                             uint8_t absexp, int8_t *dexps)
373 {
374     int i, j, grp, group_size;
375     int dexp[256];
376     int expacc, prevexp;
377
378     /* unpack groups */
379     group_size = exp_strategy + (exp_strategy == EXP_D45);
380     for (grp = 0, i = 0; grp < ngrps; grp++) {
381         expacc = get_bits(gbc, 7);
382         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];
383         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];
384         dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];
385     }
386
387     /* convert to absolute exps and expand groups */
388     prevexp = absexp;
389     for (i = 0, j = 0; i < ngrps * 3; i++) {
390         prevexp += dexp[i] - 2;
391         if (prevexp > 24U)
392             return -1;
393         switch (group_size) {
394         case 4: dexps[j++] = prevexp;
395                 dexps[j++] = prevexp;
396         case 2: dexps[j++] = prevexp;
397         case 1: dexps[j++] = prevexp;
398         }
399     }
400     return 0;
401 }
402
403 /**
404  * Generate transform coefficients for each coupled channel in the coupling
405  * range using the coupling coefficients and coupling coordinates.
406  * reference: Section 7.4.3 Coupling Coordinate Format
407  */
408 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)
409 {
410     int bin, band, ch;
411
412     bin = s->start_freq[CPL_CH];
413     for (band = 0; band < s->num_cpl_bands; band++) {
414         int band_start = bin;
415         int band_end = bin + s->cpl_band_sizes[band];
416         for (ch = 1; ch <= s->fbw_channels; ch++) {
417             if (s->channel_in_cpl[ch]) {
418                 int cpl_coord = s->cpl_coords[ch][band] << 5;
419                 for (bin = band_start; bin < band_end; bin++) {
420                     s->fixed_coeffs[ch][bin] =
421                         MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);
422                 }
423                 if (ch == 2 && s->phase_flags[band]) {
424                     for (bin = band_start; bin < band_end; bin++)
425                         s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];
426                 }
427             }
428         }
429         bin = band_end;
430     }
431 }
432
433 /**
434  * Grouped mantissas for 3-level 5-level and 11-level quantization
435  */
436 typedef struct {
437     int b1_mant[2];
438     int b2_mant[2];
439     int b4_mant;
440     int b1;
441     int b2;
442     int b4;
443 } mant_groups;
444
445 /**
446  * Decode the transform coefficients for a particular channel
447  * reference: Section 7.3 Quantization and Decoding of Mantissas
448  */
449 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)
450 {
451     int start_freq = s->start_freq[ch_index];
452     int end_freq   = s->end_freq[ch_index];
453     uint8_t *baps  = s->bap[ch_index];
454     int8_t *exps   = s->dexps[ch_index];
455     int32_t *coeffs = s->fixed_coeffs[ch_index];
456     int dither     = (ch_index == CPL_CH) || s->dither_flag[ch_index];
457     GetBitContext *gbc = &s->gbc;
458     int freq;
459
460     for (freq = start_freq; freq < end_freq; freq++) {
461         int bap = baps[freq];
462         int mantissa;
463         switch (bap) {
464         case 0:
465             /* random noise with approximate range of -0.707 to 0.707 */
466             if (dither)
467                 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;
468             else
469                 mantissa = 0;
470             break;
471         case 1:
472             if (m->b1) {
473                 m->b1--;
474                 mantissa = m->b1_mant[m->b1];
475             } else {
476                 int bits      = get_bits(gbc, 5);
477                 mantissa      = b1_mantissas[bits][0];
478                 m->b1_mant[1] = b1_mantissas[bits][1];
479                 m->b1_mant[0] = b1_mantissas[bits][2];
480                 m->b1         = 2;
481             }
482             break;
483         case 2:
484             if (m->b2) {
485                 m->b2--;
486                 mantissa = m->b2_mant[m->b2];
487             } else {
488                 int bits      = get_bits(gbc, 7);
489                 mantissa      = b2_mantissas[bits][0];
490                 m->b2_mant[1] = b2_mantissas[bits][1];
491                 m->b2_mant[0] = b2_mantissas[bits][2];
492                 m->b2         = 2;
493             }
494             break;
495         case 3:
496             mantissa = b3_mantissas[get_bits(gbc, 3)];
497             break;
498         case 4:
499             if (m->b4) {
500                 m->b4 = 0;
501                 mantissa = m->b4_mant;
502             } else {
503                 int bits   = get_bits(gbc, 7);
504                 mantissa   = b4_mantissas[bits][0];
505                 m->b4_mant = b4_mantissas[bits][1];
506                 m->b4      = 1;
507             }
508             break;
509         case 5:
510             mantissa = b5_mantissas[get_bits(gbc, 4)];
511             break;
512         default: /* 6 to 15 */
513             /* Shift mantissa and sign-extend it. */
514             if (bap > 15) {
515                 av_log(s->avctx, AV_LOG_ERROR, "bap %d is invalid in plain AC-3\n", bap);
516                 bap = 15;
517             }
518             mantissa = get_sbits(gbc, quantization_tab[bap]);
519             mantissa <<= 24 - quantization_tab[bap];
520             break;
521         }
522         coeffs[freq] = mantissa >> exps[freq];
523     }
524 }
525
526 /**
527  * Remove random dithering from coupling range coefficients with zero-bit
528  * mantissas for coupled channels which do not use dithering.
529  * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)
530  */
531 static void remove_dithering(AC3DecodeContext *s) {
532     int ch, i;
533
534     for (ch = 1; ch <= s->fbw_channels; ch++) {
535         if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {
536             for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {
537                 if (!s->bap[CPL_CH][i])
538                     s->fixed_coeffs[ch][i] = 0;
539             }
540         }
541     }
542 }
543
544 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,
545                                        mant_groups *m)
546 {
547     if (!s->channel_uses_aht[ch]) {
548         ac3_decode_transform_coeffs_ch(s, ch, m);
549     } else {
550         /* if AHT is used, mantissas for all blocks are encoded in the first
551            block of the frame. */
552         int bin;
553         if (!blk && CONFIG_EAC3_DECODER)
554             ff_eac3_decode_transform_coeffs_aht_ch(s, ch);
555         for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
556             s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];
557         }
558     }
559 }
560
561 /**
562  * Decode the transform coefficients.
563  */
564 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)
565 {
566     int ch, end;
567     int got_cplchan = 0;
568     mant_groups m;
569
570     m.b1 = m.b2 = m.b4 = 0;
571
572     for (ch = 1; ch <= s->channels; ch++) {
573         /* transform coefficients for full-bandwidth channel */
574         decode_transform_coeffs_ch(s, blk, ch, &m);
575         /* transform coefficients for coupling channel come right after the
576            coefficients for the first coupled channel*/
577         if (s->channel_in_cpl[ch])  {
578             if (!got_cplchan) {
579                 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);
580                 calc_transform_coeffs_cpl(s);
581                 got_cplchan = 1;
582             }
583             end = s->end_freq[CPL_CH];
584         } else {
585             end = s->end_freq[ch];
586         }
587         do
588             s->fixed_coeffs[ch][end] = 0;
589         while (++end < 256);
590     }
591
592     /* zero the dithered coefficients for appropriate channels */
593     remove_dithering(s);
594 }
595
596 /**
597  * Stereo rematrixing.
598  * reference: Section 7.5.4 Rematrixing : Decoding Technique
599  */
600 static void do_rematrixing(AC3DecodeContext *s)
601 {
602     int bnd, i;
603     int end, bndend;
604
605     end = FFMIN(s->end_freq[1], s->end_freq[2]);
606
607     for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {
608         if (s->rematrixing_flags[bnd]) {
609             bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);
610             for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {
611                 int tmp0 = s->fixed_coeffs[1][i];
612                 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];
613                 s->fixed_coeffs[2][i]  = tmp0 - s->fixed_coeffs[2][i];
614             }
615         }
616     }
617 }
618
619 /**
620  * Inverse MDCT Transform.
621  * Convert frequency domain coefficients to time-domain audio samples.
622  * reference: Section 7.9.4 Transformation Equations
623  */
624 static inline void do_imdct(AC3DecodeContext *s, int channels)
625 {
626     int ch;
627
628     for (ch = 1; ch <= channels; ch++) {
629         if (s->block_switch[ch]) {
630             int i;
631             float *x = s->tmp_output + 128;
632             for (i = 0; i < 128; i++)
633                 x[i] = s->transform_coeffs[ch][2 * i];
634             s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);
635             s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
636                                        s->tmp_output, s->window, 128);
637             for (i = 0; i < 128; i++)
638                 x[i] = s->transform_coeffs[ch][2 * i + 1];
639             s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);
640         } else {
641             s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);
642             s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],
643                                        s->tmp_output, s->window, 128);
644             memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));
645         }
646     }
647 }
648
649 /**
650  * Upmix delay samples from stereo to original channel layout.
651  */
652 static void ac3_upmix_delay(AC3DecodeContext *s)
653 {
654     int channel_data_size = sizeof(s->delay[0]);
655     switch (s->channel_mode) {
656     case AC3_CHMODE_DUALMONO:
657     case AC3_CHMODE_STEREO:
658         /* upmix mono to stereo */
659         memcpy(s->delay[1], s->delay[0], channel_data_size);
660         break;
661     case AC3_CHMODE_2F2R:
662         memset(s->delay[3], 0, channel_data_size);
663     case AC3_CHMODE_2F1R:
664         memset(s->delay[2], 0, channel_data_size);
665         break;
666     case AC3_CHMODE_3F2R:
667         memset(s->delay[4], 0, channel_data_size);
668     case AC3_CHMODE_3F1R:
669         memset(s->delay[3], 0, channel_data_size);
670     case AC3_CHMODE_3F:
671         memcpy(s->delay[2], s->delay[1], channel_data_size);
672         memset(s->delay[1], 0, channel_data_size);
673         break;
674     }
675 }
676
677 /**
678  * Decode band structure for coupling, spectral extension, or enhanced coupling.
679  * The band structure defines how many subbands are in each band.  For each
680  * subband in the range, 1 means it is combined with the previous band, and 0
681  * means that it starts a new band.
682  *
683  * @param[in] gbc bit reader context
684  * @param[in] blk block number
685  * @param[in] eac3 flag to indicate E-AC-3
686  * @param[in] ecpl flag to indicate enhanced coupling
687  * @param[in] start_subband subband number for start of range
688  * @param[in] end_subband subband number for end of range
689  * @param[in] default_band_struct default band structure table
690  * @param[out] num_bands number of bands (optionally NULL)
691  * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)
692  */
693 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,
694                                   int ecpl, int start_subband, int end_subband,
695                                   const uint8_t *default_band_struct,
696                                   int *num_bands, uint8_t *band_sizes)
697 {
698     int subbnd, bnd, n_subbands, n_bands=0;
699     uint8_t bnd_sz[22];
700     uint8_t coded_band_struct[22];
701     const uint8_t *band_struct;
702
703     n_subbands = end_subband - start_subband;
704
705     /* decode band structure from bitstream or use default */
706     if (!eac3 || get_bits1(gbc)) {
707         for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {
708             coded_band_struct[subbnd] = get_bits1(gbc);
709         }
710         band_struct = coded_band_struct;
711     } else if (!blk) {
712         band_struct = &default_band_struct[start_subband+1];
713     } else {
714         /* no change in band structure */
715         return;
716     }
717
718     /* calculate number of bands and band sizes based on band structure.
719        note that the first 4 subbands in enhanced coupling span only 6 bins
720        instead of 12. */
721     if (num_bands || band_sizes ) {
722         n_bands = n_subbands;
723         bnd_sz[0] = ecpl ? 6 : 12;
724         for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {
725             int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;
726             if (band_struct[subbnd - 1]) {
727                 n_bands--;
728                 bnd_sz[bnd] += subbnd_size;
729             } else {
730                 bnd_sz[++bnd] = subbnd_size;
731             }
732         }
733     }
734
735     /* set optional output params */
736     if (num_bands)
737         *num_bands = n_bands;
738     if (band_sizes)
739         memcpy(band_sizes, bnd_sz, n_bands);
740 }
741
742 /**
743  * Decode a single audio block from the AC-3 bitstream.
744  */
745 static int decode_audio_block(AC3DecodeContext *s, int blk)
746 {
747     int fbw_channels = s->fbw_channels;
748     int channel_mode = s->channel_mode;
749     int i, bnd, seg, ch;
750     int different_transforms;
751     int downmix_output;
752     int cpl_in_use;
753     GetBitContext *gbc = &s->gbc;
754     uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };
755
756     /* block switch flags */
757     different_transforms = 0;
758     if (s->block_switch_syntax) {
759         for (ch = 1; ch <= fbw_channels; ch++) {
760             s->block_switch[ch] = get_bits1(gbc);
761             if (ch > 1 && s->block_switch[ch] != s->block_switch[1])
762                 different_transforms = 1;
763         }
764     }
765
766     /* dithering flags */
767     if (s->dither_flag_syntax) {
768         for (ch = 1; ch <= fbw_channels; ch++) {
769             s->dither_flag[ch] = get_bits1(gbc);
770         }
771     }
772
773     /* dynamic range */
774     i = !s->channel_mode;
775     do {
776         if (get_bits1(gbc)) {
777             s->dynamic_range[i] = powf(dynamic_range_tab[get_bits(gbc, 8)],
778                                        s->drc_scale);
779         } else if (blk == 0) {
780             s->dynamic_range[i] = 1.0f;
781         }
782     } while (i--);
783
784     /* spectral extension strategy */
785     if (s->eac3 && (!blk || get_bits1(gbc))) {
786         s->spx_in_use = get_bits1(gbc);
787         if (s->spx_in_use) {
788             int dst_start_freq, dst_end_freq, src_start_freq,
789                 start_subband, end_subband;
790
791             /* determine which channels use spx */
792             if (s->channel_mode == AC3_CHMODE_MONO) {
793                 s->channel_uses_spx[1] = 1;
794             } else {
795                 for (ch = 1; ch <= fbw_channels; ch++)
796                     s->channel_uses_spx[ch] = get_bits1(gbc);
797             }
798
799             /* get the frequency bins of the spx copy region and the spx start
800                and end subbands */
801             dst_start_freq = get_bits(gbc, 2);
802             start_subband  = get_bits(gbc, 3) + 2;
803             if (start_subband > 7)
804                 start_subband += start_subband - 7;
805             end_subband    = get_bits(gbc, 3) + 5;
806             if (end_subband   > 7)
807                 end_subband   += end_subband   - 7;
808             dst_start_freq = dst_start_freq * 12 + 25;
809             src_start_freq = start_subband  * 12 + 25;
810             dst_end_freq   = end_subband    * 12 + 25;
811
812             /* check validity of spx ranges */
813             if (start_subband >= end_subband) {
814                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
815                        "range (%d >= %d)\n", start_subband, end_subband);
816                 return AVERROR_INVALIDDATA;
817             }
818             if (dst_start_freq >= src_start_freq) {
819                 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "
820                        "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);
821                 return AVERROR_INVALIDDATA;
822             }
823
824             s->spx_dst_start_freq = dst_start_freq;
825             s->spx_src_start_freq = src_start_freq;
826             s->spx_dst_end_freq   = dst_end_freq;
827
828             decode_band_structure(gbc, blk, s->eac3, 0,
829                                   start_subband, end_subband,
830                                   ff_eac3_default_spx_band_struct,
831                                   &s->num_spx_bands,
832                                   s->spx_band_sizes);
833         } else {
834             for (ch = 1; ch <= fbw_channels; ch++) {
835                 s->channel_uses_spx[ch] = 0;
836                 s->first_spx_coords[ch] = 1;
837             }
838         }
839     }
840
841     /* spectral extension coordinates */
842     if (s->spx_in_use) {
843         for (ch = 1; ch <= fbw_channels; ch++) {
844             if (s->channel_uses_spx[ch]) {
845                 if (s->first_spx_coords[ch] || get_bits1(gbc)) {
846                     float spx_blend;
847                     int bin, master_spx_coord;
848
849                     s->first_spx_coords[ch] = 0;
850                     spx_blend = get_bits(gbc, 5) * (1.0f/32);
851                     master_spx_coord = get_bits(gbc, 2) * 3;
852
853                     bin = s->spx_src_start_freq;
854                     for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
855                         int bandsize;
856                         int spx_coord_exp, spx_coord_mant;
857                         float nratio, sblend, nblend, spx_coord;
858
859                         /* calculate blending factors */
860                         bandsize = s->spx_band_sizes[bnd];
861                         nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;
862                         nratio = av_clipf(nratio, 0.0f, 1.0f);
863                         nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)
864                                                        // to give unity variance
865                         sblend = sqrtf(1.0f - nratio);
866                         bin += bandsize;
867
868                         /* decode spx coordinates */
869                         spx_coord_exp  = get_bits(gbc, 4);
870                         spx_coord_mant = get_bits(gbc, 2);
871                         if (spx_coord_exp == 15) spx_coord_mant <<= 1;
872                         else                     spx_coord_mant += 4;
873                         spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);
874                         spx_coord = spx_coord_mant * (1.0f / (1 << 23));
875
876                         /* multiply noise and signal blending factors by spx coordinate */
877                         s->spx_noise_blend [ch][bnd] = nblend * spx_coord;
878                         s->spx_signal_blend[ch][bnd] = sblend * spx_coord;
879                     }
880                 }
881             } else {
882                 s->first_spx_coords[ch] = 1;
883             }
884         }
885     }
886
887     /* coupling strategy */
888     if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {
889         memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
890         if (!s->eac3)
891             s->cpl_in_use[blk] = get_bits1(gbc);
892         if (s->cpl_in_use[blk]) {
893             /* coupling in use */
894             int cpl_start_subband, cpl_end_subband;
895
896             if (channel_mode < AC3_CHMODE_STEREO) {
897                 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");
898                 return AVERROR_INVALIDDATA;
899             }
900
901             /* check for enhanced coupling */
902             if (s->eac3 && get_bits1(gbc)) {
903                 /* TODO: parse enhanced coupling strategy info */
904                 avpriv_request_sample(s->avctx, "Enhanced coupling");
905                 return AVERROR_PATCHWELCOME;
906             }
907
908             /* determine which channels are coupled */
909             if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {
910                 s->channel_in_cpl[1] = 1;
911                 s->channel_in_cpl[2] = 1;
912             } else {
913                 for (ch = 1; ch <= fbw_channels; ch++)
914                     s->channel_in_cpl[ch] = get_bits1(gbc);
915             }
916
917             /* phase flags in use */
918             if (channel_mode == AC3_CHMODE_STEREO)
919                 s->phase_flags_in_use = get_bits1(gbc);
920
921             /* coupling frequency range */
922             cpl_start_subband = get_bits(gbc, 4);
923             cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :
924                                               get_bits(gbc, 4) + 3;
925             if (cpl_start_subband >= cpl_end_subband) {
926                 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",
927                        cpl_start_subband, cpl_end_subband);
928                 return AVERROR_INVALIDDATA;
929             }
930             s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;
931             s->end_freq[CPL_CH]   = cpl_end_subband   * 12 + 37;
932
933             decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,
934                                   cpl_end_subband,
935                                   ff_eac3_default_cpl_band_struct,
936                                   &s->num_cpl_bands, s->cpl_band_sizes);
937         } else {
938             /* coupling not in use */
939             for (ch = 1; ch <= fbw_channels; ch++) {
940                 s->channel_in_cpl[ch] = 0;
941                 s->first_cpl_coords[ch] = 1;
942             }
943             s->first_cpl_leak = s->eac3;
944             s->phase_flags_in_use = 0;
945         }
946     } else if (!s->eac3) {
947         if (!blk) {
948             av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "
949                    "be present in block 0\n");
950             return AVERROR_INVALIDDATA;
951         } else {
952             s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
953         }
954     }
955     cpl_in_use = s->cpl_in_use[blk];
956
957     /* coupling coordinates */
958     if (cpl_in_use) {
959         int cpl_coords_exist = 0;
960
961         for (ch = 1; ch <= fbw_channels; ch++) {
962             if (s->channel_in_cpl[ch]) {
963                 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {
964                     int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;
965                     s->first_cpl_coords[ch] = 0;
966                     cpl_coords_exist = 1;
967                     master_cpl_coord = 3 * get_bits(gbc, 2);
968                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
969                         cpl_coord_exp = get_bits(gbc, 4);
970                         cpl_coord_mant = get_bits(gbc, 4);
971                         if (cpl_coord_exp == 15)
972                             s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;
973                         else
974                             s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;
975                         s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);
976                     }
977                 } else if (!blk) {
978                     av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "
979                            "be present in block 0\n");
980                     return AVERROR_INVALIDDATA;
981                 }
982             } else {
983                 /* channel not in coupling */
984                 s->first_cpl_coords[ch] = 1;
985             }
986         }
987         /* phase flags */
988         if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {
989             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
990                 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;
991             }
992         }
993     }
994
995     /* stereo rematrixing strategy and band structure */
996     if (channel_mode == AC3_CHMODE_STEREO) {
997         if ((s->eac3 && !blk) || get_bits1(gbc)) {
998             s->num_rematrixing_bands = 4;
999             if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {
1000                 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);
1001             } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {
1002                 s->num_rematrixing_bands--;
1003             }
1004             for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)
1005                 s->rematrixing_flags[bnd] = get_bits1(gbc);
1006         } else if (!blk) {
1007             av_log(s->avctx, AV_LOG_WARNING, "Warning: "
1008                    "new rematrixing strategy not present in block 0\n");
1009             s->num_rematrixing_bands = 0;
1010         }
1011     }
1012
1013     /* exponent strategies for each channel */
1014     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1015         if (!s->eac3)
1016             s->exp_strategy[blk][ch] = get_bits(gbc, 2 - (ch == s->lfe_ch));
1017         if (s->exp_strategy[blk][ch] != EXP_REUSE)
1018             bit_alloc_stages[ch] = 3;
1019     }
1020
1021     /* channel bandwidth */
1022     for (ch = 1; ch <= fbw_channels; ch++) {
1023         s->start_freq[ch] = 0;
1024         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1025             int group_size;
1026             int prev = s->end_freq[ch];
1027             if (s->channel_in_cpl[ch])
1028                 s->end_freq[ch] = s->start_freq[CPL_CH];
1029             else if (s->channel_uses_spx[ch])
1030                 s->end_freq[ch] = s->spx_src_start_freq;
1031             else {
1032                 int bandwidth_code = get_bits(gbc, 6);
1033                 if (bandwidth_code > 60) {
1034                     av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);
1035                     return AVERROR_INVALIDDATA;
1036                 }
1037                 s->end_freq[ch] = bandwidth_code * 3 + 73;
1038             }
1039             group_size = 3 << (s->exp_strategy[blk][ch] - 1);
1040             s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;
1041             if (blk > 0 && s->end_freq[ch] != prev)
1042                 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);
1043         }
1044     }
1045     if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {
1046         s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /
1047                                     (3 << (s->exp_strategy[blk][CPL_CH] - 1));
1048     }
1049
1050     /* decode exponents for each channel */
1051     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1052         if (s->exp_strategy[blk][ch] != EXP_REUSE) {
1053             s->dexps[ch][0] = get_bits(gbc, 4) << !ch;
1054             if (decode_exponents(gbc, s->exp_strategy[blk][ch],
1055                                  s->num_exp_groups[ch], s->dexps[ch][0],
1056                                  &s->dexps[ch][s->start_freq[ch]+!!ch])) {
1057                 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");
1058                 return AVERROR_INVALIDDATA;
1059             }
1060             if (ch != CPL_CH && ch != s->lfe_ch)
1061                 skip_bits(gbc, 2); /* skip gainrng */
1062         }
1063     }
1064
1065     /* bit allocation information */
1066     if (s->bit_allocation_syntax) {
1067         if (get_bits1(gbc)) {
1068             s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1069             s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;
1070             s->bit_alloc_params.slow_gain  = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];
1071             s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];
1072             s->bit_alloc_params.floor  = ff_ac3_floor_tab[get_bits(gbc, 3)];
1073             for (ch = !cpl_in_use; ch <= s->channels; ch++)
1074                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1075         } else if (!blk) {
1076             av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "
1077                    "be present in block 0\n");
1078             return AVERROR_INVALIDDATA;
1079         }
1080     }
1081
1082     /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */
1083     if (!s->eac3 || !blk) {
1084         if (s->snr_offset_strategy && get_bits1(gbc)) {
1085             int snr = 0;
1086             int csnr;
1087             csnr = (get_bits(gbc, 6) - 15) << 4;
1088             for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {
1089                 /* snr offset */
1090                 if (ch == i || s->snr_offset_strategy == 2)
1091                     snr = (csnr + get_bits(gbc, 4)) << 2;
1092                 /* run at least last bit allocation stage if snr offset changes */
1093                 if (blk && s->snr_offset[ch] != snr) {
1094                     bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);
1095                 }
1096                 s->snr_offset[ch] = snr;
1097
1098                 /* fast gain (normal AC-3 only) */
1099                 if (!s->eac3) {
1100                     int prev = s->fast_gain[ch];
1101                     s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1102                     /* run last 2 bit allocation stages if fast gain changes */
1103                     if (blk && prev != s->fast_gain[ch])
1104                         bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1105                 }
1106             }
1107         } else if (!s->eac3 && !blk) {
1108             av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");
1109             return AVERROR_INVALIDDATA;
1110         }
1111     }
1112
1113     /* fast gain (E-AC-3 only) */
1114     if (s->fast_gain_syntax && get_bits1(gbc)) {
1115         for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1116             int prev = s->fast_gain[ch];
1117             s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];
1118             /* run last 2 bit allocation stages if fast gain changes */
1119             if (blk && prev != s->fast_gain[ch])
1120                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1121         }
1122     } else if (s->eac3 && !blk) {
1123         for (ch = !cpl_in_use; ch <= s->channels; ch++)
1124             s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];
1125     }
1126
1127     /* E-AC-3 to AC-3 converter SNR offset */
1128     if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {
1129         skip_bits(gbc, 10); // skip converter snr offset
1130     }
1131
1132     /* coupling leak information */
1133     if (cpl_in_use) {
1134         if (s->first_cpl_leak || get_bits1(gbc)) {
1135             int fl = get_bits(gbc, 3);
1136             int sl = get_bits(gbc, 3);
1137             /* run last 2 bit allocation stages for coupling channel if
1138                coupling leak changes */
1139             if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||
1140                 sl != s->bit_alloc_params.cpl_slow_leak)) {
1141                 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);
1142             }
1143             s->bit_alloc_params.cpl_fast_leak = fl;
1144             s->bit_alloc_params.cpl_slow_leak = sl;
1145         } else if (!s->eac3 && !blk) {
1146             av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "
1147                    "be present in block 0\n");
1148             return AVERROR_INVALIDDATA;
1149         }
1150         s->first_cpl_leak = 0;
1151     }
1152
1153     /* delta bit allocation information */
1154     if (s->dba_syntax && get_bits1(gbc)) {
1155         /* delta bit allocation exists (strategy) */
1156         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1157             s->dba_mode[ch] = get_bits(gbc, 2);
1158             if (s->dba_mode[ch] == DBA_RESERVED) {
1159                 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");
1160                 return AVERROR_INVALIDDATA;
1161             }
1162             bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1163         }
1164         /* channel delta offset, len and bit allocation */
1165         for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {
1166             if (s->dba_mode[ch] == DBA_NEW) {
1167                 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;
1168                 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {
1169                     s->dba_offsets[ch][seg] = get_bits(gbc, 5);
1170                     s->dba_lengths[ch][seg] = get_bits(gbc, 4);
1171                     s->dba_values[ch][seg]  = get_bits(gbc, 3);
1172                 }
1173                 /* run last 2 bit allocation stages if new dba values */
1174                 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);
1175             }
1176         }
1177     } else if (blk == 0) {
1178         for (ch = 0; ch <= s->channels; ch++) {
1179             s->dba_mode[ch] = DBA_NONE;
1180         }
1181     }
1182
1183     /* Bit allocation */
1184     for (ch = !cpl_in_use; ch <= s->channels; ch++) {
1185         if (bit_alloc_stages[ch] > 2) {
1186             /* Exponent mapping into PSD and PSD integration */
1187             ff_ac3_bit_alloc_calc_psd(s->dexps[ch],
1188                                       s->start_freq[ch], s->end_freq[ch],
1189                                       s->psd[ch], s->band_psd[ch]);
1190         }
1191         if (bit_alloc_stages[ch] > 1) {
1192             /* Compute excitation function, Compute masking curve, and
1193                Apply delta bit allocation */
1194             if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],
1195                                            s->start_freq[ch],  s->end_freq[ch],
1196                                            s->fast_gain[ch],   (ch == s->lfe_ch),
1197                                            s->dba_mode[ch],    s->dba_nsegs[ch],
1198                                            s->dba_offsets[ch], s->dba_lengths[ch],
1199                                            s->dba_values[ch],  s->mask[ch])) {
1200                 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");
1201                 return AVERROR_INVALIDDATA;
1202             }
1203         }
1204         if (bit_alloc_stages[ch] > 0) {
1205             /* Compute bit allocation */
1206             const uint8_t *bap_tab = s->channel_uses_aht[ch] ?
1207                                      ff_eac3_hebap_tab : ff_ac3_bap_tab;
1208             s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],
1209                                       s->start_freq[ch], s->end_freq[ch],
1210                                       s->snr_offset[ch],
1211                                       s->bit_alloc_params.floor,
1212                                       bap_tab, s->bap[ch]);
1213         }
1214     }
1215
1216     /* unused dummy data */
1217     if (s->skip_syntax && get_bits1(gbc)) {
1218         int skipl = get_bits(gbc, 9);
1219         while (skipl--)
1220             skip_bits(gbc, 8);
1221     }
1222
1223     /* unpack the transform coefficients
1224        this also uncouples channels if coupling is in use. */
1225     decode_transform_coeffs(s, blk);
1226
1227     /* TODO: generate enhanced coupling coordinates and uncouple */
1228
1229     /* recover coefficients if rematrixing is in use */
1230     if (s->channel_mode == AC3_CHMODE_STEREO)
1231         do_rematrixing(s);
1232
1233     /* apply scaling to coefficients (headroom, dynrng) */
1234     for (ch = 1; ch <= s->channels; ch++) {
1235         float gain = 1.0 / 4194304.0f;
1236         if (s->channel_mode == AC3_CHMODE_DUALMONO) {
1237             gain *= s->dynamic_range[2 - ch];
1238         } else {
1239             gain *= s->dynamic_range[0];
1240         }
1241         s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],
1242                                                s->fixed_coeffs[ch], gain, 256);
1243     }
1244
1245     /* apply spectral extension to high frequency bins */
1246     if (s->spx_in_use && CONFIG_EAC3_DECODER) {
1247         ff_eac3_apply_spectral_extension(s);
1248     }
1249
1250     /* downmix and MDCT. order depends on whether block switching is used for
1251        any channel in this block. this is because coefficients for the long
1252        and short transforms cannot be mixed. */
1253     downmix_output = s->channels != s->out_channels &&
1254                      !((s->output_mode & AC3_OUTPUT_LFEON) &&
1255                      s->fbw_channels == s->out_channels);
1256     if (different_transforms) {
1257         /* the delay samples have already been downmixed, so we upmix the delay
1258            samples in order to reconstruct all channels before downmixing. */
1259         if (s->downmixed) {
1260             s->downmixed = 0;
1261             ac3_upmix_delay(s);
1262         }
1263
1264         do_imdct(s, s->channels);
1265
1266         if (downmix_output) {
1267             s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,
1268                               s->out_channels, s->fbw_channels, 256);
1269         }
1270     } else {
1271         if (downmix_output) {
1272             s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,
1273                               s->out_channels, s->fbw_channels, 256);
1274         }
1275
1276         if (downmix_output && !s->downmixed) {
1277             s->downmixed = 1;
1278             s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,
1279                               s->fbw_channels, 128);
1280         }
1281
1282         do_imdct(s, s->out_channels);
1283     }
1284
1285     return 0;
1286 }
1287
1288 /**
1289  * Decode a single AC-3 frame.
1290  */
1291 static int ac3_decode_frame(AVCodecContext * avctx, void *data,
1292                             int *got_frame_ptr, AVPacket *avpkt)
1293 {
1294     AVFrame *frame     = data;
1295     const uint8_t *buf = avpkt->data;
1296     int buf_size = avpkt->size;
1297     AC3DecodeContext *s = avctx->priv_data;
1298     int blk, ch, err, ret;
1299     const uint8_t *channel_map;
1300     const float *output[AC3_MAX_CHANNELS];
1301     enum AVMatrixEncoding matrix_encoding;
1302
1303     /* copy input buffer to decoder context to avoid reading past the end
1304        of the buffer, which can be caused by a damaged input stream. */
1305     if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {
1306         // seems to be byte-swapped AC-3
1307         int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;
1308         s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);
1309     } else
1310         memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));
1311     buf = s->input_buffer;
1312     /* initialize the GetBitContext with the start of valid AC-3 Frame */
1313     init_get_bits(&s->gbc, buf, buf_size * 8);
1314
1315     /* parse the syncinfo */
1316     err = parse_frame_header(s);
1317
1318     if (err) {
1319         switch (err) {
1320         case AAC_AC3_PARSE_ERROR_SYNC:
1321             av_log(avctx, AV_LOG_ERROR, "frame sync error\n");
1322             return AVERROR_INVALIDDATA;
1323         case AAC_AC3_PARSE_ERROR_BSID:
1324             av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");
1325             break;
1326         case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:
1327             av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
1328             break;
1329         case AAC_AC3_PARSE_ERROR_FRAME_SIZE:
1330             av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");
1331             break;
1332         case AAC_AC3_PARSE_ERROR_FRAME_TYPE:
1333             /* skip frame if CRC is ok. otherwise use error concealment. */
1334             /* TODO: add support for substreams and dependent frames */
1335             if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {
1336                 av_log(avctx, AV_LOG_WARNING, "unsupported frame type : "
1337                        "skipping frame\n");
1338                 *got_frame_ptr = 0;
1339                 return buf_size;
1340             } else {
1341                 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");
1342             }
1343             break;
1344         case AAC_AC3_PARSE_ERROR_CRC:
1345         case AAC_AC3_PARSE_ERROR_CHANNEL_CFG:
1346             break;
1347         default: // Normal AVERROR do not try to recover.
1348             *got_frame_ptr = 0;
1349             return err;
1350         }
1351     } else {
1352         /* check that reported frame size fits in input buffer */
1353         if (s->frame_size > buf_size) {
1354             av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");
1355             err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;
1356         } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {
1357             /* check for crc mismatch */
1358             if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],
1359                        s->frame_size - 2)) {
1360                 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");
1361                 if (avctx->err_recognition & AV_EF_EXPLODE)
1362                     return AVERROR_INVALIDDATA;
1363                 err = AAC_AC3_PARSE_ERROR_CRC;
1364             }
1365         }
1366     }
1367
1368     /* if frame is ok, set audio parameters */
1369     if (!err) {
1370         avctx->sample_rate = s->sample_rate;
1371         avctx->bit_rate    = s->bit_rate;
1372     }
1373
1374     /* channel config */
1375     if (!err || (s->channels && s->out_channels != s->channels)) {
1376         s->out_channels = s->channels;
1377         s->output_mode  = s->channel_mode;
1378         if (s->lfe_on)
1379             s->output_mode |= AC3_OUTPUT_LFEON;
1380         if (s->channels > 1 &&
1381             avctx->request_channel_layout == AV_CH_LAYOUT_MONO) {
1382             s->out_channels = 1;
1383             s->output_mode  = AC3_CHMODE_MONO;
1384         } else if (s->channels > 2 &&
1385                    avctx->request_channel_layout == AV_CH_LAYOUT_STEREO) {
1386             s->out_channels = 2;
1387             s->output_mode  = AC3_CHMODE_STEREO;
1388         }
1389
1390         s->loro_center_mix_level   = gain_levels[s->  center_mix_level];
1391         s->loro_surround_mix_level = gain_levels[s->surround_mix_level];
1392         s->ltrt_center_mix_level   = LEVEL_MINUS_3DB;
1393         s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;
1394         /* set downmixing coefficients if needed */
1395         if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&
1396                 s->fbw_channels == s->out_channels)) {
1397             set_downmix_coeffs(s);
1398         }
1399     } else if (!s->channels) {
1400         av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");
1401         return AVERROR_INVALIDDATA;
1402     }
1403     avctx->channels = s->out_channels;
1404     avctx->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode & ~AC3_OUTPUT_LFEON];
1405     if (s->output_mode & AC3_OUTPUT_LFEON)
1406         avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1407
1408     /* set audio service type based on bitstream mode for AC-3 */
1409     avctx->audio_service_type = s->bitstream_mode;
1410     if (s->bitstream_mode == 0x7 && s->channels > 1)
1411         avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;
1412
1413     /* get output buffer */
1414     frame->nb_samples = s->num_blocks * AC3_BLOCK_SIZE;
1415     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1416         return ret;
1417
1418     /* decode the audio blocks */
1419     channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];
1420     for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {
1421         output[ch] = s->output[ch];
1422         s->outptr[ch] = s->output[ch];
1423     }
1424     for (ch = 0; ch < s->channels; ch++) {
1425         if (ch < s->out_channels)
1426             s->outptr[channel_map[ch]] = (float *)frame->data[ch];
1427     }
1428     for (blk = 0; blk < s->num_blocks; blk++) {
1429         if (!err && decode_audio_block(s, blk)) {
1430             av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");
1431             err = 1;
1432         }
1433         if (err)
1434             for (ch = 0; ch < s->out_channels; ch++)
1435                 memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1436         for (ch = 0; ch < s->out_channels; ch++)
1437             output[ch] = s->outptr[channel_map[ch]];
1438         for (ch = 0; ch < s->out_channels; ch++) {
1439             if (!ch || channel_map[ch])
1440                 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;
1441         }
1442     }
1443
1444     av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);
1445
1446     /* keep last block for error concealment in next frame */
1447     for (ch = 0; ch < s->out_channels; ch++)
1448         memcpy(s->output[ch], output[ch], sizeof(**output) * AC3_BLOCK_SIZE);
1449
1450     /*
1451      * AVMatrixEncoding
1452      *
1453      * Check whether the input layout is compatible, and make sure we're not
1454      * downmixing (else the matrix encoding is no longer applicable).
1455      */
1456     matrix_encoding = AV_MATRIX_ENCODING_NONE;
1457     if (s->channel_mode == AC3_CHMODE_STEREO &&
1458         s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1459         if (s->dolby_surround_mode == AC3_DSURMOD_ON)
1460             matrix_encoding = AV_MATRIX_ENCODING_DOLBY;
1461         else if (s->dolby_headphone_mode == AC3_DHEADPHONMOD_ON)
1462             matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;
1463     } else if (s->channel_mode >= AC3_CHMODE_2F2R &&
1464                s->channel_mode == (s->output_mode & ~AC3_OUTPUT_LFEON)) {
1465         switch (s->dolby_surround_ex_mode) {
1466         case AC3_DSUREXMOD_ON: // EX or PLIIx
1467             matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;
1468             break;
1469         case AC3_DSUREXMOD_PLIIZ:
1470             matrix_encoding = AV_MATRIX_ENCODING_DPLIIZ;
1471             break;
1472         default: // not indicated or off
1473             break;
1474         }
1475     }
1476     if ((ret = ff_side_data_update_matrix_encoding(frame, matrix_encoding)) < 0)
1477         return ret;
1478
1479     *got_frame_ptr = 1;
1480
1481     return FFMIN(buf_size, s->frame_size);
1482 }
1483
1484 /**
1485  * Uninitialize the AC-3 decoder.
1486  */
1487 static av_cold int ac3_decode_end(AVCodecContext *avctx)
1488 {
1489     AC3DecodeContext *s = avctx->priv_data;
1490     ff_mdct_end(&s->imdct_512);
1491     ff_mdct_end(&s->imdct_256);
1492
1493     return 0;
1494 }
1495
1496 #define OFFSET(x) offsetof(AC3DecodeContext, x)
1497 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)
1498 static const AVOption options[] = {
1499     { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },
1500
1501 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},
1502 {"ltrt_cmixlev",   "Lt/Rt Center Mix Level",   OFFSET(ltrt_center_mix_level),    AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1503 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level),  AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1504 {"loro_cmixlev",   "Lo/Ro Center Mix Level",   OFFSET(loro_center_mix_level),    AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1505 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level),  AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},
1506
1507     { NULL},
1508 };
1509
1510 static const AVClass ac3_decoder_class = {
1511     .class_name = "AC3 decoder",
1512     .item_name  = av_default_item_name,
1513     .option     = options,
1514     .version    = LIBAVUTIL_VERSION_INT,
1515 };
1516
1517 AVCodec ff_ac3_decoder = {
1518     .name           = "ac3",
1519     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),
1520     .type           = AVMEDIA_TYPE_AUDIO,
1521     .id             = AV_CODEC_ID_AC3,
1522     .priv_data_size = sizeof (AC3DecodeContext),
1523     .init           = ac3_decode_init,
1524     .close          = ac3_decode_end,
1525     .decode         = ac3_decode_frame,
1526     .capabilities   = CODEC_CAP_DR1,
1527     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1528                                                       AV_SAMPLE_FMT_NONE },
1529     .priv_class     = &ac3_decoder_class,
1530 };
1531
1532 #if CONFIG_EAC3_DECODER
1533 static const AVClass eac3_decoder_class = {
1534     .class_name = "E-AC3 decoder",
1535     .item_name  = av_default_item_name,
1536     .option     = options,
1537     .version    = LIBAVUTIL_VERSION_INT,
1538 };
1539
1540 AVCodec ff_eac3_decoder = {
1541     .name           = "eac3",
1542     .long_name      = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),
1543     .type           = AVMEDIA_TYPE_AUDIO,
1544     .id             = AV_CODEC_ID_EAC3,
1545     .priv_data_size = sizeof (AC3DecodeContext),
1546     .init           = ac3_decode_init,
1547     .close          = ac3_decode_end,
1548     .decode         = ac3_decode_frame,
1549     .capabilities   = CODEC_CAP_DR1,
1550     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
1551                                                       AV_SAMPLE_FMT_NONE },
1552     .priv_class     = &eac3_decoder_class,
1553 };
1554 #endif