FFmpeg
ac3enc.c
Go to the documentation of this file.
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 FFmpeg.
8  *
9  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 #include <stdint.h>
30 
31 #include "libavutil/attributes.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/channel_layout.h"
34 #include "libavutil/crc.h"
35 #include "libavutil/internal.h"
36 #include "libavutil/mem.h"
37 #include "libavutil/mem_internal.h"
38 #include "libavutil/opt.h"
39 #include "libavutil/thread.h"
40 #include "avcodec.h"
41 #include "codec_internal.h"
42 #include "config_components.h"
43 #include "encode.h"
44 #include "me_cmp.h"
45 #include "put_bits.h"
46 #include "audiodsp.h"
47 #include "ac3dsp.h"
48 #include "ac3.h"
49 #include "ac3defs.h"
50 #include "ac3tab.h"
51 #include "ac3enc.h"
52 #include "eac3enc.h"
53 
54 #define SAMPLETYPE_SIZE(ctx) (sizeof(float) == sizeof(int32_t) ? sizeof(float) : \
55  (ctx)->fixed_point ? sizeof(int32_t) : sizeof(float))
56 
57 typedef struct AC3Mant {
58  int16_t *qmant1_ptr, *qmant2_ptr, *qmant4_ptr; ///< mantissa pointers for bap=1,2,4
59  int mant1_cnt, mant2_cnt, mant4_cnt; ///< mantissa counts for bap=1,2,4
60 } AC3Mant;
61 
62 #define CMIXLEV_NUM_OPTIONS 3
63 static const float cmixlev_options[CMIXLEV_NUM_OPTIONS] = {
64  LEVEL_MINUS_3DB, LEVEL_MINUS_4POINT5DB, LEVEL_MINUS_6DB
65 };
66 
67 #define SURMIXLEV_NUM_OPTIONS 3
68 static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS] = {
69  LEVEL_MINUS_3DB, LEVEL_MINUS_6DB, LEVEL_ZERO
70 };
71 
72 #define EXTMIXLEV_NUM_OPTIONS 8
73 #define extmixlev_options ff_ac3_gain_levels
74 
75 /* The first two options apply only to the AC-3 encoders;
76  * the rest is also valid for EAC-3. When modifying it,
77  * it might be necessary to adapt said offset in eac3enc.c. */
78 #define OFFSET(param) offsetof(AC3EncodeContext, options.param)
79 #define AC3ENC_PARAM (AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM)
80 const AVOption ff_ac3_enc_options[] = {
81 /* AC-3 downmix levels */
82 {"center_mixlev", "Center Mix Level", OFFSET(center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = LEVEL_MINUS_4POINT5DB }, 0.0, 1.0, AC3ENC_PARAM},
83 {"surround_mixlev", "Surround Mix Level", OFFSET(surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = LEVEL_MINUS_6DB }, 0.0, 1.0, AC3ENC_PARAM},
84 /* audio production information */
85 {"mixing_level", "Mixing Level", OFFSET(mixing_level), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, 111, AC3ENC_PARAM},
86 {"room_type", "Room Type", OFFSET(room_type), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, AC3ENC_OPT_SMALL_ROOM, AC3ENC_PARAM, .unit = "room_type"},
87  {"notindicated", "Not Indicated (default)", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_NOT_INDICATED }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "room_type"},
88  {"large", "Large Room", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_LARGE_ROOM }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "room_type"},
89  {"small", "Small Room", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_SMALL_ROOM }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "room_type"},
90 /* Metadata Options */
91 {"per_frame_metadata", "Allow Changing Metadata Per-Frame", OFFSET(allow_per_frame_metadata), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, AC3ENC_PARAM},
92 {"copyright", "Copyright Bit", OFFSET(copyright), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, 1, AC3ENC_PARAM},
93 {"dialnorm", "Dialogue Level (dB)", OFFSET(dialogue_level), AV_OPT_TYPE_INT, {.i64 = -31 }, -31, -1, AC3ENC_PARAM},
94 {"dsur_mode", "Dolby Surround Mode", OFFSET(dolby_surround_mode), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, AC3ENC_OPT_MODE_ON, AC3ENC_PARAM, .unit = "dsur_mode"},
95  {"notindicated", "Not Indicated (default)", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_NOT_INDICATED }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dsur_mode"},
96  {"on", "Dolby Surround Encoded", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_MODE_ON }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dsur_mode"},
97  {"off", "Not Dolby Surround Encoded", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_MODE_OFF }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dsur_mode"},
98 {"original", "Original Bit Stream", OFFSET(original), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, 1, AC3ENC_PARAM},
99 /* extended bitstream information */
100 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, AC3ENC_OPT_DOWNMIX_DPLII, AC3ENC_PARAM, .unit = "dmix_mode"},
101  {"notindicated", "Not Indicated (default)", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_NOT_INDICATED }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dmix_mode"},
102  {"ltrt", "Lt/Rt Downmix Preferred", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_DOWNMIX_LTRT }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dmix_mode"},
103  {"loro", "Lo/Ro Downmix Preferred", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_DOWNMIX_LORO }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dmix_mode"},
104  {"dplii", "Dolby Pro Logic II Downmix Preferred", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_DOWNMIX_DPLII }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dmix_mode"},
105 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, AC3ENC_PARAM},
106 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, AC3ENC_PARAM},
107 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, AC3ENC_PARAM},
108 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, AC3ENC_PARAM},
109 {"dsurex_mode", "Dolby Surround EX Mode", OFFSET(dolby_surround_ex_mode), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, AC3ENC_OPT_DSUREX_DPLIIZ, AC3ENC_PARAM, .unit = "dsurex_mode"},
110  {"notindicated", "Not Indicated (default)", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_NOT_INDICATED }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dsurex_mode"},
111  {"on", "Dolby Surround EX Encoded", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_MODE_ON }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dsurex_mode"},
112  {"off", "Not Dolby Surround EX Encoded", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_MODE_OFF }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dsurex_mode"},
113  {"dpliiz", "Dolby Pro Logic IIz-encoded", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_DSUREX_DPLIIZ }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dsurex_mode"},
114 {"dheadphone_mode", "Dolby Headphone Mode", OFFSET(dolby_headphone_mode), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, AC3ENC_OPT_MODE_ON, AC3ENC_PARAM, .unit = "dheadphone_mode"},
115  {"notindicated", "Not Indicated (default)", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_NOT_INDICATED }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dheadphone_mode"},
116  {"on", "Dolby Headphone Encoded", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_MODE_ON }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dheadphone_mode"},
117  {"off", "Not Dolby Headphone Encoded", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_MODE_OFF }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "dheadphone_mode"},
118 {"ad_conv_type", "A/D Converter Type", OFFSET(ad_converter_type), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_NONE }, AC3ENC_OPT_NONE, AC3ENC_OPT_ADCONV_HDCD, AC3ENC_PARAM, .unit = "ad_conv_type"},
119  {"standard", "Standard (default)", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_ADCONV_STANDARD }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "ad_conv_type"},
120  {"hdcd", "HDCD", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_ADCONV_HDCD }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "ad_conv_type"},
121 /* Other Encoding Options */
122 {"stereo_rematrixing", "Stereo Rematrixing", OFFSET(stereo_rematrixing), AV_OPT_TYPE_BOOL, {.i64 = 1 }, 0, 1, AC3ENC_PARAM},
123 {"channel_coupling", "Channel Coupling", OFFSET(channel_coupling), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_AUTO }, AC3ENC_OPT_AUTO, AC3ENC_OPT_ON, AC3ENC_PARAM, .unit = "channel_coupling"},
124  {"auto", "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_AUTO }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "channel_coupling"},
125 {"cpl_start_band", "Coupling Start Band", OFFSET(cpl_start), AV_OPT_TYPE_INT, {.i64 = AC3ENC_OPT_AUTO }, AC3ENC_OPT_AUTO, 15, AC3ENC_PARAM, .unit = "cpl_start_band"},
126  {"auto", "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.i64 = AC3ENC_OPT_AUTO }, INT_MIN, INT_MAX, AC3ENC_PARAM, .unit = "cpl_start_band"},
127 {NULL}
128 };
129 
130 const AVClass ff_ac3enc_class = {
131  .class_name = "AC-3 Encoder",
132  .item_name = av_default_item_name,
133  .option = ff_ac3_enc_options,
134  .version = LIBAVUTIL_VERSION_INT,
135 };
136 
137 const FFCodecDefault ff_ac3_enc_defaults[] = {
138  { "b", "0" },
139  { NULL }
140 };
141 
142 /**
143  * LUT for number of exponent groups.
144  * exponent_group_tab[coupling][exponent strategy-1][number of coefficients]
145  */
146 static uint8_t exponent_group_tab[2][3][256];
147 
148 
149 /**
150  * List of supported channel layouts.
151  */
152 const AVChannelLayout ff_ac3_ch_layouts[19] = {
153  AV_CHANNEL_LAYOUT_MONO,
154  AV_CHANNEL_LAYOUT_STEREO,
155  AV_CHANNEL_LAYOUT_2_1,
156  AV_CHANNEL_LAYOUT_SURROUND,
157  AV_CHANNEL_LAYOUT_2_2,
158  AV_CHANNEL_LAYOUT_QUAD,
159  AV_CHANNEL_LAYOUT_4POINT0,
160  AV_CHANNEL_LAYOUT_5POINT0,
161  AV_CHANNEL_LAYOUT_5POINT0_BACK,
162  {
163  .nb_channels = 2,
164  .order = AV_CHANNEL_ORDER_NATIVE,
165  .u.mask = AV_CH_LAYOUT_MONO | AV_CH_LOW_FREQUENCY,
166  },
167  {
168  .nb_channels = 3,
169  .order = AV_CHANNEL_ORDER_NATIVE,
170  .u.mask = AV_CH_LAYOUT_STEREO | AV_CH_LOW_FREQUENCY,
171  },
172  {
173  .nb_channels = 4,
174  .order = AV_CHANNEL_ORDER_NATIVE,
175  .u.mask = AV_CH_LAYOUT_2_1 | AV_CH_LOW_FREQUENCY,
176  },
177  {
178  .nb_channels = 4,
179  .order = AV_CHANNEL_ORDER_NATIVE,
180  .u.mask = AV_CH_LAYOUT_SURROUND | AV_CH_LOW_FREQUENCY,
181  },
182  {
183  .nb_channels = 5,
184  .order = AV_CHANNEL_ORDER_NATIVE,
185  .u.mask = AV_CH_LAYOUT_4POINT0 | AV_CH_LOW_FREQUENCY,
186  },
187  AV_CHANNEL_LAYOUT_5POINT1,
188  AV_CHANNEL_LAYOUT_5POINT1_BACK,
189  { 0 },
190 };
191 
192 /**
193  * Table to remap channels from SMPTE order to AC-3 order.
194  * [channel_mode][lfe][ch]
195  */
196 static const uint8_t ac3_enc_channel_map[8][2][6] = {
197  COMMON_CHANNEL_MAP
198  { { 0, 1, 2, 3, }, { 0, 1, 3, 4, 2, } },
199  { { 0, 2, 1, 3, 4, }, { 0, 2, 1, 4, 5, 3 } },
200 };
201 
202 /**
203  * LUT to select the bandwidth code based on the bit rate, sample rate, and
204  * number of full-bandwidth channels.
205  * bandwidth_tab[fbw_channels-1][sample rate code][bit rate code]
206  */
207 static const uint8_t ac3_bandwidth_tab[5][3][19] = {
208 // 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
209 
210  { { 0, 0, 0, 12, 16, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
211  { 0, 0, 0, 16, 20, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
212  { 0, 0, 0, 32, 40, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
213 
214  { { 0, 0, 0, 0, 0, 0, 0, 20, 24, 32, 48, 48, 48, 48, 48, 48, 48, 48, 48 },
215  { 0, 0, 0, 0, 0, 0, 4, 24, 28, 36, 56, 56, 56, 56, 56, 56, 56, 56, 56 },
216  { 0, 0, 0, 0, 0, 0, 20, 44, 52, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60 } },
217 
218  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 24, 32, 40, 48, 48, 48, 48, 48, 48 },
219  { 0, 0, 0, 0, 0, 0, 0, 0, 4, 20, 28, 36, 44, 56, 56, 56, 56, 56, 56 },
220  { 0, 0, 0, 0, 0, 0, 0, 0, 20, 40, 48, 60, 60, 60, 60, 60, 60, 60, 60 } },
221 
222  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 32, 48, 48, 48, 48, 48, 48 },
223  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 28, 36, 56, 56, 56, 56, 56, 56 },
224  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 48, 60, 60, 60, 60, 60, 60, 60 } },
225 
226  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 20, 32, 40, 48, 48, 48, 48 },
227  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 24, 36, 44, 56, 56, 56, 56 },
228  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 44, 60, 60, 60, 60, 60, 60 } }
229 };
230 
231 
232 /**
233  * LUT to select the coupling start band based on the bit rate, sample rate, and
234  * number of full-bandwidth channels. -1 = coupling off
235  * ac3_coupling_start_tab[channel_mode-2][sample rate code][bit rate code]
236  *
237  * TODO: more testing for optimal parameters.
238  * multi-channel tests at 44.1kHz and 32kHz.
239  */
240 static const int8_t ac3_coupling_start_tab[6][3][19] = {
241 // 32 40 48 56 64 80 96 112 128 160 192 224 256 320 384 448 512 576 640
242 
243  // 2/0
244  { { 0, 0, 0, 0, 0, 0, 0, 1, 1, 7, 8, 11, 12, -1, -1, -1, -1, -1, -1 },
245  { 0, 0, 0, 0, 0, 0, 1, 3, 5, 7, 10, 12, 13, -1, -1, -1, -1, -1, -1 },
246  { 0, 0, 0, 0, 1, 2, 2, 9, 13, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
247 
248  // 3/0
249  { { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
250  { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
251  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
252 
253  // 2/1 - untested
254  { { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
255  { 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 6, 9, 11, 12, 13, -1, -1, -1, -1 },
256  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
257 
258  // 3/1
259  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
260  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
261  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
262 
263  // 2/2 - untested
264  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
265  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 2, 10, 11, 11, 12, 12, 14, -1 },
266  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
267 
268  // 3/2
269  { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
270  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 6, 8, 11, 12, 12, -1, -1 },
271  { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 } },
272 };
273 
274 
275 #define FLT_OPTION_THRESHOLD 0.01
276 
277 static int validate_float_option(float v, const float *v_list, int v_list_size)
278 {
279  int i;
280 
281  for (i = 0; i < v_list_size; i++) {
282  if (v < (v_list[i] + FLT_OPTION_THRESHOLD) &&
283  v > (v_list[i] - FLT_OPTION_THRESHOLD))
284  break;
285  }
286  if (i == v_list_size)
287  return AVERROR(EINVAL);
288 
289  return i;
290 }
291 
292 
293 static void validate_mix_level(void *log_ctx, const char *opt_name,
294  float *opt_param, const float *list,
295  int list_size, int default_value, int min_value,
296  int *ctx_param)
297 {
298  int mixlev = validate_float_option(*opt_param, list, list_size);
299  if (mixlev < min_value) {
300  mixlev = default_value;
301  if (*opt_param >= 0.0) {
302  av_log(log_ctx, AV_LOG_WARNING, "requested %s is not valid. using "
303  "default value: %0.3f\n", opt_name, list[mixlev]);
304  }
305  }
306  *opt_param = list[mixlev];
307  *ctx_param = mixlev;
308 }
309 
310 
311 /**
312  * Validate metadata options as set by AVOption system.
313  * These values can optionally be changed per-frame.
314  *
315  * @param s AC-3 encoder private context
316  */
317 static int ac3_validate_metadata(AC3EncodeContext *s)
318 {
319  AVCodecContext *avctx = s->avctx;
320  AC3EncOptions *opt = &s->options;
321 
322  opt->audio_production_info = 0;
323  opt->extended_bsi_1 = 0;
324  opt->extended_bsi_2 = 0;
325  opt->eac3_mixing_metadata = 0;
326  opt->eac3_info_metadata = 0;
327 
328  /* determine mixing metadata / xbsi1 use */
329  if (s->channel_mode > AC3_CHMODE_STEREO && opt->preferred_stereo_downmix != AC3ENC_OPT_NONE) {
330  opt->extended_bsi_1 = 1;
331  opt->eac3_mixing_metadata = 1;
332  }
333  if (s->has_center &&
334  (opt->ltrt_center_mix_level >= 0 || opt->loro_center_mix_level >= 0)) {
335  opt->extended_bsi_1 = 1;
336  opt->eac3_mixing_metadata = 1;
337  }
338  if (s->has_surround &&
339  (opt->ltrt_surround_mix_level >= 0 || opt->loro_surround_mix_level >= 0)) {
340  opt->extended_bsi_1 = 1;
341  opt->eac3_mixing_metadata = 1;
342  }
343 
344  if (s->eac3) {
345  /* determine info metadata use */
346  if (avctx->audio_service_type != AV_AUDIO_SERVICE_TYPE_MAIN)
347  opt->eac3_info_metadata = 1;
348  if (opt->copyright != AC3ENC_OPT_NONE || opt->original != AC3ENC_OPT_NONE)
349  opt->eac3_info_metadata = 1;
350  if (s->channel_mode == AC3_CHMODE_STEREO &&
351  (opt->dolby_headphone_mode != AC3ENC_OPT_NONE || opt->dolby_surround_mode != AC3ENC_OPT_NONE))
352  opt->eac3_info_metadata = 1;
353  if (s->channel_mode >= AC3_CHMODE_2F2R && opt->dolby_surround_ex_mode != AC3ENC_OPT_NONE)
354  opt->eac3_info_metadata = 1;
355  if (opt->mixing_level != AC3ENC_OPT_NONE || opt->room_type != AC3ENC_OPT_NONE ||
356  opt->ad_converter_type != AC3ENC_OPT_NONE) {
357  opt->audio_production_info = 1;
358  opt->eac3_info_metadata = 1;
359  }
360  } else {
361  /* determine audio production info use */
362  if (opt->mixing_level != AC3ENC_OPT_NONE || opt->room_type != AC3ENC_OPT_NONE)
363  opt->audio_production_info = 1;
364 
365  /* determine xbsi2 use */
366  if (s->channel_mode >= AC3_CHMODE_2F2R && opt->dolby_surround_ex_mode != AC3ENC_OPT_NONE)
367  opt->extended_bsi_2 = 1;
368  if (s->channel_mode == AC3_CHMODE_STEREO && opt->dolby_headphone_mode != AC3ENC_OPT_NONE)
369  opt->extended_bsi_2 = 1;
370  if (opt->ad_converter_type != AC3ENC_OPT_NONE)
371  opt->extended_bsi_2 = 1;
372  }
373 
374  /* validate AC-3 mixing levels */
375  if (!s->eac3) {
376  if (s->has_center) {
377  validate_mix_level(avctx, "center_mix_level", &opt->center_mix_level,
378  cmixlev_options, CMIXLEV_NUM_OPTIONS, 1, 0,
379  &s->center_mix_level);
380  }
381  if (s->has_surround) {
382  validate_mix_level(avctx, "surround_mix_level", &opt->surround_mix_level,
383  surmixlev_options, SURMIXLEV_NUM_OPTIONS, 1, 0,
384  &s->surround_mix_level);
385  }
386  }
387 
388  /* validate extended bsi 1 / mixing metadata */
389  if (opt->extended_bsi_1 || opt->eac3_mixing_metadata) {
390  /* default preferred stereo downmix */
391  if (opt->preferred_stereo_downmix == AC3ENC_OPT_NONE)
392  opt->preferred_stereo_downmix = AC3ENC_OPT_NOT_INDICATED;
393  if (!s->eac3 || s->has_center) {
394  /* validate Lt/Rt center mix level */
395  validate_mix_level(avctx, "ltrt_center_mix_level",
396  &opt->ltrt_center_mix_level, extmixlev_options,
397  EXTMIXLEV_NUM_OPTIONS, 5, 0,
398  &s->ltrt_center_mix_level);
399  /* validate Lo/Ro center mix level */
400  validate_mix_level(avctx, "loro_center_mix_level",
401  &opt->loro_center_mix_level, extmixlev_options,
402  EXTMIXLEV_NUM_OPTIONS, 5, 0,
403  &s->loro_center_mix_level);
404  }
405  if (!s->eac3 || s->has_surround) {
406  /* validate Lt/Rt surround mix level */
407  validate_mix_level(avctx, "ltrt_surround_mix_level",
408  &opt->ltrt_surround_mix_level, extmixlev_options,
409  EXTMIXLEV_NUM_OPTIONS, 6, 3,
410  &s->ltrt_surround_mix_level);
411  /* validate Lo/Ro surround mix level */
412  validate_mix_level(avctx, "loro_surround_mix_level",
413  &opt->loro_surround_mix_level, extmixlev_options,
414  EXTMIXLEV_NUM_OPTIONS, 6, 3,
415  &s->loro_surround_mix_level);
416  }
417  }
418 
419  /* validate audio service type / channels combination */
420  if ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_KARAOKE &&
421  avctx->ch_layout.nb_channels == 1) ||
422  ((avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_COMMENTARY ||
423  avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_EMERGENCY ||
424  avctx->audio_service_type == AV_AUDIO_SERVICE_TYPE_VOICE_OVER)
425  && avctx->ch_layout.nb_channels > 1)) {
426  av_log(avctx, AV_LOG_ERROR, "invalid audio service type for the "
427  "specified number of channels\n");
428  return AVERROR(EINVAL);
429  }
430 
431  /* validate extended bsi 2 / info metadata */
432  if (opt->extended_bsi_2 || opt->eac3_info_metadata) {
433  /* default dolby headphone mode */
434  if (opt->dolby_headphone_mode == AC3ENC_OPT_NONE)
435  opt->dolby_headphone_mode = AC3ENC_OPT_NOT_INDICATED;
436  /* default dolby surround ex mode */
437  if (opt->dolby_surround_ex_mode == AC3ENC_OPT_NONE)
438  opt->dolby_surround_ex_mode = AC3ENC_OPT_NOT_INDICATED;
439  /* default A/D converter type */
440  if (opt->ad_converter_type == AC3ENC_OPT_NONE)
441  opt->ad_converter_type = AC3ENC_OPT_ADCONV_STANDARD;
442  }
443 
444  /* copyright & original defaults */
445  if (!s->eac3 || opt->eac3_info_metadata) {
446  /* default copyright */
447  if (opt->copyright == AC3ENC_OPT_NONE)
448  opt->copyright = AC3ENC_OPT_OFF;
449  /* default original */
450  if (opt->original == AC3ENC_OPT_NONE)
451  opt->original = AC3ENC_OPT_ON;
452  }
453 
454  /* dolby surround mode default */
455  if (!s->eac3 || opt->eac3_info_metadata) {
456  if (opt->dolby_surround_mode == AC3ENC_OPT_NONE)
457  opt->dolby_surround_mode = AC3ENC_OPT_NOT_INDICATED;
458  }
459 
460  /* validate audio production info */
461  if (opt->audio_production_info) {
462  if (opt->mixing_level == AC3ENC_OPT_NONE) {
463  av_log(avctx, AV_LOG_ERROR, "mixing_level must be set if "
464  "room_type is set\n");
465  return AVERROR(EINVAL);
466  }
467  if (opt->mixing_level < 80) {
468  av_log(avctx, AV_LOG_ERROR, "invalid mixing level. must be between "
469  "80dB and 111dB\n");
470  return AVERROR(EINVAL);
471  }
472  /* default room type */
473  if (opt->room_type == AC3ENC_OPT_NONE)
474  opt->room_type = AC3ENC_OPT_NOT_INDICATED;
475  }
476 
477  /* set bitstream id for alternate bitstream syntax */
478  if (!s->eac3 && (opt->extended_bsi_1 || opt->extended_bsi_2))
479  s->bitstream_id = 6;
480 
481  return 0;
482 }
483 
484 /**
485  * Adjust the frame size to make the average bit rate match the target bit rate.
486  * This is only needed for 11025, 22050, and 44100 sample rates or any E-AC-3.
487  *
488  * @param s AC-3 encoder private context
489  */
490 static void ac3_adjust_frame_size(AC3EncodeContext *s)
491 {
492  while (s->bits_written >= s->bit_rate && s->samples_written >= s->sample_rate) {
493  s->bits_written -= s->bit_rate;
494  s->samples_written -= s->sample_rate;
495  }
496  s->frame_size = s->frame_size_min +
497  2 * (s->bits_written * s->sample_rate < s->samples_written * s->bit_rate);
498  s->bits_written += s->frame_size * 8;
499  s->samples_written += AC3_BLOCK_SIZE * s->num_blocks;
500 }
501 
502 /**
503  * Set the initial coupling strategy parameters prior to coupling analysis.
504  *
505  * @param s AC-3 encoder private context
506  */
507 void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
508 {
509  int blk, ch;
510  int got_cpl_snr;
511  int num_cpl_blocks;
512 
513  /* set coupling use flags for each block/channel */
514  /* TODO: turn coupling on/off and adjust start band based on bit usage */
515  for (blk = 0; blk < s->num_blocks; blk++) {
516  AC3Block *block = &s->blocks[blk];
517  for (ch = 1; ch <= s->fbw_channels; ch++)
518  block->channel_in_cpl[ch] = s->cpl_on;
519  }
520 
521  /* enable coupling for each block if at least 2 channels have coupling
522  enabled for that block */
523  got_cpl_snr = 0;
524  num_cpl_blocks = 0;
525  for (blk = 0; blk < s->num_blocks; blk++) {
526  AC3Block *block = &s->blocks[blk];
527  block->num_cpl_channels = 0;
528  for (ch = 1; ch <= s->fbw_channels; ch++)
529  block->num_cpl_channels += block->channel_in_cpl[ch];
530  block->cpl_in_use = block->num_cpl_channels > 1;
531  num_cpl_blocks += block->cpl_in_use;
532  if (!block->cpl_in_use) {
533  block->num_cpl_channels = 0;
534  for (ch = 1; ch <= s->fbw_channels; ch++)
535  block->channel_in_cpl[ch] = 0;
536  }
537 
538  block->new_cpl_strategy = !blk;
539  if (blk) {
540  for (ch = 1; ch <= s->fbw_channels; ch++) {
541  if (block->channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
542  block->new_cpl_strategy = 1;
543  break;
544  }
545  }
546  }
547  block->new_cpl_leak = block->new_cpl_strategy;
548 
549  if (!blk || (block->cpl_in_use && !got_cpl_snr)) {
550  block->new_snr_offsets = 1;
551  if (block->cpl_in_use)
552  got_cpl_snr = 1;
553  } else {
554  block->new_snr_offsets = 0;
555  }
556  }
557  if (!num_cpl_blocks)
558  s->cpl_on = 0;
559 
560  /* set bandwidth for each channel */
561  for (blk = 0; blk < s->num_blocks; blk++) {
562  AC3Block *block = &s->blocks[blk];
563  for (ch = 1; ch <= s->fbw_channels; ch++) {
564  if (block->channel_in_cpl[ch])
565  block->end_freq[ch] = s->start_freq[CPL_CH];
566  else
567  block->end_freq[ch] = s->bandwidth_code * 3 + 73;
568  }
569  }
570 }
571 
572 
573 /**
574  * Apply stereo rematrixing to coefficients based on rematrixing flags.
575  *
576  * @param s AC-3 encoder private context
577  */
578 static void ac3_apply_rematrixing(AC3EncodeContext *s)
579 {
580  int nb_coefs;
581  int blk, bnd, i;
582  int start, end;
583  uint8_t *flags = NULL;
584 
585  if (!s->rematrixing_enabled)
586  return;
587 
588  for (blk = 0; blk < s->num_blocks; blk++) {
589  AC3Block *block = &s->blocks[blk];
590  if (block->new_rematrixing_strategy)
591  flags = block->rematrixing_flags;
592  nb_coefs = FFMIN(block->end_freq[1], block->end_freq[2]);
593  for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++) {
594  if (flags[bnd]) {
595  start = ff_ac3_rematrix_band_tab[bnd];
596  end = FFMIN(nb_coefs, ff_ac3_rematrix_band_tab[bnd+1]);
597  for (i = start; i < end; i++) {
598  int32_t lt = block->fixed_coef[1][i];
599  int32_t rt = block->fixed_coef[2][i];
600  block->fixed_coef[1][i] = (lt + rt) >> 1;
601  block->fixed_coef[2][i] = (lt - rt) >> 1;
602  }
603  }
604  }
605  }
606 }
607 
608 
609 /*
610  * Initialize exponent tables.
611  */
612 static av_cold void exponent_init(void)
613 {
614  int expstr, i, grpsize;
615 
616  for (expstr = EXP_D15-1; expstr <= EXP_D45-1; expstr++) {
617  grpsize = 3 << expstr;
618  for (i = 12; i < 256; i++) {
619  exponent_group_tab[0][expstr][i] = (i + grpsize - 4) / grpsize;
620  exponent_group_tab[1][expstr][i] = (i ) / grpsize;
621  }
622  }
623  /* LFE */
624  exponent_group_tab[0][0][7] = 2;
625 }
626 
627 
628 /*
629  * Extract exponents from the MDCT coefficients.
630  */
631 static void extract_exponents(AC3EncodeContext *s)
632 {
633  int ch = !s->cpl_on;
634  int chan_size = AC3_MAX_COEFS * s->num_blocks * (s->channels - ch + 1);
635  AC3Block *block = &s->blocks[0];
636 
637  s->ac3dsp.extract_exponents(block->exp[ch], block->fixed_coef[ch], chan_size);
638 }
639 
640 
641 /**
642  * Exponent Difference Threshold.
643  * New exponents are sent if their SAD exceed this number.
644  */
645 #define EXP_DIFF_THRESHOLD 500
646 
647 /**
648  * Table used to select exponent strategy based on exponent reuse block interval.
649  */
650 static const uint8_t exp_strategy_reuse_tab[4][6] = {
651  { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
652  { EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
653  { EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15, EXP_D15 },
654  { EXP_D45, EXP_D25, EXP_D25, EXP_D15, EXP_D15, EXP_D15 }
655 };
656 
657 /*
658  * Calculate exponent strategies for all channels.
659  * Array arrangement is reversed to simplify the per-channel calculation.
660  */
661 static void compute_exp_strategy(AC3EncodeContext *s)
662 {
663  int ch, blk, blk1;
664 
665  for (ch = !s->cpl_on; ch <= s->fbw_channels; ch++) {
666  uint8_t *exp_strategy = s->exp_strategy[ch];
667  uint8_t *exp = s->blocks[0].exp[ch];
668  int exp_diff;
669 
670  /* estimate if the exponent variation & decide if they should be
671  reused in the next frame */
672  exp_strategy[0] = EXP_NEW;
673  exp += AC3_MAX_COEFS;
674  for (blk = 1; blk < s->num_blocks; blk++, exp += AC3_MAX_COEFS) {
675  if (ch == CPL_CH) {
676  if (!s->blocks[blk-1].cpl_in_use) {
677  exp_strategy[blk] = EXP_NEW;
678  continue;
679  } else if (!s->blocks[blk].cpl_in_use) {
680  exp_strategy[blk] = EXP_REUSE;
681  continue;
682  }
683  } else if (s->blocks[blk].channel_in_cpl[ch] != s->blocks[blk-1].channel_in_cpl[ch]) {
684  exp_strategy[blk] = EXP_NEW;
685  continue;
686  }
687  exp_diff = s->mecc.sad[0](NULL, exp, exp - AC3_MAX_COEFS, 16, 16);
688  exp_strategy[blk] = EXP_REUSE;
689  if (ch == CPL_CH && exp_diff > (EXP_DIFF_THRESHOLD * (s->blocks[blk].end_freq[ch] - s->start_freq[ch]) / AC3_MAX_COEFS))
690  exp_strategy[blk] = EXP_NEW;
691  else if (ch > CPL_CH && exp_diff > EXP_DIFF_THRESHOLD)
692  exp_strategy[blk] = EXP_NEW;
693  }
694 
695  /* now select the encoding strategy type : if exponents are often
696  recoded, we use a coarse encoding */
697  blk = 0;
698  while (blk < s->num_blocks) {
699  blk1 = blk + 1;
700  while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE)
701  blk1++;
702  exp_strategy[blk] = exp_strategy_reuse_tab[s->num_blks_code][blk1-blk-1];
703  blk = blk1;
704  }
705  }
706  if (s->lfe_on) {
707  ch = s->lfe_channel;
708  s->exp_strategy[ch][0] = EXP_D15;
709  for (blk = 1; blk < s->num_blocks; blk++)
710  s->exp_strategy[ch][blk] = EXP_REUSE;
711  }
712 
713  /* for E-AC-3, determine frame exponent strategy */
714  if (CONFIG_EAC3_ENCODER && s->eac3)
715  ff_eac3_get_frame_exp_strategy(s);
716 }
717 
718 
719 /**
720  * Update the exponents so that they are the ones the decoder will decode.
721  *
722  * @param[in,out] exp array of exponents for 1 block in 1 channel
723  * @param nb_exps number of exponents in active bandwidth
724  * @param exp_strategy exponent strategy for the block
725  * @param cpl indicates if the block is in the coupling channel
726  */
727 static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy,
728  int cpl)
729 {
730  int nb_groups, i, k;
731 
732  nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_exps] * 3;
733 
734  /* for each group, compute the minimum exponent */
735  switch(exp_strategy) {
736  case EXP_D25:
737  for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
738  uint8_t exp_min = exp[k];
739  if (exp[k+1] < exp_min)
740  exp_min = exp[k+1];
741  exp[i-cpl] = exp_min;
742  k += 2;
743  }
744  break;
745  case EXP_D45:
746  for (i = 1, k = 1-cpl; i <= nb_groups; i++) {
747  uint8_t exp_min = exp[k];
748  if (exp[k+1] < exp_min)
749  exp_min = exp[k+1];
750  if (exp[k+2] < exp_min)
751  exp_min = exp[k+2];
752  if (exp[k+3] < exp_min)
753  exp_min = exp[k+3];
754  exp[i-cpl] = exp_min;
755  k += 4;
756  }
757  break;
758  }
759 
760  /* constraint for DC exponent */
761  if (!cpl && exp[0] > 15)
762  exp[0] = 15;
763 
764  /* decrease the delta between each groups to within 2 so that they can be
765  differentially encoded */
766  for (i = 1; i <= nb_groups; i++)
767  exp[i] = FFMIN(exp[i], exp[i-1] + 2);
768  i--;
769  while (--i >= 0)
770  exp[i] = FFMIN(exp[i], exp[i+1] + 2);
771 
772  if (cpl)
773  exp[-1] = exp[0] & ~1;
774 
775  /* now we have the exponent values the decoder will see */
776  switch (exp_strategy) {
777  case EXP_D25:
778  for (i = nb_groups, k = (nb_groups * 2)-cpl; i > 0; i--) {
779  uint8_t exp1 = exp[i-cpl];
780  exp[k--] = exp1;
781  exp[k--] = exp1;
782  }
783  break;
784  case EXP_D45:
785  for (i = nb_groups, k = (nb_groups * 4)-cpl; i > 0; i--) {
786  exp[k] = exp[k-1] = exp[k-2] = exp[k-3] = exp[i-cpl];
787  k -= 4;
788  }
789  break;
790  }
791 }
792 
793 
794 /*
795  * Encode exponents from original extracted form to what the decoder will see.
796  * This copies and groups exponents based on exponent strategy and reduces
797  * deltas between adjacent exponent groups so that they can be differentially
798  * encoded.
799  */
800 static void encode_exponents(AC3EncodeContext *s)
801 {
802  int blk, blk1, ch, cpl;
803  uint8_t *exp, *exp_strategy;
804  int nb_coefs, num_reuse_blocks;
805 
806  for (ch = !s->cpl_on; ch <= s->channels; ch++) {
807  exp = s->blocks[0].exp[ch] + s->start_freq[ch];
808  exp_strategy = s->exp_strategy[ch];
809 
810  cpl = (ch == CPL_CH);
811  blk = 0;
812  while (blk < s->num_blocks) {
813  AC3Block *block = &s->blocks[blk];
814  if (cpl && !block->cpl_in_use) {
815  exp += AC3_MAX_COEFS;
816  blk++;
817  continue;
818  }
819  nb_coefs = block->end_freq[ch] - s->start_freq[ch];
820  blk1 = blk + 1;
821 
822  /* count the number of EXP_REUSE blocks after the current block
823  and set exponent reference block numbers */
824  s->exp_ref_block[ch][blk] = blk;
825  while (blk1 < s->num_blocks && exp_strategy[blk1] == EXP_REUSE) {
826  s->exp_ref_block[ch][blk1] = blk;
827  blk1++;
828  }
829  num_reuse_blocks = blk1 - blk - 1;
830 
831  /* for the EXP_REUSE case we select the min of the exponents */
832  s->ac3dsp.ac3_exponent_min(exp-s->start_freq[ch], num_reuse_blocks,
833  AC3_MAX_COEFS);
834 
835  encode_exponents_blk_ch(exp, nb_coefs, exp_strategy[blk], cpl);
836 
837  exp += AC3_MAX_COEFS * (num_reuse_blocks + 1);
838  blk = blk1;
839  }
840  }
841 
842  /* reference block numbers have been changed, so reset ref_bap_set */
843  s->ref_bap_set = 0;
844 }
845 
846 
847 /*
848  * Count exponent bits based on bandwidth, coupling, and exponent strategies.
849  */
850 static int count_exponent_bits(AC3EncodeContext *s)
851 {
852  int blk, ch;
853  int nb_groups, bit_count;
854 
855  bit_count = 0;
856  for (blk = 0; blk < s->num_blocks; blk++) {
857  AC3Block *block = &s->blocks[blk];
858  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
859  int exp_strategy = s->exp_strategy[ch][blk];
860  int cpl = (ch == CPL_CH);
861  int nb_coefs = block->end_freq[ch] - s->start_freq[ch];
862 
863  if (exp_strategy == EXP_REUSE)
864  continue;
865 
866  nb_groups = exponent_group_tab[cpl][exp_strategy-1][nb_coefs];
867  bit_count += 4 + (nb_groups * 7);
868  }
869  }
870 
871  return bit_count;
872 }
873 
874 
875 /**
876  * Group exponents.
877  * 3 delta-encoded exponents are in each 7-bit group. The number of groups
878  * varies depending on exponent strategy and bandwidth.
879  *
880  * @param s AC-3 encoder private context
881  */
882 static void ac3_group_exponents(AC3EncodeContext *s)
883 {
884  int blk, ch, i, cpl;
885  int group_size, nb_groups;
886  uint8_t *p;
887  int delta0, delta1, delta2;
888  int exp0, exp1;
889 
890  for (blk = 0; blk < s->num_blocks; blk++) {
891  AC3Block *block = &s->blocks[blk];
892  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
893  int exp_strategy = s->exp_strategy[ch][blk];
894  if (exp_strategy == EXP_REUSE)
895  continue;
896  cpl = (ch == CPL_CH);
897  group_size = exp_strategy + (exp_strategy == EXP_D45);
898  nb_groups = exponent_group_tab[cpl][exp_strategy-1][block->end_freq[ch]-s->start_freq[ch]];
899  p = block->exp[ch] + s->start_freq[ch] - cpl;
900 
901  /* DC exponent */
902  exp1 = *p++;
903  block->grouped_exp[ch][0] = exp1;
904 
905  /* remaining exponents are delta encoded */
906  for (i = 1; i <= nb_groups; i++) {
907  /* merge three delta in one code */
908  exp0 = exp1;
909  exp1 = p[0];
910  p += group_size;
911  delta0 = exp1 - exp0 + 2;
912  av_assert2(delta0 >= 0 && delta0 <= 4);
913 
914  exp0 = exp1;
915  exp1 = p[0];
916  p += group_size;
917  delta1 = exp1 - exp0 + 2;
918  av_assert2(delta1 >= 0 && delta1 <= 4);
919 
920  exp0 = exp1;
921  exp1 = p[0];
922  p += group_size;
923  delta2 = exp1 - exp0 + 2;
924  av_assert2(delta2 >= 0 && delta2 <= 4);
925 
926  block->grouped_exp[ch][i] = ((delta0 * 5 + delta1) * 5) + delta2;
927  }
928  }
929  }
930 }
931 
932 
933 /**
934  * Calculate final exponents from the supplied MDCT coefficients and exponent shift.
935  * Extract exponents from MDCT coefficients, calculate exponent strategies,
936  * and encode final exponents.
937  *
938  * @param s AC-3 encoder private context
939  */
940 static void ac3_process_exponents(AC3EncodeContext *s)
941 {
942  extract_exponents(s);
943 
944  compute_exp_strategy(s);
945 
946  encode_exponents(s);
947 }
948 
949 
950 /*
951  * Count frame bits that are based solely on fixed parameters.
952  * This only has to be run once when the encoder is initialized.
953  */
954 static void count_frame_bits_fixed(AC3EncodeContext *s)
955 {
956  static const uint8_t frame_bits_inc[8] = { 0, 0, 2, 2, 2, 4, 2, 4 };
957  int blk;
958  int frame_bits;
959 
960  /* assumptions:
961  * no dynamic range codes
962  * bit allocation parameters do not change between blocks
963  * no delta bit allocation
964  * no skipped data
965  * no auxiliary data
966  * no E-AC-3 metadata
967  */
968 
969  /* header */
970  frame_bits = 16; /* sync info */
971  if (s->eac3) {
972  /* bitstream info header */
973  frame_bits += 35;
974  frame_bits += 1 + 1;
975  if (s->num_blocks != 0x6)
976  frame_bits++;
977  frame_bits++;
978  /* audio frame header */
979  if (s->num_blocks == 6)
980  frame_bits += 2;
981  frame_bits += 10;
982  /* exponent strategy */
983  if (s->use_frame_exp_strategy)
984  frame_bits += 5 * s->fbw_channels;
985  else
986  frame_bits += s->num_blocks * 2 * s->fbw_channels;
987  if (s->lfe_on)
988  frame_bits += s->num_blocks;
989  /* converter exponent strategy */
990  if (s->num_blks_code != 0x3)
991  frame_bits++;
992  else
993  frame_bits += s->fbw_channels * 5;
994  /* snr offsets */
995  frame_bits += 10;
996  /* block start info */
997  if (s->num_blocks != 1)
998  frame_bits++;
999  } else {
1000  frame_bits += 49;
1001  frame_bits += frame_bits_inc[s->channel_mode];
1002  }
1003 
1004  /* audio blocks */
1005  for (blk = 0; blk < s->num_blocks; blk++) {
1006  if (!s->eac3) {
1007  /* block switch flags */
1008  frame_bits += s->fbw_channels;
1009 
1010  /* dither flags */
1011  frame_bits += s->fbw_channels;
1012  }
1013 
1014  /* dynamic range */
1015  frame_bits++;
1016 
1017  /* spectral extension */
1018  if (s->eac3)
1019  frame_bits++;
1020 
1021  /* coupling strategy exists: cplstre */
1022  if (!s->eac3)
1023  frame_bits++;
1024 
1025  if (!s->eac3) {
1026  /* exponent strategy */
1027  frame_bits += 2 * s->fbw_channels;
1028  if (s->lfe_on)
1029  frame_bits++;
1030 
1031  /* bit allocation params */
1032  frame_bits++;
1033  if (!blk)
1034  frame_bits += 2 + 2 + 2 + 2 + 3;
1035  }
1036 
1037  /* snroffste for AC-3, convsnroffste for E-AC-3 */
1038  frame_bits++;
1039 
1040  if (!s->eac3) {
1041  /* delta bit allocation */
1042  frame_bits++;
1043 
1044  /* skipped data */
1045  frame_bits++;
1046  }
1047  }
1048 
1049  /* auxiliary data */
1050  frame_bits++;
1051 
1052  /* CRC */
1053  frame_bits += 1 + 16;
1054 
1055  s->frame_bits_fixed = frame_bits;
1056 }
1057 
1058 
1059 /*
1060  * Initialize bit allocation.
1061  * Set default parameter codes and calculate parameter values.
1062  */
1063 static av_cold void bit_alloc_init(AC3EncodeContext *s)
1064 {
1065  int ch;
1066 
1067  /* init default parameters */
1068  s->slow_decay_code = 2;
1069  s->fast_decay_code = 1;
1070  s->slow_gain_code = 1;
1071  s->db_per_bit_code = s->eac3 ? 2 : 3;
1072  s->floor_code = 7;
1073  for (ch = 0; ch <= s->channels; ch++)
1074  s->fast_gain_code[ch] = 4;
1075 
1076  /* initial snr offset */
1077  s->coarse_snr_offset = 40;
1078 
1079  /* compute real values */
1080  /* currently none of these values change during encoding, so we can just
1081  set them once at initialization */
1082  s->bit_alloc.slow_decay = ff_ac3_slow_decay_tab[s->slow_decay_code];
1083  s->bit_alloc.fast_decay = ff_ac3_fast_decay_tab[s->fast_decay_code];
1084  s->bit_alloc.slow_gain = ff_ac3_slow_gain_tab[s->slow_gain_code];
1085  s->bit_alloc.db_per_bit = ff_ac3_db_per_bit_tab[s->db_per_bit_code];
1086  s->bit_alloc.floor = ff_ac3_floor_tab[s->floor_code];
1087  s->bit_alloc.cpl_fast_leak = 0;
1088  s->bit_alloc.cpl_slow_leak = 0;
1089 
1090  count_frame_bits_fixed(s);
1091 }
1092 
1093 
1094 /*
1095  * Count the bits used to encode the frame, minus exponents and mantissas.
1096  * Bits based on fixed parameters have already been counted, so now we just
1097  * have to add the bits based on parameters that change during encoding.
1098  */
1099 static void count_frame_bits(AC3EncodeContext *s)
1100 {
1101  AC3EncOptions *opt = &s->options;
1102  int blk, ch;
1103  int frame_bits = 0;
1104 
1105  /* header */
1106  if (s->eac3) {
1107  if (opt->eac3_mixing_metadata) {
1108  if (s->channel_mode > AC3_CHMODE_STEREO)
1109  frame_bits += 2;
1110  if (s->has_center)
1111  frame_bits += 6;
1112  if (s->has_surround)
1113  frame_bits += 6;
1114  frame_bits += s->lfe_on;
1115  frame_bits += 1 + 1 + 2;
1116  if (s->channel_mode < AC3_CHMODE_STEREO)
1117  frame_bits++;
1118  frame_bits++;
1119  }
1120  if (opt->eac3_info_metadata) {
1121  frame_bits += 3 + 1 + 1;
1122  if (s->channel_mode == AC3_CHMODE_STEREO)
1123  frame_bits += 2 + 2;
1124  if (s->channel_mode >= AC3_CHMODE_2F2R)
1125  frame_bits += 2;
1126  frame_bits++;
1127  if (opt->audio_production_info)
1128  frame_bits += 5 + 2 + 1;
1129  frame_bits++;
1130  }
1131  /* coupling */
1132  if (s->channel_mode > AC3_CHMODE_MONO) {
1133  frame_bits++;
1134  for (blk = 1; blk < s->num_blocks; blk++) {
1135  AC3Block *block = &s->blocks[blk];
1136  frame_bits++;
1137  if (block->new_cpl_strategy)
1138  frame_bits++;
1139  }
1140  }
1141  /* coupling exponent strategy */
1142  if (s->cpl_on) {
1143  if (s->use_frame_exp_strategy) {
1144  frame_bits += 5;
1145  } else {
1146  for (blk = 0; blk < s->num_blocks; blk++)
1147  frame_bits += 2 * s->blocks[blk].cpl_in_use;
1148  }
1149  }
1150  } else {
1151  if (opt->audio_production_info)
1152  frame_bits += 7;
1153  if (s->bitstream_id == 6) {
1154  if (opt->extended_bsi_1)
1155  frame_bits += 14;
1156  if (opt->extended_bsi_2)
1157  frame_bits += 14;
1158  }
1159  }
1160 
1161  /* audio blocks */
1162  for (blk = 0; blk < s->num_blocks; blk++) {
1163  AC3Block *block = &s->blocks[blk];
1164 
1165  /* coupling strategy */
1166  if (block->new_cpl_strategy) {
1167  if (!s->eac3)
1168  frame_bits++;
1169  if (block->cpl_in_use) {
1170  if (s->eac3)
1171  frame_bits++;
1172  if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO)
1173  frame_bits += s->fbw_channels;
1174  if (s->channel_mode == AC3_CHMODE_STEREO)
1175  frame_bits++;
1176  frame_bits += 4 + 4;
1177  if (s->eac3)
1178  frame_bits++;
1179  else
1180  frame_bits += s->num_cpl_subbands - 1;
1181  }
1182  }
1183 
1184  /* coupling coordinates */
1185  if (block->cpl_in_use) {
1186  for (ch = 1; ch <= s->fbw_channels; ch++) {
1187  if (block->channel_in_cpl[ch]) {
1188  if (!s->eac3 || block->new_cpl_coords[ch] != 2)
1189  frame_bits++;
1190  if (block->new_cpl_coords[ch]) {
1191  frame_bits += 2;
1192  frame_bits += (4 + 4) * s->num_cpl_bands;
1193  }
1194  }
1195  }
1196  }
1197 
1198  /* stereo rematrixing */
1199  if (s->channel_mode == AC3_CHMODE_STEREO) {
1200  if (!s->eac3 || blk > 0)
1201  frame_bits++;
1202  if (s->blocks[blk].new_rematrixing_strategy)
1203  frame_bits += block->num_rematrixing_bands;
1204  }
1205 
1206  /* bandwidth codes & gain range */
1207  for (ch = 1; ch <= s->fbw_channels; ch++) {
1208  if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1209  if (!block->channel_in_cpl[ch])
1210  frame_bits += 6;
1211  frame_bits += 2;
1212  }
1213  }
1214 
1215  /* coupling exponent strategy */
1216  if (!s->eac3 && block->cpl_in_use)
1217  frame_bits += 2;
1218 
1219  /* snr offsets and fast gain codes */
1220  if (!s->eac3) {
1221  if (block->new_snr_offsets)
1222  frame_bits += 6 + (s->channels + block->cpl_in_use) * (4 + 3);
1223  }
1224 
1225  /* coupling leak info */
1226  if (block->cpl_in_use) {
1227  if (!s->eac3 || block->new_cpl_leak != 2)
1228  frame_bits++;
1229  if (block->new_cpl_leak)
1230  frame_bits += 3 + 3;
1231  }
1232  }
1233 
1234  s->frame_bits = s->frame_bits_fixed + frame_bits;
1235 }
1236 
1237 
1238 /*
1239  * Calculate masking curve based on the final exponents.
1240  * Also calculate the power spectral densities to use in future calculations.
1241  */
1242 static void bit_alloc_masking(AC3EncodeContext *s)
1243 {
1244  int blk, ch;
1245 
1246  for (blk = 0; blk < s->num_blocks; blk++) {
1247  AC3Block *block = &s->blocks[blk];
1248  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1249  /* We only need psd and mask for calculating bap.
1250  Since we currently do not calculate bap when exponent
1251  strategy is EXP_REUSE we do not need to calculate psd or mask. */
1252  if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1253  ff_ac3_bit_alloc_calc_psd(block->exp[ch], s->start_freq[ch],
1254  block->end_freq[ch], block->psd[ch],
1255  block->band_psd[ch]);
1256  ff_ac3_bit_alloc_calc_mask(&s->bit_alloc, block->band_psd[ch],
1257  s->start_freq[ch], block->end_freq[ch],
1258  ff_ac3_fast_gain_tab[s->fast_gain_code[ch]],
1259  ch == s->lfe_channel,
1260  DBA_NONE, 0, NULL, NULL, NULL,
1261  block->mask[ch]);
1262  }
1263  }
1264  }
1265 }
1266 
1267 
1268 /*
1269  * Ensure that bap for each block and channel point to the current bap_buffer.
1270  * They may have been switched during the bit allocation search.
1271  */
1272 static void reset_block_bap(AC3EncodeContext *s)
1273 {
1274  int blk, ch;
1275  uint8_t *ref_bap;
1276 
1277  if (s->ref_bap[0][0] == s->bap_buffer && s->ref_bap_set)
1278  return;
1279 
1280  ref_bap = s->bap_buffer;
1281  for (ch = 0; ch <= s->channels; ch++) {
1282  for (blk = 0; blk < s->num_blocks; blk++)
1283  s->ref_bap[ch][blk] = ref_bap + AC3_MAX_COEFS * s->exp_ref_block[ch][blk];
1284  ref_bap += AC3_MAX_COEFS * s->num_blocks;
1285  }
1286  s->ref_bap_set = 1;
1287 }
1288 
1289 
1290 /**
1291  * Initialize mantissa counts.
1292  * These are set so that they are padded to the next whole group size when bits
1293  * are counted in compute_mantissa_size.
1294  *
1295  * @param[in,out] mant_cnt running counts for each bap value for each block
1296  */
1297 static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
1298 {
1299  int blk;
1300 
1301  for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
1302  memset(mant_cnt[blk], 0, sizeof(mant_cnt[blk]));
1303  mant_cnt[blk][1] = mant_cnt[blk][2] = 2;
1304  mant_cnt[blk][4] = 1;
1305  }
1306 }
1307 
1308 
1309 /**
1310  * Update mantissa bit counts for all blocks in 1 channel in a given bandwidth
1311  * range.
1312  *
1313  * @param s AC-3 encoder private context
1314  * @param ch channel index
1315  * @param[in,out] mant_cnt running counts for each bap value for each block
1316  * @param start starting coefficient bin
1317  * @param end ending coefficient bin
1318  */
1319 static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch,
1320  uint16_t mant_cnt[AC3_MAX_BLOCKS][16],
1321  int start, int end)
1322 {
1323  int blk;
1324 
1325  for (blk = 0; blk < s->num_blocks; blk++) {
1326  AC3Block *block = &s->blocks[blk];
1327  if (ch == CPL_CH && !block->cpl_in_use)
1328  continue;
1329  s->ac3dsp.update_bap_counts(mant_cnt[blk],
1330  s->ref_bap[ch][blk] + start,
1331  FFMIN(end, block->end_freq[ch]) - start);
1332  }
1333 }
1334 
1335 
1336 /*
1337  * Count the number of mantissa bits in the frame based on the bap values.
1338  */
1339 static int count_mantissa_bits(AC3EncodeContext *s)
1340 {
1341  int ch, max_end_freq;
1342  LOCAL_ALIGNED_16(uint16_t, mant_cnt, [AC3_MAX_BLOCKS], [16]);
1343 
1344  count_mantissa_bits_init(mant_cnt);
1345 
1346  max_end_freq = s->bandwidth_code * 3 + 73;
1347  for (ch = !s->cpl_enabled; ch <= s->channels; ch++)
1348  count_mantissa_bits_update_ch(s, ch, mant_cnt, s->start_freq[ch],
1349  max_end_freq);
1350 
1351  return s->ac3dsp.compute_mantissa_size(mant_cnt);
1352 }
1353 
1354 
1355 /**
1356  * Run the bit allocation with a given SNR offset.
1357  * This calculates the bit allocation pointers that will be used to determine
1358  * the quantization of each mantissa.
1359  *
1360  * @param s AC-3 encoder private context
1361  * @param snr_offset SNR offset, 0 to 1023
1362  * @return the number of bits needed for mantissas if the given SNR offset is
1363  * is used.
1364  */
1365 static int bit_alloc(AC3EncodeContext *s, int snr_offset)
1366 {
1367  int blk, ch;
1368 
1369  snr_offset = (snr_offset - 240) * 4;
1370 
1371  reset_block_bap(s);
1372  for (blk = 0; blk < s->num_blocks; blk++) {
1373  AC3Block *block = &s->blocks[blk];
1374 
1375  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1376  /* Currently the only bit allocation parameters which vary across
1377  blocks within a frame are the exponent values. We can take
1378  advantage of that by reusing the bit allocation pointers
1379  whenever we reuse exponents. */
1380  if (s->exp_strategy[ch][blk] != EXP_REUSE) {
1381  s->ac3dsp.bit_alloc_calc_bap(block->mask[ch], block->psd[ch],
1382  s->start_freq[ch], block->end_freq[ch],
1383  snr_offset, s->bit_alloc.floor,
1384  ff_ac3_bap_tab, s->ref_bap[ch][blk]);
1385  }
1386  }
1387  }
1388  return count_mantissa_bits(s);
1389 }
1390 
1391 
1392 /*
1393  * Constant bitrate bit allocation search.
1394  * Find the largest SNR offset that will allow data to fit in the frame.
1395  */
1396 static int cbr_bit_allocation(AC3EncodeContext *s)
1397 {
1398  int ch;
1399  int bits_left;
1400  int snr_offset, snr_incr;
1401 
1402  bits_left = 8 * s->frame_size - (s->frame_bits + s->exponent_bits);
1403  if (bits_left < 0)
1404  return AVERROR(EINVAL);
1405 
1406  snr_offset = s->coarse_snr_offset << 4;
1407 
1408  /* if previous frame SNR offset was 1023, check if current frame can also
1409  use SNR offset of 1023. if so, skip the search. */
1410  if ((snr_offset | s->fine_snr_offset[1]) == 1023) {
1411  if (bit_alloc(s, 1023) <= bits_left)
1412  return 0;
1413  }
1414 
1415  while (snr_offset >= 0 &&
1416  bit_alloc(s, snr_offset) > bits_left) {
1417  snr_offset -= 64;
1418  }
1419  if (snr_offset < 0)
1420  return AVERROR(EINVAL);
1421 
1422  FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1423  for (snr_incr = 64; snr_incr > 0; snr_incr >>= 2) {
1424  while (snr_offset + snr_incr <= 1023 &&
1425  bit_alloc(s, snr_offset + snr_incr) <= bits_left) {
1426  snr_offset += snr_incr;
1427  FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1428  }
1429  }
1430  FFSWAP(uint8_t *, s->bap_buffer, s->bap1_buffer);
1431  reset_block_bap(s);
1432 
1433  s->coarse_snr_offset = snr_offset >> 4;
1434  for (ch = !s->cpl_on; ch <= s->channels; ch++)
1435  s->fine_snr_offset[ch] = snr_offset & 0xF;
1436 
1437  return 0;
1438 }
1439 
1440 
1441 /*
1442  * Perform bit allocation search.
1443  * Finds the SNR offset value that maximizes quality and fits in the specified
1444  * frame size. Output is the SNR offset and a set of bit allocation pointers
1445  * used to quantize the mantissas.
1446  */
1447 static int ac3_compute_bit_allocation(AC3EncodeContext *s)
1448 {
1449  count_frame_bits(s);
1450 
1451  s->exponent_bits = count_exponent_bits(s);
1452 
1453  bit_alloc_masking(s);
1454 
1455  return cbr_bit_allocation(s);
1456 }
1457 
1458 
1459 /**
1460  * Symmetric quantization on 'levels' levels.
1461  *
1462  * @param c unquantized coefficient
1463  * @param e exponent
1464  * @param levels number of quantization levels
1465  * @return quantized coefficient
1466  */
1467 static inline int sym_quant(int c, int e, int levels)
1468 {
1469  int v = (((levels * c) >> (24 - e)) + levels) >> 1;
1470  av_assert2(v >= 0 && v < levels);
1471  return v;
1472 }
1473 
1474 
1475 /**
1476  * Asymmetric quantization on 2^qbits levels.
1477  *
1478  * @param c unquantized coefficient
1479  * @param e exponent
1480  * @param qbits number of quantization bits
1481  * @return quantized coefficient
1482  */
1483 static inline int asym_quant(int c, int e, int qbits)
1484 {
1485  int m;
1486 
1487  c = (((c * (1<<e)) >> (24 - qbits)) + 1) >> 1;
1488  m = (1 << (qbits-1));
1489  if (c >= m)
1490  c = m - 1;
1491  av_assert2(c >= -m);
1492  return c;
1493 }
1494 
1495 
1496 /**
1497  * Quantize a set of mantissas for a single channel in a single block.
1498  *
1499  * @param s Mantissa count context
1500  * @param fixed_coef unquantized fixed-point coefficients
1501  * @param exp exponents
1502  * @param bap bit allocation pointer indices
1503  * @param[out] qmant quantized coefficients
1504  * @param start_freq starting coefficient bin
1505  * @param end_freq ending coefficient bin
1506  */
1507 static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef,
1508  uint8_t *exp, uint8_t *bap,
1509  int16_t *qmant, int start_freq,
1510  int end_freq)
1511 {
1512  int i;
1513 
1514  for (i = start_freq; i < end_freq; i++) {
1515  int c = fixed_coef[i];
1516  int e = exp[i];
1517  int v = bap[i];
1518  switch (v) {
1519  case 0:
1520  break;
1521  case 1:
1522  v = sym_quant(c, e, 3);
1523  switch (s->mant1_cnt) {
1524  case 0:
1525  s->qmant1_ptr = &qmant[i];
1526  v = 9 * v;
1527  s->mant1_cnt = 1;
1528  break;
1529  case 1:
1530  *s->qmant1_ptr += 3 * v;
1531  s->mant1_cnt = 2;
1532  v = 128;
1533  break;
1534  default:
1535  *s->qmant1_ptr += v;
1536  s->mant1_cnt = 0;
1537  v = 128;
1538  break;
1539  }
1540  break;
1541  case 2:
1542  v = sym_quant(c, e, 5);
1543  switch (s->mant2_cnt) {
1544  case 0:
1545  s->qmant2_ptr = &qmant[i];
1546  v = 25 * v;
1547  s->mant2_cnt = 1;
1548  break;
1549  case 1:
1550  *s->qmant2_ptr += 5 * v;
1551  s->mant2_cnt = 2;
1552  v = 128;
1553  break;
1554  default:
1555  *s->qmant2_ptr += v;
1556  s->mant2_cnt = 0;
1557  v = 128;
1558  break;
1559  }
1560  break;
1561  case 3:
1562  v = sym_quant(c, e, 7);
1563  break;
1564  case 4:
1565  v = sym_quant(c, e, 11);
1566  switch (s->mant4_cnt) {
1567  case 0:
1568  s->qmant4_ptr = &qmant[i];
1569  v = 11 * v;
1570  s->mant4_cnt = 1;
1571  break;
1572  default:
1573  *s->qmant4_ptr += v;
1574  s->mant4_cnt = 0;
1575  v = 128;
1576  break;
1577  }
1578  break;
1579  case 5:
1580  v = sym_quant(c, e, 15);
1581  break;
1582  case 14:
1583  v = asym_quant(c, e, 14);
1584  break;
1585  case 15:
1586  v = asym_quant(c, e, 16);
1587  break;
1588  default:
1589  v = asym_quant(c, e, v - 1);
1590  break;
1591  }
1592  qmant[i] = v;
1593  }
1594 }
1595 
1596 
1597 /**
1598  * Quantize mantissas using coefficients, exponents, and bit allocation pointers.
1599  *
1600  * @param s AC-3 encoder private context
1601  */
1602 static void ac3_quantize_mantissas(AC3EncodeContext *s)
1603 {
1604  int blk, ch, ch0=0, got_cpl;
1605 
1606  for (blk = 0; blk < s->num_blocks; blk++) {
1607  AC3Block *block = &s->blocks[blk];
1608  AC3Mant m = { 0 };
1609 
1610  got_cpl = !block->cpl_in_use;
1611  for (ch = 1; ch <= s->channels; ch++) {
1612  if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
1613  ch0 = ch - 1;
1614  ch = CPL_CH;
1615  got_cpl = 1;
1616  }
1617  quantize_mantissas_blk_ch(&m, block->fixed_coef[ch],
1618  s->blocks[s->exp_ref_block[ch][blk]].exp[ch],
1619  s->ref_bap[ch][blk], block->qmant[ch],
1620  s->start_freq[ch], block->end_freq[ch]);
1621  if (ch == CPL_CH)
1622  ch = ch0;
1623  }
1624  }
1625 }
1626 
1627 
1628 /*
1629  * Write the AC-3 frame header to the output bitstream.
1630  */
1631 static void ac3_output_frame_header(AC3EncodeContext *s, PutBitContext *pb)
1632 {
1633  AC3EncOptions *opt = &s->options;
1634 
1635  put_bits_assume_flushed(pb);
1636 
1637  put_bits(pb, 16, 0x0b77); /* frame header */
1638  put_bits(pb, 16, 0); /* crc1: will be filled later */
1639  put_bits(pb, 2, s->bit_alloc.sr_code);
1640  put_bits(pb, 6, s->frame_size_code + (s->frame_size - s->frame_size_min) / 2);
1641  put_bits(pb, 5, s->bitstream_id);
1642  put_bits(pb, 3, s->bitstream_mode);
1643  put_bits(pb, 3, s->channel_mode);
1644  if ((s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO)
1645  put_bits(pb, 2, s->center_mix_level);
1646  if (s->channel_mode & 0x04)
1647  put_bits(pb, 2, s->surround_mix_level);
1648  if (s->channel_mode == AC3_CHMODE_STEREO)
1649  put_bits(pb, 2, opt->dolby_surround_mode);
1650  put_bits(pb, 1, s->lfe_on); /* LFE */
1651  put_bits(pb, 5, -opt->dialogue_level);
1652  put_bits(pb, 1, 0); /* no compression control word */
1653  put_bits(pb, 1, 0); /* no lang code */
1654  put_bits(pb, 1, opt->audio_production_info);
1655  if (opt->audio_production_info) {
1656  put_bits(pb, 5, opt->mixing_level - 80);
1657  put_bits(pb, 2, opt->room_type);
1658  }
1659  put_bits(pb, 1, opt->copyright);
1660  put_bits(pb, 1, opt->original);
1661  if (s->bitstream_id == 6) {
1662  /* alternate bit stream syntax */
1663  put_bits(pb, 1, opt->extended_bsi_1);
1664  if (opt->extended_bsi_1) {
1665  put_bits(pb, 2, opt->preferred_stereo_downmix);
1666  put_bits(pb, 3, s->ltrt_center_mix_level);
1667  put_bits(pb, 3, s->ltrt_surround_mix_level);
1668  put_bits(pb, 3, s->loro_center_mix_level);
1669  put_bits(pb, 3, s->loro_surround_mix_level);
1670  }
1671  put_bits(pb, 1, opt->extended_bsi_2);
1672  if (opt->extended_bsi_2) {
1673  put_bits(pb, 2, opt->dolby_surround_ex_mode);
1674  put_bits(pb, 2, opt->dolby_headphone_mode);
1675  put_bits(pb, 1, opt->ad_converter_type);
1676  put_bits(pb, 9, 0); /* xbsi2 and encinfo : reserved */
1677  }
1678  } else {
1679  put_bits(pb, 1, 0); /* no time code 1 */
1680  put_bits(pb, 1, 0); /* no time code 2 */
1681  }
1682  put_bits(pb, 1, 0); /* no additional bit stream info */
1683 }
1684 
1685 
1686 /*
1687  * Write one audio block to the output bitstream.
1688  */
1689 static void output_audio_block(AC3EncodeContext *s, PutBitContext *pb, int blk)
1690 {
1691  int ch, i, baie, bnd, got_cpl, av_uninit(ch0);
1692  AC3Block *block = &s->blocks[blk];
1693 
1694  /* block switching */
1695  if (!s->eac3) {
1696  for (ch = 0; ch < s->fbw_channels; ch++)
1697  put_bits(pb, 1, 0);
1698  }
1699 
1700  /* dither flags */
1701  if (!s->eac3) {
1702  for (ch = 0; ch < s->fbw_channels; ch++)
1703  put_bits(pb, 1, 1);
1704  }
1705 
1706  /* dynamic range codes */
1707  put_bits(pb, 1, 0);
1708 
1709  /* spectral extension */
1710  if (s->eac3)
1711  put_bits(pb, 1, 0);
1712 
1713  /* channel coupling */
1714  if (!s->eac3)
1715  put_bits(pb, 1, block->new_cpl_strategy);
1716  if (block->new_cpl_strategy) {
1717  if (!s->eac3)
1718  put_bits(pb, 1, block->cpl_in_use);
1719  if (block->cpl_in_use) {
1720  int start_sub, end_sub;
1721  if (s->eac3)
1722  put_bits(pb, 1, 0); /* enhanced coupling */
1723  if (!s->eac3 || s->channel_mode != AC3_CHMODE_STEREO) {
1724  for (ch = 1; ch <= s->fbw_channels; ch++)
1725  put_bits(pb, 1, block->channel_in_cpl[ch]);
1726  }
1727  if (s->channel_mode == AC3_CHMODE_STEREO)
1728  put_bits(pb, 1, 0); /* phase flags in use */
1729  start_sub = (s->start_freq[CPL_CH] - 37) / 12;
1730  end_sub = (s->cpl_end_freq - 37) / 12;
1731  put_bits(pb, 4, start_sub);
1732  put_bits(pb, 4, end_sub - 3);
1733  /* coupling band structure */
1734  if (s->eac3) {
1735  put_bits(pb, 1, 0); /* use default */
1736  } else {
1737  for (bnd = start_sub+1; bnd < end_sub; bnd++)
1738  put_bits(pb, 1, ff_eac3_default_cpl_band_struct[bnd]);
1739  }
1740  }
1741  }
1742 
1743  /* coupling coordinates */
1744  if (block->cpl_in_use) {
1745  for (ch = 1; ch <= s->fbw_channels; ch++) {
1746  if (block->channel_in_cpl[ch]) {
1747  if (!s->eac3 || block->new_cpl_coords[ch] != 2)
1748  put_bits(pb, 1, block->new_cpl_coords[ch]);
1749  if (block->new_cpl_coords[ch]) {
1750  put_bits(pb, 2, block->cpl_master_exp[ch]);
1751  for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {
1752  put_bits(pb, 4, block->cpl_coord_exp [ch][bnd]);
1753  put_bits(pb, 4, block->cpl_coord_mant[ch][bnd]);
1754  }
1755  }
1756  }
1757  }
1758  }
1759 
1760  /* stereo rematrixing */
1761  if (s->channel_mode == AC3_CHMODE_STEREO) {
1762  if (!s->eac3 || blk > 0)
1763  put_bits(pb, 1, block->new_rematrixing_strategy);
1764  if (block->new_rematrixing_strategy) {
1765  /* rematrixing flags */
1766  for (bnd = 0; bnd < block->num_rematrixing_bands; bnd++)
1767  put_bits(pb, 1, block->rematrixing_flags[bnd]);
1768  }
1769  }
1770 
1771  /* exponent strategy */
1772  if (!s->eac3) {
1773  for (ch = !block->cpl_in_use; ch <= s->fbw_channels; ch++)
1774  put_bits(pb, 2, s->exp_strategy[ch][blk]);
1775  if (s->lfe_on)
1776  put_bits(pb, 1, s->exp_strategy[s->lfe_channel][blk]);
1777  }
1778 
1779  /* bandwidth */
1780  for (ch = 1; ch <= s->fbw_channels; ch++) {
1781  if (s->exp_strategy[ch][blk] != EXP_REUSE && !block->channel_in_cpl[ch])
1782  put_bits(pb, 6, s->bandwidth_code);
1783  }
1784 
1785  /* exponents */
1786  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1787  int nb_groups;
1788  int cpl = (ch == CPL_CH);
1789 
1790  if (s->exp_strategy[ch][blk] == EXP_REUSE)
1791  continue;
1792 
1793  /* DC exponent */
1794  put_bits(pb, 4, block->grouped_exp[ch][0] >> cpl);
1795 
1796  /* exponent groups */
1797  nb_groups = exponent_group_tab[cpl][s->exp_strategy[ch][blk]-1][block->end_freq[ch]-s->start_freq[ch]];
1798  for (i = 1; i <= nb_groups; i++)
1799  put_bits(pb, 7, block->grouped_exp[ch][i]);
1800 
1801  /* gain range info */
1802  if (ch != s->lfe_channel && !cpl)
1803  put_bits(pb, 2, 0);
1804  }
1805 
1806  /* bit allocation info */
1807  if (!s->eac3) {
1808  baie = (blk == 0);
1809  put_bits(pb, 1, baie);
1810  if (baie) {
1811  put_bits(pb, 2, s->slow_decay_code);
1812  put_bits(pb, 2, s->fast_decay_code);
1813  put_bits(pb, 2, s->slow_gain_code);
1814  put_bits(pb, 2, s->db_per_bit_code);
1815  put_bits(pb, 3, s->floor_code);
1816  }
1817  }
1818 
1819  /* snr offset */
1820  if (!s->eac3) {
1821  put_bits(pb, 1, block->new_snr_offsets);
1822  if (block->new_snr_offsets) {
1823  put_bits(pb, 6, s->coarse_snr_offset);
1824  for (ch = !block->cpl_in_use; ch <= s->channels; ch++) {
1825  put_bits(pb, 4, s->fine_snr_offset[ch]);
1826  put_bits(pb, 3, s->fast_gain_code[ch]);
1827  }
1828  }
1829  } else {
1830  put_bits(pb, 1, 0); /* no converter snr offset */
1831  }
1832 
1833  /* coupling leak */
1834  if (block->cpl_in_use) {
1835  if (!s->eac3 || block->new_cpl_leak != 2)
1836  put_bits(pb, 1, block->new_cpl_leak);
1837  if (block->new_cpl_leak) {
1838  put_bits(pb, 3, s->bit_alloc.cpl_fast_leak);
1839  put_bits(pb, 3, s->bit_alloc.cpl_slow_leak);
1840  }
1841  }
1842 
1843  if (!s->eac3) {
1844  put_bits(pb, 1, 0); /* no delta bit allocation */
1845  put_bits(pb, 1, 0); /* no data to skip */
1846  }
1847 
1848  /* mantissas */
1849  got_cpl = !block->cpl_in_use;
1850  for (ch = 1; ch <= s->channels; ch++) {
1851  int b, q;
1852 
1853  if (!got_cpl && ch > 1 && block->channel_in_cpl[ch-1]) {
1854  ch0 = ch - 1;
1855  ch = CPL_CH;
1856  got_cpl = 1;
1857  }
1858  for (i = s->start_freq[ch]; i < block->end_freq[ch]; i++) {
1859  q = block->qmant[ch][i];
1860  b = s->ref_bap[ch][blk][i];
1861  switch (b) {
1862  case 0: break;
1863  case 1: if (q != 128) put_bits (pb, 5, q); break;
1864  case 2: if (q != 128) put_bits (pb, 7, q); break;
1865  case 3: put_sbits(pb, 3, q); break;
1866  case 4: if (q != 128) put_bits (pb, 7, q); break;
1867  case 14: put_sbits(pb, 14, q); break;
1868  case 15: put_sbits(pb, 16, q); break;
1869  default: put_sbits(pb, b-1, q); break;
1870  }
1871  }
1872  if (ch == CPL_CH)
1873  ch = ch0;
1874  }
1875 }
1876 
1877 
1878 /** CRC-16 Polynomial */
1879 #define CRC16_POLY ((1 << 0) | (1 << 2) | (1 << 15) | (1 << 16))
1880 
1881 
1882 static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
1883 {
1884  unsigned int c;
1885 
1886  c = 0;
1887  while (a) {
1888  if (a & 1)
1889  c ^= b;
1890  a = a >> 1;
1891  b = b << 1;
1892  if (b & (1 << 16))
1893  b ^= poly;
1894  }
1895  return c;
1896 }
1897 
1898 
1899 static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
1900 {
1901  unsigned int r;
1902  r = 1;
1903  while (n) {
1904  if (n & 1)
1905  r = mul_poly(r, a, poly);
1906  a = mul_poly(a, a, poly);
1907  n >>= 1;
1908  }
1909  return r;
1910 }
1911 
1912 
1913 /*
1914  * Fill the end of the frame with 0's and compute the two CRCs.
1915  */
1916 static void output_frame_end(AC3EncodeContext *s, PutBitContext *pb)
1917 {
1918  const AVCRC *crc_ctx = av_crc_get_table(AV_CRC_16_ANSI);
1919  int frame_size_58, pad_bytes, crc1, crc2, crc_inv;
1920  uint8_t *frame;
1921 
1922  frame_size_58 = ((s->frame_size >> 2) + (s->frame_size >> 4)) << 1;
1923 
1924  /* pad the remainder of the frame with zeros */
1925  av_assert2(s->frame_size * 8 - put_bits_count(pb) >= 18);
1926  flush_put_bits(pb);
1927  frame = pb->buf;
1928  pad_bytes = s->frame_size - (put_bits_ptr(pb) - frame) - 2;
1929  av_assert2(pad_bytes >= 0);
1930  if (pad_bytes > 0)
1931  memset(put_bits_ptr(pb), 0, pad_bytes);
1932 
1933  if (s->eac3) {
1934  /* compute crc2 */
1935  crc2 = av_crc(crc_ctx, 0, frame + 2, s->frame_size - 4);
1936  } else {
1937  /* compute crc1 */
1938  /* this is not so easy because it is at the beginning of the data... */
1939  crc1 = av_bswap16(av_crc(crc_ctx, 0, frame + 4, frame_size_58 - 4));
1940  crc_inv = s->crc_inv[s->frame_size > s->frame_size_min];
1941  crc1 = mul_poly(crc_inv, crc1, CRC16_POLY);
1942  AV_WB16(frame + 2, crc1);
1943 
1944  /* compute crc2 */
1945  crc2 = av_crc(crc_ctx, 0, frame + frame_size_58,
1946  s->frame_size - frame_size_58 - 2);
1947  }
1948  crc2 = av_bswap16(crc2);
1949  /* ensure crc2 does not match sync word by flipping crcrsv bit if needed */
1950  if (crc2 == 0x0B77) {
1951  /* The CRC generator polynomial is x^16 + x^15 + x^2 + 1,
1952  * so xor'ing with 0x18005 does not affect the CRC. */
1953  frame[s->frame_size - 3] ^= 0x1;
1954  crc2 ^= 0x8005;
1955  }
1956  AV_WB16(frame + s->frame_size - 2, crc2);
1957 }
1958 
1959 
1960 /**
1961  * Write the frame to the output bitstream.
1962  *
1963  * @param s AC-3 encoder private context
1964  * @param frame output data buffer
1965  */
1966 static void ac3_output_frame(AC3EncodeContext *s, unsigned char *frame)
1967 {
1968  PutBitContext pb;
1969  int blk;
1970 
1971  init_put_bits(&pb, frame, s->frame_size);
1972 
1973  s->output_frame_header(s, &pb);
1974 
1975  for (blk = 0; blk < s->num_blocks; blk++)
1976  output_audio_block(s, &pb, blk);
1977 
1978  output_frame_end(s, &pb);
1979 }
1980 
1981 int ff_ac3_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
1982  const AVFrame *frame, int *got_packet_ptr)
1983 {
1984  AC3EncodeContext *const s = avctx->priv_data;
1985  int ret;
1986 
1987  if (s->options.allow_per_frame_metadata) {
1988  ret = ac3_validate_metadata(s);
1989  if (ret)
1990  return ret;
1991  }
1992 
1993  if (s->bit_alloc.sr_code == 1 || s->eac3)
1994  ac3_adjust_frame_size(s);
1995 
1996  s->encode_frame(s, frame->extended_data);
1997 
1998  ac3_apply_rematrixing(s);
1999 
2000  ac3_process_exponents(s);
2001 
2002  ret = ac3_compute_bit_allocation(s);
2003  if (ret) {
2004  av_log(avctx, AV_LOG_ERROR, "Bit allocation failed. Try increasing the bitrate.\n");
2005  return ret;
2006  }
2007 
2008  ac3_group_exponents(s);
2009 
2010  ac3_quantize_mantissas(s);
2011 
2012  ret = ff_get_encode_buffer(avctx, avpkt, s->frame_size, 0);
2013  if (ret < 0)
2014  return ret;
2015  ac3_output_frame(s, avpkt->data);
2016 
2017  if (frame->pts != AV_NOPTS_VALUE)
2018  avpkt->pts = frame->pts - ff_samples_to_time_base(avctx, avctx->initial_padding);
2019 
2020  *got_packet_ptr = 1;
2021  return 0;
2022 }
2023 
2024 static void dprint_options(AC3EncodeContext *s)
2025 {
2026 #ifdef DEBUG
2027  AVCodecContext *avctx = s->avctx;
2028  AC3EncOptions *opt = &s->options;
2029  const char *msg;
2030  char strbuf[32];
2031 
2032  switch (s->bitstream_id) {
2033  case 6: msg = "AC-3 (alt syntax)"; break;
2034  case 8: msg = "AC-3 (standard)"; break;
2035  case 16: msg = "E-AC-3 (enhanced)"; break;
2036  default: msg = "ERROR";
2037  }
2038  ff_dlog(avctx, "bitstream_id: %s (%d)\n", msg, s->bitstream_id);
2039  ff_dlog(avctx, "sample_fmt: %s\n", av_get_sample_fmt_name(avctx->sample_fmt));
2040  av_channel_layout_describe(&avctx->ch_layout, strbuf, sizeof(strbuf));
2041  ff_dlog(avctx, "channel_layout: %s\n", strbuf);
2042  ff_dlog(avctx, "sample_rate: %d\n", s->sample_rate);
2043  ff_dlog(avctx, "bit_rate: %d\n", s->bit_rate);
2044  ff_dlog(avctx, "blocks/frame: %d (code=%d)\n", s->num_blocks, s->num_blks_code);
2045  if (s->cutoff)
2046  ff_dlog(avctx, "cutoff: %d\n", s->cutoff);
2047 
2048  ff_dlog(avctx, "per_frame_metadata: %s\n",
2049  opt->allow_per_frame_metadata?"on":"off");
2050  if (s->has_center)
2051  ff_dlog(avctx, "center_mixlev: %0.3f (%d)\n", opt->center_mix_level,
2052  s->center_mix_level);
2053  else
2054  ff_dlog(avctx, "center_mixlev: {not written}\n");
2055  if (s->has_surround)
2056  ff_dlog(avctx, "surround_mixlev: %0.3f (%d)\n", opt->surround_mix_level,
2057  s->surround_mix_level);
2058  else
2059  ff_dlog(avctx, "surround_mixlev: {not written}\n");
2060  if (opt->audio_production_info) {
2061  ff_dlog(avctx, "mixing_level: %ddB\n", opt->mixing_level);
2062  switch (opt->room_type) {
2063  case AC3ENC_OPT_NOT_INDICATED: msg = "notindicated"; break;
2064  case AC3ENC_OPT_LARGE_ROOM: msg = "large"; break;
2065  case AC3ENC_OPT_SMALL_ROOM: msg = "small"; break;
2066  default:
2067  snprintf(strbuf, sizeof(strbuf), "ERROR (%d)", opt->room_type);
2068  msg = strbuf;
2069  }
2070  ff_dlog(avctx, "room_type: %s\n", msg);
2071  } else {
2072  ff_dlog(avctx, "mixing_level: {not written}\n");
2073  ff_dlog(avctx, "room_type: {not written}\n");
2074  }
2075  ff_dlog(avctx, "copyright: %s\n", opt->copyright?"on":"off");
2076  ff_dlog(avctx, "dialnorm: %ddB\n", opt->dialogue_level);
2077  if (s->channel_mode == AC3_CHMODE_STEREO) {
2078  switch (opt->dolby_surround_mode) {
2079  case AC3ENC_OPT_NOT_INDICATED: msg = "notindicated"; break;
2080  case AC3ENC_OPT_MODE_ON: msg = "on"; break;
2081  case AC3ENC_OPT_MODE_OFF: msg = "off"; break;
2082  default:
2083  snprintf(strbuf, sizeof(strbuf), "ERROR (%d)", opt->dolby_surround_mode);
2084  msg = strbuf;
2085  }
2086  ff_dlog(avctx, "dsur_mode: %s\n", msg);
2087  } else {
2088  ff_dlog(avctx, "dsur_mode: {not written}\n");
2089  }
2090  ff_dlog(avctx, "original: %s\n", opt->original?"on":"off");
2091 
2092  if (s->bitstream_id == 6) {
2093  if (opt->extended_bsi_1) {
2094  switch (opt->preferred_stereo_downmix) {
2095  case AC3ENC_OPT_NOT_INDICATED: msg = "notindicated"; break;
2096  case AC3ENC_OPT_DOWNMIX_LTRT: msg = "ltrt"; break;
2097  case AC3ENC_OPT_DOWNMIX_LORO: msg = "loro"; break;
2098  default:
2099  snprintf(strbuf, sizeof(strbuf), "ERROR (%d)", opt->preferred_stereo_downmix);
2100  msg = strbuf;
2101  }
2102  ff_dlog(avctx, "dmix_mode: %s\n", msg);
2103  ff_dlog(avctx, "ltrt_cmixlev: %0.3f (%d)\n",
2104  opt->ltrt_center_mix_level, s->ltrt_center_mix_level);
2105  ff_dlog(avctx, "ltrt_surmixlev: %0.3f (%d)\n",
2106  opt->ltrt_surround_mix_level, s->ltrt_surround_mix_level);
2107  ff_dlog(avctx, "loro_cmixlev: %0.3f (%d)\n",
2108  opt->loro_center_mix_level, s->loro_center_mix_level);
2109  ff_dlog(avctx, "loro_surmixlev: %0.3f (%d)\n",
2110  opt->loro_surround_mix_level, s->loro_surround_mix_level);
2111  } else {
2112  ff_dlog(avctx, "extended bitstream info 1: {not written}\n");
2113  }
2114  if (opt->extended_bsi_2) {
2115  switch (opt->dolby_surround_ex_mode) {
2116  case AC3ENC_OPT_NOT_INDICATED: msg = "notindicated"; break;
2117  case AC3ENC_OPT_MODE_ON: msg = "on"; break;
2118  case AC3ENC_OPT_MODE_OFF: msg = "off"; break;
2119  default:
2120  snprintf(strbuf, sizeof(strbuf), "ERROR (%d)", opt->dolby_surround_ex_mode);
2121  msg = strbuf;
2122  }
2123  ff_dlog(avctx, "dsurex_mode: %s\n", msg);
2124  switch (opt->dolby_headphone_mode) {
2125  case AC3ENC_OPT_NOT_INDICATED: msg = "notindicated"; break;
2126  case AC3ENC_OPT_MODE_ON: msg = "on"; break;
2127  case AC3ENC_OPT_MODE_OFF: msg = "off"; break;
2128  default:
2129  snprintf(strbuf, sizeof(strbuf), "ERROR (%d)", opt->dolby_headphone_mode);
2130  msg = strbuf;
2131  }
2132  ff_dlog(avctx, "dheadphone_mode: %s\n", msg);
2133 
2134  switch (opt->ad_converter_type) {
2135  case AC3ENC_OPT_ADCONV_STANDARD: msg = "standard"; break;
2136  case AC3ENC_OPT_ADCONV_HDCD: msg = "hdcd"; break;
2137  default:
2138  snprintf(strbuf, sizeof(strbuf), "ERROR (%d)", opt->ad_converter_type);
2139  msg = strbuf;
2140  }
2141  ff_dlog(avctx, "ad_conv_type: %s\n", msg);
2142  } else {
2143  ff_dlog(avctx, "extended bitstream info 2: {not written}\n");
2144  }
2145  }
2146 #endif
2147 }
2148 
2149 /**
2150  * Finalize encoding and free any memory allocated by the encoder.
2151  *
2152  * @param avctx Codec context
2153  */
2154 av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
2155 {
2156  AC3EncodeContext *s = avctx->priv_data;
2157 
2158  for (int ch = 0; ch < s->channels; ch++)
2159  av_freep(&s->planar_samples[ch]);
2160  av_freep(&s->bap_buffer);
2161  av_freep(&s->bap1_buffer);
2162  av_freep(&s->mdct_coef_buffer);
2163  av_freep(&s->fixed_coef_buffer);
2164  av_freep(&s->exp_buffer);
2165  av_freep(&s->grouped_exp_buffer);
2166  av_freep(&s->psd_buffer);
2167  av_freep(&s->band_psd_buffer);
2168  av_freep(&s->mask_buffer);
2169  av_freep(&s->qmant_buffer);
2170  av_freep(&s->cpl_coord_buffer);
2171  av_freep(&s->fdsp);
2172 
2173  av_tx_uninit(&s->tx);
2174 
2175  return 0;
2176 }
2177 
2178 
2179 /*
2180  * Set channel information during initialization.
2181  */
2182 static av_cold void set_channel_info(AVCodecContext *avctx)
2183 {
2184  AC3EncodeContext *s = avctx->priv_data;
2185  uint64_t mask = av_channel_layout_subset(&avctx->ch_layout, ~(uint64_t)0);
2186  int channels = avctx->ch_layout.nb_channels;
2187 
2188  s->lfe_on = !!(mask & AV_CH_LOW_FREQUENCY);
2189  s->channels = channels;
2190  s->fbw_channels = channels - s->lfe_on;
2191  s->lfe_channel = s->lfe_on ? s->fbw_channels + 1 : -1;
2192 
2193  switch (mask & ~AV_CH_LOW_FREQUENCY) {
2194  case AV_CH_LAYOUT_MONO: s->channel_mode = AC3_CHMODE_MONO; break;
2195  case AV_CH_LAYOUT_STEREO: s->channel_mode = AC3_CHMODE_STEREO; break;
2196  case AV_CH_LAYOUT_SURROUND: s->channel_mode = AC3_CHMODE_3F; break;
2197  case AV_CH_LAYOUT_2_1: s->channel_mode = AC3_CHMODE_2F1R; break;
2198  case AV_CH_LAYOUT_4POINT0: s->channel_mode = AC3_CHMODE_3F1R; break;
2199  case AV_CH_LAYOUT_QUAD:
2200  case AV_CH_LAYOUT_2_2: s->channel_mode = AC3_CHMODE_2F2R; break;
2201  case AV_CH_LAYOUT_5POINT0:
2202  case AV_CH_LAYOUT_5POINT0_BACK: s->channel_mode = AC3_CHMODE_3F2R; break;
2203  }
2204  s->has_center = (s->channel_mode & 0x01) && s->channel_mode != AC3_CHMODE_MONO;
2205  s->has_surround = s->channel_mode & 0x04;
2206 
2207  s->channel_map = ac3_enc_channel_map[s->channel_mode][s->lfe_on];
2208 }
2209 
2210 
2211 static av_cold int validate_options(AC3EncodeContext *s)
2212 {
2213  AVCodecContext *avctx = s->avctx;
2214  int ret;
2215 
2216  set_channel_info(avctx);
2217 
2218  for (int i = 0;; i++) {
2219  if (ff_ac3_sample_rate_tab[i] == avctx->sample_rate) {
2220  s->bit_alloc.sr_code = i;
2221  break;
2222  }
2223  av_assert1(ff_ac3_sample_rate_tab[i] != 0);
2224  }
2225  s->sample_rate = avctx->sample_rate;
2226  s->bitstream_id = s->eac3 ? 16 : 8;
2227 
2228  /* select a default bit rate if not set by the user */
2229  if (!avctx->bit_rate) {
2230  switch (s->fbw_channels) {
2231  case 1: avctx->bit_rate = 96000; break;
2232  case 2: avctx->bit_rate = 192000; break;
2233  case 3: avctx->bit_rate = 320000; break;
2234  case 4: avctx->bit_rate = 384000; break;
2235  case 5: avctx->bit_rate = 448000; break;
2236  }
2237  }
2238 
2239  /* validate bit rate */
2240  if (s->eac3) {
2241  int max_br, min_br, wpf, min_br_code;
2242  int num_blks_code, num_blocks, frame_samples;
2243  long long min_br_dist;
2244 
2245  /* calculate min/max bitrate */
2246  /* TODO: More testing with 3 and 2 blocks. All E-AC-3 samples I've
2247  found use either 6 blocks or 1 block, even though 2 or 3 blocks
2248  would work as far as the bit rate is concerned. */
2249  for (num_blks_code = 3; num_blks_code >= 0; num_blks_code--) {
2250  num_blocks = ((int[]){ 1, 2, 3, 6 })[num_blks_code];
2251  frame_samples = AC3_BLOCK_SIZE * num_blocks;
2252  max_br = 2048 * s->sample_rate / frame_samples * 16;
2253  min_br = ((s->sample_rate + (frame_samples-1)) / frame_samples) * 16;
2254  if (avctx->bit_rate <= max_br)
2255  break;
2256  }
2257  if (avctx->bit_rate < min_br || avctx->bit_rate > max_br) {
2258  av_log(avctx, AV_LOG_ERROR, "invalid bit rate. must be %d to %d "
2259  "for this sample rate\n", min_br, max_br);
2260  return AVERROR(EINVAL);
2261  }
2262  s->num_blks_code = num_blks_code;
2263  s->num_blocks = num_blocks;
2264 
2265  /* calculate words-per-frame for the selected bitrate */
2266  wpf = (avctx->bit_rate / 16) * frame_samples / s->sample_rate;
2267  av_assert1(wpf > 0 && wpf <= 2048);
2268 
2269  /* find the closest AC-3 bitrate code to the selected bitrate.
2270  this is needed for lookup tables for bandwidth and coupling
2271  parameter selection */
2272  min_br_code = -1;
2273  min_br_dist = INT64_MAX;
2274  for (int i = 0; i < 19; i++) {
2275  long long br_dist = llabs(ff_ac3_bitrate_tab[i] * 1000 - avctx->bit_rate);
2276  if (br_dist < min_br_dist) {
2277  min_br_dist = br_dist;
2278  min_br_code = i;
2279  }
2280  }
2281 
2282  /* make sure the minimum frame size is below the average frame size */
2283  s->frame_size_code = min_br_code << 1;
2284  while (wpf > 1 && wpf * s->sample_rate / AC3_FRAME_SIZE * 16 > avctx->bit_rate)
2285  wpf--;
2286  s->frame_size_min = 2 * wpf;
2287  } else {
2288  int best_br = 0, best_code = 0;
2289  long long best_diff = INT64_MAX;
2290  for (int i = 0; i < 19; i++) {
2291  int br = ff_ac3_bitrate_tab[i] * 1000;
2292  long long diff = llabs(br - avctx->bit_rate);
2293  if (diff < best_diff) {
2294  best_br = br;
2295  best_code = i;
2296  best_diff = diff;
2297  }
2298  if (!best_diff)
2299  break;
2300  }
2301  avctx->bit_rate = best_br;
2302  s->frame_size_code = best_code << 1;
2303  s->frame_size_min = 2 * ff_ac3_frame_size_tab[s->frame_size_code][s->bit_alloc.sr_code];
2304  s->num_blks_code = 0x3;
2305  s->num_blocks = 6;
2306  }
2307  s->bit_rate = avctx->bit_rate;
2308  s->frame_size = s->frame_size_min;
2309 
2310  /* validate cutoff */
2311  if (avctx->cutoff < 0) {
2312  av_log(avctx, AV_LOG_ERROR, "invalid cutoff frequency\n");
2313  return AVERROR(EINVAL);
2314  }
2315  s->cutoff = avctx->cutoff;
2316  if (s->cutoff > (s->sample_rate >> 1))
2317  s->cutoff = s->sample_rate >> 1;
2318 
2319  ret = ac3_validate_metadata(s);
2320  if (ret)
2321  return ret;
2322 
2323  s->rematrixing_enabled = s->options.stereo_rematrixing &&
2324  (s->channel_mode == AC3_CHMODE_STEREO);
2325 
2326  s->cpl_enabled = s->options.channel_coupling &&
2327  s->channel_mode >= AC3_CHMODE_STEREO;
2328 
2329  return 0;
2330 }
2331 
2332 
2333 /*
2334  * Set bandwidth for all channels.
2335  * The user can optionally supply a cutoff frequency. Otherwise an appropriate
2336  * default value will be used.
2337  */
2338 static av_cold void set_bandwidth(AC3EncodeContext *s)
2339 {
2340  int blk, ch, av_uninit(cpl_start);
2341 
2342  if (s->cutoff) {
2343  /* calculate bandwidth based on user-specified cutoff frequency */
2344  int fbw_coeffs;
2345  fbw_coeffs = s->cutoff * 2 * AC3_MAX_COEFS / s->sample_rate;
2346  s->bandwidth_code = av_clip((fbw_coeffs - 73) / 3, 0, 60);
2347  } else {
2348  /* use default bandwidth setting */
2349  s->bandwidth_code = ac3_bandwidth_tab[s->fbw_channels-1][s->bit_alloc.sr_code][s->frame_size_code/2];
2350  }
2351 
2352  /* set number of coefficients for each channel */
2353  for (ch = 1; ch <= s->fbw_channels; ch++) {
2354  s->start_freq[ch] = 0;
2355  for (blk = 0; blk < s->num_blocks; blk++)
2356  s->blocks[blk].end_freq[ch] = s->bandwidth_code * 3 + 73;
2357  }
2358  /* LFE channel always has 7 coefs */
2359  if (s->lfe_on) {
2360  s->start_freq[s->lfe_channel] = 0;
2361  for (blk = 0; blk < s->num_blocks; blk++)
2362  s->blocks[blk].end_freq[ch] = 7;
2363  }
2364 
2365  /* initialize coupling strategy */
2366  if (s->cpl_enabled) {
2367  if (s->options.cpl_start != AC3ENC_OPT_AUTO) {
2368  cpl_start = s->options.cpl_start;
2369  } else {
2370  cpl_start = ac3_coupling_start_tab[s->channel_mode-2][s->bit_alloc.sr_code][s->frame_size_code/2];
2371  if (cpl_start < 0) {
2372  if (s->options.channel_coupling == AC3ENC_OPT_AUTO)
2373  s->cpl_enabled = 0;
2374  else
2375  cpl_start = 15;
2376  }
2377  }
2378  }
2379  if (s->cpl_enabled) {
2380  int i, cpl_start_band, cpl_end_band;
2381  uint8_t *cpl_band_sizes = s->cpl_band_sizes;
2382 
2383  cpl_end_band = s->bandwidth_code / 4 + 3;
2384  cpl_start_band = av_clip(cpl_start, 0, FFMIN(cpl_end_band-1, 15));
2385 
2386  s->num_cpl_subbands = cpl_end_band - cpl_start_band;
2387 
2388  s->num_cpl_bands = 1;
2389  *cpl_band_sizes = 12;
2390  for (i = cpl_start_band + 1; i < cpl_end_band; i++) {
2391  if (ff_eac3_default_cpl_band_struct[i]) {
2392  *cpl_band_sizes += 12;
2393  } else {
2394  s->num_cpl_bands++;
2395  cpl_band_sizes++;
2396  *cpl_band_sizes = 12;
2397  }
2398  }
2399 
2400  s->start_freq[CPL_CH] = cpl_start_band * 12 + 37;
2401  s->cpl_end_freq = cpl_end_band * 12 + 37;
2402  for (blk = 0; blk < s->num_blocks; blk++)
2403  s->blocks[blk].end_freq[CPL_CH] = s->cpl_end_freq;
2404  }
2405 }
2406 
2407 
2408 static av_cold int allocate_buffers(AC3EncodeContext *s)
2409 {
2410  int blk, ch;
2411  int channels = s->channels + 1; /* includes coupling channel */
2412  int channel_blocks = channels * s->num_blocks;
2413  int total_coefs = AC3_MAX_COEFS * channel_blocks;
2414  uint8_t *cpl_coord_mant_buffer;
2415  const unsigned sampletype_size = SAMPLETYPE_SIZE(s);
2416 
2417  for (int ch = 0; ch < s->channels; ch++) {
2418  s->planar_samples[ch] = av_mallocz(AC3_BLOCK_SIZE * sampletype_size);
2419  if (!s->planar_samples[ch])
2420  return AVERROR(ENOMEM);
2421  }
2422 
2423  if (!FF_ALLOC_TYPED_ARRAY(s->bap_buffer, total_coefs) ||
2424  !FF_ALLOC_TYPED_ARRAY(s->bap1_buffer, total_coefs) ||
2425  !FF_ALLOCZ_TYPED_ARRAY(s->mdct_coef_buffer, total_coefs) ||
2426  !FF_ALLOC_TYPED_ARRAY(s->exp_buffer, total_coefs) ||
2427  !FF_ALLOC_TYPED_ARRAY(s->grouped_exp_buffer, channel_blocks * 128) ||
2428  !FF_ALLOC_TYPED_ARRAY(s->psd_buffer, total_coefs) ||
2429  !FF_ALLOC_TYPED_ARRAY(s->band_psd_buffer, channel_blocks * 64) ||
2430  !FF_ALLOC_TYPED_ARRAY(s->mask_buffer, channel_blocks * 64) ||
2431  !FF_ALLOC_TYPED_ARRAY(s->qmant_buffer, total_coefs))
2432  return AVERROR(ENOMEM);
2433 
2434  if (!s->fixed_point) {
2435  if (!FF_ALLOCZ_TYPED_ARRAY(s->fixed_coef_buffer, total_coefs))
2436  return AVERROR(ENOMEM);
2437  }
2438  if (s->cpl_enabled) {
2439  if (!FF_ALLOC_TYPED_ARRAY(s->cpl_coord_buffer, channel_blocks * 32))
2440  return AVERROR(ENOMEM);
2441  cpl_coord_mant_buffer = s->cpl_coord_buffer + 16 * channel_blocks;
2442  }
2443  for (blk = 0; blk < s->num_blocks; blk++) {
2444  AC3Block *block = &s->blocks[blk];
2445 
2446  for (ch = 0; ch < channels; ch++) {
2447  /* arrangement: block, channel, coeff */
2448  block->grouped_exp[ch] = &s->grouped_exp_buffer[128 * (blk * channels + ch)];
2449  block->psd[ch] = &s->psd_buffer [AC3_MAX_COEFS * (blk * channels + ch)];
2450  block->band_psd[ch] = &s->band_psd_buffer [64 * (blk * channels + ch)];
2451  block->mask[ch] = &s->mask_buffer [64 * (blk * channels + ch)];
2452  block->qmant[ch] = &s->qmant_buffer [AC3_MAX_COEFS * (blk * channels + ch)];
2453  if (s->cpl_enabled) {
2454  block->cpl_coord_exp[ch] = &s->cpl_coord_buffer [16 * (blk * channels + ch)];
2455  block->cpl_coord_mant[ch] = &cpl_coord_mant_buffer[16 * (blk * channels + ch)];
2456  }
2457 
2458  /* arrangement: channel, block, coeff */
2459  block->exp[ch] = &s->exp_buffer [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2460  block->mdct_coef[ch] = &s->mdct_coef_buffer [AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2461  if (s->fixed_point)
2462  block->fixed_coef[ch] = (int32_t *)block->mdct_coef[ch];
2463  else
2464  block->fixed_coef[ch] = &s->fixed_coef_buffer[AC3_MAX_COEFS * (s->num_blocks * ch + blk)];
2465  }
2466  }
2467 
2468  return 0;
2469 }
2470 
2471 
2472 av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
2473 {
2474  static AVOnce init_static_once = AV_ONCE_INIT;
2475  AC3EncodeContext *s = avctx->priv_data;
2476  int ret, frame_size_58;
2477 
2478  s->avctx = avctx;
2479 
2480  ret = validate_options(s);
2481  if (ret)
2482  return ret;
2483 
2484  avctx->frame_size = AC3_BLOCK_SIZE * s->num_blocks;
2485  avctx->initial_padding = AC3_BLOCK_SIZE;
2486 
2487  s->bitstream_mode = avctx->audio_service_type;
2488  if (s->bitstream_mode == AV_AUDIO_SERVICE_TYPE_KARAOKE)
2489  s->bitstream_mode = 0x7;
2490 
2491  s->bits_written = 0;
2492  s->samples_written = 0;
2493 
2494  /* calculate crc_inv for both possible frame sizes */
2495  frame_size_58 = (( s->frame_size >> 2) + ( s->frame_size >> 4)) << 1;
2496  s->crc_inv[0] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
2497  if (s->bit_alloc.sr_code == 1) {
2498  frame_size_58 = (((s->frame_size+2) >> 2) + ((s->frame_size+2) >> 4)) << 1;
2499  s->crc_inv[1] = pow_poly((CRC16_POLY >> 1), (8 * frame_size_58) - 16, CRC16_POLY);
2500  }
2501 
2502  if (!s->output_frame_header)
2503  s->output_frame_header = ac3_output_frame_header;
2504 
2505  set_bandwidth(s);
2506 
2507  bit_alloc_init(s);
2508 
2509  ret = allocate_buffers(s);
2510  if (ret)
2511  return ret;
2512 
2513  ff_audiodsp_init(&s->adsp);
2514  ff_me_cmp_init(&s->mecc, avctx);
2515  ff_ac3dsp_init(&s->ac3dsp);
2516 
2517  dprint_options(s);
2518 
2519  ff_thread_once(&init_static_once, exponent_init);
2520 
2521  return 0;
2522 }
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:78
frame_samples
static int frame_samples(const SyncQueue *sq, SyncQueueFrame frame)
Definition: sync_queue.c:131
flags
const SwsFlags flags[]
Definition: swscale.c:61
OFFSET
#define OFFSET(param)
Definition: ac3enc.c:78
extmixlev_options
#define extmixlev_options
Definition: ac3enc.c:73
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1051
AC3_CHMODE_3F
@ AC3_CHMODE_3F
Definition: ac3defs.h:71
nb_coefs
static int nb_coefs(int length, int level, uint64_t sn)
Definition: af_afwtdn.c:515
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
ff_ac3_fast_decay_tab
const uint8_t ff_ac3_fast_decay_tab[4]
Definition: ac3tab.c:131
EXP_D45
#define EXP_D45
Definition: ac3defs.h:56
AV_CH_LAYOUT_5POINT0_BACK
#define AV_CH_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:229
av_clip
#define av_clip
Definition: common.h:100
ac3_compute_bit_allocation
static int ac3_compute_bit_allocation(AC3EncodeContext *s)
Definition: ac3enc.c:1447
AC3EncOptions::mixing_level
int mixing_level
Definition: ac3enc.h:101
ac3_validate_metadata
static int ac3_validate_metadata(AC3EncodeContext *s)
Validate metadata options as set by AVOption system.
Definition: ac3enc.c:317
r
const char * r
Definition: vf_curves.c:127
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
opt.h
cmixlev_options
static const float cmixlev_options[CMIXLEV_NUM_OPTIONS]
Definition: ac3enc.c:63
AVCodecContext::audio_service_type
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1071
AC3EncOptions::dolby_headphone_mode
int dolby_headphone_mode
Definition: ac3enc.h:113
mem_internal.h
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:395
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1024
AVCRC
uint32_t AVCRC
Definition: crc.h:46
thread.h
LEVEL_MINUS_4POINT5DB
#define LEVEL_MINUS_4POINT5DB
Definition: ac3defs.h:44
ff_ac3_compute_coupling_strategy
void ff_ac3_compute_coupling_strategy(AC3EncodeContext *s)
Set the initial coupling strategy parameters prior to coupling analysis.
Definition: ac3enc.c:507
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:217
exp_strategy_reuse_tab
static const uint8_t exp_strategy_reuse_tab[4][6]
Table used to select exponent strategy based on exponent reuse block interval.
Definition: ac3enc.c:650
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:291
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
AV_CHANNEL_LAYOUT_2_2
#define AV_CHANNEL_LAYOUT_2_2
Definition: channel_layout.h:402
mask
int mask
Definition: mediacodecdec_common.c:154
COMMON_CHANNEL_MAP
#define COMMON_CHANNEL_MAP
Definition: ac3tab.h:53
AC3EncOptions::ltrt_surround_mix_level
float ltrt_surround_mix_level
Definition: ac3enc.h:108
AC3EncOptions::dialogue_level
int dialogue_level
Definition: ac3enc.h:95
surmixlev_options
static const float surmixlev_options[SURMIXLEV_NUM_OPTIONS]
Definition: ac3enc.c:68
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:427
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:154
AC3EncOptions::dolby_surround_mode
int dolby_surround_mode
Definition: ac3enc.h:99
AC3Mant::mant1_cnt
int mant1_cnt
Definition: ac3enc.c:59
count_mantissa_bits_init
static void count_mantissa_bits_init(uint16_t mant_cnt[AC3_MAX_BLOCKS][16])
Initialize mantissa counts.
Definition: ac3enc.c:1297
AVPacket::data
uint8_t * data
Definition: packet.h:588
AVOption
AVOption.
Definition: opt.h:429
encode.h
b
#define b
Definition: input.c:42
AV_AUDIO_SERVICE_TYPE_VOICE_OVER
@ AV_AUDIO_SERVICE_TYPE_VOICE_OVER
Definition: defs.h:243
ff_ac3_encode_frame
int ff_ac3_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Definition: ac3enc.c:1981
ff_audiodsp_init
av_cold void ff_audiodsp_init(AudioDSPContext *c)
Definition: audiodsp.c:65
AC3EncOptions::center_mix_level
float center_mix_level
Definition: ac3enc.h:97
ff_eac3_get_frame_exp_strategy
void ff_eac3_get_frame_exp_strategy(AC3EncodeContext *s)
Determine frame exponent strategy use and indices.
Definition: eac3enc.c:71
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
validate_mix_level
static void validate_mix_level(void *log_ctx, const char *opt_name, float *opt_param, const float *list, int list_size, int default_value, int min_value, int *ctx_param)
Definition: ac3enc.c:293
exponent_group_tab
static uint8_t exponent_group_tab[2][3][256]
LUT for number of exponent groups.
Definition: ac3enc.c:146
AC3Mant::mant2_cnt
int mant2_cnt
Definition: ac3enc.c:59
ac3_process_exponents
static void ac3_process_exponents(AC3EncodeContext *s)
Calculate final exponents from the supplied MDCT coefficients and exponent shift.
Definition: ac3enc.c:940
ff_ac3dsp_init
av_cold void ff_ac3dsp_init(AC3DSPContext *c)
Definition: ac3dsp.c:377
LEVEL_ZERO
#define LEVEL_ZERO
Definition: ac3defs.h:47
count_mantissa_bits
static int count_mantissa_bits(AC3EncodeContext *s)
Definition: ac3enc.c:1339
ff_ac3_enc_options
const AVOption ff_ac3_enc_options[]
Definition: ac3enc.c:80
crc.h
FFCodecDefault
Definition: codec_internal.h:96
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1039
AC3Mant::qmant4_ptr
int16_t * qmant4_ptr
mantissa pointers for bap=1,2,4
Definition: ac3enc.c:58
AVCodecContext::initial_padding
int initial_padding
Audio only.
Definition: avcodec.h:1096
AC3_CHMODE_3F1R
@ AC3_CHMODE_3F1R
Definition: ac3defs.h:73
ff_me_cmp_init
av_cold void ff_me_cmp_init(MECmpContext *c, AVCodecContext *avctx)
Definition: me_cmp.c:961
LEVEL_MINUS_3DB
#define LEVEL_MINUS_3DB
Definition: ac3defs.h:43
FF_ALLOC_TYPED_ARRAY
#define FF_ALLOC_TYPED_ARRAY(p, nelem)
Definition: internal.h:77
ff_ac3_bap_tab
const uint8_t ff_ac3_bap_tab[64]
Definition: ac3tab.c:117
EXP_REUSE
#define EXP_REUSE
Definition: ac3defs.h:51
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:218
AV_CHANNEL_LAYOUT_SURROUND
#define AV_CHANNEL_LAYOUT_SURROUND
Definition: channel_layout.h:398
ac3_quantize_mantissas
static void ac3_quantize_mantissas(AC3EncodeContext *s)
Quantize mantissas using coefficients, exponents, and bit allocation pointers.
Definition: ac3enc.c:1602
bit_alloc
static int bit_alloc(AC3EncodeContext *s, int snr_offset)
Run the bit allocation with a given SNR offset.
Definition: ac3enc.c:1365
AV_CH_LAYOUT_QUAD
#define AV_CH_LAYOUT_QUAD
Definition: channel_layout.h:226
set_bandwidth
static av_cold void set_bandwidth(AC3EncodeContext *s)
Definition: ac3enc.c:2338
ff_ac3_ch_layouts
const AVChannelLayout ff_ac3_ch_layouts[19]
List of supported channel layouts.
Definition: ac3enc.c:152
avassert.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AC3EncOptions::eac3_mixing_metadata
int eac3_mixing_metadata
Definition: ac3enc.h:115
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:106
AV_CH_LOW_FREQUENCY
#define AV_CH_LOW_FREQUENCY
Definition: channel_layout.h:178
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:653
AV_CHANNEL_LAYOUT_4POINT0
#define AV_CHANNEL_LAYOUT_4POINT0
Definition: channel_layout.h:400
EXP_NEW
#define EXP_NEW
Definition: ac3defs.h:52
ac3_apply_rematrixing
static void ac3_apply_rematrixing(AC3EncodeContext *s)
Apply stereo rematrixing to coefficients based on rematrixing flags.
Definition: ac3enc.c:578
s
#define s(width, name)
Definition: cbs_vp9.c:198
EXTMIXLEV_NUM_OPTIONS
#define EXTMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:72
set_channel_info
static av_cold void set_channel_info(AVCodecContext *avctx)
Definition: ac3enc.c:2182
validate_float_option
static int validate_float_option(float v, const float *v_list, int v_list_size)
Definition: ac3enc.c:277
AC3_MAX_COEFS
#define AC3_MAX_COEFS
Definition: ac3defs.h:29
quantize_mantissas_blk_ch
static void quantize_mantissas_blk_ch(AC3Mant *s, int32_t *fixed_coef, uint8_t *exp, uint8_t *bap, int16_t *qmant, int start_freq, int end_freq)
Quantize a set of mantissas for a single channel in a single block.
Definition: ac3enc.c:1507
AV_CHANNEL_LAYOUT_5POINT0_BACK
#define AV_CHANNEL_LAYOUT_5POINT0_BACK
Definition: channel_layout.h:406
ff_ac3_floor_tab
const int16_t ff_ac3_floor_tab[8]
Definition: ac3tab.c:143
LOCAL_ALIGNED_16
#define LOCAL_ALIGNED_16(t, v,...)
Definition: mem_internal.h:130
encode_exponents_blk_ch
static void encode_exponents_blk_ch(uint8_t *exp, int nb_exps, int exp_strategy, int cpl)
Update the exponents so that they are the ones the decoder will decode.
Definition: ac3enc.c:727
ac3_group_exponents
static void ac3_group_exponents(AC3EncodeContext *s)
Group exponents.
Definition: ac3enc.c:882
channels
channels
Definition: aptx.h:31
AC3EncOptions::audio_production_info
int audio_production_info
Definition: ac3enc.h:100
blk
#define blk(i)
Definition: sha.c:186
av_get_sample_fmt_name
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:51
PutBitContext
Definition: put_bits.h:50
AV_CH_LAYOUT_2_1
#define AV_CH_LAYOUT_2_1
Definition: channel_layout.h:220
if
if(ret)
Definition: filter_design.txt:179
AV_CRC_16_ANSI
@ AV_CRC_16_ANSI
Definition: crc.h:50
SURMIXLEV_NUM_OPTIONS
#define SURMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:67
ac3defs.h
EXP_D15
#define EXP_D15
Definition: ac3defs.h:54
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
AC3EncOptions::ad_converter_type
int ad_converter_type
Definition: ac3enc.h:114
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:53
AC3ENC_OPT_AUTO
#define AC3ENC_OPT_AUTO
Definition: ac3enc.h:72
NULL
#define NULL
Definition: coverity.c:32
AC3_FRAME_SIZE
#define AC3_FRAME_SIZE
Definition: ac3defs.h:32
bits_left
#define bits_left
Definition: bitstream.h:116
ac3enc.h
extract_exponents
static void extract_exponents(AC3EncodeContext *s)
Definition: ac3enc.c:631
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:401
AC3ENC_OPT_DOWNMIX_DPLII
#define AC3ENC_OPT_DOWNMIX_DPLII
Definition: ac3enc.h:85
ff_samples_to_time_base
static av_always_inline int64_t ff_samples_to_time_base(const AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: encode.h:93
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:481
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:241
DBA_NONE
@ DBA_NONE
Definition: ac3defs.h:62
AC3ENC_OPT_NONE
#define AC3ENC_OPT_NONE
Definition: ac3enc.h:71
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
ac3dsp.h
count_frame_bits
static void count_frame_bits(AC3EncodeContext *s)
Definition: ac3enc.c:1099
AV_AUDIO_SERVICE_TYPE_EMERGENCY
@ AV_AUDIO_SERVICE_TYPE_EMERGENCY
Definition: defs.h:242
AC3EncodeContext
AC-3 encoder private context.
Definition: ac3enc.h:158
exp
int8_t exp
Definition: eval.c:73
AC3EncOptions::extended_bsi_1
int extended_bsi_1
Definition: ac3enc.h:105
AC3EncOptions::copyright
int copyright
Definition: ac3enc.h:103
AC3ENC_OPT_DOWNMIX_LORO
#define AC3ENC_OPT_DOWNMIX_LORO
Definition: ac3enc.h:84
AVOnce
#define AVOnce
Definition: thread.h:202
AC3Block
Data for a single audio block.
Definition: ac3enc.h:128
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
ac3_bandwidth_tab
static const uint8_t ac3_bandwidth_tab[5][3][19]
LUT to select the bandwidth code based on the bit rate, sample rate, and number of full-bandwidth cha...
Definition: ac3enc.c:207
pow_poly
static unsigned int pow_poly(unsigned int a, unsigned int n, unsigned int poly)
Definition: ac3enc.c:1899
AC3_CHMODE_STEREO
@ AC3_CHMODE_STEREO
Definition: ac3defs.h:70
AC3EncOptions::eac3_info_metadata
int eac3_info_metadata
Definition: ac3enc.h:116
AC3EncOptions::dolby_surround_ex_mode
int dolby_surround_ex_mode
Definition: ac3enc.h:112
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:319
codec_internal.h
AC3_BLOCK_SIZE
#define AC3_BLOCK_SIZE
Definition: ac3defs.h:30
ff_ac3_db_per_bit_tab
const uint16_t ff_ac3_db_per_bit_tab[4]
Definition: ac3tab.c:139
AC3ENC_OPT_ADCONV_HDCD
#define AC3ENC_OPT_ADCONV_HDCD
Definition: ac3enc.h:87
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1031
bit_alloc_masking
static void bit_alloc_masking(AC3EncodeContext *s)
Definition: ac3enc.c:1242
put_bits_assume_flushed
static void put_bits_assume_flushed(const PutBitContext *s)
Inform the compiler that a PutBitContext is flushed (i.e.
Definition: put_bits.h:82
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:247
AC3ENC_OPT_ON
#define AC3ENC_OPT_ON
Definition: ac3enc.h:74
AC3EncOptions::room_type
int room_type
Definition: ac3enc.h:102
EXP_DIFF_THRESHOLD
#define EXP_DIFF_THRESHOLD
Exponent Difference Threshold.
Definition: ac3enc.c:645
AC3EncOptions
Encoding Options used by AVOption.
Definition: ac3enc.h:93
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:166
AC3ENC_OPT_SMALL_ROOM
#define AC3ENC_OPT_SMALL_ROOM
Definition: ac3enc.h:82
ac3_output_frame
static void ac3_output_frame(AC3EncodeContext *s, unsigned char *frame)
Write the frame to the output bitstream.
Definition: ac3enc.c:1966
AC3ENC_OPT_ADCONV_STANDARD
#define AC3ENC_OPT_ADCONV_STANDARD
Definition: ac3enc.h:86
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
CMIXLEV_NUM_OPTIONS
#define CMIXLEV_NUM_OPTIONS
Definition: ac3enc.c:62
sym_quant
static int sym_quant(int c, int e, int levels)
Symmetric quantization on 'levels' levels.
Definition: ac3enc.c:1467
attributes.h
AV_CHANNEL_ORDER_NATIVE
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
Definition: channel_layout.h:125
ac3_coupling_start_tab
static const int8_t ac3_coupling_start_tab[6][3][19]
LUT to select the coupling start band based on the bit rate, sample rate, and number of full-bandwidt...
Definition: ac3enc.c:240
bit_alloc_init
static av_cold void bit_alloc_init(AC3EncodeContext *s)
Definition: ac3enc.c:1063
eac3enc.h
av_tx_uninit
av_cold void av_tx_uninit(AVTXContext **ctx)
Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.
Definition: tx.c:295
CRC16_POLY
#define CRC16_POLY
CRC-16 Polynomial.
Definition: ac3enc.c:1879
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition: opt.h:271
ff_ac3_rematrix_band_tab
const uint8_t ff_ac3_rematrix_band_tab[5]
Table of bin locations for rematrixing bands reference: Section 7.5.2 Rematrixing : Frequency Band De...
Definition: ac3tab.c:108
AV_CH_LAYOUT_5POINT0
#define AV_CH_LAYOUT_5POINT0
Definition: channel_layout.h:227
CPL_CH
#define CPL_CH
coupling channel index
Definition: ac3defs.h:27
AC3Mant::qmant2_ptr
int16_t * qmant2_ptr
Definition: ac3enc.c:58
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
ff_ac3_sample_rate_tab
const int ff_ac3_sample_rate_tab[]
Definition: ac3tab.c:96
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:581
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:90
AV_CHANNEL_LAYOUT_QUAD
#define AV_CHANNEL_LAYOUT_QUAD
Definition: channel_layout.h:403
internal.h
dprint_options
static void dprint_options(AC3EncodeContext *s)
Definition: ac3enc.c:2024
AC3ENC_OPT_OFF
#define AC3ENC_OPT_OFF
Definition: ac3enc.h:73
AVCodecContext::cutoff
int cutoff
Audio cutoff bandwidth (0 means "automatic")
Definition: avcodec.h:1064
count_frame_bits_fixed
static void count_frame_bits_fixed(AC3EncodeContext *s)
Definition: ac3enc.c:954
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
mul_poly
static unsigned int mul_poly(unsigned int a, unsigned int b, unsigned int poly)
Definition: ac3enc.c:1882
ff_ac3_slow_decay_tab
const uint8_t ff_ac3_slow_decay_tab[4]
Definition: ac3tab.c:127
output_frame_end
static void output_frame_end(AC3EncodeContext *s, PutBitContext *pb)
Definition: ac3enc.c:1916
AC3EncOptions::original
int original
Definition: ac3enc.h:104
AC3Mant::mant4_cnt
int mant4_cnt
mantissa counts for bap=1,2,4
Definition: ac3enc.c:59
compute_exp_strategy
static void compute_exp_strategy(AC3EncodeContext *s)
Definition: ac3enc.c:661
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AC3_MAX_BLOCKS
#define AC3_MAX_BLOCKS
Definition: ac3defs.h:31
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AC3Mant
Definition: ac3enc.c:57
AC3ENC_PARAM
#define AC3ENC_PARAM
Definition: ac3enc.c:79
ff_ac3_frame_size_tab
const uint16_t ff_ac3_frame_size_tab[38][3]
Possible frame sizes.
Definition: ac3tab.c:36
AC3ENC_OPT_MODE_OFF
#define AC3ENC_OPT_MODE_OFF
Definition: ac3enc.h:77
AC3_CHMODE_MONO
@ AC3_CHMODE_MONO
Definition: ac3defs.h:69
avcodec.h
AC3_CHMODE_3F2R
@ AC3_CHMODE_3F2R
Definition: ac3defs.h:75
AC3_CHMODE_2F1R
@ AC3_CHMODE_2F1R
Definition: ac3defs.h:72
av_uninit
#define av_uninit(x)
Definition: attributes.h:174
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:81
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
AV_CH_LAYOUT_SURROUND
#define AV_CH_LAYOUT_SURROUND
Definition: channel_layout.h:221
AC3EncOptions::loro_surround_mix_level
float loro_surround_mix_level
Definition: ac3enc.h:110
AC3ENC_OPT_LARGE_ROOM
#define AC3ENC_OPT_LARGE_ROOM
Definition: ac3enc.h:81
AC3_CHMODE_2F2R
@ AC3_CHMODE_2F2R
Definition: ac3defs.h:74
output_audio_block
static void output_audio_block(AC3EncodeContext *s, PutBitContext *pb, int blk)
Definition: ac3enc.c:1689
AV_AUDIO_SERVICE_TYPE_KARAOKE
@ AV_AUDIO_SERVICE_TYPE_KARAOKE
Definition: defs.h:244
AC3EncOptions::ltrt_center_mix_level
float ltrt_center_mix_level
Definition: ac3enc.h:107
me_cmp.h
SAMPLETYPE_SIZE
#define SAMPLETYPE_SIZE(ctx)
Definition: ac3enc.c:54
AC3EncOptions::preferred_stereo_downmix
int preferred_stereo_downmix
Definition: ac3enc.h:106
AV_CHANNEL_LAYOUT_2_1
#define AV_CHANNEL_LAYOUT_2_1
Definition: channel_layout.h:397
ac3_adjust_frame_size
static void ac3_adjust_frame_size(AC3EncodeContext *s)
Adjust the frame size to make the average bit rate match the target bit rate.
Definition: ac3enc.c:490
AVCodecContext
main external API structure.
Definition: avcodec.h:431
AC3EncOptions::allow_per_frame_metadata
int allow_per_frame_metadata
Definition: ac3enc.h:119
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:402
channel_layout.h
asym_quant
static int asym_quant(int c, int e, int qbits)
Asymmetric quantization on 2^qbits levels.
Definition: ac3enc.c:1483
av_channel_layout_subset
uint64_t av_channel_layout_subset(const AVChannelLayout *channel_layout, uint64_t mask)
Find out what channels from a given set are present in a channel layout, without regard for their pos...
Definition: channel_layout.c:865
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:105
LEVEL_MINUS_6DB
#define LEVEL_MINUS_6DB
Definition: ac3defs.h:45
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
FLT_OPTION_THRESHOLD
#define FLT_OPTION_THRESHOLD
Definition: ac3enc.c:275
ff_ac3_bitrate_tab
const uint16_t ff_ac3_bitrate_tab[19]
Definition: ac3tab.c:99
AV_AUDIO_SERVICE_TYPE_COMMENTARY
@ AV_AUDIO_SERVICE_TYPE_COMMENTARY
Definition: defs.h:241
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
allocate_buffers
static av_cold int allocate_buffers(AC3EncodeContext *s)
Definition: ac3enc.c:2408
ac3_output_frame_header
static void ac3_output_frame_header(AC3EncodeContext *s, PutBitContext *pb)
Definition: ac3enc.c:1631
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
ff_ac3enc_class
const AVClass ff_ac3enc_class
Definition: ac3enc.c:130
ff_ac3_enc_defaults
const FFCodecDefault ff_ac3_enc_defaults[]
Definition: ac3enc.c:137
ff_ac3_encode_init
av_cold int ff_ac3_encode_init(AVCodecContext *avctx)
Definition: ac3enc.c:2472
ac3_enc_channel_map
static const uint8_t ac3_enc_channel_map[8][2][6]
Table to remap channels from SMPTE order to AC-3 order.
Definition: ac3enc.c:196
audiodsp.h
mem.h
encode_exponents
static void encode_exponents(AC3EncodeContext *s)
Definition: ac3enc.c:800
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:153
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:394
ff_ac3_bit_alloc_calc_mask
int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd, int start, int end, int fast_gain, int is_lfe, int dba_mode, int dba_nsegs, uint8_t *dba_offsets, uint8_t *dba_lengths, uint8_t *dba_values, int16_t *mask)
Calculate the masking curve.
Definition: ac3.c:201
ff_ac3_slow_gain_tab
const uint16_t ff_ac3_slow_gain_tab[4]
Definition: ac3tab.c:135
AC3ENC_OPT_DSUREX_DPLIIZ
#define AC3ENC_OPT_DSUREX_DPLIIZ
Definition: ac3enc.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
AVPacket
This structure stores compressed data.
Definition: packet.h:565
ac3.h
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
count_exponent_bits
static int count_exponent_bits(AC3EncodeContext *s)
Definition: ac3enc.c:850
ff_ac3_fast_gain_tab
const uint16_t ff_ac3_fast_gain_tab[8]
Definition: ac3tab.c:147
reset_block_bap
static void reset_block_bap(AC3EncodeContext *s)
Definition: ac3enc.c:1272
AC3ENC_OPT_NOT_INDICATED
#define AC3ENC_OPT_NOT_INDICATED
Definition: ac3enc.h:75
AV_CH_LAYOUT_4POINT0
#define AV_CH_LAYOUT_4POINT0
Definition: channel_layout.h:223
ff_ac3_encode_close
av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
Finalize encoding and free any memory allocated by the encoder.
Definition: ac3enc.c:2154
AC3ENC_OPT_DOWNMIX_LTRT
#define AC3ENC_OPT_DOWNMIX_LTRT
Definition: ac3enc.h:83
int32_t
int32_t
Definition: audioconvert.c:56
AV_CHANNEL_LAYOUT_5POINT1_BACK
#define AV_CHANNEL_LAYOUT_5POINT1_BACK
Definition: channel_layout.h:407
EXP_D25
#define EXP_D25
Definition: ac3defs.h:55
cbr_bit_allocation
static int cbr_bit_allocation(AC3EncodeContext *s)
Definition: ac3enc.c:1396
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AC3EncOptions::surround_mix_level
float surround_mix_level
Definition: ac3enc.h:98
AC3ENC_OPT_MODE_ON
#define AC3ENC_OPT_MODE_ON
Definition: ac3enc.h:76
AV_CHANNEL_LAYOUT_5POINT0
#define AV_CHANNEL_LAYOUT_5POINT0
Definition: channel_layout.h:404
ac3tab.h
AC3EncOptions::extended_bsi_2
int extended_bsi_2
Definition: ac3enc.h:111
AC3Mant::qmant1_ptr
int16_t * qmant1_ptr
Definition: ac3enc.c:58
av_bswap16
#define av_bswap16
Definition: bswap.h:28
AV_CHANNEL_LAYOUT_5POINT1
#define AV_CHANNEL_LAYOUT_5POINT1
Definition: channel_layout.h:405
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
snprintf
#define snprintf
Definition: snprintf.h:34
AV_AUDIO_SERVICE_TYPE_MAIN
@ AV_AUDIO_SERVICE_TYPE_MAIN
Definition: defs.h:236
AV_CH_LAYOUT_2_2
#define AV_CH_LAYOUT_2_2
Definition: channel_layout.h:225
exponent_init
static av_cold void exponent_init(void)
Definition: ac3enc.c:612
validate_options
static av_cold int validate_options(AC3EncodeContext *s)
Definition: ac3enc.c:2211
AC3EncOptions::loro_center_mix_level
float loro_center_mix_level
Definition: ac3enc.h:109
ff_ac3_bit_alloc_calc_psd
void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd, int16_t *band_psd)
Calculate the log power-spectral density of the input signal.
Definition: ac3.c:175
ff_eac3_default_cpl_band_struct
const uint8_t ff_eac3_default_cpl_band_struct[18]
Table E2.16 Default Coupling Banding Structure.
Definition: ac3tab.c:113
count_mantissa_bits_update_ch
static void count_mantissa_bits_update_ch(AC3EncodeContext *s, int ch, uint16_t mant_cnt[AC3_MAX_BLOCKS][16], int start, int end)
Update mantissa bit counts for all blocks in 1 channel in a given bandwidth range.
Definition: ac3enc.c:1319
Generated on Sun Nov 30 2025 19:21:45 for FFmpeg by   doxygen 1.8.17