FFmpeg: libavcodec/ac3dec.c Source File

FFmpeg

[フレーム]

libavcodec

ac3dec.c

Go to the documentation of this file.

1 /*

2 * AC-3 Audio Decoder

3 * This code was developed as part of Google Summer of Code 2006.

4 * E-AC-3 support was added as part of Google Summer of Code 2007.

5 *

9 *

10 * This file is part of FFmpeg.

11 *

12 * FFmpeg is free software; you can redistribute it and/or

13 * modify it under the terms of the GNU Lesser General Public

14 * License as published by the Free Software Foundation; either

15 * version 2.1 of the License, or (at your option) any later version.

16 *

17 * FFmpeg is distributed in the hope that it will be useful,

18 * but WITHOUT ANY WARRANTY; without even the implied warranty of

19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

20 * Lesser General Public License for more details.

21 *

22 * You should have received a copy of the GNU Lesser General Public

23 * License along with FFmpeg; if not, write to the Free Software

24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

25 */

27 #include <stdio.h>

28 #include <stddef.h>

29 #include <math.h>

30 #include <string.h>

32 #include "libavutil/crc.h"

33 #include "libavutil/opt.h"

34 #include "internal.h"

35 #include "aac_ac3_parser.h"

36 #include "ac3_parser.h"

37 #include "ac3dec.h"

38 #include "ac3dec_data.h"

39 #include "kbdwin.h"

41 /**

42 * table for ungrouping 3 values in 7 bits.

43 * used for exponents and bap=2 mantissas

44 */

45 static uint8_t ungroup_3_in_7_bits_tab[128][3];

47 /** tables for ungrouping mantissas */

48 static int b1_mantissas[32][3];

49 static int b2_mantissas[128][3];

50 static int b3_mantissas[8];

51 static int b4_mantissas[128][2];

52 static int b5_mantissas[16];

54 /**

55 * Quantization table: levels for symmetric. bits for asymmetric.

56 * reference: Table 7.18 Mapping of bap to Quantizer

57 */

58 static const uint8_t quantization_tab[16] = {

59 0, 3, 5, 7, 11, 15,

60 5, 6, 7, 8, 9, 10, 11, 12, 14, 16

61 };

63 /** dynamic range table. converts codes to scale factors. */

64 static float dynamic_range_tab[256];

66 /** Adjustments in dB gain */

67 static const float gain_levels[9] = {

68 LEVEL_PLUS_3DB,

69 LEVEL_PLUS_1POINT5DB,

70 LEVEL_ONE,

71 LEVEL_MINUS_1POINT5DB,

72 LEVEL_MINUS_3DB,

73 LEVEL_MINUS_4POINT5DB,

74 LEVEL_MINUS_6DB,

75 LEVEL_ZERO,

76 LEVEL_MINUS_9DB

77 };

79 /**

80 * Table for default stereo downmixing coefficients

81 * reference: Section 7.8.2 Downmixing Into Two Channels

82 */

83 static const uint8_t ac3_default_coeffs[8][5][2] = {

84 { { 2, 7 }, { 7, 2 }, },

85 { { 4, 4 }, },

86 { { 2, 7 }, { 7, 2 }, },

87 { { 2, 7 }, { 5, 5 }, { 7, 2 }, },

88 { { 2, 7 }, { 7, 2 }, { 6, 6 }, },

89 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 8, 8 }, },

90 { { 2, 7 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },

91 { { 2, 7 }, { 5, 5 }, { 7, 2 }, { 6, 7 }, { 7, 6 }, },

92 };

94 /**

95 * Symmetrical Dequantization

96 * reference: Section 7.3.3 Expansion of Mantissas for Symmetrical Quantization

97 * Tables 7.19 to 7.23

98 */

99 static inline int

100 symmetric_dequant(int code, int levels)

101 {

102 return ((code - (levels >> 1)) << 24) / levels;

103 }

104

105 /*

106 * Initialize tables at runtime.

107 */

108 static av_cold void ac3_tables_init(void)

109 {

110 int i;

111

112 /* generate table for ungrouping 3 values in 7 bits

113 reference: Section 7.1.3 Exponent Decoding */

114 for (i = 0; i < 128; i++) {

115 ungroup_3_in_7_bits_tab[i][0] = i / 25;

116 ungroup_3_in_7_bits_tab[i][1] = (i % 25) / 5;

117 ungroup_3_in_7_bits_tab[i][2] = (i % 25) % 5;

118 }

119

120 /* generate grouped mantissa tables

121 reference: Section 7.3.5 Ungrouping of Mantissas */

122 for (i = 0; i < 32; i++) {

123 /* bap=1 mantissas */

124 b1_mantissas[i][0] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][0], 3);

125 b1_mantissas[i][1] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][1], 3);

126 b1_mantissas[i][2] = symmetric_dequant(ff_ac3_ungroup_3_in_5_bits_tab[i][2], 3);

127 }

128 for (i = 0; i < 128; i++) {

129 /* bap=2 mantissas */

130 b2_mantissas[i][0] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][0], 5);

131 b2_mantissas[i][1] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][1], 5);

132 b2_mantissas[i][2] = symmetric_dequant(ungroup_3_in_7_bits_tab[i][2], 5);

133

134 /* bap=4 mantissas */

135 b4_mantissas[i][0] = symmetric_dequant(i / 11, 11);

136 b4_mantissas[i][1] = symmetric_dequant(i % 11, 11);

137 }

138 /* generate ungrouped mantissa tables

139 reference: Tables 7.21 and 7.23 */

140 for (i = 0; i < 7; i++) {

141 /* bap=3 mantissas */

142 b3_mantissas[i] = symmetric_dequant(i, 7);

143 }

144 for (i = 0; i < 15; i++) {

145 /* bap=5 mantissas */

146 b5_mantissas[i] = symmetric_dequant(i, 15);

147 }

148

149 /* generate dynamic range table

150 reference: Section 7.7.1 Dynamic Range Control */

151 for (i = 0; i < 256; i++) {

152 int v = (i >> 5) - ((i >> 7) << 3) - 5;

153 dynamic_range_tab[i] = powf(2.0f, v) * ((i & 0x1F) | 0x20);

154 }

155 }

156

157 /**

158 * AVCodec initialization

159 */

160 static av_cold int ac3_decode_init(AVCodecContext *avctx)

161 {

162 AC3DecodeContext *s = avctx->priv_data;

163 int i;

164

165 s->avctx = avctx;

166

167 ff_ac3_common_init();

168 ac3_tables_init();

169 ff_mdct_init(&s->imdct_256, 8, 1, 1.0);

170 ff_mdct_init(&s->imdct_512, 9, 1, 1.0);

171 ff_kbd_window_init(s->window, 5.0, 256);

172 ff_dsputil_init(&s->dsp, avctx);

173 avpriv_float_dsp_init(&s->fdsp, avctx->flags & CODEC_FLAG_BITEXACT);

174 ff_ac3dsp_init(&s->ac3dsp, avctx->flags & CODEC_FLAG_BITEXACT);

175 ff_fmt_convert_init(&s->fmt_conv, avctx);

176 av_lfg_init(&s->dith_state, 0);

177

178 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

179

180 /* allow downmixing to stereo or mono */

181 if (avctx->channels > 0 && avctx->request_channels > 0 &&

182 avctx->request_channels < avctx->channels &&

183 avctx->request_channels <= 2) {

184 avctx->channels = avctx->request_channels;

185 }

186 s->downmixed = 1;

187

188 for (i = 0; i < AC3_MAX_CHANNELS; i++) {

189 s->xcfptr[i] = s->transform_coeffs[i];

190 s->dlyptr[i] = s->delay[i];

191 }

192

193 return 0;

194 }

195

196 /**

197 * Parse the 'sync info' and 'bit stream info' from the AC-3 bitstream.

198 * GetBitContext within AC3DecodeContext must point to

199 * the start of the synchronized AC-3 bitstream.

200 */

