FFmpeg: libavcodec/eac3dec.c Source File

FFmpeg

[フレーム]

libavcodec

eac3dec.c

Go to the documentation of this file.

1 /*

2 * E-AC-3 decoder

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 */

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 */

41 #include "avcodec.h"

42 #include "ac3.h"

43 #include "ac3_parser_internal.h"

44 #include "ac3dec.h"

45 #include "ac3dec_data.h"

46 #include "eac3_data.h"

48 /** gain adaptive quantization mode */

49 typedef enum {

50 EAC3_GAQ_NO =0,

51 EAC3_GAQ_12,

52 EAC3_GAQ_14,

53 EAC3_GAQ_124

54 } EAC3GaqMode;

56 static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)

57 {

58 int bin, bnd, ch, i;

59 uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];

60 float rms_energy[SPX_MAX_BANDS];

62 /* Set copy index mapping table. Set wrap flags to apply a notch filter at

63 wrap points later on. */

64 bin = s->spx_dst_start_freq;

65 num_copy_sections = 0;

66 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {

67 int copysize;

68 int bandsize = s->spx_band_sizes[bnd];

69 if (bin + bandsize > s->spx_src_start_freq) {

70 copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;

71 bin = s->spx_dst_start_freq;

72 wrapflag[bnd] = 1;

73 }

74 for (i = 0; i < bandsize; i += copysize) {

75 if (bin == s->spx_src_start_freq) {

76 copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;

77 bin = s->spx_dst_start_freq;

78 }

79 copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin);

80 bin += copysize;

81 }

82 }

83 copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;

85 for (ch = 1; ch <= s->fbw_channels; ch++) {

86 if (!s->channel_uses_spx[ch])

87 continue;

89 /* Copy coeffs from normal bands to extension bands */

90 bin = s->spx_src_start_freq;

91 for (i = 0; i < num_copy_sections; i++) {

92 memcpy(&s->transform_coeffs[ch][bin],

93 &s->transform_coeffs[ch][s->spx_dst_start_freq],

94 copy_sizes[i]*sizeof(INTFLOAT));

95 bin += copy_sizes[i];

96 }

98 /* Calculate RMS energy for each SPX band. */

99 bin = s->spx_src_start_freq;

100 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {

101 int bandsize = s->spx_band_sizes[bnd];

102 float accum = 0.0f;

103 for (i = 0; i < bandsize; i++) {

104 float coeff = s->transform_coeffs[ch][bin++];

105 accum += coeff * coeff;

106 }

107 rms_energy[bnd] = sqrtf(accum / bandsize);

108 }

109

110 /* Apply a notch filter at transitions between normal and extension

111 bands and at all wrap points. */

112 if (s->spx_atten_code[ch] >= 0) {

113 const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]];

114 bin = s->spx_src_start_freq - 2;

115 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {

116 if (wrapflag[bnd]) {

117 INTFLOAT *coeffs = &s->transform_coeffs[ch][bin];

118 coeffs[0] *= atten_tab[0];

119 coeffs[1] *= atten_tab[1];

120 coeffs[2] *= atten_tab[2];

121 coeffs[3] *= atten_tab[1];

122 coeffs[4] *= atten_tab[0];

123 }

124 bin += s->spx_band_sizes[bnd];

125 }

126 }

127

128 /* Apply noise-blended coefficient scaling based on previously

129 calculated RMS energy, blending factors, and SPX coordinates for

130 each band. */

131 bin = s->spx_src_start_freq;

132 for (bnd = 0; bnd < s->num_spx_bands; bnd++) {

133 float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN);

134 float sscale = s->spx_signal_blend[ch][bnd];

135 #if USE_FIXED

136 // spx_noise_blend and spx_signal_blend are both FP.23

137 nscale *= 1.0 / (1<<23);

138 sscale *= 1.0 / (1<<23);

139 if (nscale < -1.0)

140 nscale = -1.0;

141 #endif

142 for (i = 0; i < s->spx_band_sizes[bnd]; i++) {

143 UINTFLOAT noise = (INTFLOAT)(nscale * (int32_t)av_lfg_get(&s->dith_state));

144 s->transform_coeffs[ch][bin] *= sscale;

145 s->transform_coeffs[ch][bin++] += noise;

146 }

147 }

148 }

149 }

150

151

152 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */

