1 |
|
|
/* |
2 |
|
|
* E-AC-3 decoder |
3 |
|
|
* Copyright (c) 2007 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com> |
4 |
|
|
* Copyright (c) 2008 Justin Ruggles |
5 |
|
|
* |
6 |
|
|
* This file is part of FFmpeg. |
7 |
|
|
* |
8 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
9 |
|
|
* modify it under the terms of the GNU Lesser General Public |
10 |
|
|
* License as published by the Free Software Foundation; either |
11 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
12 |
|
|
* |
13 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
14 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 |
|
|
* Lesser General Public License for more details. |
17 |
|
|
* |
18 |
|
|
* You should have received a copy of the GNU Lesser General Public |
19 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
20 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
21 |
|
|
*/ |
22 |
|
|
|
23 |
|
|
/* |
24 |
|
|
* There are several features of E-AC-3 that this decoder does not yet support. |
25 |
|
|
* |
26 |
|
|
* Enhanced Coupling |
27 |
|
|
* No known samples exist. If any ever surface, this feature should not be |
28 |
|
|
* too difficult to implement. |
29 |
|
|
* |
30 |
|
|
* Reduced Sample Rates |
31 |
|
|
* No known samples exist. The spec also does not give clear information |
32 |
|
|
* on how this is to be implemented. |
33 |
|
|
* |
34 |
|
|
* Transient Pre-noise Processing |
35 |
|
|
* This is side information which a decoder should use to reduce artifacts |
36 |
|
|
* caused by transients. There are samples which are known to have this |
37 |
|
|
* information, but this decoder currently ignores it. |
38 |
|
|
*/ |
39 |
|
|
|
40 |
|
|
|
41 |
|
|
#include "avcodec.h" |
42 |
|
|
#include "internal.h" |
43 |
|
|
#include "aac_ac3_parser.h" |
44 |
|
|
#include "ac3.h" |
45 |
|
|
#include "ac3dec.h" |
46 |
|
|
#include "ac3dec_data.h" |
47 |
|
|
#include "eac3_data.h" |
48 |
|
|
|
49 |
|
|
/** gain adaptive quantization mode */ |
50 |
|
|
typedef enum { |
51 |
|
|
EAC3_GAQ_NO =0, |
52 |
|
|
EAC3_GAQ_12, |
53 |
|
|
EAC3_GAQ_14, |
54 |
|
|
EAC3_GAQ_124 |
55 |
|
|
} EAC3GaqMode; |
56 |
|
|
|
57 |
|
|
#define EAC3_SR_CODE_REDUCED 3 |
58 |
|
|
|
59 |
|
3234 |
static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s) |
60 |
|
|
{ |
61 |
|
|
int bin, bnd, ch, i; |
62 |
|
3234 |
uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS]; |
63 |
|
|
float rms_energy[SPX_MAX_BANDS]; |
64 |
|
|
|
65 |
|
|
/* Set copy index mapping table. Set wrap flags to apply a notch filter at |
66 |
|
|
wrap points later on. */ |
67 |
|
3234 |
bin = s->spx_dst_start_freq; |
68 |
|
3234 |
num_copy_sections = 0; |
69 |
✓✓ |
10566 |
for (bnd = 0; bnd < s->num_spx_bands; bnd++) { |
70 |
|
|
int copysize; |
71 |
|
7332 |
int bandsize = s->spx_band_sizes[bnd]; |
72 |
✗✓ |
7332 |
if (bin + bandsize > s->spx_src_start_freq) { |
73 |
|
|
copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq; |
74 |
|
|
bin = s->spx_dst_start_freq; |
75 |
|
|
wrapflag[bnd] = 1; |
76 |
|
|
} |
77 |
✓✓ |
14664 |
for (i = 0; i < bandsize; i += copysize) { |
78 |
✗✓ |
7332 |
if (bin == s->spx_src_start_freq) { |
79 |
|
|
copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq; |
80 |
|
|
bin = s->spx_dst_start_freq; |
81 |
|
|
} |
82 |
|
7332 |
copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin); |
83 |
|
7332 |
bin += copysize; |
84 |
|
|
} |
85 |
|
|
} |
86 |
|
3234 |
copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq; |
87 |
|
|
|
88 |
✓✓ |
10566 |
for (ch = 1; ch <= s->fbw_channels; ch++) { |
89 |
✗✓ |
7332 |
if (!s->channel_uses_spx[ch]) |
90 |
|
|
continue; |
91 |
|
|
|
92 |
|
|
/* Copy coeffs from normal bands to extension bands */ |
93 |
|
7332 |
bin = s->spx_src_start_freq; |
94 |
✓✓ |
14664 |
for (i = 0; i < num_copy_sections; i++) { |
95 |
|
7332 |
memcpy(&s->transform_coeffs[ch][bin], |
96 |
|
7332 |
&s->transform_coeffs[ch][s->spx_dst_start_freq], |
97 |
|
7332 |
copy_sizes[i]*sizeof(INTFLOAT)); |
98 |
|
7332 |
bin += copy_sizes[i]; |
99 |
|
|
} |
100 |
|
|
|
101 |
|
|
/* Calculate RMS energy for each SPX band. */ |
102 |
|
7332 |
bin = s->spx_src_start_freq; |
103 |
✓✓ |
26316 |
for (bnd = 0; bnd < s->num_spx_bands; bnd++) { |
104 |
|
18984 |
int bandsize = s->spx_band_sizes[bnd]; |
105 |
|
18984 |
float accum = 0.0f; |
106 |
✓✓ |
264072 |
for (i = 0; i < bandsize; i++) { |
107 |
|
245088 |
float coeff = s->transform_coeffs[ch][bin++]; |
108 |
|
245088 |
accum += coeff * coeff; |
109 |
|
|
} |
110 |
|
18984 |
rms_energy[bnd] = sqrtf(accum / bandsize); |
111 |
|
|
} |
112 |
|
|
|
113 |
|
|
/* Apply a notch filter at transitions between normal and extension |
114 |
|
|
bands and at all wrap points. */ |
115 |
✓✓ |
7332 |
if (s->spx_atten_code[ch] >= 0) { |
116 |
|
6294 |
const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]]; |
117 |
|
6294 |
bin = s->spx_src_start_freq - 2; |
118 |
✓✓ |
20088 |
for (bnd = 0; bnd < s->num_spx_bands; bnd++) { |
119 |
✓✓ |
13794 |
if (wrapflag[bnd]) { |
120 |
|
6294 |
INTFLOAT *coeffs = &s->transform_coeffs[ch][bin]; |
121 |
|
6294 |
coeffs[0] *= atten_tab[0]; |
122 |
|
6294 |
coeffs[1] *= atten_tab[1]; |
123 |
|
6294 |
coeffs[2] *= atten_tab[2]; |
124 |
|
6294 |
coeffs[3] *= atten_tab[1]; |
125 |
|
6294 |
coeffs[4] *= atten_tab[0]; |
126 |
|
|
} |
127 |
|
13794 |
bin += s->spx_band_sizes[bnd]; |
128 |
|
|
} |
129 |
|
|
} |
130 |
|
|
|
131 |
|
|
/* Apply noise-blended coefficient scaling based on previously |
132 |
|
|
calculated RMS energy, blending factors, and SPX coordinates for |
133 |
|
|
each band. */ |
134 |
|
7332 |
bin = s->spx_src_start_freq; |
135 |
✓✓ |
26316 |
for (bnd = 0; bnd < s->num_spx_bands; bnd++) { |
136 |
|
18984 |
float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN); |
137 |
|
18984 |
float sscale = s->spx_signal_blend[ch][bnd]; |
138 |
|
|
#if USE_FIXED |
139 |
|
|
// spx_noise_blend and spx_signal_blend are both FP.23 |
140 |
|
|
nscale *= 1.0 / (1<<23); |
141 |
|
|
sscale *= 1.0 / (1<<23); |
142 |
|
|
#endif |
143 |
✓✓ |
264072 |
for (i = 0; i < s->spx_band_sizes[bnd]; i++) { |
144 |
|
245088 |
float noise = nscale * (int32_t)av_lfg_get(&s->dith_state); |
145 |
|
245088 |
s->transform_coeffs[ch][bin] *= sscale; |
146 |
|
245088 |
s->transform_coeffs[ch][bin++] += noise; |
147 |
|
|
} |
148 |
|
|
} |
149 |
|
|
} |
150 |
|
3234 |
} |
151 |
|
|
|
152 |
|
|
|
153 |
|
|
/** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */ |
154 |
|
|
#define COEFF_0 10273905LL |
155 |
|
|
|
156 |
|
|
/** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */ |
157 |
|
|
#define COEFF_1 11863283LL |
158 |
|
|
|
159 |
|
|
/** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */ |
160 |
|
|
#define COEFF_2 3070444LL |
161 |
|
|
|
162 |
|
|
/** |
163 |
|
|
* Calculate 6-point IDCT of the pre-mantissas. |
164 |
|
|
* All calculations are 24-bit fixed-point. |
165 |
|
|
*/ |
166 |
|
99072 |
static void idct6(int pre_mant[6]) |
167 |
|
|
{ |
168 |
|
|
int tmp; |
169 |
|
|
int even0, even1, even2, odd0, odd1, odd2; |
170 |
|
|
|
171 |
|
99072 |
odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5]; |
172 |
|
|
|
173 |
|
99072 |
even2 = ( pre_mant[2] * COEFF_0) >> 23; |
174 |
|
99072 |
tmp = ( pre_mant[4] * COEFF_1) >> 23; |
175 |
|
99072 |
odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23; |
176 |
|
|
|
177 |
|
99072 |
even0 = pre_mant[0] + (tmp >> 1); |
178 |
|
99072 |
even1 = pre_mant[0] - tmp; |
179 |
|
|
|
180 |
|
99072 |
tmp = even0; |
181 |
|
99072 |
even0 = tmp + even2; |
182 |
|
99072 |
even2 = tmp - even2; |
183 |
|
|
|
184 |
|
99072 |
tmp = odd0; |
185 |
|
99072 |
odd0 = tmp + pre_mant[1] + pre_mant[3]; |
186 |
|
99072 |
odd2 = tmp + pre_mant[5] - pre_mant[3]; |
187 |
|
|
|
188 |
|
99072 |
pre_mant[0] = even0 + odd0; |
189 |
|
99072 |
pre_mant[1] = even1 + odd1; |
190 |
|
99072 |
pre_mant[2] = even2 + odd2; |
191 |
|
99072 |
pre_mant[3] = even2 - odd2; |
192 |
|
99072 |
pre_mant[4] = even1 - odd1; |
193 |
|
99072 |
pre_mant[5] = even0 - odd0; |
194 |
|
99072 |
} |
195 |
|
|
|
196 |
|
810 |
static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch) |
197 |
|
|
{ |
198 |
|
|
int bin, blk, gs; |
199 |
|
|
int end_bap, gaq_mode; |
200 |
|
810 |
GetBitContext *gbc = &s->gbc; |
201 |
|
|
int gaq_gain[AC3_MAX_COEFS]; |
202 |
|
|
|
203 |
|
810 |
gaq_mode = get_bits(gbc, 2); |
204 |
✓✓ |
810 |
end_bap = (gaq_mode < 2) ? 12 : 17; |
205 |
|
|
|
206 |
|
|
/* if GAQ gain is used, decode gain codes for bins with hebap between |
207 |
|
|
8 and end_bap */ |
208 |
|
810 |
gs = 0; |
209 |
✓✓✓✓
|
810 |
if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) { |
210 |
|
|
/* read 1-bit GAQ gain codes */ |
211 |
✓✓ |
87458 |
for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { |
212 |
✓✓✓✓
|
86761 |
if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap) |
213 |
|
31300 |
gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1); |
214 |
|
|
} |
215 |
✓✓ |
113 |
} else if (gaq_mode == EAC3_GAQ_124) { |
216 |
|
|
/* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */ |
217 |
|
52 |
int gc = 2; |
218 |
✓✓ |
6560 |
for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { |
219 |
✓✓✓✗
|
6508 |
if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) { |
220 |
✓✓ |
1905 |
if (gc++ == 2) { |
221 |
|
655 |
int group_code = get_bits(gbc, 5); |
222 |
✗✓ |
655 |
if (group_code > 26) { |
223 |
|
|
av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n"); |
224 |
|
|
group_code = 26; |
225 |
|
|
} |
226 |
|
655 |
gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0]; |
227 |
|
655 |
gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1]; |
228 |
|
655 |
gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2]; |
229 |
|
655 |
gc = 0; |
230 |
|
|
} |
231 |
|
|
} |
232 |
|
|
} |
233 |
|
|
} |
234 |
|
|
|
235 |
|
810 |
gs=0; |
236 |
✓✓ |
99882 |
for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) { |
237 |
|
99072 |
int hebap = s->bap[ch][bin]; |
238 |
|
99072 |
int bits = ff_eac3_bits_vs_hebap[hebap]; |
239 |
✓✓ |
99072 |
if (!hebap) { |
240 |
|
|
/* zero-mantissa dithering */ |
241 |
✓✓ |
223454 |
for (blk = 0; blk < 6; blk++) { |
242 |
|
191532 |
s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000; |
243 |
|
|
} |
244 |
✓✓ |
67150 |
} else if (hebap < 8) { |
245 |
|
|
/* Vector Quantization */ |
246 |
|
31011 |
int v = get_bits(gbc, bits); |
247 |
✓✓ |
217077 |
for (blk = 0; blk < 6; blk++) { |
248 |
|
186066 |
s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] * (1 << 8); |
249 |
|
|
} |
250 |
|
|
} else { |
251 |
|
|
/* Gain Adaptive Quantization */ |
252 |
|
|
int gbits, log_gain; |
253 |
✓✓✓✓
|
36139 |
if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) { |
254 |
|
33205 |
log_gain = gaq_gain[gs++]; |
255 |
|
|
} else { |
256 |
|
2934 |
log_gain = 0; |
257 |
|
|
} |
258 |
|
36139 |
gbits = bits - log_gain; |
259 |
|
|
|
260 |
✓✓ |
252973 |
for (blk = 0; blk < 6; blk++) { |
261 |
|
216834 |
int mant = get_sbits(gbc, gbits); |
262 |
✓✓✓✓
|
216834 |
if (log_gain && mant == -(1 << (gbits-1))) { |
263 |
|
|
/* large mantissa */ |
264 |
|
|
int b; |
265 |
|
24448 |
int mbits = bits - (2 - log_gain); |
266 |
|
24448 |
mant = get_sbits(gbc, mbits); |
267 |
|
24448 |
mant = ((unsigned)mant) << (23 - (mbits - 1)); |
268 |
|
|
/* remap mantissa value to correct for asymmetric quantization */ |
269 |
✓✓ |
24448 |
if (mant >= 0) |
270 |
|
12146 |
b = 1 << (23 - log_gain); |
271 |
|
|
else |
272 |
|
12302 |
b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] * (1 << 8); |
273 |
|
24448 |
mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b; |
274 |
|
|
} else { |
275 |
|
|
/* small mantissa, no GAQ, or Gk=1 */ |
276 |
|
192386 |
mant *= (1 << 24 - bits); |
277 |
✓✓ |
192386 |
if (!log_gain) { |
278 |
|
|
/* remap mantissa value for no GAQ or Gk=1 */ |
279 |
|
114906 |
mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15; |
280 |
|
|
} |
281 |
|
|
} |
282 |
|
216834 |
s->pre_mantissa[ch][bin][blk] = mant; |
283 |
|
|
} |
284 |
|
|
} |
285 |
|
99072 |
idct6(s->pre_mantissa[ch][bin]); |
286 |
|
|
} |
287 |
|
810 |
} |
288 |
|
|
|
289 |
|
1201 |
static int ff_eac3_parse_header(AC3DecodeContext *s) |
290 |
|
|
{ |
291 |
|
|
int i, blk, ch; |
292 |
|
|
int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data; |
293 |
|
|
int parse_transient_proc_info; |
294 |
|
|
int num_cpl_blocks; |
295 |
|
1201 |
GetBitContext *gbc = &s->gbc; |
296 |
|
|
|
297 |
|
|
/* An E-AC-3 stream can have multiple independent streams which the |
298 |
|
|
application can select from. each independent stream can also contain |
299 |
|
|
dependent streams which are used to add or replace channels. */ |
300 |
✗✓ |
1201 |
if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) { |
301 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n"); |
302 |
|
|
return AAC_AC3_PARSE_ERROR_FRAME_TYPE; |
303 |
|
|
} |
304 |
|
|
|
305 |
|
|
/* The substream id indicates which substream this frame belongs to. each |
306 |
|
|
independent stream has its own substream id, and the dependent streams |
307 |
|
|
associated to an independent stream have matching substream id's. */ |
308 |
✗✓ |
1201 |
if (s->substreamid) { |
309 |
|
|
/* only decode substream with id=0. skip any additional substreams. */ |
310 |
|
|
if (!s->eac3_subsbtreamid_found) { |
311 |
|
|
s->eac3_subsbtreamid_found = 1; |
312 |
|
|
avpriv_request_sample(s->avctx, "Additional substreams"); |
313 |
|
|
} |
314 |
|
|
return AAC_AC3_PARSE_ERROR_FRAME_TYPE; |
315 |
|
|
} |
316 |
|
|
|
317 |
✗✓ |
1201 |
if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) { |
318 |
|
|
/* The E-AC-3 specification does not tell how to handle reduced sample |
319 |
|
|
rates in bit allocation. The best assumption would be that it is |
320 |
|
|
handled like AC-3 DolbyNet, but we cannot be sure until we have a |
321 |
|
|
sample which utilizes this feature. */ |
322 |
|
|
avpriv_request_sample(s->avctx, "Reduced sampling rate"); |
323 |
|
|
return AVERROR_PATCHWELCOME; |
324 |
|
|
} |
325 |
|
1201 |
skip_bits(gbc, 5); // skip bitstream id |
326 |
|
|
|
327 |
|
|
/* volume control params */ |
328 |
✓✗✓✓
|
2402 |
for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { |
329 |
|
1201 |
s->dialog_normalization[i] = -get_bits(gbc, 5); |
330 |
✗✓ |
1201 |
if (s->dialog_normalization[i] == 0) { |
331 |
|
|
s->dialog_normalization[i] = -31; |
332 |
|
|
} |
333 |
✗✓ |
1201 |
if (s->target_level != 0) { |
334 |
|
|
s->level_gain[i] = powf(2.0f, |
335 |
|
|
(float)(s->target_level - s->dialog_normalization[i])/6.0f); |
336 |
|
|
} |
337 |
|
1201 |
s->compression_exists[i] = get_bits1(gbc); |
338 |
✓✓ |
1201 |
if (s->compression_exists[i]) { |
339 |
|
927 |
s->heavy_dynamic_range[i] = AC3_HEAVY_RANGE(get_bits(gbc, 8)); |
340 |
|
|
} |
341 |
|
|
} |
342 |
|
|
|
343 |
|
|
/* dependent stream channel map */ |
344 |
✓✓ |
1201 |
if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT) { |
345 |
✓✗ |
159 |
if (get_bits1(gbc)) { |
346 |
|
159 |
int64_t channel_layout = 0; |
347 |
|
159 |
int channel_map = get_bits(gbc, 16); |
348 |
|
159 |
av_log(s->avctx, AV_LOG_DEBUG, "channel_map: %0X\n", channel_map); |
349 |
|
|
|
350 |
✓✓ |
2703 |
for (i = 0; i < 16; i++) |
351 |
✓✓ |
2544 |
if (channel_map & (1 << (EAC3_MAX_CHANNELS - i - 1))) |
352 |
|
477 |
channel_layout |= ff_eac3_custom_channel_map_locations[i][1]; |
353 |
|
|
|
354 |
✗✓ |
159 |
if (av_popcount64(channel_layout) > EAC3_MAX_CHANNELS) { |
355 |
|
|
return AVERROR_INVALIDDATA; |
356 |
|
|
} |
357 |
|
159 |
s->channel_map = channel_map; |
358 |
|
|
} |
359 |
|
|
} |
360 |
|
|
|
361 |
|
|
/* mixing metadata */ |
362 |
✓✓ |
1201 |
if (get_bits1(gbc)) { |
363 |
|
|
/* center and surround mix levels */ |
364 |
✓✓ |
637 |
if (s->channel_mode > AC3_CHMODE_STEREO) { |
365 |
|
146 |
s->preferred_downmix = get_bits(gbc, 2); |
366 |
✓✗ |
146 |
if (s->channel_mode & 1) { |
367 |
|
|
/* if three front channels exist */ |
368 |
|
146 |
s->center_mix_level_ltrt = get_bits(gbc, 3); |
369 |
|
146 |
s->center_mix_level = get_bits(gbc, 3); |
370 |
|
|
} |
371 |
✓✗ |
146 |
if (s->channel_mode & 4) { |
372 |
|
|
/* if a surround channel exists */ |
373 |
|
146 |
s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7); |
374 |
|
146 |
s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7); |
375 |
|
|
} |
376 |
|
|
} |
377 |
|
|
|
378 |
|
|
/* lfe mix level */ |
379 |
✓✓✓✗
|
637 |
if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) { |
380 |
|
146 |
s->lfe_mix_level = get_bits(gbc, 5); |
381 |
|
|
} |
382 |
|
|
|
383 |
|
|
/* info for mixing with other streams and substreams */ |
384 |
✓✗ |
637 |
if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT) { |
385 |
✓✗✓✓
|
1274 |
for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { |
386 |
|
|
// TODO: apply program scale factor |
387 |
✗✓ |
637 |
if (get_bits1(gbc)) { |
388 |
|
|
skip_bits(gbc, 6); // skip program scale factor |
389 |
|
|
} |
390 |
|
|
} |
391 |
✗✓ |
637 |
if (get_bits1(gbc)) { |
392 |
|
|
skip_bits(gbc, 6); // skip external program scale factor |
393 |
|
|
} |
394 |
|
|
/* skip mixing parameter data */ |
395 |
✗✗✗✓
|
637 |
switch(get_bits(gbc, 2)) { |
396 |
|
|
case 1: skip_bits(gbc, 5); break; |
397 |
|
|
case 2: skip_bits(gbc, 12); break; |
398 |
|
|
case 3: { |
399 |
|
|
int mix_data_size = (get_bits(gbc, 5) + 2) << 3; |
400 |
|
|
skip_bits_long(gbc, mix_data_size); |
401 |
|
|
break; |
402 |
|
|
} |
403 |
|
|
} |
404 |
|
|
/* skip pan information for mono or dual mono source */ |
405 |
✗✓ |
637 |
if (s->channel_mode < AC3_CHMODE_STEREO) { |
406 |
|
|
for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { |
407 |
|
|
if (get_bits1(gbc)) { |
408 |
|
|
/* note: this is not in the ATSC A/52B specification |
409 |
|
|
reference: ETSI TS 102 366 V1.1.1 |
410 |
|
|
section: E.1.3.1.25 */ |
411 |
|
|
skip_bits(gbc, 8); // skip pan mean direction index |
412 |
|
|
skip_bits(gbc, 6); // skip reserved paninfo bits |
413 |
|
|
} |
414 |
|
|
} |
415 |
|
|
} |
416 |
|
|
/* skip mixing configuration information */ |
417 |
✗✓ |
637 |
if (get_bits1(gbc)) { |
418 |
|
|
for (blk = 0; blk < s->num_blocks; blk++) { |
419 |
|
|
if (s->num_blocks == 1 || get_bits1(gbc)) { |
420 |
|
|
skip_bits(gbc, 5); |
421 |
|
|
} |
422 |
|
|
} |
423 |
|
|
} |
424 |
|
|
} |
425 |
|
|
} |
426 |
|
|
|
427 |
|
|
/* informational metadata */ |
428 |
✓✓ |
1201 |
if (get_bits1(gbc)) { |
429 |
|
768 |
s->bitstream_mode = get_bits(gbc, 3); |
430 |
|
768 |
skip_bits(gbc, 2); // skip copyright bit and original bitstream bit |
431 |
✓✓ |
768 |
if (s->channel_mode == AC3_CHMODE_STEREO) { |
432 |
|
622 |
s->dolby_surround_mode = get_bits(gbc, 2); |
433 |
|
622 |
s->dolby_headphone_mode = get_bits(gbc, 2); |
434 |
|
|
} |
435 |
✓✓ |
768 |
if (s->channel_mode >= AC3_CHMODE_2F2R) { |
436 |
|
146 |
s->dolby_surround_ex_mode = get_bits(gbc, 2); |
437 |
|
|
} |
438 |
✓✗✓✓
|
1536 |
for (i = 0; i < (s->channel_mode ? 1 : 2); i++) { |
439 |
✓✗ |
768 |
if (get_bits1(gbc)) { |
440 |
|
768 |
skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type |
441 |
|
|
} |
442 |
|
|
} |
443 |
✓✗ |
768 |
if (s->bit_alloc_params.sr_code != EAC3_SR_CODE_REDUCED) { |
444 |
|
768 |
skip_bits1(gbc); // skip source sample rate code |
445 |
|
|
} |
446 |
|
|
} |
447 |
|
|
|
448 |
|
|
/* converter synchronization flag |
449 |
|
|
If frames are less than six blocks, this bit should be turned on |
450 |
|
|
once every 6 blocks to indicate the start of a frame set. |
451 |
|
|
reference: RFC 4598, Section 2.1.3 Frame Sets */ |
452 |
✓✓✓✓
|
1201 |
if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) { |
453 |
|
98 |
skip_bits1(gbc); // skip converter synchronization flag |
454 |
|
|
} |
455 |
|
|
|
456 |
|
|
/* original frame size code if this stream was converted from AC-3 */ |
457 |
✗✓ |
1201 |
if (s->frame_type == EAC3_FRAME_TYPE_AC3_CONVERT && |
458 |
|
|
(s->num_blocks == 6 || get_bits1(gbc))) { |
459 |
|
|
skip_bits(gbc, 6); // skip frame size code |
460 |
|
|
} |
461 |
|
|
|
462 |
|
|
/* additional bitstream info */ |
463 |
✓✓ |
1201 |
if (get_bits1(gbc)) { |
464 |
|
159 |
int addbsil = get_bits(gbc, 6); |
465 |
✓✓ |
477 |
for (i = 0; i < addbsil + 1; i++) { |
466 |
|
318 |
skip_bits(gbc, 8); // skip additional bit stream info |
467 |
|
|
} |
468 |
|
|
} |
469 |
|
|
|
470 |
|
|
/* audio frame syntax flags, strategy data, and per-frame data */ |
471 |
|
|
|
472 |
✓✓ |
1201 |
if (s->num_blocks == 6) { |
473 |
|
1103 |
ac3_exponent_strategy = get_bits1(gbc); |
474 |
|
1103 |
parse_aht_info = get_bits1(gbc); |
475 |
|
|
} else { |
476 |
|
|
/* less than 6 blocks, so use AC-3-style exponent strategy syntax, and |
477 |
|
|
do not use AHT */ |
478 |
|
98 |
ac3_exponent_strategy = 1; |
479 |
|
98 |
parse_aht_info = 0; |
480 |
|
|
} |
481 |
|
|
|
482 |
|
1201 |
s->snr_offset_strategy = get_bits(gbc, 2); |
483 |
|
1201 |
parse_transient_proc_info = get_bits1(gbc); |
484 |
|
|
|
485 |
|
1201 |
s->block_switch_syntax = get_bits1(gbc); |
486 |
✓✗ |
1201 |
if (!s->block_switch_syntax) |
487 |
|
1201 |
memset(s->block_switch, 0, sizeof(s->block_switch)); |
488 |
|
|
|
489 |
|
1201 |
s->dither_flag_syntax = get_bits1(gbc); |
490 |
✓✗ |
1201 |
if (!s->dither_flag_syntax) { |
491 |
✓✓ |
4359 |
for (ch = 1; ch <= s->fbw_channels; ch++) |
492 |
|
3158 |
s->dither_flag[ch] = 1; |
493 |
|
|
} |
494 |
|
1201 |
s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0; |
495 |
|
|
|
496 |
|
1201 |
s->bit_allocation_syntax = get_bits1(gbc); |
497 |
✓✓ |
1201 |
if (!s->bit_allocation_syntax) { |
498 |
|
|
/* set default bit allocation parameters */ |
499 |
|
915 |
s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2]; |
500 |
|
915 |
s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1]; |
501 |
|
915 |
s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1]; |
502 |
|
915 |
s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2]; |
503 |
|
915 |
s->bit_alloc_params.floor = ff_ac3_floor_tab [7]; |
504 |
|
|
} |
505 |
|
|
|
506 |
|
1201 |
s->fast_gain_syntax = get_bits1(gbc); |
507 |
|
1201 |
s->dba_syntax = get_bits1(gbc); |
508 |
|
1201 |
s->skip_syntax = get_bits1(gbc); |
509 |
|
1201 |
parse_spx_atten_data = get_bits1(gbc); |
510 |
|
|
|
511 |
|
|
/* coupling strategy occurrence and coupling use per block */ |
512 |
|
1201 |
num_cpl_blocks = 0; |
513 |
✓✗ |
1201 |
if (s->channel_mode > 1) { |
514 |
✓✓ |
7917 |
for (blk = 0; blk < s->num_blocks; blk++) { |
515 |
✓✓✗✓
|
6716 |
s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc)); |
516 |
✓✓ |
6716 |
if (s->cpl_strategy_exists[blk]) { |
517 |
|
1201 |
s->cpl_in_use[blk] = get_bits1(gbc); |
518 |
|
|
} else { |
519 |
|
5515 |
s->cpl_in_use[blk] = s->cpl_in_use[blk-1]; |
520 |
|
|
} |
521 |
|
6716 |
num_cpl_blocks += s->cpl_in_use[blk]; |
522 |
|
|
} |
523 |
|
|
} else { |
524 |
|
|
memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use)); |
525 |
|
|
} |
526 |
|
|
|
527 |
|
|
/* exponent strategy data */ |
528 |
✓✓ |
1201 |
if (ac3_exponent_strategy) { |
529 |
|
|
/* AC-3-style exponent strategy syntax */ |
530 |
✓✓ |
196 |
for (blk = 0; blk < s->num_blocks; blk++) { |
531 |
✓✓ |
588 |
for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) { |
532 |
|
490 |
s->exp_strategy[blk][ch] = get_bits(gbc, 2); |
533 |
|
|
} |
534 |
|
|
} |
535 |
|
|
} else { |
536 |
|
|
/* LUT-based exponent strategy syntax */ |
537 |
✓✗✓✓ ✓✓ |
4176 |
for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) { |
538 |
|
3073 |
int frmchexpstr = get_bits(gbc, 5); |
539 |
✓✓ |
21511 |
for (blk = 0; blk < 6; blk++) { |
540 |
|
18438 |
s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk]; |
541 |
|
|
} |
542 |
|
|
} |
543 |
|
|
} |
544 |
|
|
/* LFE exponent strategy */ |
545 |
✓✓ |
1201 |
if (s->lfe_on) { |
546 |
✓✓ |
532 |
for (blk = 0; blk < s->num_blocks; blk++) { |
547 |
|
386 |
s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc); |
548 |
|
|
} |
549 |
|
|
} |
550 |
|
|
/* original exponent strategies if this stream was converted from AC-3 */ |
551 |
✓✓ |
1201 |
if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && |
552 |
✓✓✓✓
|
1042 |
(s->num_blocks == 6 || get_bits1(gbc))) { |
553 |
|
960 |
skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy |
554 |
|
|
} |
555 |
|
|
|
556 |
|
|
/* determine which channels use AHT */ |
557 |
✓✓ |
1201 |
if (parse_aht_info) { |
558 |
|
|
/* For AHT to be used, all non-zero blocks must reuse exponents from |
559 |
|
|
the first block. Furthermore, for AHT to be used in the coupling |
560 |
|
|
channel, all blocks must use coupling and use the same coupling |
561 |
|
|
strategy. */ |
562 |
|
445 |
s->channel_uses_aht[CPL_CH]=0; |
563 |
✓✓ |
1527 |
for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) { |
564 |
|
1082 |
int use_aht = 1; |
565 |
✓✓ |
5514 |
for (blk = 1; blk < 6; blk++) { |
566 |
✓✓✗✓
|
4704 |
if ((s->exp_strategy[blk][ch] != EXP_REUSE) || |
567 |
|
|
(!ch && s->cpl_strategy_exists[blk])) { |
568 |
|
272 |
use_aht = 0; |
569 |
|
272 |
break; |
570 |
|
|
} |
571 |
|
|
} |
572 |
✓✓✓✗
|
1082 |
s->channel_uses_aht[ch] = use_aht && get_bits1(gbc); |
573 |
|
|
} |
574 |
|
|
} else { |
575 |
|
756 |
memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht)); |
576 |
|
|
} |
577 |
|
|
|
578 |
|
|
/* per-frame SNR offset */ |
579 |
✓✗ |
1201 |
if (!s->snr_offset_strategy) { |
580 |
|
1201 |
int csnroffst = (get_bits(gbc, 6) - 15) << 4; |
581 |
|
1201 |
int snroffst = (csnroffst + get_bits(gbc, 4)) << 2; |
582 |
✓✓ |
5706 |
for (ch = 0; ch <= s->channels; ch++) |
583 |
|
4505 |
s->snr_offset[ch] = snroffst; |
584 |
|
|
} |
585 |
|
|
|
586 |
|
|
/* transient pre-noise processing data */ |
587 |
✗✓ |
1201 |
if (parse_transient_proc_info) { |
588 |
|
|
for (ch = 1; ch <= s->fbw_channels; ch++) { |
589 |
|
|
if (get_bits1(gbc)) { // channel in transient processing |
590 |
|
|
skip_bits(gbc, 10); // skip transient processing location |
591 |
|
|
skip_bits(gbc, 8); // skip transient processing length |
592 |
|
|
} |
593 |
|
|
} |
594 |
|
|
} |
595 |
|
|
|
596 |
|
|
/* spectral extension attenuation data */ |
597 |
✓✓ |
4359 |
for (ch = 1; ch <= s->fbw_channels; ch++) { |
598 |
✓✓✓✓
|
3158 |
if (parse_spx_atten_data && get_bits1(gbc)) { |
599 |
|
1049 |
s->spx_atten_code[ch] = get_bits(gbc, 5); |
600 |
|
|
} else { |
601 |
|
2109 |
s->spx_atten_code[ch] = -1; |
602 |
|
|
} |
603 |
|
|
} |
604 |
|
|
|
605 |
|
|
/* block start information */ |
606 |
✓✓✗✓
|
1201 |
if (s->num_blocks > 1 && get_bits1(gbc)) { |
607 |
|
|
/* reference: Section E2.3.2.27 |
608 |
|
|
nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame))) |
609 |
|
|
The spec does not say what this data is or what it's used for. |
610 |
|
|
It is likely the offset of each block within the frame. */ |
611 |
|
|
int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2)); |
612 |
|
|
skip_bits_long(gbc, block_start_bits); |
613 |
|
|
avpriv_request_sample(s->avctx, "Block start info"); |
614 |
|
|
} |
615 |
|
|
|
616 |
|
|
/* syntax state initialization */ |
617 |
✓✓ |
4359 |
for (ch = 1; ch <= s->fbw_channels; ch++) { |
618 |
|
3158 |
s->first_spx_coords[ch] = 1; |
619 |
|
3158 |
s->first_cpl_coords[ch] = 1; |
620 |
|
|
} |
621 |
|
1201 |
s->first_cpl_leak = 1; |
622 |
|
|
|
623 |
|
1201 |
return 0; |
624 |
|
|
} |