201 static int ac3_parse_header(AC3DecodeContext *s)

202 {

203 GetBitContext *gbc = &s->gbc;

204 int i;

205

206 /* read the rest of the bsi. read twice for dual mono mode. */

207 i = !s->channel_mode;

208 do {

209 skip_bits(gbc, 5); // skip dialog normalization

210 if (get_bits1(gbc))

211 skip_bits(gbc, 8); //skip compression

212 if (get_bits1(gbc))

213 skip_bits(gbc, 8); //skip language code

214 if (get_bits1(gbc))

215 skip_bits(gbc, 7); //skip audio production information

216 } while (i--);

217

218 skip_bits(gbc, 2); //skip copyright bit and original bitstream bit

219

220 /* skip the timecodes (or extra bitstream information for Alternate Syntax)

221 TODO: read & use the xbsi1 downmix levels */

222 if (get_bits1(gbc))

223 skip_bits(gbc, 14); //skip timecode1 / xbsi1

224 if (get_bits1(gbc))

225 skip_bits(gbc, 14); //skip timecode2 / xbsi2

226

227 /* skip additional bitstream info */

228 if (get_bits1(gbc)) {

229 i = get_bits(gbc, 6);

230 do {

231 skip_bits(gbc, 8);

232 } while (i--);

233 }

234

235 return 0;

236 }

237

238 /**

239 * Common function to parse AC-3 or E-AC-3 frame header

240 */

241 static int parse_frame_header(AC3DecodeContext *s)

242 {

243 AC3HeaderInfo hdr;

244 int err;

245

246 err = avpriv_ac3_parse_header(&s->gbc, &hdr);

247 if (err)

248 return err;

249

250 /* get decoding parameters from header info */

251 s->bit_alloc_params.sr_code = hdr.sr_code;

252 s->bitstream_mode = hdr.bitstream_mode;

253 s->channel_mode = hdr.channel_mode;

254 s->channel_layout = hdr.channel_layout;

255 s->lfe_on = hdr.lfe_on;

256 s->bit_alloc_params.sr_shift = hdr.sr_shift;

257 s->sample_rate = hdr.sample_rate;

258 s->bit_rate = hdr.bit_rate;

259 s->channels = hdr.channels;

260 s->fbw_channels = s->channels - s->lfe_on;

261 s->lfe_ch = s->fbw_channels + 1;

262 s->frame_size = hdr.frame_size;

263 s->center_mix_level = hdr.center_mix_level;

264 s->surround_mix_level = hdr.surround_mix_level;

265 s->num_blocks = hdr.num_blocks;

266 s->frame_type = hdr.frame_type;

267 s->substreamid = hdr.substreamid;

268

269 if (s->lfe_on) {

270 s->start_freq[s->lfe_ch] = 0;

271 s->end_freq[s->lfe_ch] = 7;

272 s->num_exp_groups[s->lfe_ch] = 2;

273 s->channel_in_cpl[s->lfe_ch] = 0;

274 }

275

276 if (hdr.bitstream_id <= 10) {

277 s->eac3 = 0;

278 s->snr_offset_strategy = 2;

279 s->block_switch_syntax = 1;

280 s->dither_flag_syntax = 1;

281 s->bit_allocation_syntax = 1;

282 s->fast_gain_syntax = 0;

283 s->first_cpl_leak = 0;

284 s->dba_syntax = 1;

285 s->skip_syntax = 1;

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

287 return ac3_parse_header(s);

288 } else if (CONFIG_EAC3_DECODER) {

289 s->eac3 = 1;

290 return ff_eac3_parse_header(s);

291 } else {

292 av_log(s->avctx, AV_LOG_ERROR, "E-AC-3 support not compiled in\n");

293 return -1;

294 }

295 }

296

297 /**

298 * Set stereo downmixing coefficients based on frame header info.

299 * reference: Section 7.8.2 Downmixing Into Two Channels

300 */

301 static void set_downmix_coeffs(AC3DecodeContext *s)

302 {

303 int i;

304 float cmix = gain_levels[s-> center_mix_level];

305 float smix = gain_levels[s->surround_mix_level];

306 float norm0, norm1;

307

308 for (i = 0; i < s->fbw_channels; i++) {

309 s->downmix_coeffs[i][0] = gain_levels[ac3_default_coeffs[s->channel_mode][i][0]];

310 s->downmix_coeffs[i][1] = gain_levels[ac3_default_coeffs[s->channel_mode][i][1]];

311 }

312 if (s->channel_mode > 1 && s->channel_mode & 1) {

313 s->downmix_coeffs[1][0] = s->downmix_coeffs[1][1] = cmix;

314 }

315 if (s->channel_mode == AC3_CHMODE_2F1R || s->channel_mode == AC3_CHMODE_3F1R) {

316 int nf = s->channel_mode - 2;

317 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf][1] = smix * LEVEL_MINUS_3DB;

318 }

319 if (s->channel_mode == AC3_CHMODE_2F2R || s->channel_mode == AC3_CHMODE_3F2R) {

320 int nf = s->channel_mode - 4;

321 s->downmix_coeffs[nf][0] = s->downmix_coeffs[nf+1][1] = smix;

322 }

323

324 /* renormalize */

325 norm0 = norm1 = 0.0;

326 for (i = 0; i < s->fbw_channels; i++) {

327 norm0 += s->downmix_coeffs[i][0];

328 norm1 += s->downmix_coeffs[i][1];

329 }

330 norm0 = 1.0f / norm0;

331 norm1 = 1.0f / norm1;

332 for (i = 0; i < s->fbw_channels; i++) {

333 s->downmix_coeffs[i][0] *= norm0;

334 s->downmix_coeffs[i][1] *= norm1;

335 }

336

337 if (s->output_mode == AC3_CHMODE_MONO) {

338 for (i = 0; i < s->fbw_channels; i++)

339 s->downmix_coeffs[i][0] = (s->downmix_coeffs[i][0] +

340 s->downmix_coeffs[i][1]) * LEVEL_MINUS_3DB;

341 }

342 }

343

344 /**

345 * Decode the grouped exponents according to exponent strategy.

346 * reference: Section 7.1.3 Exponent Decoding

347 */

348 static int decode_exponents(GetBitContext *gbc, int exp_strategy, int ngrps,

349 uint8_t absexp, int8_t *dexps)

350 {

351 int i, j, grp, group_size;

352 int dexp[256];

353 int expacc, prevexp;

354

355 /* unpack groups */

356 group_size = exp_strategy + (exp_strategy == EXP_D45);

357 for (grp = 0, i = 0; grp < ngrps; grp++) {

358 expacc = get_bits(gbc, 7);

359 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][0];

360 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][1];

361 dexp[i++] = ungroup_3_in_7_bits_tab[expacc][2];

362 }

363

364 /* convert to absolute exps and expand groups */

365 prevexp = absexp;

366 for (i = 0, j = 0; i < ngrps * 3; i++) {

367 prevexp += dexp[i] - 2;

368 if (prevexp > 24U)

369 return -1;

370 switch (group_size) {

371 case 4: dexps[j++] = prevexp;

372 dexps[j++] = prevexp;

373 case 2: dexps[j++] = prevexp;

374 case 1: dexps[j++] = prevexp;

375 }

376 }

377 return 0;

378 }

379

380 /**

381 * Generate transform coefficients for each coupled channel in the coupling

382 * range using the coupling coefficients and coupling coordinates.

383 * reference: Section 7.4.3 Coupling Coordinate Format

384 */

385 static void calc_transform_coeffs_cpl(AC3DecodeContext *s)