153 #define COEFF_0 10273905LL

154

155 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */

156 #define COEFF_1 11863283LL

157

158 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */

159 #define COEFF_2 3070444LL

160

161 /**

162 * Calculate 6-point IDCT of the pre-mantissas.

163 * All calculations are 24-bit fixed-point.

164 */

165 static void idct6(int pre_mant[6])

166 {

167 int tmp;

168 int even0, even1, even2, odd0, odd1, odd2;

169

170 odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];

171

172 even2 = ( pre_mant[2] * COEFF_0) >> 23;

173 tmp = ( pre_mant[4] * COEFF_1) >> 23;

174 odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;

175

176 even0 = pre_mant[0] + (tmp >> 1);

177 even1 = pre_mant[0] - tmp;

178

179 tmp = even0;

180 even0 = tmp + even2;

181 even2 = tmp - even2;

182

183 tmp = odd0;

184 odd0 = tmp + pre_mant[1] + pre_mant[3];

185 odd2 = tmp + pre_mant[5] - pre_mant[3];

186

187 pre_mant[0] = even0 + odd0;

188 pre_mant[1] = even1 + odd1;

189 pre_mant[2] = even2 + odd2;

190 pre_mant[3] = even2 - odd2;

191 pre_mant[4] = even1 - odd1;

192 pre_mant[5] = even0 - odd0;

193 }

194

195 static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)

196 {

197 int bin, blk, gs;

198 int end_bap, gaq_mode;

199 GetBitContext *gbc = &s->gbc;

200 int gaq_gain[AC3_MAX_COEFS];

201

202 gaq_mode = get_bits(gbc, 2);

203 end_bap = (gaq_mode < 2) ? 12 : 17;

204

205 /* if GAQ gain is used, decode gain codes for bins with hebap between

206 8 and end_bap */

207 gs = 0;

208 if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {

209 /* read 1-bit GAQ gain codes */

210 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {

211 if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)

212 gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);

213 }

214 } else if (gaq_mode == EAC3_GAQ_124) {

215 /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */

216 int gc = 2;

217 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {

218 if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {

219 if (gc++ == 2) {

220 int group_code = get_bits(gbc, 5);

221 if (group_code > 26) {

222 av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");

223 group_code = 26;

224 }

225 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];

226 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];

227 gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];

228 gc = 0;

229 }

230 }

231 }

232 }

233

234 gs=0;

235 for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {

236 int hebap = s->bap[ch][bin];

237 int bits = ff_eac3_bits_vs_hebap[hebap];

238 if (!hebap) {

239 /* zero-mantissa dithering */

240 for (blk = 0; blk < 6; blk++) {

241 s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;

242 }

243 } else if (hebap < 8) {

244 /* Vector Quantization */

245 int v = get_bits(gbc, bits);

246 for (blk = 0; blk < 6; blk++) {

247 s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] * (1 << 8);

248 }

249 } else {

250 /* Gain Adaptive Quantization */

251 int gbits, log_gain;

252 if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {

253 log_gain = gaq_gain[gs++];

254 } else {

255 log_gain = 0;

256 }

257 gbits = bits - log_gain;

258

259 for (blk = 0; blk < 6; blk++) {

260 int mant = get_sbits(gbc, gbits);

261 if (log_gain && mant == -(1 << (gbits-1))) {

262 /* large mantissa */

263 int b;

264 int mbits = bits - (2 - log_gain);

265 mant = get_sbits(gbc, mbits);

266 mant = ((unsigned)mant) << (23 - (mbits - 1));

267 /* remap mantissa value to correct for asymmetric quantization */

268 if (mant >= 0)

269 b = 1 << (23 - log_gain);

270 else

271 b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] * (1 << 8);

272 mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;

273 } else {

274 /* small mantissa, no GAQ, or Gk=1 */

275 mant *= (1 << 24 - bits);

276 if (!log_gain) {

277 /* remap mantissa value for no GAQ or Gk=1 */

278 mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;

279 }

280 }

281 s->pre_mantissa[ch][bin][blk] = mant;

282 }

283 }

284 idct6(s->pre_mantissa[ch][bin]);

285 }

286 }

287

288 static int ff_eac3_parse_header(AC3DecodeContext *s, const AC3HeaderInfo *hdr)

