Mercurial > libavcodec.hg
annotate eac3dec.c @ 12266:48d6738904a9 libavcodec
Fix SPLATB_REG mess. Used to be a if/elseif/elseif/elseif spaghetti, so this
splits it into small optimization-specific macros which are selected for each
DSP function. The advantage of this approach is that the sse4 functions now
use the ssse3 codepath also without needing an explicit sse4 codepath.
author | rbultje |
---|---|
date | Sat, 24 Jul 2010 19:33:05 +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 } |