386 {

387 int bin, band, ch;

388

389 bin = s->start_freq[CPL_CH];

390 for (band = 0; band < s->num_cpl_bands; band++) {

391 int band_start = bin;

392 int band_end = bin + s->cpl_band_sizes[band];

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

394 if (s->channel_in_cpl[ch]) {

395 int cpl_coord = s->cpl_coords[ch][band] << 5;

396 for (bin = band_start; bin < band_end; bin++) {

397 s->fixed_coeffs[ch][bin] =

398 MULH(s->fixed_coeffs[CPL_CH][bin] << 4, cpl_coord);

399 }

400 if (ch == 2 && s->phase_flags[band]) {

401 for (bin = band_start; bin < band_end; bin++)

402 s->fixed_coeffs[2][bin] = -s->fixed_coeffs[2][bin];

403 }

404 }

405 }

406 bin = band_end;

407 }

408 }

409

410 /**

411 * Grouped mantissas for 3-level 5-level and 11-level quantization

412 */

413 typedef struct {

414 int b1_mant[2];

415 int b2_mant[2];

416 int b4_mant;

417 int b1;

418 int b2;

419 int b4;

420 } mant_groups;

421

422 /**

423 * Decode the transform coefficients for a particular channel

424 * reference: Section 7.3 Quantization and Decoding of Mantissas

425 */

426 static void ac3_decode_transform_coeffs_ch(AC3DecodeContext *s, int ch_index, mant_groups *m)

427 {

428 int start_freq = s->start_freq[ch_index];

429 int end_freq = s->end_freq[ch_index];

430 uint8_t *baps = s->bap[ch_index];

431 int8_t *exps = s->dexps[ch_index];

432 int32_t *coeffs = s->fixed_coeffs[ch_index];

433 int dither = (ch_index == CPL_CH) || s->dither_flag[ch_index];

434 GetBitContext *gbc = &s->gbc;

435 int freq;

436

437 for (freq = start_freq; freq < end_freq; freq++) {

438 int bap = baps[freq];

439 int mantissa;

440 switch (bap) {

441 case 0:

442 /* random noise with approximate range of -0.707 to 0.707 */

443 if (dither)

444 mantissa = (((av_lfg_get(&s->dith_state)>>8)*181)>>8) - 5931008;

445 else

446 mantissa = 0;

447 break;

448 case 1:

449 if (m->b1) {

450 m->b1--;

451 mantissa = m->b1_mant[m->b1];

452 } else {

453 int bits = get_bits(gbc, 5);

454 mantissa = b1_mantissas[bits][0];

455 m->b1_mant[1] = b1_mantissas[bits][1];

456 m->b1_mant[0] = b1_mantissas[bits][2];

457 m->b1 = 2;

458 }

459 break;

460 case 2:

461 if (m->b2) {

462 m->b2--;

463 mantissa = m->b2_mant[m->b2];

464 } else {

465 int bits = get_bits(gbc, 7);

466 mantissa = b2_mantissas[bits][0];

467 m->b2_mant[1] = b2_mantissas[bits][1];

468 m->b2_mant[0] = b2_mantissas[bits][2];

469 m->b2 = 2;

470 }

471 break;

472 case 3:

473 mantissa = b3_mantissas[get_bits(gbc, 3)];

474 break;

475 case 4:

476 if (m->b4) {

477 m->b4 = 0;

478 mantissa = m->b4_mant;

479 } else {

480 int bits = get_bits(gbc, 7);

481 mantissa = b4_mantissas[bits][0];

482 m->b4_mant = b4_mantissas[bits][1];

483 m->b4 = 1;

484 }

485 break;

486 case 5:

487 mantissa = b5_mantissas[get_bits(gbc, 4)];

488 break;

489 default: /* 6 to 15 */

490 /* Shift mantissa and sign-extend it. */

491 mantissa = get_sbits(gbc, quantization_tab[bap]);

492 mantissa <<= 24 - quantization_tab[bap];

493 break;

494 }

495 coeffs[freq] = mantissa >> exps[freq];

496 }

497 }

498

499 /**

500 * Remove random dithering from coupling range coefficients with zero-bit

501 * mantissas for coupled channels which do not use dithering.

502 * reference: Section 7.3.4 Dither for Zero Bit Mantissas (bap=0)

503 */

504 static void remove_dithering(AC3DecodeContext *s) {

505 int ch, i;

506

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

508 if (!s->dither_flag[ch] && s->channel_in_cpl[ch]) {

509 for (i = s->start_freq[CPL_CH]; i < s->end_freq[CPL_CH]; i++) {

510 if (!s->bap[CPL_CH][i])

511 s->fixed_coeffs[ch][i] = 0;

512 }

513 }

514 }

515 }

516

517 static void decode_transform_coeffs_ch(AC3DecodeContext *s, int blk, int ch,

518 mant_groups *m)

519 {

520 if (!s->channel_uses_aht[ch]) {

521 ac3_decode_transform_coeffs_ch(s, ch, m);

522 } else {

523 /* if AHT is used, mantissas for all blocks are encoded in the first

524 block of the frame. */

525 int bin;

526 if (!blk && CONFIG_EAC3_DECODER)

527 ff_eac3_decode_transform_coeffs_aht_ch(s, ch);

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

529 s->fixed_coeffs[ch][bin] = s->pre_mantissa[ch][bin][blk] >> s->dexps[ch][bin];

530 }

531 }

532 }

533

534 /**

535 * Decode the transform coefficients.

536 */

537 static void decode_transform_coeffs(AC3DecodeContext *s, int blk)

538 {

539 int ch, end;

540 int got_cplchan = 0;

541 mant_groups m;

542

543 m.b1 = m.b2 = m.b4 = 0;

544

545 for (ch = 1; ch <= s->channels; ch++) {

546 /* transform coefficients for full-bandwidth channel */

547 decode_transform_coeffs_ch(s, blk, ch, &m);

548 /* transform coefficients for coupling channel come right after the

549 coefficients for the first coupled channel*/

550 if (s->channel_in_cpl[ch]) {

551 if (!got_cplchan) {

552 decode_transform_coeffs_ch(s, blk, CPL_CH, &m);

553 calc_transform_coeffs_cpl(s);

554 got_cplchan = 1;

555 }

556 end = s->end_freq[CPL_CH];

557 } else {

558 end = s->end_freq[ch];

559 }

560 do

561 s->fixed_coeffs[ch][end] = 0;

562 while (++end < 256);

563 }

564

565 /* zero the dithered coefficients for appropriate channels */

566 remove_dithering(s);

567 }

568

569 /**

570 * Stereo rematrixing.

571 * reference: Section 7.5.4 Rematrixing : Decoding Technique

572 */

573 static void do_rematrixing(AC3DecodeContext *s)

574 {

575 int bnd, i;

576 int end, bndend;

577

578 end = FFMIN(s->end_freq[1], s->end_freq[2]);

579

580 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++) {

581 if (s->rematrixing_flags[bnd]) {

582 bndend = FFMIN(end, ff_ac3_rematrix_band_tab[bnd + 1]);

583 for (i = ff_ac3_rematrix_band_tab[bnd]; i < bndend; i++) {

584 int tmp0 = s->fixed_coeffs[1][i];

585 s->fixed_coeffs[1][i] += s->fixed_coeffs[2][i];

586 s->fixed_coeffs[2][i] = tmp0 - s->fixed_coeffs[2][i];

587 }

588 }

589 }

590 }

591

592 /**

593 * Inverse MDCT Transform.

594 * Convert frequency domain coefficients to time-domain audio samples.

595 * reference: Section 7.9.4 Transformation Equations

596 */

597 static inline void do_imdct(AC3DecodeContext *s, int channels)

598 {

599 int ch;

600

601 for (ch = 1; ch <= channels; ch++) {

602 if (s->block_switch[ch]) {

603 int i;

604 float *x = s->tmp_output + 128;

605 for (i = 0; i < 128; i++)

606 x[i] = s->transform_coeffs[ch][2 * i];

607 s->imdct_256.imdct_half(&s->imdct_256, s->tmp_output, x);

608 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],

609 s->tmp_output, s->window, 128);

610 for (i = 0; i < 128; i++)

611 x[i] = s->transform_coeffs[ch][2 * i + 1];

612 s->imdct_256.imdct_half(&s->imdct_256, s->delay[ch - 1], x);

613 } else {

614 s->imdct_512.imdct_half(&s->imdct_512, s->tmp_output, s->transform_coeffs[ch]);

615 s->fdsp.vector_fmul_window(s->outptr[ch - 1], s->delay[ch - 1],

616 s->tmp_output, s->window, 128);

617 memcpy(s->delay[ch - 1], s->tmp_output + 128, 128 * sizeof(float));

618 }

