ac3enc: use function pointer to choose between AC-3 and E-AC-3 header output
[ffmpeg.git] / libavcodec / ac3enc.c
1 /*
2  * The simplest AC-3 encoder
3  * Copyright (c) 2000 Fabrice Bellard
4  * Copyright (c) 2006-2010 Justin Ruggles <justin.ruggles@gmail.com>
5  * Copyright (c) 2006-2010 Prakash Punnoor <prakash@punnoor.de>
6  *
7  * This file is part of Libav.
8  *
9  * Libav is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * Libav is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with Libav; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23
24 /**
25  * @file
26  * The simplest AC-3 encoder.
27  */
28
29 //#define ASSERT_LEVEL 2
30
31 #include <stdint.h>
32
33 #include "libavutil/audioconvert.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/crc.h"
37 #include "libavutil/opt.h"
38 #include "avcodec.h"
39 #include "put_bits.h"
40 #include "dsputil.h"
41 #include "ac3dsp.h"
42 #include "ac3.h"
43 #include "audioconvert.h"
44 #include "fft.h"
45 #include "ac3enc.h"
46 #include "eac3enc.h"
47
48 typedef struct AC3Mant {
49     uint16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
50     int mant1_cnt, mant2_cnt, mant4_cnt;    ///< mantissa counts for bap=1,2,4
51 } AC3Mant;
52
53 #define CMIXLEV_NUM_OPTIONS 3
54 static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = {
55     LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB
56 };
57
58 #define SURMIXLEV_NUM_OPTIONS 3
59 static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = {
60     LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO
61 };
62
63 #define EXTMIXLEV_NUM_OPTIONS 8
64 static const float extmixlev_options[EXTMIXLEV_NUM_OPTIONS] = {
65     LEVEL_PLUS_3DB,  LEVEL_PLUS_1POINT5DB,  LEVEL_ONE,       LEVEL_MINUS_4POINT5DB,
66     LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB, LEVEL_ZERO
67 };
68
69
70 #define OFFSET(param) offsetof(AC3EncodeContext, options.param)
71 #define AC3ENC_PARAM (AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
72
73 #define AC3ENC_TYPE_AC3_FIXED   0
74 #define AC3ENC_TYPE_AC3         1
75 #define AC3ENC_TYPE_EAC3        2
76
77 #if CONFIG_AC3ENC_FLOAT
78 #define AC3ENC_TYPE AC3ENC_TYPE_AC3
79 #include "ac3enc_opts_template.c"
80 static AVClass ac3enc_class = { "AC-3 Encoder", av_default_item_name,
81                                 ac3_options, LIBAVUTIL_VERSION_INT };
82 #undef AC3ENC_TYPE
83 #define AC3ENC_TYPE AC3ENC_TYPE_EAC3
84 #include "ac3enc_opts_template.c"
85 static AVClass eac3enc_class = { "E-AC-3 Encoder", av_default_item_name,
86                                  eac3_options, LIBAVUTIL_VERSION_INT };
87 #else
88 #define AC3ENC_TYPE AC3ENC_TYPE_AC3_FIXED
89 #include "ac3enc_opts_template.c"
90 static AVClass ac3enc_class = { "Fixed-Point AC-3 Encoder", av_default_item_name,
91                                 ac3fixed_options, LIBAVUTIL_VERSION_INT };
92 #endif
93
94
95 /* prototypes for functions in ac3enc_fixed.c and ac3enc_float.c */
96
97 static av_cold void mdct_end(AC3MDCTContext *mdct);
98
99 static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
100                              int nbits);
101
102 static void apply_window(DSPContext *dsp, SampleType *output, const SampleType *input,
103                          const SampleType *window, unsigned int len);
104
105 static int normalize_samples(AC3EncodeContext *s);
106
107 static void scale_coefficients(AC3EncodeContext *s);
108
109
110 /**
111  * LUT for number of exponent groups.
112  * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
113  */
114 static uint8_t exponent_group_tab[2][3][256];
115
116
117 /**
118  * List of supported channel layouts.
119  */
120 static const int64_t ac3_channel_layouts[] = {
121      AV_CH_LAYOUT_MONO,
122      AV_CH_LAYOUT_STEREO,
123      AV_CH_LAYOUT_2_1,
124      AV_CH_LAYOUT_SURROUND,
125      AV_CH_LAYOUT_2_2,
126      AV_CH_LAYOUT_QUAD,
127      AV_CH_LAYOUT_4POINT0,
128      AV_CH_LAYOUT_5POINT0,
129      AV_CH_LAYOUT_5POINT0_BACK,
130     (AV_CH_LAYOUT_MONO     | AV_CH_LOW_FREQUENCY),
131     (AV_CH_LAYOUT_STEREO   | AV_CH_LOW_FREQUENCY),
132     (AV_CH_LAYOUT_2_1      | AV_CH_LOW_FREQUENCY),
133     (AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY),
134     (AV_CH_LAYOUT_2_2      | AV_CH_LOW_FREQUENCY),
135     (AV_CH_LAYOUT_QUAD     | AV_CH_LOW_FREQUENCY),
136     (AV_CH_LAYOUT_4POINT0  | AV_CH_LOW_FREQUENCY),
137      AV_CH_LAYOUT_5POINT1,
138      AV_CH_LAYOUT_5POINT1_BACK,
139      0
140 };
141
142
143 /**
144  * LUT to select the bandwidth code based on the bit rate, sample rate, and
145  * number of full-bandwidth channels.
146  * bandwidth_tab[fbw_channels-1][sample rate code][bit rate code]
147  */
148 static const uint8_t ac3_bandwidth_tab[5][3][19] = {
149 //      32  40  48  56  64  80  96 112 128 160 192 224 256 320 384 448 512 576 640
150
151     { {  0,  0,  0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
152       {  0,  0,  0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
153       {  0,  0,  0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
154
155     { {  0,  0,  0,  0,  0,  0,  0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
156       {  0,  0,  0,  0,  0,  0,  4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
157       {  0,  0,  0,  0,  0,  0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
158
159     { {  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 },
160       {  0,  0,  0,  0,  0,  0,  0,  0,  4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 },
161       {  0,  0,  0,  0,  0,  0,  0,  0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } },
162
163     { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 24, 32, 48, 48, 48, 48, 48, 48 },
164       {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 28, 36, 56, 56, 56, 56, 56, 56 },
165       {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } },
166
167     { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  8, 20, 32, 40, 48, 48, 48, 48 },
168       {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 12, 24, 36, 44, 56, 56, 56, 56 },
169       {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 28, 44, 60, 60, 60, 60, 60, 60 } }
170 };
171
172
173 /**
174  * LUT to select the coupling start band based on the bit rate, sample rate, and
175  * number of full-bandwidth channels. -1 = coupling off
176  * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]
177  *
178  * TODO: more testing for optimal parameters.
179  *       multi-channel tests at 44.1kHz and 32kHz.
180  */
181 static const int8_t ac3_coupling_start_tab[6][3][19] = {
182 //      32  40  48  56  64  80  96 112 128 160 192 224 256 320 384 448 512 576 640
183
184     // 2/0
185     { {  0,  0,  0,  0,  0,  0,  0,  1,  1,  7,  8, 11, 12, -1, -1, -1, -1, -1, -1 },
186       {  0,  0,  0,  0,  0,  0,  1,  3,  5,  7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },
187       {  0,  0,  0,  0,  1,  2,  2,  9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
188
189     // 3/0
190     { {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
191       {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
192       { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
193
194     // 2/1 - untested
195     { {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
196       {  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  6,  9, 11, 12, 13, -1, -1, -1, -1 },
197       { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
198
199     // 3/1
200     { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
201       {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
202       { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
203
204     // 2/2 - untested
205     { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
206       {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3,  2, 10, 11, 11, 12, 12, 14, -1 },
207       { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
208
209     // 3/2
210     { {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  6,  8, 11, 12, 12, -1, -1 },
211       {  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  6,  8, 11, 12, 12, -1, -1 },
212       { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
213 };
214
215
216 /**
217  * Adjust the frame size to make the average bit rate match the target bit rate.
218  * This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3.
219  */
220 static void adjust_frame_size(AC3EncodeContext *s)
221 {
222     while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
223         s->bits_written    -= s->bit_rate;
224         s->samples_written -= s->sample_rate;
225     }
226     s->frame_size = s->frame_size_min +
227                     2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
228     s->bits_written    += s->frame_size * 8;
229     s->samples_written += AC3_FRAME_SIZE;
230 }
231
232
233 /**
234  * Deinterleave input samples.
235  * Channels are reordered from Libav's default order to AC-3 order.
236  */
237 static void deinterleave_input_samples(AC3EncodeContext *s,
238                                        const SampleType *samples)
239 {
240     int ch, i;
241
242     /* deinterleave and remap input samples */
243     for (ch = 0; ch < s->channels; ch++) {
244         const SampleType *sptr;
245         int sinc;
246
247         /* copy last 256 samples of previous frame to the start of the current frame */
248         memcpy(&s->planar_samples[ch][0], &s->planar_samples[ch][AC3_FRAME_SIZE],
249                AC3_BLOCK_SIZE * sizeof(s->planar_samples[0][0]));
250
251         /* deinterleave */
252         sinc = s->channels;
253         sptr = samples + s->channel_map[ch];
254         for (i = AC3_BLOCK_SIZE; i < AC3_FRAME_SIZE+AC3_BLOCK_SIZE; i++) {
255             s->planar_samples[ch][i] = *sptr;
256             sptr += sinc;
257         }
258     }
259 }
260
261
262 /**
263  * Apply the MDCT to input samples to generate frequency coefficients.
264  * This applies the KBD window and normalizes the input to reduce precision
265  * loss due to fixed-point calculations.
266  */
267 static void apply_mdct(AC3EncodeContext *s)
268 {
269     int blk, ch;
270
271     for (ch = 0; ch < s->channels; ch++) {
272         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
273             AC3Block *block = &s->blocks[blk];
274             const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
275
276             apply_window(&s->dsp, s->windowed_samples, input_samples, s->mdct.window, AC3_WINDOW_SIZE);
277
278             block->coeff_shift[ch+1] = normalize_samples(s);
279
280             s->mdct.fft.mdct_calcw(&s->mdct.fft, block->mdct_coef[ch+1],
281                                    s->windowed_samples);
282         }
283     }
284 }
285
286
287 static void compute_coupling_strategy(AC3EncodeContext *s)
288 {
289     int blk, ch;
290     int got_cpl_snr;
291
292     /* set coupling use flags for each block/channel */
293     /* TODO: turn coupling on/off and adjust start band based on bit usage */
294     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
295         AC3Block *block = &s->blocks[blk];
296         for (ch = 1; ch <= s->fbw_channels; ch++)
297             block->channel_in_cpl[ch] = s->cpl_on;
298     }
299
300     /* enable coupling for each block if at least 2 channels have coupling
301        enabled for that block */
302     got_cpl_snr = 0;
303     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
304         AC3Block *block = &s->blocks[blk];
305         block->num_cpl_channels = 0;
306         for (ch = 1; ch <= s->fbw_channels; ch++)
307             block->num_cpl_channels += block->channel_in_cpl[ch];
308         block->cpl_in_use = block->num_cpl_channels > 1;
309         if (!block->cpl_in_use) {
310             block->num_cpl_channels = 0;
311             for (ch = 1; ch <= s->fbw_channels; ch++)
312                 block->channel_in_cpl[ch] = 0;
313         }
314
315         block->new_cpl_strategy = !blk;
316         if (blk) {
317             for (ch = 1; ch <= s->fbw_channels; ch++) {
318                 if (block->channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
319                     block->new_cpl_strategy = 1;
320                     break;
321                 }
322             }
323         }
324         block->new_cpl_leak = block->new_cpl_strategy;
325
326         if (!blk || (block->cpl_in_use && !got_cpl_snr)) {
327             block->new_snr_offsets = 1;
328             if (block->cpl_in_use)
329                 got_cpl_snr = 1;
330         } else {
331             block->new_snr_offsets = 0;
332         }
333     }
334
335     /* set bandwidth for each channel */
336     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
337         AC3Block *block = &s->blocks[blk];
338         for (ch = 1; ch <= s->fbw_channels; ch++) {
339             if (block->channel_in_cpl[ch])
340                 block->end_freq[ch] = s->start_freq[CPL_CH];
341             else
342                 block->end_freq[ch] = s->bandwidth_code * 3 + 73;
343         }
344     }
345 }
346
347
348 /**
349  * Calculate a single coupling coordinate.
350  */
351 static inline float calc_cpl_coord(float energy_ch, float energy_cpl)
352 {
353     float coord = 0.125;
354     if (energy_cpl > 0)
355         coord *= sqrtf(energy_ch / energy_cpl);
356     return coord;
357 }
358
359
360 /**
361  * Calculate coupling channel and coupling coordinates.
362  * TODO: Currently this is only used for the floating-point encoder. I was
363  *       able to make it work for the fixed-point encoder, but quality was
364  *       generally lower in most cases than not using coupling. If a more
365  *       adaptive coupling strategy were to be implemented it might be useful
366  *       at that time to use coupling for the fixed-point encoder as well.
367  */
368 static void apply_channel_coupling(AC3EncodeContext *s)
369 {
370 #if CONFIG_AC3ENC_FLOAT
371     LOCAL_ALIGNED_16(float,   cpl_coords,       [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
372     LOCAL_ALIGNED_16(int32_t, fixed_cpl_coords, [AC3_MAX_BLOCKS], [AC3_MAX_CHANNELS][16]);
373     int blk, ch, bnd, i, j;
374     CoefSumType energy[AC3_MAX_BLOCKS][AC3_MAX_CHANNELS][16] = {{{0}}};
375     int num_cpl_coefs = s->num_cpl_subbands * 12;
376
377     memset(cpl_coords,       0, AC3_MAX_BLOCKS * sizeof(*cpl_coords));
378     memset(fixed_cpl_coords, 0, AC3_MAX_BLOCKS * sizeof(*fixed_cpl_coords));
379
380     /* calculate coupling channel from fbw channels */
381     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
382         AC3Block *block = &s->blocks[blk];
383         CoefType *cpl_coef = &block->mdct_coef[CPL_CH][s->start_freq[CPL_CH]];
384         if (!block->cpl_in_use)
385             continue;
386         memset(cpl_coef-1, 0, (num_cpl_coefs+4) * sizeof(*cpl_coef));
387         for (ch = 1; ch <= s->fbw_channels; ch++) {
388             CoefType *ch_coef = &block->mdct_coef[ch][s->start_freq[CPL_CH]];
389             if (!block->channel_in_cpl[ch])
390                 continue;
391             for (i = 0; i < num_cpl_coefs; i++)
392                 cpl_coef[i] += ch_coef[i];
393         }
394         /* note: coupling start bin % 4 will always be 1 and num_cpl_coefs
395                  will always be a multiple of 12, so we need to subtract 1 from
396                  the start and add 4 to the length when using optimized
397                  functions which require 16-byte alignment. */
398
399         /* coefficients must be clipped to +/- 1.0 in order to be encoded */
400         s->dsp.vector_clipf(cpl_coef-1, cpl_coef-1, -1.0f, 1.0f, num_cpl_coefs+4);
401
402         /* scale coupling coefficients from float to 24-bit fixed-point */
403         s->ac3dsp.float_to_fixed24(&block->fixed_coef[CPL_CH][s->start_freq[CPL_CH]-1],
404                                    cpl_coef-1, num_cpl_coefs+4);
405     }
406
407     /* calculate energy in each band in coupling channel and each fbw channel */
408     /* TODO: possibly use SIMD to speed up energy calculation */
409     bnd = 0;
410     i = s->start_freq[CPL_CH];
411     while (i < s->cpl_end_freq) {
412         int band_size = s->cpl_band_sizes[bnd];
413         for (ch = CPL_CH; ch <= s->fbw_channels; ch++) {
414             for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
415                 AC3Block *block = &s->blocks[blk];
416                 if (!block->cpl_in_use || (ch > CPL_CH && !block->channel_in_cpl[ch]))
417                     continue;
418                 for (j = 0; j < band_size; j++) {
419                     CoefType v = block->mdct_coef[ch][i+j];
420                     MAC_COEF(energy[blk][ch][bnd], v, v);
421                 }
422             }
423         }
424         i += band_size;
425         bnd++;
426     }
427
428     /* determine which blocks to send new coupling coordinates for */
429     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
430         AC3Block *block  = &s->blocks[blk];
431         AC3Block *block0 = blk ? &s->blocks[blk-1] : NULL;
432         int new_coords = 0;
433         CoefSumType coord_diff[AC3_MAX_CHANNELS] = {0,};
434
435         if (block->cpl_in_use) {
436             /* calculate coupling coordinates for all blocks and calculate the
437                average difference between coordinates in successive blocks */
438             for (ch = 1; ch <= s->fbw_channels; ch++) {
439                 if (!block->channel_in_cpl[ch])
440                     continue;
441
442                 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
443                     cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy[blk][ch][bnd],
444                                                               energy[blk][CPL_CH][bnd]);
445                     if (blk > 0 && block0->cpl_in_use &&
446                         block0->channel_in_cpl[ch]) {
447                         coord_diff[ch] += fabs(cpl_coords[blk-1][ch][bnd] -
448                                                cpl_coords[blk  ][ch][bnd]);
449                     }
450                 }
451                 coord_diff[ch] /= s->num_cpl_bands;
452             }
453
454             /* send new coordinates if this is the first block, if previous
455              * block did not use coupling but this block does, the channels
456              * using coupling has changed from the previous block, or the
457              * coordinate difference from the last block for any channel is
458              * greater than a threshold value. */
459             if (blk == 0) {
460                 new_coords = 1;
461             } else if (!block0->cpl_in_use) {
462                 new_coords = 1;
463             } else {
464                 for (ch = 1; ch <= s->fbw_channels; ch++) {
465                     if (block->channel_in_cpl[ch] && !block0->channel_in_cpl[ch]) {
466                         new_coords = 1;
467                         break;
468                     }
469                 }
470                 if (!new_coords) {
471                     for (ch = 1; ch <= s->fbw_channels; ch++) {
472                         if (block->channel_in_cpl[ch] && coord_diff[ch] > 0.04) {
473                             new_coords = 1;
474                             break;
475                         }
476                     }
477                 }
478             }
479         }
480         block->new_cpl_coords = new_coords;
481     }
482
483     /* calculate final coupling coordinates, taking into account reusing of
484        coordinates in successive blocks */
485     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
486         blk = 0;
487         while (blk < AC3_MAX_BLOCKS) {
488             int blk1;
489             CoefSumType energy_cpl;
490             AC3Block *block  = &s->blocks[blk];
491
492             if (!block->cpl_in_use) {
493                 blk++;
494                 continue;
495             }
496
497             energy_cpl = energy[blk][CPL_CH][bnd];
498             blk1 = blk+1;
499             while (!s->blocks[blk1].new_cpl_coords && blk1 < AC3_MAX_BLOCKS) {
500                 if (s->blocks[blk1].cpl_in_use)
501                     energy_cpl += energy[blk1][CPL_CH][bnd];
502                 blk1++;
503             }
504
505             for (ch = 1; ch <= s->fbw_channels; ch++) {
506                 CoefType energy_ch;
507                 if (!block->channel_in_cpl[ch])
508                     continue;
509                 energy_ch = energy[blk][ch][bnd];
510                 blk1 = blk+1;
511                 while (!s->blocks[blk1].new_cpl_coords && blk1 < AC3_MAX_BLOCKS) {
512                     if (s->blocks[blk1].cpl_in_use)
513                         energy_ch += energy[blk1][ch][bnd];
514                     blk1++;
515                 }
516                 cpl_coords[blk][ch][bnd] = calc_cpl_coord(energy_ch, energy_cpl);
517             }
518             blk = blk1;
519         }
520     }
521
522     /* calculate exponents/mantissas for coupling coordinates */
523     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
524         AC3Block *block = &s->blocks[blk];
525         if (!block->cpl_in_use || !block->new_cpl_coords)
526             continue;
527
528         s->ac3dsp.float_to_fixed24(fixed_cpl_coords[blk][1],
529                                    cpl_coords[blk][1],
530                                    s->fbw_channels * 16);
531         s->ac3dsp.extract_exponents(block->cpl_coord_exp[1],
532                                     fixed_cpl_coords[blk][1],
533                                     s->fbw_channels * 16);
534
535         for (ch = 1; ch <= s->fbw_channels; ch++) {
536             int bnd, min_exp, max_exp, master_exp;
537
538             /* determine master exponent */
539             min_exp = max_exp = block->cpl_coord_exp[ch][0];
540             for (bnd = 1; bnd < s->num_cpl_bands; bnd++) {
541                 int exp = block->cpl_coord_exp[ch][bnd];
542                 min_exp = FFMIN(exp, min_exp);
543                 max_exp = FFMAX(exp, max_exp);
544             }
545             master_exp = ((max_exp - 15) + 2) / 3;
546             master_exp = FFMAX(master_exp, 0);
547             while (min_exp < master_exp * 3)
548                 master_exp--;
549             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
550                 block->cpl_coord_exp[ch][bnd] = av_clip(block->cpl_coord_exp[ch][bnd] -
551                                                         master_exp * 3, 0, 15);
552             }
553             block->cpl_master_exp[ch] = master_exp;
554
555             /* quantize mantissas */
556             for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
557                 int cpl_exp  = block->cpl_coord_exp[ch][bnd];
558                 int cpl_mant = (fixed_cpl_coords[blk][ch][bnd] << (5 + cpl_exp + master_exp * 3)) >> 24;
559                 if (cpl_exp == 15)
560                     cpl_mant >>= 1;
561                 else
562                     cpl_mant -= 16;
563
564                 block->cpl_coord_mant[ch][bnd] = cpl_mant;
565             }
566         }
567     }
568
569     if (CONFIG_EAC3_ENCODER && s->eac3)
570         ff_eac3_set_cpl_states(s);
571 #endif /* CONFIG_AC3ENC_FLOAT */
572 }
573
574
575 /**
576  * Determine rematrixing flags for each block and band.
577  */
578 static void compute_rematrixing_strategy(AC3EncodeContext *s)
579 {
580     int nb_coefs;
581     int blk, bnd, i;
582     AC3Block *block, *block0;
583
584     if (s->channel_mode != AC3_CHMODE_STEREO)
585         return;
586
587     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
588         block = &s->blocks[blk];
589         block->new_rematrixing_strategy = !blk;
590
591         if (!s->rematrixing_enabled) {
592             block0 = block;
593             continue;
594         }
595
596         block->num_rematrixing_bands = 4;
597         if (block->cpl_in_use) {
598             block->num_rematrixing_bands -= (s->start_freq[CPL_CH] <= 61);
599             block->num_rematrixing_bands -= (s->start_freq[CPL_CH] == 37);
600             if (blk && block->num_rematrixing_bands != block0->num_rematrixing_bands)
601                 block->new_rematrixing_strategy = 1;
602         }
603         nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
604
605         for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
606             /* calculate calculate sum of squared coeffs for one band in one block */
607             int start = ff_ac3_rematrix_band_tab[bnd];
608             int end   = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
609             CoefSumType sum[4] = {0,};
610             for (i = start; i < end; i++) {
611                 CoefType lt = block->mdct_coef[1][i];
612                 CoefType rt = block->mdct_coef[2][i];
613                 CoefType md = lt + rt;
614                 CoefType sd = lt - rt;
615                 MAC_COEF(sum[0], lt, lt);
616                 MAC_COEF(sum[1], rt, rt);
617                 MAC_COEF(sum[2], md, md);
618                 MAC_COEF(sum[3], sd, sd);
619             }
620
621             /* compare sums to determine if rematrixing will be used for this band */
622             if (FFMIN(sum[2], sum[3]) < FFMIN(sum[0], sum[1]))
623                 block->rematrixing_flags[bnd] = 1;
624             else
625                 block->rematrixing_flags[bnd] = 0;
626
627             /* determine if new rematrixing flags will be sent */
628             if (blk &&
629                 block->rematrixing_flags[bnd] != block0->rematrixing_flags[bnd]) {
630                 block->new_rematrixing_strategy = 1;
631             }
632         }
633         block0 = block;
634     }
635 }
636
637
638 /**
639  * Apply stereo rematrixing to coefficients based on rematrixing flags.
640  */
641 static void apply_rematrixing(AC3EncodeContext *s)
642 {
643     int nb_coefs;
644     int blk, bnd, i;
645     int start, end;
646     uint8_t *flags;
647
648     if (!s->rematrixing_enabled)
649         return;
650
651     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
652         AC3Block *block = &s->blocks[blk];
653         if (block->new_rematrixing_strategy)
654             flags = block->rematrixing_flags;
655         nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
656         for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
657             if (flags[bnd]) {
658                 start = ff_ac3_rematrix_band_tab[bnd];
659                 end   = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
660                 for (i = start; i < end; i++) {
661                     int32_t lt = block->fixed_coef[1][i];
662                     int32_t rt = block->fixed_coef[2][i];
663                     block->fixed_coef[1][i] = (lt + rt) >> 1;
664                     block->fixed_coef[2][i] = (lt - rt) >> 1;
665                 }
666             }
667         }
668     }
669 }
670
671
672 /**
673  * Initialize exponent tables.
674  */
675 static av_cold void exponent_init(AC3EncodeContext *s)
676 {
677     int expstr, i, grpsize;
678
679     for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {
680         grpsize = 3 << expstr;
681         for (i = 12; i < 256; i++) {
682             exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize;
683             exponent_group_tab[1][expstr][i] = (i              ) / grpsize;
684         }
685     }
686     /* LFE */
687     exponent_group_tab[0][0][7] = 2;
688 }
689
690
691 /**
692  * Extract exponents from the MDCT coefficients.
693  * This takes into account the normalization that was done to the input samples
694  * by adjusting the exponents by the exponent shift values.
695  */
696 static void extract_exponents(AC3EncodeContext *s)
697 {
698     int ch        = !s->cpl_on;
699     int chan_size = AC3_MAX_COEFS * AC3_MAX_BLOCKS * (s->channels - ch + 1);
700     AC3Block *block = &s->blocks[0];
701
702     s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], chan_size);
703 }
704
705
706 /**
707  * Exponent Difference Threshold.
708  * New exponents are sent if their SAD exceed this number.
709  */
710 #define EXP_DIFF_THRESHOLD 500
711
712
713 /**
714  * Calculate exponent strategies for all channels.
715  * Array arrangement is reversed to simplify the per-channel calculation.
716  */
717 static void compute_exp_strategy(AC3EncodeContext *s)
718 {
719     int ch, blk, blk1;
720
721     for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) {
722         uint8_t *exp_strategy = s->exp_strategy[ch];
723         uint8_t *exp          = s->blocks[0].exp[ch];
724         int exp_diff;
725
726         /* estimate if the exponent variation & decide if they should be
727            reused in the next frame */
728         exp_strategy[0] = EXP_NEW;
729         exp += AC3_MAX_COEFS;
730         for (blk = 1; blk < AC3_MAX_BLOCKS; blk++, exp += AC3_MAX_COEFS) {
731             if ((ch == CPL_CH && (!s->blocks[blk].cpl_in_use || !s->blocks[blk-1].cpl_in_use)) ||
732                 (ch  > CPL_CH && (s->blocks[blk].channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]))) {
733                 exp_strategy[blk] = EXP_NEW;
734                 continue;
735             }
736             exp_diff = s->dsp.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
737             exp_strategy[blk] = EXP_REUSE;
738             if (ch == CPL_CH && exp_diff > (EXP_DIFF_THRESHOLD * (s->blocks[blk].end_freq[ch] - s->start_freq[ch]) / AC3_MAX_COEFS))
739                 exp_strategy[blk] = EXP_NEW;
740             else if (ch > CPL_CH && exp_diff > EXP_DIFF_THRESHOLD)
741                 exp_strategy[blk] = EXP_NEW;
742         }
743
744         /* now select the encoding strategy type : if exponents are often
745            recoded, we use a coarse encoding */
746         blk = 0;
747         while (blk < AC3_MAX_BLOCKS) {
748             blk1 = blk + 1;
749             while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE)
750                 blk1++;
751             switch (blk1 - blk) {
752             case 1:  exp_strategy[blk] = EXP_D45; break;
753             case 2:
754             case 3:  exp_strategy[blk] = EXP_D25; break;
755             default: exp_strategy[blk] = EXP_D15; break;
756             }
757             blk = blk1;
758         }
759     }
760     if (s->lfe_on) {
761         ch = s->lfe_channel;
762         s->exp_strategy[ch][0] = EXP_D15;
763         for (blk = 1; blk < AC3_MAX_BLOCKS; blk++)
764             s->exp_strategy[ch][blk] = EXP_REUSE;
765     }
766 }
767
768
769 /**
770  * Update the exponents so that they are the ones the decoder will decode.
771  */
772 static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,
773                                     int cpl)
774 {
775     int nb_groups, i, k;
776
777     nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;
778
779     /* for each group, compute the minimum exponent */
780     switch(exp_strategy) {
781     case EXP_D25:
782         for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
783             uint8_t exp_min = exp[k];
784             if (exp[k+1] < exp_min)
785                 exp_min = exp[k+1];
786             exp[i-cpl] = exp_min;
787             k += 2;
788         }
789         break;
790     case EXP_D45:
791         for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
792             uint8_t exp_min = exp[k];
793             if (exp[k+1] < exp_min)
794                 exp_min = exp[k+1];
795             if (exp[k+2] < exp_min)
796                 exp_min = exp[k+2];
797             if (exp[k+3] < exp_min)
798                 exp_min = exp[k+3];
799             exp[i-cpl] = exp_min;
800             k += 4;
801         }
802         break;
803     }
804
805     /* constraint for DC exponent */
806     if (!cpl && exp[0] > 15)
807         exp[0] = 15;
808
809     /* decrease the delta between each groups to within 2 so that they can be
810        differentially encoded */
811     for (i = 1; i <= nb_groups; i++)
812         exp[i] = FFMIN(exp[i], exp[i-1] + 2);
813     i--;
814     while (--i >= 0)
815         exp[i] = FFMIN(exp[i], exp[i+1] + 2);
816
817     if (cpl)
818         exp[-1] = exp[0] & ~1;
819
820     /* now we have the exponent values the decoder will see */
821     switch (exp_strategy) {
822     case EXP_D25:
823         for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) {
824             uint8_t exp1 = exp[i-cpl];
825             exp[k--] = exp1;
826             exp[k--] = exp1;
827         }
828         break;
829     case EXP_D45:
830         for (i = nb_groups, k = (nb_groups * 4)-cpl; i > 0; i--) {
831             exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i-cpl];
832             k -= 4;
833         }
834         break;
835     }
836 }
837
838
839 /**
840  * Encode exponents from original extracted form to what the decoder will see.
841  * This copies and groups exponents based on exponent strategy and reduces
842  * deltas between adjacent exponent groups so that they can be differentially
843  * encoded.
844  */
845 static void encode_exponents(AC3EncodeContext *s)
846 {
847     int blk, blk1, ch, cpl;
848     uint8_t *exp, *exp_strategy;
849     int nb_coefs, num_reuse_blocks;
850
851     for (ch = !s->cpl_on; ch <= s->channels; ch++) {
852         exp          = s->blocks[0].exp[ch] + s->start_freq[ch];
853         exp_strategy = s->exp_strategy[ch];
854
855         cpl = (ch == CPL_CH);
856         blk = 0;
857         while (blk < AC3_MAX_BLOCKS) {
858             AC3Block *block = &s->blocks[blk];
859             if (cpl && !block->cpl_in_use) {
860                 exp += AC3_MAX_COEFS;
861                 blk++;
862                 continue;
863             }
864             nb_coefs = block->end_freq[ch] - s->start_freq[ch];
865             blk1 = blk + 1;
866
867             /* count the number of EXP_REUSE blocks after the current block
868                and set exponent reference block numbers */
869             s->exp_ref_block[ch][blk] = blk;
870             while (blk1 < AC3_MAX_BLOCKS && exp_strategy[blk1] == EXP_REUSE) {
871                 s->exp_ref_block[ch][blk1] = blk;
872                 blk1++;
873             }
874             num_reuse_blocks = blk1 - blk - 1;
875
876             /* for the EXP_REUSE case we select the min of the exponents */
877             s->ac3dsp.ac3_exponent_min(exp-s->start_freq[ch], num_reuse_blocks,
878                                        AC3_MAX_COEFS);
879
880             encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk], cpl);
881
882             exp += AC3_MAX_COEFS * (num_reuse_blocks + 1);
883             blk = blk1;
884         }
885     }
886
887     /* reference block numbers have been changed, so reset ref_bap_set */
888     s->ref_bap_set = 0;
889 }
890
891
892 /**
893  * Group exponents.
894  * 3 delta-encoded exponents are in each 7-bit group. The number of groups
895  * varies depending on exponent strategy and bandwidth.
896  */
897 static void group_exponents(AC3EncodeContext *s)
898 {
899     int blk, ch, i, cpl;
900     int group_size, nb_groups, bit_count;
901     uint8_t *p;
902     int delta0, delta1, delta2;
903     int exp0, exp1;
904
905     bit_count = 0;
906     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
907         AC3Block *block = &s->blocks[blk];
908         for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
909             int exp_strategy = s->exp_strategy[ch][blk];
910             if (exp_strategy == EXP_REUSE)
911                 continue;
912             cpl = (ch == CPL_CH);
913             group_size = exp_strategy + (exp_strategy == EXP_D45);
914             nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]];
915             bit_count += 4 + (nb_groups * 7);
916             p = block->exp[ch] + s->start_freq[ch] - cpl;
917
918             /* DC exponent */
919             exp1 = *p++;
920             block->grouped_exp[ch][0] = exp1;
921
922             /* remaining exponents are delta encoded */
923             for (i = 1; i <= nb_groups; i++) {
924                 /* merge three delta in one code */
925                 exp0   = exp1;
926                 exp1   = p[0];
927                 p     += group_size;
928                 delta0 = exp1 - exp0 + 2;
929                 av_assert2(delta0 >= 0 && delta0 <= 4);
930
931                 exp0   = exp1;
932                 exp1   = p[0];
933                 p     += group_size;
934                 delta1 = exp1 - exp0 + 2;
935                 av_assert2(delta1 >= 0 && delta1 <= 4);
936
937                 exp0   = exp1;
938                 exp1   = p[0];
939                 p     += group_size;
940                 delta2 = exp1 - exp0 + 2;
941                 av_assert2(delta2 >= 0 && delta2 <= 4);
942
943                 block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
944             }
945         }
946     }
947
948     s->exponent_bits = bit_count;
949 }
950
951
952 /**
953  * Calculate final exponents from the supplied MDCT coefficients and exponent shift.
954  * Extract exponents from MDCT coefficients, calculate exponent strategies,
955  * and encode final exponents.
956  */
957 static void process_exponents(AC3EncodeContext *s)
958 {
959     extract_exponents(s);
960
961     compute_exp_strategy(s);
962
963     encode_exponents(s);
964
965     group_exponents(s);
966
967     emms_c();
968 }
969
970
971 /**
972  * Count frame bits that are based solely on fixed parameters.
973  * This only has to be run once when the encoder is initialized.
974  */
975 static void count_frame_bits_fixed(AC3EncodeContext *s)
976 {
977     static const int frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
978     int blk;
979     int frame_bits;
980
981     /* assumptions:
982      *   no dynamic range codes
983      *   bit allocation parameters do not change between blocks
984      *   no delta bit allocation
985      *   no skipped data
986      *   no auxilliary data
987      *   no E-AC-3 metadata
988      */
989
990     /* header */
991     frame_bits = 16; /* sync info */
992     if (s->eac3) {
993         /* bitstream info header */
994         frame_bits += 35;
995         frame_bits += 1 + 1 + 1;
996         /* audio frame header */
997         frame_bits += 2;
998         frame_bits += 10;
999         /* exponent strategy */
1000         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
1001             frame_bits += 2 * s->fbw_channels + s->lfe_on;
1002         /* converter exponent strategy */
1003         frame_bits += s->fbw_channels * 5;
1004         /* snr offsets */
1005         frame_bits += 10;
1006         /* block start info */
1007         frame_bits++;
1008     } else {
1009         frame_bits += 49;
1010         frame_bits += frame_bits_inc[s->channel_mode];
1011     }
1012
1013     /* audio blocks */
1014     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1015         if (!s->eac3) {
1016             /* block switch flags */
1017             frame_bits += s->fbw_channels;
1018
1019             /* dither flags */
1020             frame_bits += s->fbw_channels;
1021         }
1022
1023         /* dynamic range */
1024         frame_bits++;
1025
1026         /* spectral extension */
1027         if (s->eac3)
1028             frame_bits++;
1029
1030         if (!s->eac3) {
1031             /* exponent strategy */
1032             frame_bits += 2 * s->fbw_channels;
1033             if (s->lfe_on)
1034                 frame_bits++;
1035
1036             /* bit allocation params */
1037             frame_bits++;
1038             if (!blk)
1039                 frame_bits += 2 + 2 + 2 + 2 + 3;
1040         }
1041
1042         /* converter snr offset */
1043         if (s->eac3)
1044             frame_bits++;
1045
1046         if (!s->eac3) {
1047             /* delta bit allocation */
1048             frame_bits++;
1049
1050             /* skipped data */
1051             frame_bits++;
1052         }
1053     }
1054
1055     /* auxiliary data */
1056     frame_bits++;
1057
1058     /* CRC */
1059     frame_bits += 1 + 16;
1060
1061     s->frame_bits_fixed = frame_bits;
1062 }
1063
1064
1065 /**
1066  * Initialize bit allocation.
1067  * Set default parameter codes and calculate parameter values.
1068  */
1069 static void bit_alloc_init(AC3EncodeContext *s)
1070 {
1071     int ch;
1072
1073     /* init default parameters */
1074     s->slow_decay_code = 2;
1075     s->fast_decay_code = 1;
1076     s->slow_gain_code  = 1;
1077     s->db_per_bit_code = s->eac3 ? 2 : 3;
1078     s->floor_code      = 7;
1079     for (ch = 0; ch <= s->channels; ch++)
1080         s->fast_gain_code[ch] = 4;
1081
1082     /* initial snr offset */
1083     s->coarse_snr_offset = 40;
1084
1085     /* compute real values */
1086     /* currently none of these values change during encoding, so we can just
1087        set them once at initialization */
1088     s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code] >> s->bit_alloc.sr_shift;
1089     s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code] >> s->bit_alloc.sr_shift;
1090     s->bit_alloc.slow_gain  = ff_ac3_slow_gain_tab[s->slow_gain_code];
1091     s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
1092     s->bit_alloc.floor      = ff_ac3_floor_tab[s->floor_code];
1093     s->bit_alloc.cpl_fast_leak = 0;
1094     s->bit_alloc.cpl_slow_leak = 0;
1095
1096     count_frame_bits_fixed(s);
1097 }
1098
1099
1100 /**
1101  * Count the bits used to encode the frame, minus exponents and mantissas.
1102  * Bits based on fixed parameters have already been counted, so now we just
1103  * have to add the bits based on parameters that change during encoding.
1104  */
1105 static void count_frame_bits(AC3EncodeContext *s)
1106 {
1107     AC3EncOptions *opt = &s->options;
1108     int blk, ch;
1109     int frame_bits = 0;
1110
1111     /* header */
1112     if (s->eac3) {
1113         /* coupling */
1114         if (s->channel_mode > AC3_CHMODE_MONO) {
1115             frame_bits++;
1116             for (blk = 1; blk < AC3_MAX_BLOCKS; blk++) {
1117                 AC3Block *block = &s->blocks[blk];
1118                 frame_bits++;
1119                 if (block->new_cpl_strategy)
1120                     frame_bits++;
1121             }
1122         }
1123         /* coupling exponent strategy */
1124         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
1125             frame_bits += 2 * s->blocks[blk].cpl_in_use;
1126     } else {
1127         if (opt->audio_production_info)
1128             frame_bits += 7;
1129         if (s->bitstream_id == 6) {
1130             if (opt->extended_bsi_1)
1131                 frame_bits += 14;
1132             if (opt->extended_bsi_2)
1133                 frame_bits += 14;
1134         }
1135     }
1136
1137     /* audio blocks */
1138     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1139         AC3Block *block = &s->blocks[blk];
1140
1141         /* coupling strategy */
1142         if (!s->eac3)
1143             frame_bits++;
1144         if (block->new_cpl_strategy) {
1145             if (!s->eac3)
1146                 frame_bits++;
1147             if (block->cpl_in_use) {
1148                 if (s->eac3)
1149                     frame_bits++;
1150                 if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO)
1151                     frame_bits += s->fbw_channels;
1152                 if (s->channel_mode == AC3_CHMODE_STEREO)
1153                     frame_bits++;
1154                 frame_bits += 4 + 4;
1155                 if (s->eac3)
1156                     frame_bits++;
1157                 else
1158                     frame_bits += s->num_cpl_subbands - 1;
1159             }
1160         }
1161
1162         /* coupling coordinates */
1163         if (block->cpl_in_use) {
1164             for (ch = 1; ch <= s->fbw_channels; ch++) {
1165                 if (block->channel_in_cpl[ch]) {
1166                     if (!s->eac3 || block->new_cpl_coords != 2)
1167                         frame_bits++;
1168                     if (block->new_cpl_coords) {
1169                         frame_bits += 2;
1170                         frame_bits += (4 + 4) * s->num_cpl_bands;
1171                     }
1172                 }
1173             }
1174         }
1175
1176         /* stereo rematrixing */
1177         if (s->channel_mode == AC3_CHMODE_STEREO) {
1178             if (!s->eac3 || blk > 0)
1179                 frame_bits++;
1180             if (s->blocks[blk].new_rematrixing_strategy)
1181                 frame_bits += block->num_rematrixing_bands;
1182         }
1183
1184         /* bandwidth codes & gain range */
1185         for (ch = 1; ch <= s->fbw_channels; ch++) {
1186             if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1187                 if (!block->channel_in_cpl[ch])
1188                     frame_bits += 6;
1189                 frame_bits += 2;
1190             }
1191         }
1192
1193         /* coupling exponent strategy */
1194         if (!s->eac3 && block->cpl_in_use)
1195             frame_bits += 2;
1196
1197         /* snr offsets and fast gain codes */
1198         if (!s->eac3) {
1199             frame_bits++;
1200             if (block->new_snr_offsets)
1201                 frame_bits += 6 + (s->channels + block->cpl_in_use) * (4 + 3);
1202         }
1203
1204         /* coupling leak info */
1205         if (block->cpl_in_use) {
1206             if (!s->eac3 || block->new_cpl_leak != 2)
1207                 frame_bits++;
1208             if (block->new_cpl_leak)
1209                 frame_bits += 3 + 3;
1210         }
1211     }
1212
1213     s->frame_bits = s->frame_bits_fixed + frame_bits;
1214 }
1215
1216
1217 /**
1218  * Calculate masking curve based on the final exponents.
1219  * Also calculate the power spectral densities to use in future calculations.
1220  */
1221 static void bit_alloc_masking(AC3EncodeContext *s)
1222 {
1223     int blk, ch;
1224
1225     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1226         AC3Block *block = &s->blocks[blk];
1227         for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1228             /* We only need psd and mask for calculating bap.
1229                Since we currently do not calculate bap when exponent
1230                strategy is EXP_REUSE we do not need to calculate psd or mask. */
1231             if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1232                 ff_ac3_bit_alloc_calc_psd(block->exp[ch], s->start_freq[ch],
1233                                           block->end_freq[ch], block->psd[ch],
1234                                           block->band_psd[ch]);
1235                 ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch],
1236                                            s->start_freq[ch], block->end_freq[ch],
1237                                            ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
1238                                            ch == s->lfe_channel,
1239                                            DBA_NONE, 0, NULL, NULL, NULL,
1240                                            block->mask[ch]);
1241             }
1242         }
1243     }
1244 }
1245
1246
1247 /**
1248  * Ensure that bap for each block and channel point to the current bap_buffer.
1249  * They may have been switched during the bit allocation search.
1250  */
1251 static void reset_block_bap(AC3EncodeContext *s)
1252 {
1253     int blk, ch;
1254     uint8_t *ref_bap;
1255
1256     if (s->ref_bap[0][0] == s->bap_buffer && s->ref_bap_set)
1257         return;
1258
1259     ref_bap = s->bap_buffer;
1260     for (ch = 0; ch <= s->channels; ch++) {
1261         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
1262             s->ref_bap[ch][blk] = ref_bap + AC3_MAX_COEFS * s->exp_ref_block[ch][blk];
1263         ref_bap += AC3_MAX_COEFS * AC3_MAX_BLOCKS;
1264     }
1265     s->ref_bap_set = 1;
1266 }
1267
1268
1269 /**
1270  * Initialize mantissa counts.
1271  * These are set so that they are padded to the next whole group size when bits
1272  * are counted in compute_mantissa_size.
1273  */
1274 static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
1275 {
1276     int blk;
1277
1278     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1279         memset(mant_cnt[blk], 0, sizeof(mant_cnt[blk]));
1280         mant_cnt[blk][1] = mant_cnt[blk][2] = 2;
1281         mant_cnt[blk][4] = 1;
1282     }
1283 }
1284
1285
1286 /**
1287  * Update mantissa bit counts for all blocks in 1 channel in a given bandwidth
1288  * range.
1289  */
1290 static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch,
1291                                           uint16_t mant_cnt[AC3_MAX_BLOCKS][16],
1292                                           int start, int end)
1293 {
1294     int blk;
1295
1296     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1297         AC3Block *block = &s->blocks[blk];
1298         if (ch == CPL_CH && !block->cpl_in_use)
1299             continue;
1300         s->ac3dsp.update_bap_counts(mant_cnt[blk],
1301                                     s->ref_bap[ch][blk] + start,
1302                                     FFMIN(end, block->end_freq[ch]) - start);
1303     }
1304 }
1305
1306
1307 /**
1308  * Count the number of mantissa bits in the frame based on the bap values.
1309  */
1310 static int count_mantissa_bits(AC3EncodeContext *s)
1311 {
1312     int ch, max_end_freq;
1313     LOCAL_ALIGNED_16(uint16_t, mant_cnt, [AC3_MAX_BLOCKS], [16]);
1314
1315     count_mantissa_bits_init(mant_cnt);
1316
1317     max_end_freq = s->bandwidth_code * 3 + 73;
1318     for (ch = !s->cpl_enabled; ch <= s->channels; ch++)
1319         count_mantissa_bits_update_ch(s, ch, mant_cnt, s->start_freq[ch],
1320                                       max_end_freq);
1321
1322     return s->ac3dsp.compute_mantissa_size(mant_cnt);
1323 }
1324
1325
1326 /**
1327  * Run the bit allocation with a given SNR offset.
1328  * This calculates the bit allocation pointers that will be used to determine
1329  * the quantization of each mantissa.
1330  * @return the number of bits needed for mantissas if the given SNR offset is
1331  *         is used.
1332  */
1333 static int bit_alloc(AC3EncodeContext *s, int snr_offset)
1334 {
1335     int blk, ch;
1336
1337     snr_offset = (snr_offset - 240) << 2;
1338
1339     reset_block_bap(s);
1340     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1341         AC3Block *block = &s->blocks[blk];
1342
1343         for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1344             /* Currently the only bit allocation parameters which vary across
1345                blocks within a frame are the exponent values.  We can take
1346                advantage of that by reusing the bit allocation pointers
1347                whenever we reuse exponents. */
1348             if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1349                 s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch],
1350                                              s->start_freq[ch], block->end_freq[ch],
1351                                              snr_offset, s->bit_alloc.floor,
1352                                              ff_ac3_bap_tab, s->ref_bap[ch][blk]);
1353             }
1354         }
1355     }
1356     return count_mantissa_bits(s);
1357 }
1358
1359
1360 /**
1361  * Constant bitrate bit allocation search.
1362  * Find the largest SNR offset that will allow data to fit in the frame.
1363  */
1364 static int cbr_bit_allocation(AC3EncodeContext *s)
1365 {
1366     int ch;
1367     int bits_left;
1368     int snr_offset, snr_incr;
1369
1370     bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
1371     if (bits_left < 0)
1372         return AVERROR(EINVAL);
1373
1374     snr_offset = s->coarse_snr_offset << 4;
1375
1376     /* if previous frame SNR offset was 1023, check if current frame can also
1377        use SNR offset of 1023. if so, skip the search. */
1378     if ((snr_offset | s->fine_snr_offset[1]) == 1023) {
1379         if (bit_alloc(s, 1023) <= bits_left)
1380             return 0;
1381     }
1382
1383     while (snr_offset >= 0 &&
1384            bit_alloc(s, snr_offset) > bits_left) {
1385         snr_offset -= 64;
1386     }
1387     if (snr_offset < 0)
1388         return AVERROR(EINVAL);
1389
1390     FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1391     for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) {
1392         while (snr_offset + snr_incr <= 1023 &&
1393                bit_alloc(s, snr_offset + snr_incr) <= bits_left) {
1394             snr_offset += snr_incr;
1395             FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1396         }
1397     }
1398     FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1399     reset_block_bap(s);
1400
1401     s->coarse_snr_offset = snr_offset >> 4;
1402     for (ch = !s->cpl_on; ch <= s->channels; ch++)
1403         s->fine_snr_offset[ch] = snr_offset & 0xF;
1404
1405     return 0;
1406 }
1407
1408
1409 /**
1410  * Downgrade exponent strategies to reduce the bits used by the exponents.
1411  * This is a fallback for when bit allocation fails with the normal exponent
1412  * strategies.  Each time this function is run it only downgrades the
1413  * strategy in 1 channel of 1 block.
1414  * @return non-zero if downgrade was unsuccessful
1415  */
1416 static int downgrade_exponents(AC3EncodeContext *s)
1417 {
1418     int ch, blk;
1419
1420     for (blk = AC3_MAX_BLOCKS-1; blk >= 0; blk--) {
1421         for (ch = !s->blocks[blk].cpl_in_use; ch <= s->fbw_channels; ch++) {
1422             if (s->exp_strategy[ch][blk] == EXP_D15) {
1423                 s->exp_strategy[ch][blk] = EXP_D25;
1424                 return 0;
1425             }
1426         }
1427     }
1428     for (blk = AC3_MAX_BLOCKS-1; blk >= 0; blk--) {
1429         for (ch = !s->blocks[blk].cpl_in_use; ch <= s->fbw_channels; ch++) {
1430             if (s->exp_strategy[ch][blk] == EXP_D25) {
1431                 s->exp_strategy[ch][blk] = EXP_D45;
1432                 return 0;
1433             }
1434         }
1435     }
1436     /* block 0 cannot reuse exponents, so only downgrade D45 to REUSE if
1437        the block number > 0 */
1438     for (blk = AC3_MAX_BLOCKS-1; blk > 0; blk--) {
1439         for (ch = !s->blocks[blk].cpl_in_use; ch <= s->fbw_channels; ch++) {
1440             if (s->exp_strategy[ch][blk] > EXP_REUSE) {
1441                 s->exp_strategy[ch][blk] = EXP_REUSE;
1442                 return 0;
1443             }
1444         }
1445     }
1446     return -1;
1447 }
1448
1449
1450 /**
1451  * Perform bit allocation search.
1452  * Finds the SNR offset value that maximizes quality and fits in the specified
1453  * frame size.  Output is the SNR offset and a set of bit allocation pointers
1454  * used to quantize the mantissas.
1455  */
1456 static int compute_bit_allocation(AC3EncodeContext *s)
1457 {
1458     int ret;
1459
1460     count_frame_bits(s);
1461
1462     bit_alloc_masking(s);
1463
1464     ret = cbr_bit_allocation(s);
1465     while (ret) {
1466         /* fallback 1: disable channel coupling */
1467         if (s->cpl_on) {
1468             s->cpl_on = 0;
1469             compute_coupling_strategy(s);
1470             compute_rematrixing_strategy(s);
1471             apply_rematrixing(s);
1472             process_exponents(s);
1473             ret = compute_bit_allocation(s);
1474             continue;
1475         }
1476
1477         /* fallback 2: downgrade exponents */
1478         if (!downgrade_exponents(s)) {
1479             extract_exponents(s);
1480             encode_exponents(s);
1481             group_exponents(s);
1482             ret = compute_bit_allocation(s);
1483             continue;
1484         }
1485
1486         /* fallbacks were not enough... */
1487         break;
1488     }
1489
1490     return ret;
1491 }
1492
1493
1494 /**
1495  * Symmetric quantization on 'levels' levels.
1496  */
1497 static inline int sym_quant(int c, int e, int levels)
1498 {
1499     int v = (((levels * c) >> (24 - e)) + levels) >> 1;
1500     av_assert2(v >= 0 && v < levels);
1501     return v;
1502 }
1503
1504
1505 /**
1506  * Asymmetric quantization on 2^qbits levels.
1507  */
1508 static inline int asym_quant(int c, int e, int qbits)
1509 {
1510     int lshift, m, v;
1511
1512     lshift = e + qbits - 24;
1513     if (lshift >= 0)
1514         v = c << lshift;
1515     else
1516         v = c >> (-lshift);
1517     /* rounding */
1518     v = (v + 1) >> 1;
1519     m = (1 << (qbits-1));
1520     if (v >= m)
1521         v = m - 1;
1522     av_assert2(v >= -m);
1523     return v & ((1 << qbits)-1);
1524 }
1525
1526
1527 /**
1528  * Quantize a set of mantissas for a single channel in a single block.
1529  */
1530 static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef,
1531                                       uint8_t *exp, uint8_t *bap,
1532                                       uint16_t *qmant, int start_freq,
1533                                       int end_freq)
1534 {
1535     int i;
1536
1537     for (i = start_freq; i < end_freq; i++) {
1538         int v;
1539         int c = fixed_coef[i];
1540         int e = exp[i];
1541         int b = bap[i];
1542         switch (b) {
1543         case 0:
1544             v = 0;
1545             break;
1546         case 1:
1547             v = sym_quant(c, e, 3);
1548             switch (s->mant1_cnt) {
1549             case 0:
1550                 s->qmant1_ptr = &qmant[i];
1551                 v = 9 * v;
1552                 s->mant1_cnt = 1;
1553                 break;
1554             case 1:
1555                 *s->qmant1_ptr += 3 * v;
1556                 s->mant1_cnt = 2;
1557                 v = 128;
1558                 break;
1559             default:
1560                 *s->qmant1_ptr += v;
1561                 s->mant1_cnt = 0;
1562                 v = 128;
1563                 break;
1564             }
1565             break;
1566         case 2:
1567             v = sym_quant(c, e, 5);
1568             switch (s->mant2_cnt) {
1569             case 0:
1570                 s->qmant2_ptr = &qmant[i];
1571                 v = 25 * v;
1572                 s->mant2_cnt = 1;
1573                 break;
1574             case 1:
1575                 *s->qmant2_ptr += 5 * v;
1576                 s->mant2_cnt = 2;
1577                 v = 128;
1578                 break;
1579             default:
1580                 *s->qmant2_ptr += v;
1581                 s->mant2_cnt = 0;
1582                 v = 128;
1583                 break;
1584             }
1585             break;
1586         case 3:
1587             v = sym_quant(c, e, 7);
1588             break;
1589         case 4:
1590             v = sym_quant(c, e, 11);
1591             switch (s->mant4_cnt) {
1592             case 0:
1593                 s->qmant4_ptr = &qmant[i];
1594                 v = 11 * v;
1595                 s->mant4_cnt = 1;
1596                 break;
1597             default:
1598                 *s->qmant4_ptr += v;
1599                 s->mant4_cnt = 0;
1600                 v = 128;
1601                 break;
1602             }
1603             break;
1604         case 5:
1605             v = sym_quant(c, e, 15);
1606             break;
1607         case 14:
1608             v = asym_quant(c, e, 14);
1609             break;
1610         case 15:
1611             v = asym_quant(c, e, 16);
1612             break;
1613         default:
1614             v = asym_quant(c, e, b - 1);
1615             break;
1616         }
1617         qmant[i] = v;
1618     }
1619 }
1620
1621
1622 /**
1623  * Quantize mantissas using coefficients, exponents, and bit allocation pointers.
1624  */
1625 static void quantize_mantissas(AC3EncodeContext *s)
1626 {
1627     int blk, ch, ch0=0, got_cpl;
1628
1629     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1630         AC3Block *block = &s->blocks[blk];
1631         AC3Mant m = { 0 };
1632
1633         got_cpl = !block->cpl_in_use;
1634         for (ch = 1; ch <= s->channels; ch++) {
1635             if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
1636                 ch0     = ch - 1;
1637                 ch      = CPL_CH;
1638                 got_cpl = 1;
1639             }
1640             quantize_mantissas_blk_ch(&m, block->fixed_coef[ch],
1641                                       s->blocks[s->exp_ref_block[ch][blk]].exp[ch],
1642                                       s->ref_bap[ch][blk], block->qmant[ch],
1643                                       s->start_freq[ch], block->end_freq[ch]);
1644             if (ch == CPL_CH)
1645                 ch = ch0;
1646         }
1647     }
1648 }
1649
1650
1651 /**
1652  * Write the AC-3 frame header to the output bitstream.
1653  */
1654 static void ac3_output_frame_header(AC3EncodeContext *s)
1655 {
1656     AC3EncOptions *opt = &s->options;
1657
1658     put_bits(&s->pb, 16, 0x0b77);   /* frame header */
1659     put_bits(&s->pb, 16, 0);        /* crc1: will be filled later */
1660     put_bits(&s->pb, 2,  s->bit_alloc.sr_code);
1661     put_bits(&s->pb, 6,  s->frame_size_code + (s->frame_size - s->frame_size_min) / 2);
1662     put_bits(&s->pb, 5,  s->bitstream_id);
1663     put_bits(&s->pb, 3,  s->bitstream_mode);
1664     put_bits(&s->pb, 3,  s->channel_mode);
1665     if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO)
1666         put_bits(&s->pb, 2, s->center_mix_level);
1667     if (s->channel_mode & 0x04)
1668         put_bits(&s->pb, 2, s->surround_mix_level);
1669     if (s->channel_mode == AC3_CHMODE_STEREO)
1670         put_bits(&s->pb, 2, opt->dolby_surround_mode);
1671     put_bits(&s->pb, 1, s->lfe_on); /* LFE */
1672     put_bits(&s->pb, 5, -opt->dialogue_level);
1673     put_bits(&s->pb, 1, 0);         /* no compression control word */
1674     put_bits(&s->pb, 1, 0);         /* no lang code */
1675     put_bits(&s->pb, 1, opt->audio_production_info);
1676     if (opt->audio_production_info) {
1677         put_bits(&s->pb, 5, opt->mixing_level - 80);
1678         put_bits(&s->pb, 2, opt->room_type);
1679     }
1680     put_bits(&s->pb, 1, opt->copyright);
1681     put_bits(&s->pb, 1, opt->original);
1682     if (s->bitstream_id == 6) {
1683         /* alternate bit stream syntax */
1684         put_bits(&s->pb, 1, opt->extended_bsi_1);
1685         if (opt->extended_bsi_1) {
1686             put_bits(&s->pb, 2, opt->preferred_stereo_downmix);
1687             put_bits(&s->pb, 3, s->ltrt_center_mix_level);
1688             put_bits(&s->pb, 3, s->ltrt_surround_mix_level);
1689             put_bits(&s->pb, 3, s->loro_center_mix_level);
1690             put_bits(&s->pb, 3, s->loro_surround_mix_level);
1691         }
1692         put_bits(&s->pb, 1, opt->extended_bsi_2);
1693         if (opt->extended_bsi_2) {
1694             put_bits(&s->pb, 2, opt->dolby_surround_ex_mode);
1695             put_bits(&s->pb, 2, opt->dolby_headphone_mode);
1696             put_bits(&s->pb, 1, opt->ad_converter_type);
1697             put_bits(&s->pb, 9, 0);     /* xbsi2 and encinfo : reserved */
1698         }
1699     } else {
1700     put_bits(&s->pb, 1, 0);         /* no time code 1 */
1701     put_bits(&s->pb, 1, 0);         /* no time code 2 */
1702     }
1703     put_bits(&s->pb, 1, 0);         /* no additional bit stream info */
1704 }
1705
1706
1707 /**
1708  * Write one audio block to the output bitstream.
1709  */
1710 static void output_audio_block(AC3EncodeContext *s, int blk)
1711 {
1712     int ch, i, baie, bnd, got_cpl;
1713     int av_uninit(ch0);
1714     AC3Block *block = &s->blocks[blk];
1715
1716     /* block switching */
1717     if (!s->eac3) {
1718         for (ch = 0; ch < s->fbw_channels; ch++)
1719             put_bits(&s->pb, 1, 0);
1720     }
1721
1722     /* dither flags */
1723     if (!s->eac3) {
1724         for (ch = 0; ch < s->fbw_channels; ch++)
1725             put_bits(&s->pb, 1, 1);
1726     }
1727
1728     /* dynamic range codes */
1729     put_bits(&s->pb, 1, 0);
1730
1731     /* spectral extension */
1732     if (s->eac3)
1733         put_bits(&s->pb, 1, 0);
1734
1735     /* channel coupling */
1736     if (!s->eac3)
1737         put_bits(&s->pb, 1, block->new_cpl_strategy);
1738     if (block->new_cpl_strategy) {
1739         if (!s->eac3)
1740             put_bits(&s->pb, 1, block->cpl_in_use);
1741         if (block->cpl_in_use) {
1742             int start_sub, end_sub;
1743             if (s->eac3)
1744                 put_bits(&s->pb, 1, 0); /* enhanced coupling */
1745             if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO) {
1746                 for (ch = 1; ch <= s->fbw_channels; ch++)
1747                     put_bits(&s->pb, 1, block->channel_in_cpl[ch]);
1748             }
1749             if (s->channel_mode == AC3_CHMODE_STEREO)
1750                 put_bits(&s->pb, 1, 0); /* phase flags in use */
1751             start_sub = (s->start_freq[CPL_CH] - 37) / 12;
1752             end_sub   = (s->cpl_end_freq       - 37) / 12;
1753             put_bits(&s->pb, 4, start_sub);
1754             put_bits(&s->pb, 4, end_sub - 3);
1755             /* coupling band structure */
1756             if (s->eac3) {
1757                 put_bits(&s->pb, 1, 0); /* use default */
1758             } else {
1759                 for (bnd = start_sub+1; bnd < end_sub; bnd++)
1760                     put_bits(&s->pb, 1, ff_eac3_default_cpl_band_struct[bnd]);
1761             }
1762         }
1763     }
1764
1765     /* coupling coordinates */
1766     if (block->cpl_in_use) {
1767         for (ch = 1; ch <= s->fbw_channels; ch++) {
1768             if (block->channel_in_cpl[ch]) {
1769                 if (!s->eac3 || block->new_cpl_coords != 2)
1770                     put_bits(&s->pb, 1, block->new_cpl_coords);
1771                 if (block->new_cpl_coords) {
1772                     put_bits(&s->pb, 2, block->cpl_master_exp[ch]);
1773                     for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1774                         put_bits(&s->pb, 4, block->cpl_coord_exp [ch][bnd]);
1775                         put_bits(&s->pb, 4, block->cpl_coord_mant[ch][bnd]);
1776                     }
1777                 }
1778             }
1779         }
1780     }
1781
1782     /* stereo rematrixing */
1783     if (s->channel_mode == AC3_CHMODE_STEREO) {
1784         if (!s->eac3 || blk > 0)
1785             put_bits(&s->pb, 1, block->new_rematrixing_strategy);
1786         if (block->new_rematrixing_strategy) {
1787             /* rematrixing flags */
1788             for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++)
1789                 put_bits(&s->pb, 1, block->rematrixing_flags[bnd]);
1790         }
1791     }
1792
1793     /* exponent strategy */
1794     if (!s->eac3) {
1795         for (ch = !block->cpl_in_use; ch <= s->fbw_channels; ch++)
1796             put_bits(&s->pb, 2, s->exp_strategy[ch][blk]);
1797         if (s->lfe_on)
1798             put_bits(&s->pb, 1, s->exp_strategy[s->lfe_channel][blk]);
1799     }
1800
1801     /* bandwidth */
1802     for (ch = 1; ch <= s->fbw_channels; ch++) {
1803         if (s->exp_strategy[ch][blk] != EXP_REUSE && !block->channel_in_cpl[ch])
1804             put_bits(&s->pb, 6, s->bandwidth_code);
1805     }
1806
1807     /* exponents */
1808     for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1809         int nb_groups;
1810         int cpl = (ch == CPL_CH);
1811
1812         if (s->exp_strategy[ch][blk] == EXP_REUSE)
1813             continue;
1814
1815         /* DC exponent */
1816         put_bits(&s->pb, 4, block->grouped_exp[ch][0] >> cpl);
1817
1818         /* exponent groups */
1819         nb_groups = exponent_group_tab[cpl][s->exp_strategy[ch][blk]-1][block->end_freq[ch]-s->start_freq[ch]];
1820         for (i = 1; i <= nb_groups; i++)
1821             put_bits(&s->pb, 7, block->grouped_exp[ch][i]);
1822
1823         /* gain range info */
1824         if (ch != s->lfe_channel && !cpl)
1825             put_bits(&s->pb, 2, 0);
1826     }
1827
1828     /* bit allocation info */
1829     if (!s->eac3) {
1830         baie = (blk == 0);
1831         put_bits(&s->pb, 1, baie);
1832         if (baie) {
1833             put_bits(&s->pb, 2, s->slow_decay_code);
1834             put_bits(&s->pb, 2, s->fast_decay_code);
1835             put_bits(&s->pb, 2, s->slow_gain_code);
1836             put_bits(&s->pb, 2, s->db_per_bit_code);
1837             put_bits(&s->pb, 3, s->floor_code);
1838         }
1839     }
1840
1841     /* snr offset */
1842     if (!s->eac3) {
1843         put_bits(&s->pb, 1, block->new_snr_offsets);
1844         if (block->new_snr_offsets) {
1845             put_bits(&s->pb, 6, s->coarse_snr_offset);
1846             for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1847                 put_bits(&s->pb, 4, s->fine_snr_offset[ch]);
1848                 put_bits(&s->pb, 3, s->fast_gain_code[ch]);
1849             }
1850         }
1851     } else {
1852         put_bits(&s->pb, 1, 0); /* no converter snr offset */
1853     }
1854
1855     /* coupling leak */
1856     if (block->cpl_in_use) {
1857         if (!s->eac3 || block->new_cpl_leak != 2)
1858             put_bits(&s->pb, 1, block->new_cpl_leak);
1859         if (block->new_cpl_leak) {
1860             put_bits(&s->pb, 3, s->bit_alloc.cpl_fast_leak);
1861             put_bits(&s->pb, 3, s->bit_alloc.cpl_slow_leak);
1862         }
1863     }
1864
1865     if (!s->eac3) {
1866         put_bits(&s->pb, 1, 0); /* no delta bit allocation */
1867         put_bits(&s->pb, 1, 0); /* no data to skip */
1868     }
1869
1870     /* mantissas */
1871     got_cpl = !block->cpl_in_use;
1872     for (ch = 1; ch <= s->channels; ch++) {
1873         int b, q;
1874
1875         if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
1876             ch0     = ch - 1;
1877             ch      = CPL_CH;
1878             got_cpl = 1;
1879         }
1880         for (i = s->start_freq[ch]; i < block->end_freq[ch]; i++) {
1881             q = block->qmant[ch][i];
1882             b = s->ref_bap[ch][blk][i];
1883             switch (b) {
1884             case 0:                                         break;
1885             case 1: if (q != 128) put_bits(&s->pb,   5, q); break;
1886             case 2: if (q != 128) put_bits(&s->pb,   7, q); break;
1887             case 3:               put_bits(&s->pb,   3, q); break;
1888             case 4: if (q != 128) put_bits(&s->pb,   7, q); break;
1889             case 14:              put_bits(&s->pb,  14, q); break;
1890             case 15:              put_bits(&s->pb,  16, q); break;
1891             default:              put_bits(&s->pb, b-1, q); break;
1892             }
1893         }
1894         if (ch == CPL_CH)
1895             ch = ch0;
1896     }
1897 }
1898
1899
1900 /** CRC-16 Polynomial */
1901 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))
1902
1903
1904 static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
1905 {
1906     unsigned int c;
1907
1908     c = 0;
1909     while (a) {
1910         if (a & 1)
1911             c ^= b;
1912         a = a >> 1;
1913         b = b << 1;
1914         if (b & (1 << 16))
1915             b ^= poly;
1916     }
1917     return c;
1918 }
1919
1920
1921 static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
1922 {
1923     unsigned int r;
1924     r = 1;
1925     while (n) {
1926         if (n & 1)
1927             r = mul_poly(r, a, poly);
1928         a = mul_poly(a, a, poly);
1929         n >>= 1;
1930     }
1931     return r;
1932 }
1933
1934
1935 /**
1936  * Fill the end of the frame with 0's and compute the two CRCs.
1937  */
1938 static void output_frame_end(AC3EncodeContext *s)
1939 {
1940     const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI);
1941     int frame_size_58, pad_bytes, crc1, crc2_partial, crc2, crc_inv;
1942     uint8_t *frame;
1943
1944     frame_size_58 = ((s->frame_size >> 2) + (s->frame_size >> 4)) << 1;
1945
1946     /* pad the remainder of the frame with zeros */
1947     av_assert2(s->frame_size * 8 - put_bits_count(&s->pb) >= 18);
1948     flush_put_bits(&s->pb);
1949     frame = s->pb.buf;
1950     pad_bytes = s->frame_size - (put_bits_ptr(&s->pb) - frame) - 2;
1951     av_assert2(pad_bytes >= 0);
1952     if (pad_bytes > 0)
1953         memset(put_bits_ptr(&s->pb), 0, pad_bytes);
1954
1955     if (s->eac3) {
1956         /* compute crc2 */
1957         crc2_partial = av_crc(crc_ctx, 0, frame + 2, s->frame_size - 5);
1958     } else {
1959     /* compute crc1 */
1960     /* this is not so easy because it is at the beginning of the data... */
1961     crc1    = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58 - 4));
1962     crc_inv = s->crc_inv[s->frame_size > s->frame_size_min];
1963     crc1    = mul_poly(crc_inv, crc1, CRC16_POLY);
1964     AV_WB16(frame + 2, crc1);
1965
1966     /* compute crc2 */
1967     crc2_partial = av_crc(crc_ctx, 0, frame + frame_size_58,
1968                           s->frame_size - frame_size_58 - 3);
1969     }
1970     crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
1971     /* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
1972     if (crc2 == 0x770B) {
1973         frame[s->frame_size - 3] ^= 0x1;
1974         crc2 = av_crc(crc_ctx, crc2_partial, frame + s->frame_size - 3, 1);
1975     }
1976     crc2 = av_bswap16(crc2);
1977     AV_WB16(frame + s->frame_size - 2, crc2);
1978 }
1979
1980
1981 /**
1982  * Write the frame to the output bitstream.
1983  */
1984 static void output_frame(AC3EncodeContext *s, unsigned char *frame)
1985 {
1986     int blk;
1987
1988     init_put_bits(&s->pb, frame, AC3_MAX_CODED_FRAME_SIZE);
1989
1990     s->output_frame_header(s);
1991
1992     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
1993         output_audio_block(s, blk);
1994
1995     output_frame_end(s);
1996 }
1997
1998
1999 static void dprint_options(AVCodecContext *avctx)
2000 {
2001 #ifdef DEBUG
2002     AC3EncodeContext *s = avctx->priv_data;
2003     AC3EncOptions *opt = &s->options;
2004     char strbuf[32];
2005
2006     switch (s->bitstream_id) {
2007     case  6:  av_strlcpy(strbuf, "AC-3 (alt syntax)",       32); break;
2008     case  8:  av_strlcpy(strbuf, "AC-3 (standard)",         32); break;
2009     case  9:  av_strlcpy(strbuf, "AC-3 (dnet half-rate)",   32); break;
2010     case 10:  av_strlcpy(strbuf, "AC-3 (dnet quater-rate)", 32); break;
2011     case 16:  av_strlcpy(strbuf, "E-AC-3 (enhanced)",       32); break;
2012     default: snprintf(strbuf, 32, "ERROR");
2013     }
2014     av_dlog(avctx, "bitstream_id: %s (%d)\n", strbuf, s->bitstream_id);
2015     av_dlog(avctx, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx->sample_fmt));
2016     av_get_channel_layout_string(strbuf, 32, s->channels, avctx->channel_layout);
2017     av_dlog(avctx, "channel_layout: %s\n", strbuf);
2018     av_dlog(avctx, "sample_rate: %d\n", s->sample_rate);
2019     av_dlog(avctx, "bit_rate: %d\n", s->bit_rate);
2020     if (s->cutoff)
2021         av_dlog(avctx, "cutoff: %d\n", s->cutoff);
2022
2023     av_dlog(avctx, "per_frame_metadata: %s\n",
2024             opt->allow_per_frame_metadata?"on":"off");
2025     if (s->has_center)
2026         av_dlog(avctx, "center_mixlev: %0.3f (%d)\n", opt->center_mix_level,
2027                 s->center_mix_level);
2028     else
2029         av_dlog(avctx, "center_mixlev: {not written}\n");
2030     if (s->has_surround)
2031         av_dlog(avctx, "surround_mixlev: %0.3f (%d)\n", opt->surround_mix_level,
2032                 s->surround_mix_level);
2033     else
2034         av_dlog(avctx, "surround_mixlev: {not written}\n");
2035     if (opt->audio_production_info) {
2036         av_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level);
2037         switch (opt->room_type) {
2038         case 0:  av_strlcpy(strbuf, "notindicated", 32); break;
2039         case 1:  av_strlcpy(strbuf, "large", 32);        break;
2040         case 2:  av_strlcpy(strbuf, "small", 32);        break;
2041         default: snprintf(strbuf, 32, "ERROR (%d)", opt->room_type);
2042         }
2043         av_dlog(avctx, "room_type: %s\n", strbuf);
2044     } else {
2045         av_dlog(avctx, "mixing_level: {not written}\n");
2046         av_dlog(avctx, "room_type: {not written}\n");
2047     }
2048     av_dlog(avctx, "copyright: %s\n", opt->copyright?"on":"off");
2049     av_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level);
2050     if (s->channel_mode == AC3_CHMODE_STEREO) {
2051         switch (opt->dolby_surround_mode) {
2052         case 0:  av_strlcpy(strbuf, "notindicated", 32); break;
2053         case 1:  av_strlcpy(strbuf, "on", 32);           break;
2054         case 2:  av_strlcpy(strbuf, "off", 32);          break;
2055         default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_mode);
2056         }
2057         av_dlog(avctx, "dsur_mode: %s\n", strbuf);
2058     } else {
2059         av_dlog(avctx, "dsur_mode: {not written}\n");
2060     }
2061     av_dlog(avctx, "original: %s\n", opt->original?"on":"off");
2062
2063     if (s->bitstream_id == 6) {
2064         if (opt->extended_bsi_1) {
2065             switch (opt->preferred_stereo_downmix) {
2066             case 0:  av_strlcpy(strbuf, "notindicated", 32); break;
2067             case 1:  av_strlcpy(strbuf, "ltrt", 32);         break;
2068             case 2:  av_strlcpy(strbuf, "loro", 32);         break;
2069             default: snprintf(strbuf, 32, "ERROR (%d)", opt->preferred_stereo_downmix);
2070             }
2071             av_dlog(avctx, "dmix_mode: %s\n", strbuf);
2072             av_dlog(avctx, "ltrt_cmixlev: %0.3f (%d)\n",
2073                     opt->ltrt_center_mix_level, s->ltrt_center_mix_level);
2074             av_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n",
2075                     opt->ltrt_surround_mix_level, s->ltrt_surround_mix_level);
2076             av_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n",
2077                     opt->loro_center_mix_level, s->loro_center_mix_level);
2078             av_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n",
2079                     opt->loro_surround_mix_level, s->loro_surround_mix_level);
2080         } else {
2081             av_dlog(avctx, "extended bitstream info 1: {not written}\n");
2082         }
2083         if (opt->extended_bsi_2) {
2084             switch (opt->dolby_surround_ex_mode) {
2085             case 0:  av_strlcpy(strbuf, "notindicated", 32); break;
2086             case 1:  av_strlcpy(strbuf, "on", 32);           break;
2087             case 2:  av_strlcpy(strbuf, "off", 32);          break;
2088             default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_surround_ex_mode);
2089             }
2090             av_dlog(avctx, "dsurex_mode: %s\n", strbuf);
2091             switch (opt->dolby_headphone_mode) {
2092             case 0:  av_strlcpy(strbuf, "notindicated", 32); break;
2093             case 1:  av_strlcpy(strbuf, "on", 32);           break;
2094             case 2:  av_strlcpy(strbuf, "off", 32);          break;
2095             default: snprintf(strbuf, 32, "ERROR (%d)", opt->dolby_headphone_mode);
2096             }
2097             av_dlog(avctx, "dheadphone_mode: %s\n", strbuf);
2098
2099             switch (opt->ad_converter_type) {
2100             case 0:  av_strlcpy(strbuf, "standard", 32); break;
2101             case 1:  av_strlcpy(strbuf, "hdcd", 32);     break;
2102             default: snprintf(strbuf, 32, "ERROR (%d)", opt->ad_converter_type);
2103             }
2104             av_dlog(avctx, "ad_conv_type: %s\n", strbuf);
2105         } else {
2106             av_dlog(avctx, "extended bitstream info 2: {not written}\n");
2107         }
2108     }
2109 #endif
2110 }
2111
2112
2113 #define FLT_OPTION_THRESHOLD 0.01
2114
2115 static int validate_float_option(float v, const float *v_list, int v_list_size)
2116 {
2117     int i;
2118
2119     for (i = 0; i < v_list_size; i++) {
2120         if (v < (v_list[i] + FLT_OPTION_THRESHOLD) &&
2121             v > (v_list[i] - FLT_OPTION_THRESHOLD))
2122             break;
2123     }
2124     if (i == v_list_size)
2125         return -1;
2126
2127     return i;
2128 }
2129
2130
2131 static void validate_mix_level(void *log_ctx, const char *opt_name,
2132                                float *opt_param, const float *list,
2133                                int list_size, int default_value, int min_value,
2134                                int *ctx_param)
2135 {
2136     int mixlev = validate_float_option(*opt_param, list, list_size);
2137     if (mixlev < min_value) {
2138         mixlev = default_value;
2139         if (*opt_param >= 0.0) {
2140             av_log(log_ctx, AV_LOG_WARNING, "requested %s is not valid. using "
2141                    "default value: %0.3f\n", opt_name, list[mixlev]);
2142         }
2143     }
2144     *opt_param = list[mixlev];
2145     *ctx_param = mixlev;
2146 }
2147
2148
2149 /**
2150  * Validate metadata options as set by AVOption system.
2151  * These values can optionally be changed per-frame.
2152  */
2153 static int validate_metadata(AVCodecContext *avctx)
2154 {
2155     AC3EncodeContext *s = avctx->priv_data;
2156     AC3EncOptions *opt = &s->options;
2157
2158     /* validate mixing levels */
2159     if (s->has_center) {
2160         validate_mix_level(avctx, "center_mix_level", &opt->center_mix_level,
2161                            cmixlev_options, CMIXLEV_NUM_OPTIONS, 1, 0,
2162                            &s->center_mix_level);
2163     }
2164     if (s->has_surround) {
2165         validate_mix_level(avctx, "surround_mix_level", &opt->surround_mix_level,
2166                            surmixlev_options, SURMIXLEV_NUM_OPTIONS, 1, 0,
2167                            &s->surround_mix_level);
2168     }
2169
2170     /* set audio production info flag */
2171     if (opt->mixing_level >= 0 || opt->room_type >= 0) {
2172         if (opt->mixing_level < 0) {
2173             av_log(avctx, AV_LOG_ERROR, "mixing_level must be set if "
2174                    "room_type is set\n");
2175             return AVERROR(EINVAL);
2176         }
2177         if (opt->mixing_level < 80) {
2178             av_log(avctx, AV_LOG_ERROR, "invalid mixing level. must be between "
2179                    "80dB and 111dB\n");
2180             return AVERROR(EINVAL);
2181         }
2182         /* default room type */
2183         if (opt->room_type < 0)
2184             opt->room_type = 0;
2185         opt->audio_production_info = 1;
2186     } else {
2187         opt->audio_production_info = 0;
2188     }
2189
2190     /* set extended bsi 1 flag */
2191     if ((s->has_center || s->has_surround) &&
2192         (opt->preferred_stereo_downmix >= 0 ||
2193          opt->ltrt_center_mix_level   >= 0 ||
2194          opt->ltrt_surround_mix_level >= 0 ||
2195          opt->loro_center_mix_level   >= 0 ||
2196          opt->loro_surround_mix_level >= 0)) {
2197         /* default preferred stereo downmix */
2198         if (opt->preferred_stereo_downmix < 0)
2199             opt->preferred_stereo_downmix = 0;
2200         /* validate Lt/Rt center mix level */
2201         validate_mix_level(avctx, "ltrt_center_mix_level",
2202                            &opt->ltrt_center_mix_level, extmixlev_options,
2203                            EXTMIXLEV_NUM_OPTIONS, 5, 0,
2204                            &s->ltrt_center_mix_level);
2205         /* validate Lt/Rt surround mix level */
2206         validate_mix_level(avctx, "ltrt_surround_mix_level",
2207                            &opt->ltrt_surround_mix_level, extmixlev_options,
2208                            EXTMIXLEV_NUM_OPTIONS, 6, 3,
2209                            &s->ltrt_surround_mix_level);
2210         /* validate Lo/Ro center mix level */
2211         validate_mix_level(avctx, "loro_center_mix_level",
2212                            &opt->loro_center_mix_level, extmixlev_options,
2213                            EXTMIXLEV_NUM_OPTIONS, 5, 0,
2214                            &s->loro_center_mix_level);
2215         /* validate Lo/Ro surround mix level */
2216         validate_mix_level(avctx, "loro_surround_mix_level",
2217                            &opt->loro_surround_mix_level, extmixlev_options,
2218                            EXTMIXLEV_NUM_OPTIONS, 6, 3,
2219                            &s->loro_surround_mix_level);
2220         opt->extended_bsi_1 = 1;
2221     } else {
2222         opt->extended_bsi_1 = 0;
2223     }
2224
2225     /* set extended bsi 2 flag */
2226     if (opt->dolby_surround_ex_mode >= 0 ||
2227         opt->dolby_headphone_mode   >= 0 ||
2228         opt->ad_converter_type      >= 0) {
2229         /* default dolby surround ex mode */
2230         if (opt->dolby_surround_ex_mode < 0)
2231             opt->dolby_surround_ex_mode = 0;
2232         /* default dolby headphone mode */
2233         if (opt->dolby_headphone_mode < 0)
2234             opt->dolby_headphone_mode = 0;
2235         /* default A/D converter type */
2236         if (opt->ad_converter_type < 0)
2237             opt->ad_converter_type = 0;
2238         opt->extended_bsi_2 = 1;
2239     } else {
2240         opt->extended_bsi_2 = 0;
2241     }
2242
2243     /* set bitstream id for alternate bitstream syntax */
2244     if (opt->extended_bsi_1 || opt->extended_bsi_2) {
2245         if (s->bitstream_id > 8 && s->bitstream_id < 11) {
2246             static int warn_once = 1;
2247             if (warn_once) {
2248                 av_log(avctx, AV_LOG_WARNING, "alternate bitstream syntax is "
2249                        "not compatible with reduced samplerates. writing of "
2250                        "extended bitstream information will be disabled.\n");
2251                 warn_once = 0;
2252             }
2253         } else {
2254             s->bitstream_id = 6;
2255         }
2256     }
2257
2258     return 0;
2259 }
2260
2261
2262 /**
2263  * Encode a single AC-3 frame.
2264  */
2265 static int ac3_encode_frame(AVCodecContext *avctx, unsigned char *frame,
2266                             int buf_size, void *data)
2267 {
2268     AC3EncodeContext *s = avctx->priv_data;
2269     const SampleType *samples = data;
2270     int ret;
2271
2272     if (!s->eac3 && s->options.allow_per_frame_metadata) {
2273         ret = validate_metadata(avctx);
2274         if (ret)
2275             return ret;
2276     }
2277
2278     if (s->bit_alloc.sr_code == 1 || s->eac3)
2279         adjust_frame_size(s);
2280
2281     deinterleave_input_samples(s, samples);
2282
2283     apply_mdct(s);
2284
2285     scale_coefficients(s);
2286
2287     s->cpl_on = s->cpl_enabled;
2288     compute_coupling_strategy(s);
2289
2290     if (s->cpl_on)
2291         apply_channel_coupling(s);
2292
2293     compute_rematrixing_strategy(s);
2294
2295     apply_rematrixing(s);
2296
2297     process_exponents(s);
2298
2299     ret = compute_bit_allocation(s);
2300     if (ret) {
2301         av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
2302         return ret;
2303     }
2304
2305     quantize_mantissas(s);
2306
2307     output_frame(s, frame);
2308
2309     return s->frame_size;
2310 }
2311
2312
2313 /**
2314  * Finalize encoding and free any memory allocated by the encoder.
2315  */
2316 static av_cold int ac3_encode_close(AVCodecContext *avctx)
2317 {
2318     int blk, ch;
2319     AC3EncodeContext *s = avctx->priv_data;
2320
2321     for (ch = 0; ch < s->channels; ch++)
2322         av_freep(&s->planar_samples[ch]);
2323     av_freep(&s->planar_samples);
2324     av_freep(&s->bap_buffer);
2325     av_freep(&s->bap1_buffer);
2326     av_freep(&s->mdct_coef_buffer);
2327     av_freep(&s->fixed_coef_buffer);
2328     av_freep(&s->exp_buffer);
2329     av_freep(&s->grouped_exp_buffer);
2330     av_freep(&s->psd_buffer);
2331     av_freep(&s->band_psd_buffer);
2332     av_freep(&s->mask_buffer);
2333     av_freep(&s->qmant_buffer);
2334     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
2335         AC3Block *block = &s->blocks[blk];
2336         av_freep(&block->mdct_coef);
2337         av_freep(&block->fixed_coef);
2338         av_freep(&block->exp);
2339         av_freep(&block->grouped_exp);
2340         av_freep(&block->psd);
2341         av_freep(&block->band_psd);
2342         av_freep(&block->mask);
2343         av_freep(&block->qmant);
2344     }
2345
2346     mdct_end(&s->mdct);
2347
2348     av_freep(&avctx->coded_frame);
2349     return 0;
2350 }
2351
2352
2353 /**
2354  * Set channel information during initialization.
2355  */
2356 static av_cold int set_channel_info(AC3EncodeContext *s, int channels,
2357                                     int64_t *channel_layout)
2358 {
2359     int ch_layout;
2360
2361     if (channels < 1 || channels > AC3_MAX_CHANNELS)
2362         return AVERROR(EINVAL);
2363     if ((uint64_t)*channel_layout > 0x7FF)
2364         return AVERROR(EINVAL);
2365     ch_layout = *channel_layout;
2366     if (!ch_layout)
2367         ch_layout = avcodec_guess_channel_layout(channels, CODEC_ID_AC3, NULL);
2368
2369     s->lfe_on       = !!(ch_layout & AV_CH_LOW_FREQUENCY);
2370     s->channels     = channels;
2371     s->fbw_channels = channels - s->lfe_on;
2372     s->lfe_channel  = s->lfe_on ? s->fbw_channels + 1 : -1;
2373     if (s->lfe_on)
2374         ch_layout -= AV_CH_LOW_FREQUENCY;
2375
2376     switch (ch_layout) {
2377     case AV_CH_LAYOUT_MONO:           s->channel_mode = AC3_CHMODE_MONO;   break;
2378     case AV_CH_LAYOUT_STEREO:         s->channel_mode = AC3_CHMODE_STEREO; break;
2379     case AV_CH_LAYOUT_SURROUND:       s->channel_mode = AC3_CHMODE_3F;     break;
2380     case AV_CH_LAYOUT_2_1:            s->channel_mode = AC3_CHMODE_2F1R;   break;
2381     case AV_CH_LAYOUT_4POINT0:        s->channel_mode = AC3_CHMODE_3F1R;   break;
2382     case AV_CH_LAYOUT_QUAD:
2383     case AV_CH_LAYOUT_2_2:            s->channel_mode = AC3_CHMODE_2F2R;   break;
2384     case AV_CH_LAYOUT_5POINT0:
2385     case AV_CH_LAYOUT_5POINT0_BACK:   s->channel_mode = AC3_CHMODE_3F2R;   break;
2386     default:
2387         return AVERROR(EINVAL);
2388     }
2389     s->has_center   = (s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO;
2390     s->has_surround =  s->channel_mode & 0x04;
2391
2392     s->channel_map  = ff_ac3_enc_channel_map[s->channel_mode][s->lfe_on];
2393     *channel_layout = ch_layout;
2394     if (s->lfe_on)
2395         *channel_layout |= AV_CH_LOW_FREQUENCY;
2396
2397     return 0;
2398 }
2399
2400
2401 static av_cold int validate_options(AVCodecContext *avctx, AC3EncodeContext *s)
2402 {
2403     int i, ret, max_sr;
2404
2405     /* validate channel layout */
2406     if (!avctx->channel_layout) {
2407         av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The "
2408                                       "encoder will guess the layout, but it "
2409                                       "might be incorrect.\n");
2410     }
2411     ret = set_channel_info(s, avctx->channels, &avctx->channel_layout);
2412     if (ret) {
2413         av_log(avctx, AV_LOG_ERROR, "invalid channel layout\n");
2414         return ret;
2415     }
2416
2417     /* validate sample rate */
2418     /* note: max_sr could be changed from 2 to 5 for E-AC-3 once we find a
2419              decoder that supports half sample rate so we can validate that
2420              the generated files are correct. */
2421     max_sr = s->eac3 ? 2 : 8;
2422     for (i = 0; i <= max_sr; i++) {
2423         if ((ff_ac3_sample_rate_tab[i % 3] >> (i / 3)) == avctx->sample_rate)
2424             break;
2425     }
2426     if (i > max_sr) {
2427         av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");
2428         return AVERROR(EINVAL);
2429     }
2430     s->sample_rate        = avctx->sample_rate;
2431     s->bit_alloc.sr_shift = i / 3;
2432     s->bit_alloc.sr_code  = i % 3;
2433     s->bitstream_id       = s->eac3 ? 16 : 8 + s->bit_alloc.sr_shift;
2434
2435     /* validate bit rate */
2436     if (s->eac3) {
2437         int max_br, min_br, wpf, min_br_dist, min_br_code;
2438
2439         /* calculate min/max bitrate */
2440         max_br = 2048 * s->sample_rate / AC3_FRAME_SIZE * 16;
2441         min_br = ((s->sample_rate + (AC3_FRAME_SIZE-1)) / AC3_FRAME_SIZE) * 16;
2442         if (avctx->bit_rate < min_br || avctx->bit_rate > max_br) {
2443             av_log(avctx, AV_LOG_ERROR, "invalid bit rate. must be %d to %d "
2444                    "for this sample rate\n", min_br, max_br);
2445             return AVERROR(EINVAL);
2446         }
2447
2448         /* calculate words-per-frame for the selected bitrate */
2449         wpf = (avctx->bit_rate / 16) * AC3_FRAME_SIZE / s->sample_rate;
2450         av_assert1(wpf > 0 && wpf <= 2048);
2451
2452         /* find the closest AC-3 bitrate code to the selected bitrate.
2453            this is needed for lookup tables for bandwidth and coupling
2454            parameter selection */
2455         min_br_code = -1;
2456         min_br_dist = INT_MAX;
2457         for (i = 0; i < 19; i++) {
2458             int br_dist = abs(ff_ac3_bitrate_tab[i] * 1000 - avctx->bit_rate);
2459             if (br_dist < min_br_dist) {
2460                 min_br_dist = br_dist;
2461                 min_br_code = i;
2462             }
2463         }
2464
2465         /* make sure the minimum frame size is below the average frame size */
2466         s->frame_size_code = min_br_code << 1;
2467         while (wpf > 1 && wpf * s->sample_rate / AC3_FRAME_SIZE * 16 > avctx->bit_rate)
2468             wpf--;
2469         s->frame_size_min = 2 * wpf;
2470     } else {
2471         for (i = 0; i < 19; i++) {
2472             if ((ff_ac3_bitrate_tab[i] >> s->bit_alloc.sr_shift)*1000 == avctx->bit_rate)
2473                 break;
2474         }
2475         if (i == 19) {
2476             av_log(avctx, AV_LOG_ERROR, "invalid bit rate\n");
2477             return AVERROR(EINVAL);
2478         }
2479         s->frame_size_code = i << 1;
2480         s->frame_size_min  = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
2481     }
2482     s->bit_rate   = avctx->bit_rate;
2483     s->frame_size = s->frame_size_min;
2484
2485     /* validate cutoff */
2486     if (avctx->cutoff < 0) {
2487         av_log(avctx, AV_LOG_ERROR, "invalid cutoff frequency\n");
2488         return AVERROR(EINVAL);
2489     }
2490     s->cutoff = avctx->cutoff;
2491     if (s->cutoff > (s->sample_rate >> 1))
2492         s->cutoff = s->sample_rate >> 1;
2493
2494     /* validate audio service type / channels combination */
2495     if ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_KARAOKE &&
2496          avctx->channels == 1) ||
2497         ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_COMMENTARY ||
2498           avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_EMERGENCY  ||
2499           avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_VOICE_OVER)
2500          && avctx->channels > 1)) {
2501         av_log(avctx, AV_LOG_ERROR, "invalid audio service type for the "
2502                                     "specified number of channels\n");
2503         return AVERROR(EINVAL);
2504     }
2505
2506     if (!s->eac3) {
2507         ret = validate_metadata(avctx);
2508         if (ret)
2509             return ret;
2510     }
2511
2512     s->rematrixing_enabled = s->options.stereo_rematrixing &&
2513                              (s->channel_mode == AC3_CHMODE_STEREO);
2514
2515     s->cpl_enabled = s->options.channel_coupling &&
2516                      s->channel_mode >= AC3_CHMODE_STEREO &&
2517                      CONFIG_AC3ENC_FLOAT;
2518
2519     return 0;
2520 }
2521
2522
2523 /**
2524  * Set bandwidth for all channels.
2525  * The user can optionally supply a cutoff frequency. Otherwise an appropriate
2526  * default value will be used.
2527  */
2528 static av_cold void set_bandwidth(AC3EncodeContext *s)
2529 {
2530     int blk, ch;
2531     int av_uninit(cpl_start);
2532
2533     if (s->cutoff) {
2534         /* calculate bandwidth based on user-specified cutoff frequency */
2535         int fbw_coeffs;
2536         fbw_coeffs     = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
2537         s->bandwidth_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
2538     } else {
2539         /* use default bandwidth setting */
2540         s->bandwidth_code = ac3_bandwidth_tab[s->fbw_channels-1][s->bit_alloc.sr_code][s->frame_size_code/2];
2541     }
2542
2543     /* set number of coefficients for each channel */
2544     for (ch = 1; ch <= s->fbw_channels; ch++) {
2545         s->start_freq[ch] = 0;
2546         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
2547             s->blocks[blk].end_freq[ch] = s->bandwidth_code * 3 + 73;
2548     }
2549     /* LFE channel always has 7 coefs */
2550     if (s->lfe_on) {
2551         s->start_freq[s->lfe_channel] = 0;
2552         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
2553             s->blocks[blk].end_freq[ch] = 7;
2554     }
2555
2556     /* initialize coupling strategy */
2557     if (s->cpl_enabled) {
2558         if (s->options.cpl_start >= 0) {
2559             cpl_start = s->options.cpl_start;
2560         } else {
2561             cpl_start = ac3_coupling_start_tab[s->channel_mode-2][s->bit_alloc.sr_code][s->frame_size_code/2];
2562             if (cpl_start < 0)
2563                 s->cpl_enabled = 0;
2564         }
2565     }
2566     if (s->cpl_enabled) {
2567         int i, cpl_start_band, cpl_end_band;
2568         uint8_t *cpl_band_sizes = s->cpl_band_sizes;
2569
2570         cpl_end_band   = s->bandwidth_code / 4 + 3;
2571         cpl_start_band = av_clip(cpl_start, 0, FFMIN(cpl_end_band-1, 15));
2572
2573         s->num_cpl_subbands = cpl_end_band - cpl_start_band;
2574
2575         s->num_cpl_bands = 1;
2576         *cpl_band_sizes  = 12;
2577         for (i = cpl_start_band + 1; i < cpl_end_band; i++) {
2578             if (ff_eac3_default_cpl_band_struct[i]) {
2579                 *cpl_band_sizes += 12;
2580             } else {
2581                 s->num_cpl_bands++;
2582                 cpl_band_sizes++;
2583                 *cpl_band_sizes = 12;
2584             }
2585         }
2586
2587         s->start_freq[CPL_CH] = cpl_start_band * 12 + 37;
2588         s->cpl_end_freq       = cpl_end_band   * 12 + 37;
2589         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++)
2590             s->blocks[blk].end_freq[CPL_CH] = s->cpl_end_freq;
2591     }
2592 }
2593
2594
2595 static av_cold int allocate_buffers(AVCodecContext *avctx)
2596 {
2597     int blk, ch;
2598     AC3EncodeContext *s = avctx->priv_data;
2599     int channels = s->channels + 1; /* includes coupling channel */
2600
2601     FF_ALLOC_OR_GOTO(avctx, s->planar_samples, s->channels * sizeof(*s->planar_samples),
2602                      alloc_fail);
2603     for (ch = 0; ch < s->channels; ch++) {
2604         FF_ALLOCZ_OR_GOTO(avctx, s->planar_samples[ch],
2605                           (AC3_FRAME_SIZE+AC3_BLOCK_SIZE) * sizeof(**s->planar_samples),
2606                           alloc_fail);
2607     }
2608     FF_ALLOC_OR_GOTO(avctx, s->bap_buffer,  AC3_MAX_BLOCKS * channels *
2609                      AC3_MAX_COEFS * sizeof(*s->bap_buffer),  alloc_fail);
2610     FF_ALLOC_OR_GOTO(avctx, s->bap1_buffer, AC3_MAX_BLOCKS * channels *
2611                      AC3_MAX_COEFS * sizeof(*s->bap1_buffer), alloc_fail);
2612     FF_ALLOCZ_OR_GOTO(avctx, s->mdct_coef_buffer, AC3_MAX_BLOCKS * channels *
2613                       AC3_MAX_COEFS * sizeof(*s->mdct_coef_buffer), alloc_fail);
2614     FF_ALLOC_OR_GOTO(avctx, s->exp_buffer, AC3_MAX_BLOCKS * channels *
2615                      AC3_MAX_COEFS * sizeof(*s->exp_buffer), alloc_fail);
2616     FF_ALLOC_OR_GOTO(avctx, s->grouped_exp_buffer, AC3_MAX_BLOCKS * channels *
2617                      128 * sizeof(*s->grouped_exp_buffer), alloc_fail);
2618     FF_ALLOC_OR_GOTO(avctx, s->psd_buffer, AC3_MAX_BLOCKS * channels *
2619                      AC3_MAX_COEFS * sizeof(*s->psd_buffer), alloc_fail);
2620     FF_ALLOC_OR_GOTO(avctx, s->band_psd_buffer, AC3_MAX_BLOCKS * channels *
2621                      64 * sizeof(*s->band_psd_buffer), alloc_fail);
2622     FF_ALLOC_OR_GOTO(avctx, s->mask_buffer, AC3_MAX_BLOCKS * channels *
2623                      64 * sizeof(*s->mask_buffer), alloc_fail);
2624     FF_ALLOC_OR_GOTO(avctx, s->qmant_buffer, AC3_MAX_BLOCKS * channels *
2625                      AC3_MAX_COEFS * sizeof(*s->qmant_buffer), alloc_fail);
2626     if (s->cpl_enabled) {
2627         FF_ALLOC_OR_GOTO(avctx, s->cpl_coord_exp_buffer, AC3_MAX_BLOCKS * channels *
2628                          16 * sizeof(*s->cpl_coord_exp_buffer), alloc_fail);
2629         FF_ALLOC_OR_GOTO(avctx, s->cpl_coord_mant_buffer, AC3_MAX_BLOCKS * channels *
2630                          16 * sizeof(*s->cpl_coord_mant_buffer), alloc_fail);
2631     }
2632     for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
2633         AC3Block *block = &s->blocks[blk];
2634         FF_ALLOCZ_OR_GOTO(avctx, block->mdct_coef, channels * sizeof(*block->mdct_coef),
2635                           alloc_fail);
2636         FF_ALLOCZ_OR_GOTO(avctx, block->exp, channels * sizeof(*block->exp),
2637                           alloc_fail);
2638         FF_ALLOCZ_OR_GOTO(avctx, block->grouped_exp, channels * sizeof(*block->grouped_exp),
2639                           alloc_fail);
2640         FF_ALLOCZ_OR_GOTO(avctx, block->psd, channels * sizeof(*block->psd),
2641                           alloc_fail);
2642         FF_ALLOCZ_OR_GOTO(avctx, block->band_psd, channels * sizeof(*block->band_psd),
2643                           alloc_fail);
2644         FF_ALLOCZ_OR_GOTO(avctx, block->mask, channels * sizeof(*block->mask),
2645                           alloc_fail);
2646         FF_ALLOCZ_OR_GOTO(avctx, block->qmant, channels * sizeof(*block->qmant),
2647                           alloc_fail);
2648         if (s->cpl_enabled) {
2649             FF_ALLOCZ_OR_GOTO(avctx, block->cpl_coord_exp, channels * sizeof(*block->cpl_coord_exp),
2650                               alloc_fail);
2651             FF_ALLOCZ_OR_GOTO(avctx, block->cpl_coord_mant, channels * sizeof(*block->cpl_coord_mant),
2652                               alloc_fail);
2653         }
2654
2655         for (ch = 0; ch < channels; ch++) {
2656             /* arrangement: block, channel, coeff */
2657             block->grouped_exp[ch] = &s->grouped_exp_buffer[128           * (blk * channels + ch)];
2658             block->psd[ch]         = &s->psd_buffer        [AC3_MAX_COEFS * (blk * channels + ch)];
2659             block->band_psd[ch]    = &s->band_psd_buffer   [64            * (blk * channels + ch)];
2660             block->mask[ch]        = &s->mask_buffer       [64            * (blk * channels + ch)];
2661             block->qmant[ch]       = &s->qmant_buffer      [AC3_MAX_COEFS * (blk * channels + ch)];
2662             if (s->cpl_enabled) {
2663                 block->cpl_coord_exp[ch]  = &s->cpl_coord_exp_buffer [16  * (blk * channels + ch)];
2664                 block->cpl_coord_mant[ch] = &s->cpl_coord_mant_buffer[16  * (blk * channels + ch)];
2665             }
2666
2667             /* arrangement: channel, block, coeff */
2668             block->exp[ch]         = &s->exp_buffer        [AC3_MAX_COEFS * (AC3_MAX_BLOCKS * ch + blk)];
2669             block->mdct_coef[ch]   = &s->mdct_coef_buffer  [AC3_MAX_COEFS * (AC3_MAX_BLOCKS * ch + blk)];
2670         }
2671     }
2672
2673     if (CONFIG_AC3ENC_FLOAT) {
2674         FF_ALLOCZ_OR_GOTO(avctx, s->fixed_coef_buffer, AC3_MAX_BLOCKS * channels *
2675                           AC3_MAX_COEFS * sizeof(*s->fixed_coef_buffer), alloc_fail);
2676         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
2677             AC3Block *block = &s->blocks[blk];
2678             FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, channels *
2679                               sizeof(*block->fixed_coef), alloc_fail);
2680             for (ch = 0; ch < channels; ch++)
2681                 block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (AC3_MAX_BLOCKS * ch + blk)];
2682         }
2683     } else {
2684         for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
2685             AC3Block *block = &s->blocks[blk];
2686             FF_ALLOCZ_OR_GOTO(avctx, block->fixed_coef, channels *
2687                               sizeof(*block->fixed_coef), alloc_fail);
2688             for (ch = 0; ch < channels; ch++)
2689                 block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch];
2690         }
2691     }
2692
2693     return 0;
2694 alloc_fail:
2695     return AVERROR(ENOMEM);
2696 }
2697
2698
2699 /**
2700  * Initialize the encoder.
2701  */
2702 static av_cold int ac3_encode_init(AVCodecContext *avctx)
2703 {
2704     AC3EncodeContext *s = avctx->priv_data;
2705     int ret, frame_size_58;
2706
2707     s->eac3 = avctx->codec_id == CODEC_ID_EAC3;
2708
2709     avctx->frame_size = AC3_FRAME_SIZE;
2710
2711     ff_ac3_common_init();
2712
2713     ret = validate_options(avctx, s);
2714     if (ret)
2715         return ret;
2716
2717     s->bitstream_mode = avctx->audio_service_type;
2718     if (s->bitstream_mode == AV_AUDIO_SERVICE_TYPE_KARAOKE)
2719         s->bitstream_mode = 0x7;
2720
2721     s->bits_written    = 0;
2722     s->samples_written = 0;
2723
2724     /* calculate crc_inv for both possible frame sizes */
2725     frame_size_58 = (( s->frame_size    >> 2) + ( s->frame_size    >> 4)) << 1;
2726     s->crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
2727     if (s->bit_alloc.sr_code == 1) {
2728         frame_size_58 = (((s->frame_size+2) >> 2) + ((s->frame_size+2) >> 4)) << 1;
2729         s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
2730     }
2731
2732     /* set function pointers */
2733     if (CONFIG_EAC3_ENCODER && s->eac3)
2734         s->output_frame_header = ff_eac3_output_frame_header;
2735     else
2736         s->output_frame_header = ac3_output_frame_header;
2737
2738     set_bandwidth(s);
2739
2740     exponent_init(s);
2741
2742     bit_alloc_init(s);
2743
2744     ret = mdct_init(avctx, &s->mdct, 9);
2745     if (ret)
2746         goto init_fail;
2747
2748     ret = allocate_buffers(avctx);
2749     if (ret)
2750         goto init_fail;
2751
2752     avctx->coded_frame= avcodec_alloc_frame();
2753
2754     dsputil_init(&s->dsp, avctx);
2755     ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);
2756
2757     dprint_options(avctx);
2758
2759     return 0;
2760 init_fail:
2761     ac3_encode_close(avctx);
2762     return ret;
2763 }