289 {

290 int i, blk, ch;

291 int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;

292 int parse_transient_proc_info;

293 int num_cpl_blocks;

294 GetBitContext *gbc = &s->gbc;

295

296 /* An E-AC-3 stream can have multiple independent streams which the

297 application can select from. each independent stream can also contain

298 dependent streams which are used to add or replace channels. */

299 if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {

300 av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");

301 return AC3_PARSE_ERROR_FRAME_TYPE;

302 }

303

304 /* The substream id indicates which substream this frame belongs to. each

305 independent stream has its own substream id, and the dependent streams

306 associated to an independent stream have matching substream id's. */

307 if (s->substreamid) {

308 /* only decode substream with id=0. skip any additional substreams. */

309 if (!s->eac3_subsbtreamid_found) {

310 s->eac3_subsbtreamid_found = 1;

311 avpriv_request_sample(s->avctx, "Additional substreams");

312 }

313 return AC3_PARSE_ERROR_FRAME_TYPE;

314 }

315

316 if (s->bit_alloc_params.sr_code == EAC3_SR_CODE_REDUCED) {

317 /* The E-AC-3 specification does not tell how to handle reduced sample

318 rates in bit allocation. The best assumption would be that it is

319 handled like AC-3 DolbyNet, but we cannot be sure until we have a

320 sample which utilizes this feature. */

321 avpriv_request_sample(s->avctx, "Reduced sampling rate");

322 return AVERROR_PATCHWELCOME;

323 }

324

325 /* volume control params */

326 for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {

327 s->dialog_normalization[i] = hdr->dialog_normalization[i];

328 if (s->dialog_normalization[i] == 0) {

329 s->dialog_normalization[i] = -31;

330 }

331 if (s->target_level != 0) {

332 s->level_gain[i] = powf(2.0f,

333 (float)(s->target_level - s->dialog_normalization[i])/6.0f);

334 }

335 if (hdr->compression_exists[i]) {

336 s->heavy_dynamic_range[i] = AC3_HEAVY_RANGE(hdr->heavy_dynamic_range[i]);

337 }

338 }

339

340 s->channel_map = hdr->channel_map;

341

342 /* mixing metadata */

343 s->preferred_downmix = hdr->preferred_downmix;

344 s->center_mix_level_ltrt = hdr->center_mix_level_ltrt;

345 s->center_mix_level = hdr->center_mix_level;

346 s->surround_mix_level_ltrt = hdr->surround_mix_level_ltrt;

347 s->surround_mix_level = hdr->surround_mix_level;

348 s->lfe_mix_level_exists = hdr->lfe_mix_level_exists;

349 s->lfe_mix_level = hdr->lfe_mix_level;

350 s->dolby_surround_mode = hdr->dolby_surround_mode;

351 s->dolby_headphone_mode = hdr->dolby_headphone_mode;

352 s->dolby_surround_ex_mode = hdr->dolby_surround_ex_mode;

353

354 /* informational metadata */

355 s->bitstream_mode = hdr->bitstream_mode;

356

357 /* additional bitstream info */

358 s->eac3_extension_type_a = hdr->eac3_extension_type_a;

359

360 /* audio frame syntax flags, strategy data, and per-frame data */

361

362 if (s->num_blocks == 6) {

363 ac3_exponent_strategy = get_bits1(gbc);

364 parse_aht_info = get_bits1(gbc);

365 } else {

366 /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and

367 do not use AHT */

368 ac3_exponent_strategy = 1;

369 parse_aht_info = 0;

370 }

371

372 s->snr_offset_strategy = get_bits(gbc, 2);

373 parse_transient_proc_info = get_bits1(gbc);

374

375 s->block_switch_syntax = get_bits1(gbc);

376 if (!s->block_switch_syntax)

377 memset(s->block_switch, 0, sizeof(s->block_switch));

378

379 s->dither_flag_syntax = get_bits1(gbc);

380 if (!s->dither_flag_syntax) {

381 for (ch = 1; ch <= s->fbw_channels; ch++)

382 s->dither_flag[ch] = 1;

383 }

384 s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;

385

386 s->bit_allocation_syntax = get_bits1(gbc);

387 if (!s->bit_allocation_syntax) {

388 /* set default bit allocation parameters */

389 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[2];

390 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[1];

391 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab [1];

392 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[2];

393 s->bit_alloc_params.floor = ff_ac3_floor_tab [7];

394 }

395

396 s->fast_gain_syntax = get_bits1(gbc);

397 s->dba_syntax = get_bits1(gbc);

398 s->skip_syntax = get_bits1(gbc);

399 parse_spx_atten_data = get_bits1(gbc);

400

401 /* coupling strategy occurrence and coupling use per block */

402 num_cpl_blocks = 0;

403 if (s->channel_mode > 1) {

404 for (blk = 0; blk < s->num_blocks; blk++) {

405 s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));

406 if (s->cpl_strategy_exists[blk]) {

407 s->cpl_in_use[blk] = get_bits1(gbc);

408 } else {

409 s->cpl_in_use[blk] = s->cpl_in_use[blk-1];

410 }

411 num_cpl_blocks += s->cpl_in_use[blk];

412 }