619 }

620 }

621

622 /**

623 * Upmix delay samples from stereo to original channel layout.

624 */

625 static void ac3_upmix_delay(AC3DecodeContext *s)

626 {

627 int channel_data_size = sizeof(s->delay[0]);

628 switch (s->channel_mode) {

629 case AC3_CHMODE_DUALMONO:

630 case AC3_CHMODE_STEREO:

631 /* upmix mono to stereo */

632 memcpy(s->delay[1], s->delay[0], channel_data_size);

633 break;

634 case AC3_CHMODE_2F2R:

635 memset(s->delay[3], 0, channel_data_size);

636 case AC3_CHMODE_2F1R:

637 memset(s->delay[2], 0, channel_data_size);

638 break;

639 case AC3_CHMODE_3F2R:

640 memset(s->delay[4], 0, channel_data_size);

641 case AC3_CHMODE_3F1R:

642 memset(s->delay[3], 0, channel_data_size);

643 case AC3_CHMODE_3F:

644 memcpy(s->delay[2], s->delay[1], channel_data_size);

645 memset(s->delay[1], 0, channel_data_size);

646 break;

647 }

648 }

649

650 /**

651 * Decode band structure for coupling, spectral extension, or enhanced coupling.

652 * The band structure defines how many subbands are in each band. For each

653 * subband in the range, 1 means it is combined with the previous band, and 0

654 * means that it starts a new band.

655 *

656 * @param[in] gbc bit reader context

657 * @param[in] blk block number

658 * @param[in] eac3 flag to indicate E-AC-3

659 * @param[in] ecpl flag to indicate enhanced coupling

660 * @param[in] start_subband subband number for start of range

661 * @param[in] end_subband subband number for end of range

662 * @param[in] default_band_struct default band structure table

663 * @param[out] num_bands number of bands (optionally NULL)

664 * @param[out] band_sizes array containing the number of bins in each band (optionally NULL)

665 */

666 static void decode_band_structure(GetBitContext *gbc, int blk, int eac3,

667 int ecpl, int start_subband, int end_subband,

668 const uint8_t *default_band_struct,

669 int *num_bands, uint8_t *band_sizes)

670 {

671 int subbnd, bnd, n_subbands, n_bands=0;

672 uint8_t bnd_sz[22];

673 uint8_t coded_band_struct[22];

674 const uint8_t *band_struct;

675

676 n_subbands = end_subband - start_subband;

677

678 /* decode band structure from bitstream or use default */

679 if (!eac3 || get_bits1(gbc)) {

680 for (subbnd = 0; subbnd < n_subbands - 1; subbnd++) {

681 coded_band_struct[subbnd] = get_bits1(gbc);

682 }

683 band_struct = coded_band_struct;

684 } else if (!blk) {

685 band_struct = &default_band_struct[start_subband+1];

686 } else {

687 /* no change in band structure */

688 return;

689 }

690

691 /* calculate number of bands and band sizes based on band structure.

692 note that the first 4 subbands in enhanced coupling span only 6 bins

693 instead of 12. */

694 if (num_bands || band_sizes ) {

695 n_bands = n_subbands;

696 bnd_sz[0] = ecpl ? 6 : 12;

697 for (bnd = 0, subbnd = 1; subbnd < n_subbands; subbnd++) {

698 int subbnd_size = (ecpl && subbnd < 4) ? 6 : 12;

699 if (band_struct[subbnd - 1]) {

700 n_bands--;

701 bnd_sz[bnd] += subbnd_size;

702 } else {

703 bnd_sz[++bnd] = subbnd_size;

704 }

705 }

706 }

707

708 /* set optional output params */

709 if (num_bands)

710 *num_bands = n_bands;

711 if (band_sizes)

712 memcpy(band_sizes, bnd_sz, n_bands);

713 }

714

715 /**

716 * Decode a single audio block from the AC-3 bitstream.

717 */

718 static int decode_audio_block(AC3DecodeContext *s, int blk)

719 {

720 int fbw_channels = s->fbw_channels;

721 int channel_mode = s->channel_mode;

722 int i, bnd, seg, ch;

723 int different_transforms;

724 int downmix_output;

725 int cpl_in_use;

726 GetBitContext *gbc = &s->gbc;

727 uint8_t bit_alloc_stages[AC3_MAX_CHANNELS] = { 0 };

728

729 /* block switch flags */

730 different_transforms = 0;

731 if (s->block_switch_syntax) {

732 for (ch = 1; ch <= fbw_channels; ch++) {

733 s->block_switch[ch] = get_bits1(gbc);

734 if (ch > 1 && s->block_switch[ch] != s->block_switch[1])

735 different_transforms = 1;

736 }

737 }

738

739 /* dithering flags */

740 if (s->dither_flag_syntax) {

741 for (ch = 1; ch <= fbw_channels; ch++) {

742 s->dither_flag[ch] = get_bits1(gbc);

743 }

744 }

745

746 /* dynamic range */

747 i = !s->channel_mode;

748 do {

749 if (get_bits1(gbc)) {

750 s->dynamic_range[i] = ((dynamic_range_tab[get_bits(gbc, 8)] - 1.0) *

751 s->drc_scale) + 1.0;

752 } else if (blk == 0) {

753 s->dynamic_range[i] = 1.0f;

754 }

755 } while (i--);

756

757 /* spectral extension strategy */

758 if (s->eac3 && (!blk || get_bits1(gbc))) {

759 s->spx_in_use = get_bits1(gbc);

760 if (s->spx_in_use) {

761 int dst_start_freq, dst_end_freq, src_start_freq,

762 start_subband, end_subband;

763

764 /* determine which channels use spx */

765 if (s->channel_mode == AC3_CHMODE_MONO) {

766 s->channel_uses_spx[1] = 1;

767 } else {

768 for (ch = 1; ch <= fbw_channels; ch++)

769 s->channel_uses_spx[ch] = get_bits1(gbc);

770 }

771

772 /* get the frequency bins of the spx copy region and the spx start

773 and end subbands */

774 dst_start_freq = get_bits(gbc, 2);

775 start_subband = get_bits(gbc, 3) + 2;

776 if (start_subband > 7)

777 start_subband += start_subband - 7;

778 end_subband = get_bits(gbc, 3) + 5;

779 if (end_subband > 7)

780 end_subband += end_subband - 7;

781 dst_start_freq = dst_start_freq * 12 + 25;

782 src_start_freq = start_subband * 12 + 25;

783 dst_end_freq = end_subband * 12 + 25;

784

785 /* check validity of spx ranges */

786 if (start_subband >= end_subband) {

787 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "

788 "range (%d >= %d)\n", start_subband, end_subband);

789 return -1;

790 }

791 if (dst_start_freq >= src_start_freq) {

792 av_log(s->avctx, AV_LOG_ERROR, "invalid spectral extension "

793 "copy start bin (%d >= %d)\n", dst_start_freq, src_start_freq);

794 return -1;

795 }

796

797 s->spx_dst_start_freq = dst_start_freq;

798 s->spx_src_start_freq = src_start_freq;

799 s->spx_dst_end_freq = dst_end_freq;

800

801 decode_band_structure(gbc, blk, s->eac3, 0,

802 start_subband, end_subband,

803 ff_eac3_default_spx_band_struct,

804 &s->num_spx_bands,

805 s->spx_band_sizes);

806 } else {

807 for (ch = 1; ch <= fbw_channels; ch++) {

808 s->channel_uses_spx[ch] = 0;

809 s->first_spx_coords[ch] = 1;

810 }

811 }

812 }

813

