Mercurial > libavcodec.hg
annotate eac3dec.c @ 11633:d47bd24cb380 libavcodec
H.264: move avctx->{profile,level} init before AVCodecContext.get_format().
author | gb |
---|---|
date | Thu, 15 Apr 2010 08:30:48 +0000 |
parents | 444f4b594fdb |
children |
rev | line source |
---|---|
7666 | 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 | |
7679 | 9 * modify it under the terms of the GNU Lesser General Public |
7666 | 10 * License as published by the Free Software Foundation; either |
7679 | 11 * version 2.1 of the License, or (at your option) any later version. |
7666 | 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 | |
7679 | 16 * Lesser General Public License for more details. |
7666 | 17 * |
7679 | 18 * You should have received a copy of the GNU Lesser General Public |
7666 | 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 | |
9181 | 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 | |
7666 | 47 #include "avcodec.h" |
8281
f93efc084e41
Make av_log_missing_feature an internal function, and change its name
stefano
parents:
8273
diff
changeset
|
48 #include "internal.h" |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
49 #include "aac_ac3_parser.h" |
7666 | 50 #include "ac3.h" |
51 #include "ac3_parser.h" | |
52 #include "ac3dec.h" | |
53 #include "ac3dec_data.h" | |
9983 | 54 #include "eac3dec_data.h" |
7666 | 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 | |
11559 | 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 | |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
155 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */ |
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
156 #define COEFF_0 10273905LL |
7666 | 157 |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
158 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */ |
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
159 #define COEFF_1 11863283LL |
7666 | 160 |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
161 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */ |
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
162 #define COEFF_2 3070444LL |
7666 | 163 |
164 /** | |
165 * Calculate 6-point IDCT of the pre-mantissas. | |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
166 * All calculations are 24-bit fixed-point. |
7666 | 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 | |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
175 even2 = ( pre_mant[2] * COEFF_0) >> 23; |
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
176 tmp = ( pre_mant[4] * COEFF_1) >> 23; |
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
177 odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23; |
7666 | 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 } | |
7745 | 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++) { | |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
244 s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000; |
7745 | 245 } |
246 } else if (hebap < 8) { | |
247 /* Vector Quantization */ | |
248 int v = get_bits(gbc, bits); | |
249 for (blk = 0; blk < 6; blk++) { | |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
250 s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8; |
7745 | 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); | |
9682
0596729ae4af
eac3dec: fix bug in GAQ dequantization. large mantissas should only be
jbr
parents:
9681
diff
changeset
|
264 if (log_gain && mant == -(1 << (gbits-1))) { |
7745 | 265 /* large mantissa */ |
266 int b; | |
9681 | 267 int mbits = bits - (2 - log_gain); |
268 mant = get_sbits(gbc, mbits); | |
269 mant <<= (23 - (mbits - 1)); | |
7745 | 270 /* remap mantissa value to correct for asymmetric quantization */ |
271 if (mant >= 0) | |
9683 | 272 b = 1 << (23 - log_gain); |
7745 | 273 else |
9681 | 274 b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] << 8; |
9708
d23332ab364f
eac3dec: get rid of unnecessary left shifts in 16-bit * 24-bit
jbr
parents:
9683
diff
changeset
|
275 mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b; |
7745 | 276 } else { |
277 /* small mantissa, no GAQ, or Gk=1 */ | |
9680
debe2623a70a
eac3dec: revert commit r18860. keep the AHT IDCT 24-bit. will make AHT GAQ
jbr
parents:
9661
diff
changeset
|
278 mant <<= 24 - bits; |
7745 | 279 if (!log_gain) { |
280 /* remap mantissa value for no GAQ or Gk=1 */ | |
9708
d23332ab364f
eac3dec: get rid of unnecessary left shifts in 16-bit * 24-bit
jbr
parents:
9683
diff
changeset
|
281 mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15; |
7745 | 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) { | |
9891
7ad7d4094d1f
Rename ff_log_missing_feature() to av_log_missing_feature().
rbultje
parents:
9708
diff
changeset
|
303 av_log_missing_feature(s->avctx, "Dependent substream decoding", 1); |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
304 return AAC_AC3_PARSE_ERROR_FRAME_TYPE; |
7745 | 305 } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) { |
306 av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n"); | |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
307 return AAC_AC3_PARSE_ERROR_FRAME_TYPE; |
7745 | 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. */ | |
9891
7ad7d4094d1f
Rename ff_log_missing_feature() to av_log_missing_feature().
rbultje
parents:
9708
diff
changeset
|
315 av_log_missing_feature(s->avctx, "Additional substreams", 1); |
8545
a5402e89a80c
Factorise enum of AC3 error types to be usable by AAC in the ADTS patch that
superdump
parents:
8281
diff
changeset
|
316 return AAC_AC3_PARSE_ERROR_FRAME_TYPE; |
7745 | 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. */ | |
9891
7ad7d4094d1f
Rename ff_log_missing_feature() to av_log_missing_feature().
rbultje
parents:
9708
diff
changeset
|
324 av_log_missing_feature(s->avctx, "Reduced sampling rates", 1); |
7745 | 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 skip_bits(gbc, 3); // skip bit stream mode | |
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++) { | |
7750
f9bd775992d4
merge declaration and init. variable is not used outside the loop.
jbr
parents:
7745
diff
changeset
|
521 int frmchexpstr = get_bits(gbc, 5); |
7745 | 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))) { | |
7752
e3fb2606d5b5
skip converter exponent strategy for all channels at once
jbr
parents:
7750
diff
changeset
|
536 skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy |
7745 | 537 } |
538 | |
539 /* determine which channels use AHT */ | |
540 if (parse_aht_info) { | |
7755
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
541 /* For AHT to be used, all non-zero blocks must reuse exponents from |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
542 the first block. Furthermore, for AHT to be used in the coupling |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
543 channel, all blocks must use coupling and use the same coupling |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
544 strategy. */ |
7745 | 545 s->channel_uses_aht[CPL_CH]=0; |
546 for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) { | |
7755
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
547 int use_aht = 1; |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
548 for (blk = 1; blk < 6; blk++) { |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
549 if ((s->exp_strategy[blk][ch] != EXP_REUSE) || |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
550 (!ch && s->cpl_strategy_exists[blk])) { |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
551 use_aht = 0; |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
552 break; |
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
553 } |
7745 | 554 } |
7755
1c0e498ac7bd
simplify code and comment regarding determination whether or not AHT is used.
jbr
parents:
7754
diff
changeset
|
555 s->channel_uses_aht[ch] = use_aht && get_bits1(gbc); |
7745 | 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 */ | |
11559 | 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; | |
8142
f17b1eb9ccd1
revert r15812 (E-AC-3 Spectral Extension) pending further review
jbr
parents:
8136
diff
changeset
|
585 } |
f17b1eb9ccd1
revert r15812 (E-AC-3 Spectral Extension) pending further review
jbr
parents:
8136
diff
changeset
|
586 } |
7745 | 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)); | |
8272 | 595 skip_bits_long(gbc, block_start_bits); |
9891
7ad7d4094d1f
Rename ff_log_missing_feature() to av_log_missing_feature().
rbultje
parents:
9708
diff
changeset
|
596 av_log_missing_feature(s->avctx, "Block start info", 1); |
7745 | 597 } |
598 | |
599 /* syntax state initialization */ | |
600 for (ch = 1; ch <= s->fbw_channels; ch++) { | |
11559 | 601 s->first_spx_coords[ch] = 1; |
7745 | 602 s->first_cpl_coords[ch] = 1; |
603 } | |
604 s->first_cpl_leak = 1; | |
605 | |
606 return 0; | |
607 } |