413 } else {

414 memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));

415 }

416

417 /* exponent strategy data */

418 if (ac3_exponent_strategy) {

419 /* AC-3-style exponent strategy syntax */

420 for (blk = 0; blk < s->num_blocks; blk++) {

421 for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {

422 s->exp_strategy[blk][ch] = get_bits(gbc, 2);

423 }

424 }

425 } else {

426 /* LUT-based exponent strategy syntax */

427 for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {

428 int frmchexpstr = get_bits(gbc, 5);

429 for (blk = 0; blk < 6; blk++) {

430 s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];

431 }

432 }

433 }

434 /* LFE exponent strategy */

435 if (s->lfe_on) {

436 for (blk = 0; blk < s->num_blocks; blk++) {

437 s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);

438 }

439 }

440 /* original exponent strategies if this stream was converted from AC-3 */

441 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT &&

442 (s->num_blocks == 6 || get_bits1(gbc))) {

443 skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy

444 }

445

446 /* determine which channels use AHT */

447 if (parse_aht_info) {

448 /* For AHT to be used, all non-zero blocks must reuse exponents from

449 the first block. Furthermore, for AHT to be used in the coupling

450 channel, all blocks must use coupling and use the same coupling

451 strategy. */

452 s->channel_uses_aht[CPL_CH]=0;

453 for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {

454 int use_aht = 1;

455 for (blk = 1; blk < 6; blk++) {

456 if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||

457 (!ch && s->cpl_strategy_exists[blk])) {

458 use_aht = 0;

459 break;

460 }

461 }

462 s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);

463 }

464 } else {

465 memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));

466 }

467

468 /* per-frame SNR offset */

469 if (!s->snr_offset_strategy) {

470 int csnroffst = (get_bits(gbc, 6) - 15) << 4;

471 int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;

472 for (ch = 0; ch <= s->channels; ch++)

473 s->snr_offset[ch] = snroffst;

474 }

475

476 /* transient pre-noise processing data */

477 if (parse_transient_proc_info) {

478 for (ch = 1; ch <= s->fbw_channels; ch++) {

479 if (get_bits1(gbc)) { // channel in transient processing

480 skip_bits(gbc, 10); // skip transient processing location

481 skip_bits(gbc, 8); // skip transient processing length

482 }

483 }

484 }

485

486 /* spectral extension attenuation data */

487 for (ch = 1; ch <= s->fbw_channels; ch++) {

488 if (parse_spx_atten_data && get_bits1(gbc)) {

489 s->spx_atten_code[ch] = get_bits(gbc, 5);

490 } else {

491 s->spx_atten_code[ch] = -1;

492 }

493 }

494

495 /* block start information */

496 if (s->num_blocks > 1 && get_bits1(gbc)) {

497 /* reference: Section E2.3.2.27

498 nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))

499 The spec does not say what this data is or what it's used for.

500 It is likely the offset of each block within the frame. */

501 int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));

502 skip_bits_long(gbc, block_start_bits);

503 avpriv_request_sample(s->avctx, "Block start info");

504 }

505

506 /* syntax state initialization */

507 for (ch = 1; ch <= s->fbw_channels; ch++) {

508 s->first_spx_coords[ch] = 1;

509 s->first_cpl_coords[ch] = 1;

510 }

511 s->first_cpl_leak = 1;

512

513 return 0;

514 }

AC3HeaderInfo::lfe_mix_level

uint8_t lfe_mix_level

Definition: ac3_parser_internal.h:78

EAC3_SR_CODE_REDUCED