814 /* spectral extension coordinates */

815 if (s->spx_in_use) {

816 for (ch = 1; ch <= fbw_channels; ch++) {

817 if (s->channel_uses_spx[ch]) {

818 if (s->first_spx_coords[ch] || get_bits1(gbc)) {

819 float spx_blend;

820 int bin, master_spx_coord;

821

822 s->first_spx_coords[ch] = 0;

823 spx_blend = get_bits(gbc, 5) * (1.0f/32);

824 master_spx_coord = get_bits(gbc, 2) * 3;

825

826 bin = s->spx_src_start_freq;

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

828 int bandsize;

829 int spx_coord_exp, spx_coord_mant;

830 float nratio, sblend, nblend, spx_coord;

831

832 /* calculate blending factors */

833 bandsize = s->spx_band_sizes[bnd];

834 nratio = ((float)((bin + (bandsize >> 1))) / s->spx_dst_end_freq) - spx_blend;

835 nratio = av_clipf(nratio, 0.0f, 1.0f);

836 nblend = sqrtf(3.0f * nratio); // noise is scaled by sqrt(3)

837 // to give unity variance

838 sblend = sqrtf(1.0f - nratio);

839 bin += bandsize;

840

841 /* decode spx coordinates */

842 spx_coord_exp = get_bits(gbc, 4);

843 spx_coord_mant = get_bits(gbc, 2);

844 if (spx_coord_exp == 15) spx_coord_mant <<= 1;

845 else spx_coord_mant += 4;

846 spx_coord_mant <<= (25 - spx_coord_exp - master_spx_coord);

847 spx_coord = spx_coord_mant * (1.0f / (1 << 23));

848

849 /* multiply noise and signal blending factors by spx coordinate */

850 s->spx_noise_blend [ch][bnd] = nblend * spx_coord;

851 s->spx_signal_blend[ch][bnd] = sblend * spx_coord;

852 }

853 }

854 } else {

855 s->first_spx_coords[ch] = 1;

856 }

857 }

858 }

859

860 /* coupling strategy */

861 if (s->eac3 ? s->cpl_strategy_exists[blk] : get_bits1(gbc)) {

862 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

863 if (!s->eac3)

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

865 if (s->cpl_in_use[blk]) {

866 /* coupling in use */

867 int cpl_start_subband, cpl_end_subband;

868

869 if (channel_mode < AC3_CHMODE_STEREO) {

870 av_log(s->avctx, AV_LOG_ERROR, "coupling not allowed in mono or dual-mono\n");

871 return -1;

872 }

873

874 /* check for enhanced coupling */

875 if (s->eac3 && get_bits1(gbc)) {

876 /* TODO: parse enhanced coupling strategy info */

877 avpriv_request_sample(s->avctx, "Enhanced coupling");

878 return AVERROR_PATCHWELCOME;

879 }

880

881 /* determine which channels are coupled */

882 if (s->eac3 && s->channel_mode == AC3_CHMODE_STEREO) {

883 s->channel_in_cpl[1] = 1;

884 s->channel_in_cpl[2] = 1;

885 } else {

886 for (ch = 1; ch <= fbw_channels; ch++)

887 s->channel_in_cpl[ch] = get_bits1(gbc);

888 }

889

890 /* phase flags in use */

891 if (channel_mode == AC3_CHMODE_STEREO)

892 s->phase_flags_in_use = get_bits1(gbc);

893

894 /* coupling frequency range */

895 cpl_start_subband = get_bits(gbc, 4);

896 cpl_end_subband = s->spx_in_use ? (s->spx_src_start_freq - 37) / 12 :

897 get_bits(gbc, 4) + 3;

898 if (cpl_start_subband >= cpl_end_subband) {

899 av_log(s->avctx, AV_LOG_ERROR, "invalid coupling range (%d >= %d)\n",

900 cpl_start_subband, cpl_end_subband);

901 return -1;

902 }

903 s->start_freq[CPL_CH] = cpl_start_subband * 12 + 37;

904 s->end_freq[CPL_CH] = cpl_end_subband * 12 + 37;

905

906 decode_band_structure(gbc, blk, s->eac3, 0, cpl_start_subband,

907 cpl_end_subband,

908 ff_eac3_default_cpl_band_struct,

909 &s->num_cpl_bands, s->cpl_band_sizes);

910 } else {

911 /* coupling not in use */

912 for (ch = 1; ch <= fbw_channels; ch++) {

913 s->channel_in_cpl[ch] = 0;

914 s->first_cpl_coords[ch] = 1;

915 }

916 s->first_cpl_leak = s->eac3;

917 s->phase_flags_in_use = 0;

918 }

919 } else if (!s->eac3) {

920 if (!blk) {

921 av_log(s->avctx, AV_LOG_ERROR, "new coupling strategy must "

922 "be present in block 0\n");

923 return -1;

924 } else {

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

926 }

927 }

928 cpl_in_use = s->cpl_in_use[blk];

929

930 /* coupling coordinates */

931 if (cpl_in_use) {

932 int cpl_coords_exist = 0;

933

934 for (ch = 1; ch <= fbw_channels; ch++) {

935 if (s->channel_in_cpl[ch]) {

936 if ((s->eac3 && s->first_cpl_coords[ch]) || get_bits1(gbc)) {

937 int master_cpl_coord, cpl_coord_exp, cpl_coord_mant;

938 s->first_cpl_coords[ch] = 0;

939 cpl_coords_exist = 1;

940 master_cpl_coord = 3 * get_bits(gbc, 2);

941 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {

942 cpl_coord_exp = get_bits(gbc, 4);

943 cpl_coord_mant = get_bits(gbc, 4);

944 if (cpl_coord_exp == 15)

945 s->cpl_coords[ch][bnd] = cpl_coord_mant << 22;

946 else

947 s->cpl_coords[ch][bnd] = (cpl_coord_mant + 16) << 21;

948 s->cpl_coords[ch][bnd] >>= (cpl_coord_exp + master_cpl_coord);

949 }

950 } else if (!blk) {

951 av_log(s->avctx, AV_LOG_ERROR, "new coupling coordinates must "

952 "be present in block 0\n");

953 return -1;

954 }

955 } else {

956 /* channel not in coupling */

957 s->first_cpl_coords[ch] = 1;

958 }

959 }

960 /* phase flags */

961 if (channel_mode == AC3_CHMODE_STEREO && cpl_coords_exist) {

962 for (bnd = 0; bnd < s->num_cpl_bands; bnd++) {

963 s->phase_flags[bnd] = s->phase_flags_in_use? get_bits1(gbc) : 0;

964 }

965 }

966 }

967

968 /* stereo rematrixing strategy and band structure */

969 if (channel_mode == AC3_CHMODE_STEREO) {

970 if ((s->eac3 && !blk) || get_bits1(gbc)) {

971 s->num_rematrixing_bands = 4;

972 if (cpl_in_use && s->start_freq[CPL_CH] <= 61) {

973 s->num_rematrixing_bands -= 1 + (s->start_freq[CPL_CH] == 37);

974 } else if (s->spx_in_use && s->spx_src_start_freq <= 61) {

975 s->num_rematrixing_bands--;

976 }

977 for (bnd = 0; bnd < s->num_rematrixing_bands; bnd++)

978 s->rematrixing_flags[bnd] = get_bits1(gbc);

979 } else if (!blk) {

980 av_log(s->avctx, AV_LOG_WARNING, "Warning: "

981 "new rematrixing strategy not present in block 0\n");

982 s->num_rematrixing_bands = 0;

983 }

984 }

985

986 /* exponent strategies for each channel */

987 for (ch = !cpl_in_use; ch <= s->channels; ch++) {

988 if (!s->eac3)

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

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

991 bit_alloc_stages[ch] = 3;

992 }

993

994 /* channel bandwidth */

