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