#define EAC3_SR_CODE_REDUCED

Definition: ac3defs.h:37

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:276

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

AC3HeaderInfo::center_mix_level

int center_mix_level

Center mix level index.

Definition: ac3_parser_internal.h:47

INTFLOAT

#define INTFLOAT

Definition: dct32_template.c:44

ff_ac3_fast_decay_tab

const uint8_t ff_ac3_fast_decay_tab[4]

Definition: ac3tab.c:131

AC3HeaderInfo::dolby_surround_mode

int dolby_surround_mode

Definition: ac3_parser_internal.h:52

ff_eac3_frm_expstr

const uint8_t ff_eac3_frm_expstr[32][6]

Table E2.14 Frame Exponent Strategy Combinations.

Definition: eac3_data.c:1064

int64_t

long long int64_t

Definition: coverity.c:34

EAC3_GAQ_14

@ EAC3_GAQ_14

Definition: eac3dec.c:52

AC3HeaderInfo::lfe_mix_level_exists

uint8_t lfe_mix_level_exists

Definition: ac3_parser_internal.h:77

#define b

Definition: input.c:42

EAC3_FRAME_TYPE_RESERVED

@ EAC3_FRAME_TYPE_RESERVED

Definition: ac3defs.h:114

COEFF_0

#define COEFF_0

lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23))

Definition: eac3dec.c:153

ff_eac3_decode_transform_coeffs_aht_ch

static void ff_eac3_decode_transform_coeffs_aht_ch(AC3DecodeContext *s, int ch)

Definition: eac3dec.c:195

AC3HeaderInfo::heavy_dynamic_range

uint8_t heavy_dynamic_range[2]

Definition: ac3_parser_internal.h:72

ff_eac3_gaq_remap_2_4_a

const int16_t ff_eac3_gaq_remap_2_4_a[9][2]

Table E3.6, Gk=2 & Gk=4, A Large mantissa inverse quantization, remapping scale factors ff_eac3_gaq_r...

Definition: eac3_data.c:51

AC3HeaderInfo::center_mix_level_ltrt

uint8_t center_mix_level_ltrt

Center mix level index.

Definition: ac3_parser_internal.h:73

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:379

AC3_PARSE_ERROR_FRAME_TYPE

@ AC3_PARSE_ERROR_FRAME_TYPE

Definition: ac3_parser_internal.h:90

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:333

ac3dec.h

GetBitContext

Definition: get_bits.h:109

AC3HeaderInfo

Definition: ac3_parser_internal.h:34

noise

static int noise(AVBSFContext *ctx, AVPacket *pkt)

Definition: noise.c:124

COEFF_2

#define COEFF_2

lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23))

Definition: eac3dec.c:159

EXP_REUSE

#define EXP_REUSE

Definition: ac3defs.h:51

AC3HeaderInfo::compression_exists

uint8_t compression_exists[2]

Definition: ac3_parser_internal.h:71

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

#define s(width, name)

Definition: cbs_vp9.c:198

EAC3_GAQ_12

@ EAC3_GAQ_12

Definition: eac3dec.c:51

av_lfg_get

static unsigned int av_lfg_get(AVLFG *c)

Get the next random unsigned 32-bit number using an ALFG.

Definition: lfg.h:53

AC3_MAX_COEFS

#define AC3_MAX_COEFS

Definition: ac3defs.h:29

eac3_data.h

ff_ac3_floor_tab

const int16_t ff_ac3_floor_tab[8]

Definition: ac3tab.c:143

bits

uint8_t bits

Definition: vp3data.h:128

EAC3_FRAME_TYPE_INDEPENDENT

@ EAC3_FRAME_TYPE_INDEPENDENT

Definition: ac3defs.h:111

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:318

blk

#define blk(i)

Definition: sha.c:186

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:386

AC3HeaderInfo::dolby_surround_ex_mode

uint8_t dolby_surround_ex_mode

Definition: ac3_parser_internal.h:76

sqrtf

static __device__ float sqrtf(float a)

Definition: cuda_runtime.h:184

AC3HeaderInfo::eac3_extension_type_a

uint8_t eac3_extension_type_a

Definition: ac3_parser_internal.h:80

idct6

static void idct6(int pre_mant[6])

Calculate 6-point IDCT of the pre-mantissas.

Definition: eac3dec.c:165

ff_eac3_gaq_remap_2_4_b