995 for (ch = 1; ch <= fbw_channels; ch++) {

996 s->start_freq[ch] = 0;

997 if (s->exp_strategy[blk][ch] != EXP_REUSE) {

998 int group_size;

999 int prev = s->end_freq[ch];

1000 if (s->channel_in_cpl[ch])

1001 s->end_freq[ch] = s->start_freq[CPL_CH];

1002 else if (s->channel_uses_spx[ch])

1003 s->end_freq[ch] = s->spx_src_start_freq;

1004 else {

1005 int bandwidth_code = get_bits(gbc, 6);

1006 if (bandwidth_code > 60) {

1007 av_log(s->avctx, AV_LOG_ERROR, "bandwidth code = %d > 60\n", bandwidth_code);

1008 return -1;

1009 }

1010 s->end_freq[ch] = bandwidth_code * 3 + 73;

1011 }

1012 group_size = 3 << (s->exp_strategy[blk][ch] - 1);

1013 s->num_exp_groups[ch] = (s->end_freq[ch] + group_size-4) / group_size;

1014 if (blk > 0 && s->end_freq[ch] != prev)

1015 memset(bit_alloc_stages, 3, AC3_MAX_CHANNELS);

1016 }

1017 }

1018 if (cpl_in_use && s->exp_strategy[blk][CPL_CH] != EXP_REUSE) {

1019 s->num_exp_groups[CPL_CH] = (s->end_freq[CPL_CH] - s->start_freq[CPL_CH]) /

1020 (3 << (s->exp_strategy[blk][CPL_CH] - 1));

1021 }

1022

1023 /* decode exponents for each channel */

1024 for (ch = !cpl_in_use; ch <= s->channels; ch++) {

1025 if (s->exp_strategy[blk][ch] != EXP_REUSE) {

1026 s->dexps[ch][0] = get_bits(gbc, 4) << !ch;

1027 if (decode_exponents(gbc, s->exp_strategy[blk][ch],

1028 s->num_exp_groups[ch], s->dexps[ch][0],

1029 &s->dexps[ch][s->start_freq[ch]+!!ch])) {

1030 av_log(s->avctx, AV_LOG_ERROR, "exponent out-of-range\n");

1031 return -1;

1032 }

1033 if (ch != CPL_CH && ch != s->lfe_ch)

1034 skip_bits(gbc, 2); /* skip gainrng */

1035 }

1036 }

1037

1038 /* bit allocation information */

1039 if (s->bit_allocation_syntax) {

1040 if (get_bits1(gbc)) {

1041 s->bit_alloc_params.slow_decay = ff_ac3_slow_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;

1042 s->bit_alloc_params.fast_decay = ff_ac3_fast_decay_tab[get_bits(gbc, 2)] >> s->bit_alloc_params.sr_shift;

1043 s->bit_alloc_params.slow_gain = ff_ac3_slow_gain_tab[get_bits(gbc, 2)];

1044 s->bit_alloc_params.db_per_bit = ff_ac3_db_per_bit_tab[get_bits(gbc, 2)];

1045 s->bit_alloc_params.floor = ff_ac3_floor_tab[get_bits(gbc, 3)];

1046 for (ch = !cpl_in_use; ch <= s->channels; ch++)

1047 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

1048 } else if (!blk) {

1049 av_log(s->avctx, AV_LOG_ERROR, "new bit allocation info must "

1050 "be present in block 0\n");

1051 return -1;

1052 }

1053 }

1054

1055 /* signal-to-noise ratio offsets and fast gains (signal-to-mask ratios) */

1056 if (!s->eac3 || !blk) {

1057 if (s->snr_offset_strategy && get_bits1(gbc)) {

1058 int snr = 0;

1059 int csnr;

1060 csnr = (get_bits(gbc, 6) - 15) << 4;

1061 for (i = ch = !cpl_in_use; ch <= s->channels; ch++) {

1062 /* snr offset */

1063 if (ch == i || s->snr_offset_strategy == 2)

1064 snr = (csnr + get_bits(gbc, 4)) << 2;

1065 /* run at least last bit allocation stage if snr offset changes */

1066 if (blk && s->snr_offset[ch] != snr) {

1067 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 1);

1068 }

1069 s->snr_offset[ch] = snr;

1070

1071 /* fast gain (normal AC-3 only) */

1072 if (!s->eac3) {

1073 int prev = s->fast_gain[ch];

1074 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];

1075 /* run last 2 bit allocation stages if fast gain changes */

1076 if (blk && prev != s->fast_gain[ch])

1077 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

1078 }

1079 }

1080 } else if (!s->eac3 && !blk) {

1081 av_log(s->avctx, AV_LOG_ERROR, "new snr offsets must be present in block 0\n");

1082 return -1;

1083 }

1084 }

1085

1086 /* fast gain (E-AC-3 only) */

1087 if (s->fast_gain_syntax && get_bits1(gbc)) {

1088 for (ch = !cpl_in_use; ch <= s->channels; ch++) {

1089 int prev = s->fast_gain[ch];

1090 s->fast_gain[ch] = ff_ac3_fast_gain_tab[get_bits(gbc, 3)];

1091 /* run last 2 bit allocation stages if fast gain changes */

1092 if (blk && prev != s->fast_gain[ch])

1093 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

1094 }

1095 } else if (s->eac3 && !blk) {

1096 for (ch = !cpl_in_use; ch <= s->channels; ch++)

1097 s->fast_gain[ch] = ff_ac3_fast_gain_tab[4];

1098 }

1099

1100 /* E-AC-3 to AC-3 converter SNR offset */

1101 if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && get_bits1(gbc)) {

1102 skip_bits(gbc, 10); // skip converter snr offset

1103 }

1104

1105 /* coupling leak information */

1106 if (cpl_in_use) {

1107 if (s->first_cpl_leak || get_bits1(gbc)) {

1108 int fl = get_bits(gbc, 3);

1109 int sl = get_bits(gbc, 3);

1110 /* run last 2 bit allocation stages for coupling channel if

1111 coupling leak changes */

1112 if (blk && (fl != s->bit_alloc_params.cpl_fast_leak ||

1113 sl != s->bit_alloc_params.cpl_slow_leak)) {

1114 bit_alloc_stages[CPL_CH] = FFMAX(bit_alloc_stages[CPL_CH], 2);

1115 }

1116 s->bit_alloc_params.cpl_fast_leak = fl;

1117 s->bit_alloc_params.cpl_slow_leak = sl;

1118 } else if (!s->eac3 && !blk) {

1119 av_log(s->avctx, AV_LOG_ERROR, "new coupling leak info must "

1120 "be present in block 0\n");

1121 return -1;

1122 }

1123 s->first_cpl_leak = 0;

1124 }

1125

1126 /* delta bit allocation information */

1127 if (s->dba_syntax && get_bits1(gbc)) {

1128 /* delta bit allocation exists (strategy) */

1129 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {

1130 s->dba_mode[ch] = get_bits(gbc, 2);

1131 if (s->dba_mode[ch] == DBA_RESERVED) {

1132 av_log(s->avctx, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");

1133 return -1;

1134 }

1135 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

1136 }

1137 /* channel delta offset, len and bit allocation */

1138 for (ch = !cpl_in_use; ch <= fbw_channels; ch++) {

1139 if (s->dba_mode[ch] == DBA_NEW) {

1140 s->dba_nsegs[ch] = get_bits(gbc, 3) + 1;

1141 for (seg = 0; seg < s->dba_nsegs[ch]; seg++) {

1142 s->dba_offsets[ch][seg] = get_bits(gbc, 5);

1143 s->dba_lengths[ch][seg] = get_bits(gbc, 4);

1144 s->dba_values[ch][seg] = get_bits(gbc, 3);

1145 }

1146 /* run last 2 bit allocation stages if new dba values */

1147 bit_alloc_stages[ch] = FFMAX(bit_alloc_stages[ch], 2);

1148 }

1149 }

1150 } else if (blk == 0) {

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

1152 s->dba_mode[ch] = DBA_NONE;

1153 }

1154 }

1155

1156 /* Bit allocation */

