Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dec.c @ 984ff38a

History | View | Annotate | Download (43.1 KB)

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