const int16_t ff_eac3_gaq_remap_2_4_b[9][2]

Table E3.6, Gk=2 & Gk=4, B Large mantissa inverse quantization, negative mantissa remapping offsets f...

Definition: eac3_data.c:68

ff_eac3_bits_vs_hebap

const uint8_t ff_eac3_bits_vs_hebap[20]

Definition: eac3_data.c:32

Definition: af_crystalizer.c:122

ac3_parser_internal.h

powf

#define powf(x, y)

Definition: libm.h:52

ff_ac3_db_per_bit_tab

const uint16_t ff_ac3_db_per_bit_tab[4]

Definition: ac3tab.c:139

AC3HeaderInfo::dolby_headphone_mode

uint8_t dolby_headphone_mode

Definition: ac3_parser_internal.h:75

ac3dec_data.h

AC3HeaderInfo::preferred_downmix

uint8_t preferred_downmix

Definition: ac3_parser_internal.h:79

ff_ac3_ungroup_3_in_5_bits_tab

const uint8_t ff_ac3_ungroup_3_in_5_bits_tab[32][3]

Table used to ungroup 3 values stored in 5 bits.

Definition: ac3dec_data.c:35

COEFF_1

#define COEFF_1

lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23))

Definition: eac3dec.c:156

AC3HeaderInfo::bitstream_mode

uint8_t bitstream_mode

Definition: ac3_parser_internal.h:42

ff_eac3_mantissa_vq

const int16_t(*const [8] ff_eac3_mantissa_vq)[6]

Definition: eac3_data.c:1050

CPL_CH

#define CPL_CH

coupling channel index

Definition: ac3defs.h:27

EAC3_GAQ_NO

@ EAC3_GAQ_NO

Definition: eac3dec.c:50

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

ff_ac3_slow_decay_tab

const uint8_t ff_ac3_slow_decay_tab[4]

Definition: ac3tab.c:127

ff_eac3_apply_spectral_extension

static void ff_eac3_apply_spectral_extension(AC3DecodeContext *s)

Definition: eac3dec.c:56

AC3_HEAVY_RANGE

#define AC3_HEAVY_RANGE(x)

Definition: ac3.h:71

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AC3HeaderInfo::channel_map

uint16_t channel_map

Definition: ac3_parser_internal.h:50

EAC3_GAQ_124

@ EAC3_GAQ_124

Definition: eac3dec.c:53

UINTFLOAT

float UINTFLOAT

Definition: aac_defines.h:102

avcodec.h

ff_eac3_gaq_remap_1

const int16_t ff_eac3_gaq_remap_1[12]

Table E3.6, Gk=1 No gain (Gk=1) inverse quantization, remapping scale factors ff_eac3_gaq_remap[hebap...

Definition: eac3_data.c:42

avpriv_request_sample

#define avpriv_request_sample(...)

Definition: tableprint_vlc.h:37

ff_ac3_slow_gain_tab

const uint16_t ff_ac3_slow_gain_tab[4]

Definition: ac3tab.c:135

ac3.h

int32_t

Definition: audioconvert.c:56

coeff

static const double coeff[2][5]

Definition: vf_owdenoise.c:80

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

ff_eac3_parse_header

static int ff_eac3_parse_header(AC3DecodeContext *s, const AC3HeaderInfo *hdr)

Definition: eac3dec.c:288

AC3HeaderInfo::dialog_normalization

int8_t dialog_normalization[2]

Definition: ac3_parser_internal.h:70

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

AC3HeaderInfo::surround_mix_level

int surround_mix_level

Surround mix level index.

Definition: ac3_parser_internal.h:48

INTFLOAT

float INTFLOAT

Definition: aac_defines.h:101

EAC3GaqMode

gain adaptive quantization mode

Definition: eac3dec.c:49

AC3HeaderInfo::surround_mix_level_ltrt

uint8_t surround_mix_level_ltrt

Surround mix level index.

Definition: ac3_parser_internal.h:74

ff_eac3_spx_atten_tab

const float ff_eac3_spx_atten_tab[32][3]

Table E.25: Spectral Extension Attenuation Table ff_eac3_spx_atten_tab[code][bin]=pow(2....

Definition: eac3_data.c:1103

Generated on Sat Oct 18 2025 19:22:02 for FFmpeg by doxygen 1.8.17