1157 for (ch = !cpl_in_use; ch <= s->channels; ch++) {

1158 if (bit_alloc_stages[ch] > 2) {

1159 /* Exponent mapping into PSD and PSD integration */

1160 ff_ac3_bit_alloc_calc_psd(s->dexps[ch],

1161 s->start_freq[ch], s->end_freq[ch],

1162 s->psd[ch], s->band_psd[ch]);

1163 }

1164 if (bit_alloc_stages[ch] > 1) {

1165 /* Compute excitation function, Compute masking curve, and

1166 Apply delta bit allocation */

1167 if (ff_ac3_bit_alloc_calc_mask(&s->bit_alloc_params, s->band_psd[ch],

1168 s->start_freq[ch], s->end_freq[ch],

1169 s->fast_gain[ch], (ch == s->lfe_ch),

1170 s->dba_mode[ch], s->dba_nsegs[ch],

1171 s->dba_offsets[ch], s->dba_lengths[ch],

1172 s->dba_values[ch], s->mask[ch])) {

1173 av_log(s->avctx, AV_LOG_ERROR, "error in bit allocation\n");

1174 return -1;

1175 }

1176 }

1177 if (bit_alloc_stages[ch] > 0) {

1178 /* Compute bit allocation */

1179 const uint8_t *bap_tab = s->channel_uses_aht[ch] ?

1180 ff_eac3_hebap_tab : ff_ac3_bap_tab;

1181 s->ac3dsp.bit_alloc_calc_bap(s->mask[ch], s->psd[ch],

1182 s->start_freq[ch], s->end_freq[ch],

1183 s->snr_offset[ch],

1184 s->bit_alloc_params.floor,

1185 bap_tab, s->bap[ch]);

1186 }

1187 }

1188

1189 /* unused dummy data */

1190 if (s->skip_syntax && get_bits1(gbc)) {

1191 int skipl = get_bits(gbc, 9);

1192 while (skipl--)

1193 skip_bits(gbc, 8);

1194 }

1195

1196 /* unpack the transform coefficients

1197 this also uncouples channels if coupling is in use. */

1198 decode_transform_coeffs(s, blk);

1199

1200 /* TODO: generate enhanced coupling coordinates and uncouple */

1201

1202 /* recover coefficients if rematrixing is in use */

1203 if (s->channel_mode == AC3_CHMODE_STEREO)

1204 do_rematrixing(s);

1205

1206 /* apply scaling to coefficients (headroom, dynrng) */

1207 for (ch = 1; ch <= s->channels; ch++) {

1208 float gain = 1.0 / 4194304.0f;

1209 if (s->channel_mode == AC3_CHMODE_DUALMONO) {

1210 gain *= s->dynamic_range[2 - ch];

1211 } else {

1212 gain *= s->dynamic_range[0];

1213 }

1214 s->fmt_conv.int32_to_float_fmul_scalar(s->transform_coeffs[ch],

1215 s->fixed_coeffs[ch], gain, 256);

1216 }

1217

1218 /* apply spectral extension to high frequency bins */

1219 if (s->spx_in_use && CONFIG_EAC3_DECODER) {

1220 ff_eac3_apply_spectral_extension(s);

1221 }

1222

1223 /* downmix and MDCT. order depends on whether block switching is used for

1224 any channel in this block. this is because coefficients for the long

1225 and short transforms cannot be mixed. */

1226 downmix_output = s->channels != s->out_channels &&

1227 !((s->output_mode & AC3_OUTPUT_LFEON) &&

1228 s->fbw_channels == s->out_channels);

1229 if (different_transforms) {

1230 /* the delay samples have already been downmixed, so we upmix the delay

1231 samples in order to reconstruct all channels before downmixing. */

1232 if (s->downmixed) {

1233 s->downmixed = 0;

1234 ac3_upmix_delay(s);

1235 }

1236

1237 do_imdct(s, s->channels);

1238

1239 if (downmix_output) {

1240 s->ac3dsp.downmix(s->outptr, s->downmix_coeffs,

1241 s->out_channels, s->fbw_channels, 256);

1242 }

1243 } else {

1244 if (downmix_output) {

1245 s->ac3dsp.downmix(s->xcfptr + 1, s->downmix_coeffs,

1246 s->out_channels, s->fbw_channels, 256);

1247 }

1248

1249 if (downmix_output && !s->downmixed) {

1250 s->downmixed = 1;

1251 s->ac3dsp.downmix(s->dlyptr, s->downmix_coeffs, s->out_channels,

1252 s->fbw_channels, 128);

1253 }

1254

1255 do_imdct(s, s->out_channels);

1256 }

1257

1258 return 0;

1259 }

1260

1261 /**

1262 * Decode a single AC-3 frame.

1263 */

1264 static int ac3_decode_frame(AVCodecContext * avctx, void *data,

1265 int *got_frame_ptr, AVPacket *avpkt)

1266 {

1267 AVFrame *frame = data;

1268 const uint8_t *buf = avpkt->data;

1269 int buf_size = avpkt->size;

1270 AC3DecodeContext *s = avctx->priv_data;

1271 int blk, ch, err, ret;

1272 const uint8_t *channel_map;

1273 const float *output[AC3_MAX_CHANNELS];

1274

1275 /* copy input buffer to decoder context to avoid reading past the end

1276 of the buffer, which can be caused by a damaged input stream. */

1277 if (buf_size >= 2 && AV_RB16(buf) == 0x770B) {

1278 // seems to be byte-swapped AC-3

1279 int cnt = FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE) >> 1;

1280 s->dsp.bswap16_buf((uint16_t *)s->input_buffer, (const uint16_t *)buf, cnt);

1281 } else

1282 memcpy(s->input_buffer, buf, FFMIN(buf_size, AC3_FRAME_BUFFER_SIZE));

1283 buf = s->input_buffer;

1284 /* initialize the GetBitContext with the start of valid AC-3 Frame */

1285 init_get_bits(&s->gbc, buf, buf_size * 8);

1286

1287 /* parse the syncinfo */

1288 err = parse_frame_header(s);

1289

1290 if (err) {

1291 switch (err) {

1292 case AAC_AC3_PARSE_ERROR_SYNC:

1293 av_log(avctx, AV_LOG_ERROR, "frame sync error\n");

1294 return -1;

1295 case AAC_AC3_PARSE_ERROR_BSID:

1296 av_log(avctx, AV_LOG_ERROR, "invalid bitstream id\n");

1297 break;

1298 case AAC_AC3_PARSE_ERROR_SAMPLE_RATE:

1299 av_log(avctx, AV_LOG_ERROR, "invalid sample rate\n");

1300 break;

1301 case AAC_AC3_PARSE_ERROR_FRAME_SIZE:

1302 av_log(avctx, AV_LOG_ERROR, "invalid frame size\n");

1303 break;

1304 case AAC_AC3_PARSE_ERROR_FRAME_TYPE:

1305 /* skip frame if CRC is ok. otherwise use error concealment. */

1306 /* TODO: add support for substreams and dependent frames */

1307 if (s->frame_type == EAC3_FRAME_TYPE_DEPENDENT || s->substreamid) {

1308 av_log(avctx, AV_LOG_ERROR, "unsupported frame type : "

1309 "skipping frame\n");

1310 *got_frame_ptr = 0;

1311 return s->frame_size;

1312 } else {

1313 av_log(avctx, AV_LOG_ERROR, "invalid frame type\n");

1314 }

1315 break;

1316 default:

1317 av_log(avctx, AV_LOG_ERROR, "invalid header\n");

1318 break;

1319 }

1320 } else {

1321 /* check that reported frame size fits in input buffer */

1322 if (s->frame_size > buf_size) {

1323 av_log(avctx, AV_LOG_ERROR, "incomplete frame\n");

1324 err = AAC_AC3_PARSE_ERROR_FRAME_SIZE;

1325 } else if (avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_CAREFUL)) {

1326 /* check for crc mismatch */

1327 if (av_crc(av_crc_get_table(AV_CRC_16_ANSI), 0, &buf[2],

1328 s->frame_size - 2)) {

1329 av_log(avctx, AV_LOG_ERROR, "frame CRC mismatch\n");

1330 err = AAC_AC3_PARSE_ERROR_CRC;

1331 }

1332 }

1333 }

1334

1335 /* if frame is ok, set audio parameters */

1336 if (!err) {

1337 avctx->sample_rate = s->sample_rate;

1338 avctx->bit_rate = s->bit_rate;

1339 }

1340

1341 /* channel config */

1342 if (!err || (s->channels && s->out_channels != s->channels)) {

1343 s->out_channels = s->channels;

1344 s->output_mode = s->channel_mode;

1345 if (s->lfe_on)

1346 s->output_mode |= AC3_OUTPUT_LFEON;

1347 if (avctx->request_channels > 0 && avctx->request_channels <= 2 &&

1348 avctx->request_channels < s->channels) {

1349 s->out_channels = avctx->request_channels;

1350 s->output_mode = avctx->request_channels == 1 ? AC3_CHMODE_MONO : AC3_CHMODE_STEREO;

1351 s->channel_layout = avpriv_ac3_channel_layout_tab[s->output_mode];

1352 }

1353 avctx->channels = s->out_channels;

1354 avctx->channel_layout = s->channel_layout;

1355

1356 s->loro_center_mix_level = gain_levels[s-> center_mix_level];

1357 s->loro_surround_mix_level = gain_levels[s->surround_mix_level];

1358 s->ltrt_center_mix_level = LEVEL_MINUS_3DB;

1359 s->ltrt_surround_mix_level = LEVEL_MINUS_3DB;

1360 /* set downmixing coefficients if needed */

1361 if (s->channels != s->out_channels && !((s->output_mode & AC3_OUTPUT_LFEON) &&

1362 s->fbw_channels == s->out_channels)) {

1363 set_downmix_coeffs(s);

1364 }

1365 } else if (!s->channels) {

1366 av_log(avctx, AV_LOG_ERROR, "unable to determine channel mode\n");

1367 return AVERROR_INVALIDDATA;

1368 }

1369 avctx->channels = s->out_channels;

1370

1371 /* set audio service type based on bitstream mode for AC-3 */

1372 avctx->audio_service_type = s->bitstream_mode;

1373 if (s->bitstream_mode == 0x7 && s->channels > 1)

1374 avctx->audio_service_type = AV_AUDIO_SERVICE_TYPE_KARAOKE;

1375

1376 /* get output buffer */

1377 frame->nb_samples = s->num_blocks * 256;

1378 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

1379 return ret;

1380

1381 /* decode the audio blocks */

1382 channel_map = ff_ac3_dec_channel_map[s->output_mode & ~AC3_OUTPUT_LFEON][s->lfe_on];

1383 for (ch = 0; ch < AC3_MAX_CHANNELS; ch++) {

1384 output[ch] = s->output[ch];

1385 s->outptr[ch] = s->output[ch];

1386 }

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

1388 if (ch < s->out_channels)

1389 s->outptr[channel_map[ch]] = (float *)frame->data[ch];

1390 }

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

1392 if (!err && decode_audio_block(s, blk)) {

1393 av_log(avctx, AV_LOG_ERROR, "error decoding the audio block\n");

1394 err = 1;

1395 }

1396 if (err)

1397 for (ch = 0; ch < s->out_channels; ch++)

1398 memcpy(((float*)frame->data[ch]) + AC3_BLOCK_SIZE*blk, output[ch], 1024);

1399 for (ch = 0; ch < s->out_channels; ch++)

1400 output[ch] = s->outptr[channel_map[ch]];

1401 for (ch = 0; ch < s->out_channels; ch++) {

1402 if (!ch || channel_map[ch])

1403 s->outptr[channel_map[ch]] += AC3_BLOCK_SIZE;

1404 }

1405 }

1406

1407 av_frame_set_decode_error_flags(frame, err ? FF_DECODE_ERROR_INVALID_BITSTREAM : 0);

1408

1409 /* keep last block for error concealment in next frame */

1410 for (ch = 0; ch < s->out_channels; ch++)

1411 memcpy(s->output[ch], output[ch], 1024);

1412

1413 *got_frame_ptr = 1;

1414

1415 return FFMIN(buf_size, s->frame_size);

1416 }

1417

1418 /**

1419 * Uninitialize the AC-3 decoder.

1420 */

1421 static av_cold int ac3_decode_end(AVCodecContext *avctx)

1422 {

1423 AC3DecodeContext *s = avctx->priv_data;

1424 ff_mdct_end(&s->imdct_512);

1425 ff_mdct_end(&s->imdct_256);

1426

1427 return 0;

1428 }

1429

1430 #define OFFSET(x) offsetof(AC3DecodeContext, x)

1431 #define PAR (AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM)

1432 static const AVOption options[] = {

1433 { "drc_scale", "percentage of dynamic range compression to apply", OFFSET(drc_scale), AV_OPT_TYPE_FLOAT, {.dbl = 1.0}, 0.0, 1.0, PAR },

1434

1435 {"dmix_mode", "Preferred Stereo Downmix Mode", OFFSET(preferred_stereo_downmix), AV_OPT_TYPE_INT, {.i64 = -1 }, -1, 2, 0, "dmix_mode"},

1436 {"ltrt_cmixlev", "Lt/Rt Center Mix Level", OFFSET(ltrt_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},

1437 {"ltrt_surmixlev", "Lt/Rt Surround Mix Level", OFFSET(ltrt_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},

1438 {"loro_cmixlev", "Lo/Ro Center Mix Level", OFFSET(loro_center_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},

1439 {"loro_surmixlev", "Lo/Ro Surround Mix Level", OFFSET(loro_surround_mix_level), AV_OPT_TYPE_FLOAT, {.dbl = -1.0 }, -1.0, 2.0, 0},

1440

1441 { NULL},

1442 };

1443

1444 static const AVClass ac3_decoder_class = {

1445 .class_name = "AC3 decoder",

1446 .item_name = av_default_item_name,

1447 .option = options,

1448 .version = LIBAVUTIL_VERSION_INT,

1449 };

1450

1451 AVCodec ff_ac3_decoder = {

1452 .name = "ac3",

1453 .type = AVMEDIA_TYPE_AUDIO,

1454 .id = AV_CODEC_ID_AC3,

1455 .priv_data_size = sizeof (AC3DecodeContext),

1456 .init = ac3_decode_init,

1457 .close = ac3_decode_end,

1458 .decode = ac3_decode_frame,

1459 .capabilities = CODEC_CAP_DR1,

1460 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52A (AC-3)"),

1461 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,

1462 AV_SAMPLE_FMT_NONE },

1463 .priv_class = &ac3_decoder_class,

1464 };

1465

1466 #if CONFIG_EAC3_DECODER

1467 static const AVClass eac3_decoder_class = {

1468 .class_name = "E-AC3 decoder",

1469 .item_name = av_default_item_name,

1470 .option = options,

1471 .version = LIBAVUTIL_VERSION_INT,

1472 };

1473

1474 AVCodec ff_eac3_decoder = {

1475 .name = "eac3",

1476 .type = AVMEDIA_TYPE_AUDIO,

1477 .id = AV_CODEC_ID_EAC3,

1478 .priv_data_size = sizeof (AC3DecodeContext),

1479 .init = ac3_decode_init,

1480 .close = ac3_decode_end,

1481 .decode = ac3_decode_frame,

1482 .capabilities = CODEC_CAP_DR1,

1483 .long_name = NULL_IF_CONFIG_SMALL("ATSC A/52B (AC-3, E-AC-3)"),

1484 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,

1485 AV_SAMPLE_FMT_NONE },

1486 .priv_class = &eac3_decoder_class,

1487 };

1488 #endif

Generated on Wed Jul 10 2013 23:47:54 for FFmpeg by doxygen 1.8.2