FFmpeg: libavcodec/mlpdec.c Source File

FFmpeg

[フレーム]

libavcodec

mlpdec.c

Go to the documentation of this file.

1 /*

2 * MLP decoder

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * MLP decoder

25 */

27 #include <stdint.h>

29 #include "avcodec.h"

30 #include "libavutil/internal.h"

31 #include "libavutil/intreadwrite.h"

32 #include "libavutil/channel_layout.h"

33 #include "get_bits.h"

34 #include "internal.h"

35 #include "libavutil/crc.h"

36 #include "parser.h"

37 #include "mlp_parser.h"

38 #include "mlpdsp.h"

39 #include "mlp.h"

40 #include "config.h"

42 /** number of bits used for VLC lookup - longest Huffman code is 9 */

43 #if ARCH_ARM

44 #define VLC_BITS 5

45 #define VLC_STATIC_SIZE 64

46 #else

47 #define VLC_BITS 9

48 #define VLC_STATIC_SIZE 512

49 #endif

51 typedef struct SubStream {

52 /// Set if a valid restart header has been read. Otherwise the substream cannot be decoded.

53 uint8_t restart_seen;

55 //@{

56 /** restart header data */

57 /// The type of noise to be used in the rematrix stage.

58 uint16_t noise_type;

60 /// The index of the first channel coded in this substream.

61 uint8_t min_channel;

62 /// The index of the last channel coded in this substream.

63 uint8_t max_channel;

64 /// The number of channels input into the rematrix stage.

65 uint8_t max_matrix_channel;

66 /// For each channel output by the matrix, the output channel to map it to

67 uint8_t ch_assign[MAX_CHANNELS];

68 /// The channel layout for this substream

69 uint64_t ch_layout;

70 /// The matrix encoding mode for this substream

71 enum AVMatrixEncoding matrix_encoding;

73 /// Channel coding parameters for channels in the substream

74 ChannelParams channel_params[MAX_CHANNELS];

76 /// The left shift applied to random noise in 0x31ea substreams.

77 uint8_t noise_shift;

78 /// The current seed value for the pseudorandom noise generator(s).

79 uint32_t noisegen_seed;

81 /// Set if the substream contains extra info to check the size of VLC blocks.

82 uint8_t data_check_present;

84 /// Bitmask of which parameter sets are conveyed in a decoding parameter block.

85 uint8_t param_presence_flags;

86 #define PARAM_BLOCKSIZE (1 << 7)

87 #define PARAM_MATRIX (1 << 6)

88 #define PARAM_OUTSHIFT (1 << 5)

89 #define PARAM_QUANTSTEP (1 << 4)

90 #define PARAM_FIR (1 << 3)

91 #define PARAM_IIR (1 << 2)

92 #define PARAM_HUFFOFFSET (1 << 1)

93 #define PARAM_PRESENCE (1 << 0)

94 //@}

96 //@{

97 /** matrix data */

99 /// Number of matrices to be applied.

100 uint8_t num_primitive_matrices;

101

102 /// matrix output channel

103 uint8_t matrix_out_ch[MAX_MATRICES];

104

105 /// Whether the LSBs of the matrix output are encoded in the bitstream.

106 uint8_t lsb_bypass[MAX_MATRICES];

107 /// Matrix coefficients, stored as 2.14 fixed point.

108 DECLARE_ALIGNED(32, int32_t, matrix_coeff)[MAX_MATRICES][MAX_CHANNELS];

109 /// Left shift to apply to noise values in 0x31eb substreams.

110 uint8_t matrix_noise_shift[MAX_MATRICES];

111 //@}

112

113 /// Left shift to apply to Huffman-decoded residuals.

114 uint8_t quant_step_size[MAX_CHANNELS];

115

116 /// number of PCM samples in current audio block

117 uint16_t blocksize;

118 /// Number of PCM samples decoded so far in this frame.

119 uint16_t blockpos;

120

121 /// Left shift to apply to decoded PCM values to get final 24-bit output.

122 int8_t output_shift[MAX_CHANNELS];

123

124 /// Running XOR of all output samples.

125 int32_t lossless_check_data;

126

127 } SubStream;

128

129 typedef struct MLPDecodeContext {

130 AVCodecContext *avctx;

131

132 /// Current access unit being read has a major sync.

133 int is_major_sync_unit;

134

135 /// Size of the major sync unit, in bytes

136 int major_sync_header_size;

137

138 /// Set if a valid major sync block has been read. Otherwise no decoding is possible.

139 uint8_t params_valid;

140

141 /// Number of substreams contained within this stream.

142 uint8_t num_substreams;

143

144 /// Index of the last substream to decode - further substreams are skipped.

145 uint8_t max_decoded_substream;

146

147 /// Stream needs channel reordering to comply with FFmpeg's channel order

148 uint8_t needs_reordering;

149

150 /// number of PCM samples contained in each frame

151 int access_unit_size;

152 /// next power of two above the number of samples in each frame

153 int access_unit_size_pow2;

154

155 SubStream substream[MAX_SUBSTREAMS];

156

157 int matrix_changed;

158 int filter_changed[MAX_CHANNELS][NUM_FILTERS];

159

160 int8_t noise_buffer[MAX_BLOCKSIZE_POW2];

161 int8_t bypassed_lsbs[MAX_BLOCKSIZE][MAX_CHANNELS];

162 DECLARE_ALIGNED(32, int32_t, sample_buffer)[MAX_BLOCKSIZE][MAX_CHANNELS];

163

164 MLPDSPContext dsp;

165 } MLPDecodeContext;

166

167 static const uint64_t thd_channel_order[] = {

168 AV_CH_FRONT_LEFT, AV_CH_FRONT_RIGHT, // LR

169 AV_CH_FRONT_CENTER, // C

170 AV_CH_LOW_FREQUENCY, // LFE

171 AV_CH_SIDE_LEFT, AV_CH_SIDE_RIGHT, // LRs

172 AV_CH_TOP_FRONT_LEFT, AV_CH_TOP_FRONT_RIGHT, // LRvh

173 AV_CH_FRONT_LEFT_OF_CENTER, AV_CH_FRONT_RIGHT_OF_CENTER, // LRc

174 AV_CH_BACK_LEFT, AV_CH_BACK_RIGHT, // LRrs

175 AV_CH_BACK_CENTER, // Cs

176 AV_CH_TOP_CENTER, // Ts

177 AV_CH_SURROUND_DIRECT_LEFT, AV_CH_SURROUND_DIRECT_RIGHT, // LRsd

178 AV_CH_WIDE_LEFT, AV_CH_WIDE_RIGHT, // LRw

179 AV_CH_TOP_FRONT_CENTER, // Cvh

180 AV_CH_LOW_FREQUENCY_2, // LFE2

181 };

182

183 static uint64_t thd_channel_layout_extract_channel(uint64_t channel_layout,

184 int index)

185 {

186 int i;

187

188 if (av_get_channel_layout_nb_channels(channel_layout) <= index)

189 return 0;

190

191 for (i = 0; i < FF_ARRAY_ELEMS(thd_channel_order); i++)

192 if (channel_layout & thd_channel_order[i] && !index--)

193 return thd_channel_order[i];

194 return 0;

195 }

196

197 static VLC huff_vlc[3];

198

199 /** Initialize static data, constant between all invocations of the codec. */

200

201 static av_cold void init_static(void)

202 {

203 if (!huff_vlc[0].bits) {

204 INIT_VLC_STATIC(&huff_vlc[0], VLC_BITS, 18,

205 &ff_mlp_huffman_tables[0][0][1], 2, 1,

206 &ff_mlp_huffman_tables[0][0][0], 2, 1, VLC_STATIC_SIZE);

207 INIT_VLC_STATIC(&huff_vlc[1], VLC_BITS, 16,

208 &ff_mlp_huffman_tables[1][0][1], 2, 1,

209 &ff_mlp_huffman_tables[1][0][0], 2, 1, VLC_STATIC_SIZE);

210 INIT_VLC_STATIC(&huff_vlc[2], VLC_BITS, 15,

211 &ff_mlp_huffman_tables[2][0][1], 2, 1,

212 &ff_mlp_huffman_tables[2][0][0], 2, 1, VLC_STATIC_SIZE);

213 }

214

215 ff_mlp_init_crc();

216 }

217

218 static inline int32_t calculate_sign_huff(MLPDecodeContext *m,

219 unsigned int substr, unsigned int ch)

220 {

221 SubStream *s = &m->substream[substr];

222 ChannelParams *cp = &s->channel_params[ch];

223 int lsb_bits = cp->huff_lsbs - s->quant_step_size[ch];

224 int sign_shift = lsb_bits + (cp->codebook ? 2 - cp->codebook : -1);

225 int32_t sign_huff_offset = cp->huff_offset;

226

227 if (cp->codebook > 0)

228 sign_huff_offset -= 7 << lsb_bits;

229

230 if (sign_shift >= 0)

231 sign_huff_offset -= 1 << sign_shift;

232

233 return sign_huff_offset;

234 }

235

236 /** Read a sample, consisting of either, both or neither of entropy-coded MSBs

237 * and plain LSBs. */

238

239 static inline int read_huff_channels(MLPDecodeContext *m, GetBitContext *gbp,

240 unsigned int substr, unsigned int pos)

241 {

242 SubStream *s = &m->substream[substr];

243 unsigned int mat, channel;

244

245 for (mat = 0; mat < s->num_primitive_matrices; mat++)

246 if (s->lsb_bypass[mat])

247 m->bypassed_lsbs[pos + s->blockpos][mat] = get_bits1(gbp);

248

249 for (channel = s->min_channel; channel <= s->max_channel; channel++) {

250 ChannelParams *cp = &s->channel_params[channel];

251 int codebook = cp->codebook;

252 int quant_step_size = s->quant_step_size[channel];

253 int lsb_bits = cp->huff_lsbs - quant_step_size;

254 int result = 0;

255

256 if (codebook > 0)

257 result = get_vlc2(gbp, huff_vlc[codebook-1].table,

258 VLC_BITS, (9 + VLC_BITS - 1) / VLC_BITS);

259

260 if (result < 0)

261 return AVERROR_INVALIDDATA;

262

263 if (lsb_bits > 0)

264 result = (result << lsb_bits) + get_bits(gbp, lsb_bits);

265

266 result += cp->sign_huff_offset;

267 result <<= quant_step_size;

268

269 m->sample_buffer[pos + s->blockpos][channel] = result;

270 }

271

272 return 0;

273 }

274

275 static av_cold int mlp_decode_init(AVCodecContext *avctx)

276 {

277 MLPDecodeContext *m = avctx->priv_data;

278 int substr;

279

280 init_static();

281 m->avctx = avctx;

282 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)

283 m->substream[substr].lossless_check_data = 0xffffffff;

284 ff_mlpdsp_init(&m->dsp);

285

286 return 0;

287 }

288

289 /** Read a major sync info header - contains high level information about

290 * the stream - sample rate, channel arrangement etc. Most of this

291 * information is not actually necessary for decoding, only for playback.

292 */

293

294 static int read_major_sync(MLPDecodeContext *m, GetBitContext *gb)

295 {

296 MLPHeaderInfo mh;

297 int substr, ret;

298

299 if ((ret = ff_mlp_read_major_sync(m->avctx, &mh, gb)) != 0)

300 return ret;

301

302 if (mh.group1_bits == 0) {

303 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown bits per sample\n");

304 return AVERROR_INVALIDDATA;

305 }

306 if (mh.group2_bits > mh.group1_bits) {

307 av_log(m->avctx, AV_LOG_ERROR,

308 "Channel group 2 cannot have more bits per sample than group 1.\n");

309 return AVERROR_INVALIDDATA;

310 }

311

312 if (mh.group2_samplerate && mh.group2_samplerate != mh.group1_samplerate) {

313 av_log(m->avctx, AV_LOG_ERROR,

314 "Channel groups with differing sample rates are not currently supported.\n");

315 return AVERROR_INVALIDDATA;

316 }

317

318 if (mh.group1_samplerate == 0) {

319 av_log(m->avctx, AV_LOG_ERROR, "invalid/unknown sampling rate\n");

320 return AVERROR_INVALIDDATA;

321 }

322 if (mh.group1_samplerate > MAX_SAMPLERATE) {

323 av_log(m->avctx, AV_LOG_ERROR,

324 "Sampling rate %d is greater than the supported maximum (%d).\n",

325 mh.group1_samplerate, MAX_SAMPLERATE);

326 return AVERROR_INVALIDDATA;

327 }

328 if (mh.access_unit_size > MAX_BLOCKSIZE) {

329 av_log(m->avctx, AV_LOG_ERROR,

330 "Block size %d is greater than the supported maximum (%d).\n",

331 mh.access_unit_size, MAX_BLOCKSIZE);

332 return AVERROR_INVALIDDATA;

333 }

334 if (mh.access_unit_size_pow2 > MAX_BLOCKSIZE_POW2) {

335 av_log(m->avctx, AV_LOG_ERROR,

336 "Block size pow2 %d is greater than the supported maximum (%d).\n",

337 mh.access_unit_size_pow2, MAX_BLOCKSIZE_POW2);

338 return AVERROR_INVALIDDATA;

339 }

340

341 if (mh.num_substreams == 0)

342 return AVERROR_INVALIDDATA;

343 if (m->avctx->codec_id == AV_CODEC_ID_MLP && mh.num_substreams > 2) {

344 av_log(m->avctx, AV_LOG_ERROR, "MLP only supports up to 2 substreams.\n");

345 return AVERROR_INVALIDDATA;

346 }

347 if (mh.num_substreams > MAX_SUBSTREAMS) {

348 avpriv_request_sample(m->avctx,

349 "%d substreams (more than the "

350 "maximum supported by the decoder)",

351 mh.num_substreams);

352 return AVERROR_PATCHWELCOME;

353 }

354

355 m->major_sync_header_size = mh.header_size;

356

357 m->access_unit_size = mh.access_unit_size;

358 m->access_unit_size_pow2 = mh.access_unit_size_pow2;

359

360 m->num_substreams = mh.num_substreams;

361

362 /* limit to decoding 3 substreams, as the 4th is used by Dolby Atmos for non-audio data */

363 m->max_decoded_substream = FFMIN(m->num_substreams - 1, 2);

364

365 m->avctx->sample_rate = mh.group1_samplerate;

366 m->avctx->frame_size = mh.access_unit_size;

367

368 m->avctx->bits_per_raw_sample = mh.group1_bits;

369 if (mh.group1_bits > 16)

370 m->avctx->sample_fmt = AV_SAMPLE_FMT_S32;

371 else

372 m->avctx->sample_fmt = AV_SAMPLE_FMT_S16;

373 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(m->substream[m->max_decoded_substream].ch_assign,

374 m->substream[m->max_decoded_substream].output_shift,

375 m->substream[m->max_decoded_substream].max_matrix_channel,

376 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);

377

378 m->params_valid = 1;

379 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)

380 m->substream[substr].restart_seen = 0;

381

382 /* Set the layout for each substream. When there's more than one, the first

383 * substream is Stereo. Subsequent substreams' layouts are indicated in the

384 * major sync. */

385 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {

386 if (mh.stream_type != 0xbb) {

387 avpriv_request_sample(m->avctx,

388 "unexpected stream_type %X in MLP",

389 mh.stream_type);

390 return AVERROR_PATCHWELCOME;

391 }

392 if ((substr = (mh.num_substreams > 1)))

393 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;

394 m->substream[substr].ch_layout = mh.channel_layout_mlp;

395 } else {

396 if (mh.stream_type != 0xba) {

397 avpriv_request_sample(m->avctx,

398 "unexpected stream_type %X in !MLP",

399 mh.stream_type);

400 return AVERROR_PATCHWELCOME;

401 }

402 if ((substr = (mh.num_substreams > 1)))

403 m->substream[0].ch_layout = AV_CH_LAYOUT_STEREO;

404 if (mh.num_substreams > 2)

405 if (mh.channel_layout_thd_stream2)

406 m->substream[2].ch_layout = mh.channel_layout_thd_stream2;

407 else

408 m->substream[2].ch_layout = mh.channel_layout_thd_stream1;

409 m->substream[substr].ch_layout = mh.channel_layout_thd_stream1;

410

411 if (m->avctx->channels<=2 && m->substream[substr].ch_layout == AV_CH_LAYOUT_MONO && m->max_decoded_substream == 1) {

412 av_log(m->avctx, AV_LOG_DEBUG, "Mono stream with 2 substreams, ignoring 2nd\n");

413 m->max_decoded_substream = 0;

414 if (m->avctx->channels==2)

415 m->avctx->channel_layout = AV_CH_LAYOUT_STEREO;

416 }

417 }

418

419 m->needs_reordering = mh.channel_arrangement >= 18 && mh.channel_arrangement <= 20;

420

421 /* Parse the TrueHD decoder channel modifiers and set each substream's

422 * AVMatrixEncoding accordingly.

423 *

424 * The meaning of the modifiers depends on the channel layout:

425 *

426 * - THD_CH_MODIFIER_LTRT, THD_CH_MODIFIER_LBINRBIN only apply to 2-channel

427 *

428 * - THD_CH_MODIFIER_MONO applies to 1-channel or 2-channel (dual mono)

429 *

430 * - THD_CH_MODIFIER_SURROUNDEX, THD_CH_MODIFIER_NOTSURROUNDEX only apply to

431 * layouts with an Ls/Rs channel pair

432 */

433 for (substr = 0; substr < MAX_SUBSTREAMS; substr++)

434 m->substream[substr].matrix_encoding = AV_MATRIX_ENCODING_NONE;

435 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {

436 if (mh.num_substreams > 2 &&

437 mh.channel_layout_thd_stream2 & AV_CH_SIDE_LEFT &&

438 mh.channel_layout_thd_stream2 & AV_CH_SIDE_RIGHT &&

439 mh.channel_modifier_thd_stream2 == THD_CH_MODIFIER_SURROUNDEX)

440 m->substream[2].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;

441

442 if (mh.num_substreams > 1 &&

443 mh.channel_layout_thd_stream1 & AV_CH_SIDE_LEFT &&

444 mh.channel_layout_thd_stream1 & AV_CH_SIDE_RIGHT &&

445 mh.channel_modifier_thd_stream1 == THD_CH_MODIFIER_SURROUNDEX)

446 m->substream[1].matrix_encoding = AV_MATRIX_ENCODING_DOLBYEX;

447

448 if (mh.num_substreams > 0)

449 switch (mh.channel_modifier_thd_stream0) {

450 case THD_CH_MODIFIER_LTRT:

451 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBY;

452 break;

453 case THD_CH_MODIFIER_LBINRBIN:

454 m->substream[0].matrix_encoding = AV_MATRIX_ENCODING_DOLBYHEADPHONE;

455 break;

456 default:

457 break;

458 }

459 }

460

461 return 0;

462 }

463

464 /** Read a restart header from a block in a substream. This contains parameters

465 * required to decode the audio that do not change very often. Generally

466 * (always) present only in blocks following a major sync. */

467

468 static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,

469 const uint8_t *buf, unsigned int substr)

470 {

471 SubStream *s = &m->substream[substr];

472 unsigned int ch;

473 int sync_word, tmp;

474 uint8_t checksum;

475 uint8_t lossless_check;

476 int start_count = get_bits_count(gbp);

477 int min_channel, max_channel, max_matrix_channel;

478 const int std_max_matrix_channel = m->avctx->codec_id == AV_CODEC_ID_MLP

479 ? MAX_MATRIX_CHANNEL_MLP

480 : MAX_MATRIX_CHANNEL_TRUEHD;

481

482 sync_word = get_bits(gbp, 13);

483

484 if (sync_word != 0x31ea >> 1) {

485 av_log(m->avctx, AV_LOG_ERROR,

486 "restart header sync incorrect (got 0x%04x)\n", sync_word);

487 return AVERROR_INVALIDDATA;

488 }

489

490 s->noise_type = get_bits1(gbp);

491

492 if (m->avctx->codec_id == AV_CODEC_ID_MLP && s->noise_type) {

493 av_log(m->avctx, AV_LOG_ERROR, "MLP must have 0x31ea sync word.\n");

494 return AVERROR_INVALIDDATA;

495 }

496

497 skip_bits(gbp, 16); /* Output timestamp */

498

499 min_channel = get_bits(gbp, 4);

500 max_channel = get_bits(gbp, 4);

501 max_matrix_channel = get_bits(gbp, 4);

502

503 if (max_matrix_channel > std_max_matrix_channel) {

504 av_log(m->avctx, AV_LOG_ERROR,

505 "Max matrix channel cannot be greater than %d.\n",

506 std_max_matrix_channel);

507 return AVERROR_INVALIDDATA;

508 }

509

510 if (max_channel != max_matrix_channel) {

511 av_log(m->avctx, AV_LOG_ERROR,

512 "Max channel must be equal max matrix channel.\n");

513 return AVERROR_INVALIDDATA;

514 }

515

516 /* This should happen for TrueHD streams with >6 channels and MLP's noise

517 * type. It is not yet known if this is allowed. */

518 if (max_channel > MAX_MATRIX_CHANNEL_MLP && !s->noise_type) {

519 avpriv_request_sample(m->avctx,

520 "%d channels (more than the "

521 "maximum supported by the decoder)",

522 max_channel + 2);

523 return AVERROR_PATCHWELCOME;

524 }

525

526 if (min_channel > max_channel) {

527 av_log(m->avctx, AV_LOG_ERROR,

528 "Substream min channel cannot be greater than max channel.\n");

529 return AVERROR_INVALIDDATA;

530 }

531

532 s->min_channel = min_channel;

533 s->max_channel = max_channel;

534 s->max_matrix_channel = max_matrix_channel;

535

536 #if FF_API_REQUEST_CHANNELS

537 FF_DISABLE_DEPRECATION_WARNINGS

538 if (m->avctx->request_channels > 0 &&

539 m->avctx->request_channels <= s->max_channel + 1 &&

540 m->max_decoded_substream > substr) {

541 av_log(m->avctx, AV_LOG_DEBUG,

542 "Extracting %d-channel downmix from substream %d. "

543 "Further substreams will be skipped.\n",

544 s->max_channel + 1, substr);

545 m->max_decoded_substream = substr;

546 FF_ENABLE_DEPRECATION_WARNINGS

547 } else

548 #endif

549 if (m->avctx->request_channel_layout && (s->ch_layout & m->avctx->request_channel_layout) ==

550 m->avctx->request_channel_layout && m->max_decoded_substream > substr) {

551 av_log(m->avctx, AV_LOG_DEBUG,

552 "Extracting %d-channel downmix (0x%"PRIx64") from substream %d. "

553 "Further substreams will be skipped.\n",

554 s->max_channel + 1, s->ch_layout, substr);

555 m->max_decoded_substream = substr;

556 }

557

558 s->noise_shift = get_bits(gbp, 4);

559 s->noisegen_seed = get_bits(gbp, 23);

560

561 skip_bits(gbp, 19);

562

563 s->data_check_present = get_bits1(gbp);

564 lossless_check = get_bits(gbp, 8);

565 if (substr == m->max_decoded_substream

566 && s->lossless_check_data != 0xffffffff) {

567 tmp = xor_32_to_8(s->lossless_check_data);

568 if (tmp != lossless_check)

569 av_log(m->avctx, AV_LOG_WARNING,

570 "Lossless check failed - expected %02x, calculated %02x.\n",

571 lossless_check, tmp);

572 }

573

574 skip_bits(gbp, 16);

575

576 memset(s->ch_assign, 0, sizeof(s->ch_assign));

577

578 for (ch = 0; ch <= s->max_matrix_channel; ch++) {

579 int ch_assign = get_bits(gbp, 6);

580 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD) {

581 uint64_t channel = thd_channel_layout_extract_channel(s->ch_layout,

582 ch_assign);

583 ch_assign = av_get_channel_layout_channel_index(s->ch_layout,

584 channel);

585 }

586 if (ch_assign < 0 || ch_assign > s->max_matrix_channel) {

587 avpriv_request_sample(m->avctx,

588 "Assignment of matrix channel %d to invalid output channel %d",

589 ch, ch_assign);

590 return AVERROR_PATCHWELCOME;

591 }

592 s->ch_assign[ch_assign] = ch;

593 }

594

595 checksum = ff_mlp_restart_checksum(buf, get_bits_count(gbp) - start_count);

596

597 if (checksum != get_bits(gbp, 8))

598 av_log(m->avctx, AV_LOG_ERROR, "restart header checksum error\n");

599

600 /* Set default decoding parameters. */

601 s->param_presence_flags = 0xff;

602 s->num_primitive_matrices = 0;

603 s->blocksize = 8;

604 s->lossless_check_data = 0;

605

606 memset(s->output_shift , 0, sizeof(s->output_shift ));

607 memset(s->quant_step_size, 0, sizeof(s->quant_step_size));

608

609 for (ch = s->min_channel; ch <= s->max_channel; ch++) {

610 ChannelParams *cp = &s->channel_params[ch];

611 cp->filter_params[FIR].order = 0;

612 cp->filter_params[IIR].order = 0;

613 cp->filter_params[FIR].shift = 0;

614 cp->filter_params[IIR].shift = 0;

615

616 /* Default audio coding is 24-bit raw PCM. */

617 cp->huff_offset = 0;

618 cp->sign_huff_offset = (-1) << 23;

619 cp->codebook = 0;

620 cp->huff_lsbs = 24;

621 }

622

623 if (substr == m->max_decoded_substream) {

624 m->avctx->channels = s->max_matrix_channel + 1;

625 m->avctx->channel_layout = s->ch_layout;

626 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,

627 s->output_shift,

628 s->max_matrix_channel,

629 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);

630

631 if (m->avctx->codec_id == AV_CODEC_ID_MLP && m->needs_reordering) {

632 if (m->avctx->channel_layout == (AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY) ||

633 m->avctx->channel_layout == AV_CH_LAYOUT_5POINT0_BACK) {

634 int i = s->ch_assign[4];

635 s->ch_assign[4] = s->ch_assign[3];

636 s->ch_assign[3] = s->ch_assign[2];

637 s->ch_assign[2] = i;

638 } else if (m->avctx->channel_layout == AV_CH_LAYOUT_5POINT1_BACK) {

639 FFSWAP(int, s->ch_assign[2], s->ch_assign[4]);

640 FFSWAP(int, s->ch_assign[3], s->ch_assign[5]);

641 }

642 }

643

644 }

645

646 return 0;

647 }

648

649 /** Read parameters for one of the prediction filters. */

650

651 static int read_filter_params(MLPDecodeContext *m, GetBitContext *gbp,

652 unsigned int substr, unsigned int channel,

653 unsigned int filter)

654 {

655 SubStream *s = &m->substream[substr];

656 FilterParams *fp = &s->channel_params[channel].filter_params[filter];

657 const int max_order = filter ? MAX_IIR_ORDER : MAX_FIR_ORDER;

658 const char fchar = filter ? 'I' : 'F';

659 int i, order;

660

661 // Filter is 0 for FIR, 1 for IIR.

662 av_assert0(filter < 2);

663

664 if (m->filter_changed[channel][filter]++ > 1) {

665 av_log(m->avctx, AV_LOG_ERROR, "Filters may change only once per access unit.\n");

666 return AVERROR_INVALIDDATA;

667 }

668

669 order = get_bits(gbp, 4);

670 if (order > max_order) {

671 av_log(m->avctx, AV_LOG_ERROR,

672 "%cIR filter order %d is greater than maximum %d.\n",

673 fchar, order, max_order);

674 return AVERROR_INVALIDDATA;

675 }

676 fp->order = order;

677

678 if (order > 0) {

679 int32_t *fcoeff = s->channel_params[channel].coeff[filter];

680 int coeff_bits, coeff_shift;

681

682 fp->shift = get_bits(gbp, 4);

683

684 coeff_bits = get_bits(gbp, 5);

685 coeff_shift = get_bits(gbp, 3);

686 if (coeff_bits < 1 || coeff_bits > 16) {

687 av_log(m->avctx, AV_LOG_ERROR,

688 "%cIR filter coeff_bits must be between 1 and 16.\n",

689 fchar);

690 return AVERROR_INVALIDDATA;

691 }

692 if (coeff_bits + coeff_shift > 16) {

693 av_log(m->avctx, AV_LOG_ERROR,

694 "Sum of coeff_bits and coeff_shift for %cIR filter must be 16 or less.\n",

695 fchar);

696 return AVERROR_INVALIDDATA;

697 }

698

699 for (i = 0; i < order; i++)

700 fcoeff[i] = get_sbits(gbp, coeff_bits) << coeff_shift;

701

702 if (get_bits1(gbp)) {

703 int state_bits, state_shift;

704

705 if (filter == FIR) {

706 av_log(m->avctx, AV_LOG_ERROR,

707 "FIR filter has state data specified.\n");

708 return AVERROR_INVALIDDATA;

709 }

710

711 state_bits = get_bits(gbp, 4);

712 state_shift = get_bits(gbp, 4);

713

714 /* TODO: Check validity of state data. */

715

716 for (i = 0; i < order; i++)

717 fp->state[i] = state_bits ? get_sbits(gbp, state_bits) << state_shift : 0;

718 }

719 }

720

721 return 0;

722 }

723

724 /** Read parameters for primitive matrices. */

725

726 static int read_matrix_params(MLPDecodeContext *m, unsigned int substr, GetBitContext *gbp)

727 {

728 SubStream *s = &m->substream[substr];

729 unsigned int mat, ch;

730 const int max_primitive_matrices = m->avctx->codec_id == AV_CODEC_ID_MLP

731 ? MAX_MATRICES_MLP

732 : MAX_MATRICES_TRUEHD;

733

734 if (m->matrix_changed++ > 1) {

735 av_log(m->avctx, AV_LOG_ERROR, "Matrices may change only once per access unit.\n");

736 return AVERROR_INVALIDDATA;

737 }

738

739 s->num_primitive_matrices = get_bits(gbp, 4);

740

741 if (s->num_primitive_matrices > max_primitive_matrices) {

742 av_log(m->avctx, AV_LOG_ERROR,

743 "Number of primitive matrices cannot be greater than %d.\n",

744 max_primitive_matrices);

745 return AVERROR_INVALIDDATA;

746 }

747

748 for (mat = 0; mat < s->num_primitive_matrices; mat++) {

749 int frac_bits, max_chan;

750 s->matrix_out_ch[mat] = get_bits(gbp, 4);

751 frac_bits = get_bits(gbp, 4);

752 s->lsb_bypass [mat] = get_bits1(gbp);

753

754 if (s->matrix_out_ch[mat] > s->max_matrix_channel) {

755 av_log(m->avctx, AV_LOG_ERROR,

756 "Invalid channel %d specified as output from matrix.\n",

757 s->matrix_out_ch[mat]);

758 return AVERROR_INVALIDDATA;

759 }

760 if (frac_bits > 14) {

761 av_log(m->avctx, AV_LOG_ERROR,

762 "Too many fractional bits specified.\n");

763 return AVERROR_INVALIDDATA;

764 }

765

766 max_chan = s->max_matrix_channel;

767 if (!s->noise_type)

768 max_chan+=2;

769

770 for (ch = 0; ch <= max_chan; ch++) {

771 int coeff_val = 0;

772 if (get_bits1(gbp))

773 coeff_val = get_sbits(gbp, frac_bits + 2);

774

775 s->matrix_coeff[mat][ch] = coeff_val << (14 - frac_bits);

776 }

777

778 if (s->noise_type)

779 s->matrix_noise_shift[mat] = get_bits(gbp, 4);

780 else

781 s->matrix_noise_shift[mat] = 0;

782 }

783

784 return 0;

785 }

786

787 /** Read channel parameters. */

788

789 static int read_channel_params(MLPDecodeContext *m, unsigned int substr,

790 GetBitContext *gbp, unsigned int ch)

791 {

792 SubStream *s = &m->substream[substr];

793 ChannelParams *cp = &s->channel_params[ch];

794 FilterParams *fir = &cp->filter_params[FIR];

795 FilterParams *iir = &cp->filter_params[IIR];

796 int ret;

797

798 if (s->param_presence_flags & PARAM_FIR)

799 if (get_bits1(gbp))

800 if ((ret = read_filter_params(m, gbp, substr, ch, FIR)) < 0)

801 return ret;

802

803 if (s->param_presence_flags & PARAM_IIR)

804 if (get_bits1(gbp))

805 if ((ret = read_filter_params(m, gbp, substr, ch, IIR)) < 0)

806 return ret;

807

808 if (fir->order + iir->order > 8) {

809 av_log(m->avctx, AV_LOG_ERROR, "Total filter orders too high.\n");

810 return AVERROR_INVALIDDATA;

811 }

812

813 if (fir->order && iir->order &&

814 fir->shift != iir->shift) {

815 av_log(m->avctx, AV_LOG_ERROR,

816 "FIR and IIR filters must use the same precision.\n");

817 return AVERROR_INVALIDDATA;

818 }

819 /* The FIR and IIR filters must have the same precision.

820 * To simplify the filtering code, only the precision of the

821 * FIR filter is considered. If only the IIR filter is employed,

822 * the FIR filter precision is set to that of the IIR filter, so

823 * that the filtering code can use it. */

824 if (!fir->order && iir->order)

825 fir->shift = iir->shift;

826

827 if (s->param_presence_flags & PARAM_HUFFOFFSET)

828 if (get_bits1(gbp))

829 cp->huff_offset = get_sbits(gbp, 15);

830

831 cp->codebook = get_bits(gbp, 2);

832 cp->huff_lsbs = get_bits(gbp, 5);

833

834 if (cp->huff_lsbs > 24) {

835 av_log(m->avctx, AV_LOG_ERROR, "Invalid huff_lsbs.\n");

836 cp->huff_lsbs = 0;

837 return AVERROR_INVALIDDATA;

838 }

839

840 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);

841

842 return 0;

843 }

844

845 /** Read decoding parameters that change more often than those in the restart

846 * header. */

847

848 static int read_decoding_params(MLPDecodeContext *m, GetBitContext *gbp,

849 unsigned int substr)

850 {

851 SubStream *s = &m->substream[substr];

852 unsigned int ch;

853 int ret;

854

855 if (s->param_presence_flags & PARAM_PRESENCE)

856 if (get_bits1(gbp))

857 s->param_presence_flags = get_bits(gbp, 8);

858

859 if (s->param_presence_flags & PARAM_BLOCKSIZE)

860 if (get_bits1(gbp)) {

861 s->blocksize = get_bits(gbp, 9);

862 if (s->blocksize < 8 || s->blocksize > m->access_unit_size) {

863 av_log(m->avctx, AV_LOG_ERROR, "Invalid blocksize.\n");

864 s->blocksize = 0;

865 return AVERROR_INVALIDDATA;

866 }

867 }

868

869 if (s->param_presence_flags & PARAM_MATRIX)

870 if (get_bits1(gbp))

871 if ((ret = read_matrix_params(m, substr, gbp)) < 0)

872 return ret;

873

874 if (s->param_presence_flags & PARAM_OUTSHIFT)

875 if (get_bits1(gbp)) {

876 for (ch = 0; ch <= s->max_matrix_channel; ch++)

877 s->output_shift[ch] = get_sbits(gbp, 4);

878 if (substr == m->max_decoded_substream)

879 m->dsp.mlp_pack_output = m->dsp.mlp_select_pack_output(s->ch_assign,

880 s->output_shift,

881 s->max_matrix_channel,

882 m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);

883 }

884

885 if (s->param_presence_flags & PARAM_QUANTSTEP)

886 if (get_bits1(gbp))

887 for (ch = 0; ch <= s->max_channel; ch++) {

888 ChannelParams *cp = &s->channel_params[ch];

889

890 s->quant_step_size[ch] = get_bits(gbp, 4);

891

892 cp->sign_huff_offset = calculate_sign_huff(m, substr, ch);

893 }

894

895 for (ch = s->min_channel; ch <= s->max_channel; ch++)

896 if (get_bits1(gbp))

897 if ((ret = read_channel_params(m, substr, gbp, ch)) < 0)

898 return ret;

899

900 return 0;

901 }

902

903 #define MSB_MASK(bits) (-1u << (bits))

904

905 /** Generate PCM samples using the prediction filters and residual values

906 * read from the data stream, and update the filter state. */

907

908 static void filter_channel(MLPDecodeContext *m, unsigned int substr,

909 unsigned int channel)

910 {

911 SubStream *s = &m->substream[substr];

912 const int32_t *fircoeff = s->channel_params[channel].coeff[FIR];

913 int32_t state_buffer[NUM_FILTERS][MAX_BLOCKSIZE + MAX_FIR_ORDER];

914 int32_t *firbuf = state_buffer[FIR] + MAX_BLOCKSIZE;

915 int32_t *iirbuf = state_buffer[IIR] + MAX_BLOCKSIZE;

916 FilterParams *fir = &s->channel_params[channel].filter_params[FIR];

917 FilterParams *iir = &s->channel_params[channel].filter_params[IIR];

918 unsigned int filter_shift = fir->shift;

919 int32_t mask = MSB_MASK(s->quant_step_size[channel]);

920

921 memcpy(firbuf, fir->state, MAX_FIR_ORDER * sizeof(int32_t));

922 memcpy(iirbuf, iir->state, MAX_IIR_ORDER * sizeof(int32_t));

923

924 m->dsp.mlp_filter_channel(firbuf, fircoeff,

925 fir->order, iir->order,

926 filter_shift, mask, s->blocksize,

927 &m->sample_buffer[s->blockpos][channel]);

928

929 memcpy(fir->state, firbuf - s->blocksize, MAX_FIR_ORDER * sizeof(int32_t));

930 memcpy(iir->state, iirbuf - s->blocksize, MAX_IIR_ORDER * sizeof(int32_t));

931 }

932

933 /** Read a block of PCM residual data (or actual if no filtering active). */

934

935 static int read_block_data(MLPDecodeContext *m, GetBitContext *gbp,

936 unsigned int substr)

937 {

938 SubStream *s = &m->substream[substr];

939 unsigned int i, ch, expected_stream_pos = 0;

940 int ret;

941

942 if (s->data_check_present) {

943 expected_stream_pos = get_bits_count(gbp);

944 expected_stream_pos += get_bits(gbp, 16);

945 avpriv_request_sample(m->avctx,

946 "Substreams with VLC block size check info");

947 }

948

949 if (s->blockpos + s->blocksize > m->access_unit_size) {

950 av_log(m->avctx, AV_LOG_ERROR, "too many audio samples in frame\n");

951 return AVERROR_INVALIDDATA;

952 }

953

954 memset(&m->bypassed_lsbs[s->blockpos][0], 0,

955 s->blocksize * sizeof(m->bypassed_lsbs[0]));

956

957 for (i = 0; i < s->blocksize; i++)

958 if ((ret = read_huff_channels(m, gbp, substr, i)) < 0)

959 return ret;

960

961 for (ch = s->min_channel; ch <= s->max_channel; ch++)

962 filter_channel(m, substr, ch);

963

964 s->blockpos += s->blocksize;

965

966 if (s->data_check_present) {

967 if (get_bits_count(gbp) != expected_stream_pos)

968 av_log(m->avctx, AV_LOG_ERROR, "block data length mismatch\n");

969 skip_bits(gbp, 8);

970 }

971

972 return 0;

973 }

974

975 /** Data table used for TrueHD noise generation function. */

976

977 static const int8_t noise_table[256] = {

978 30, 51, 22, 54, 3, 7, -4, 38, 14, 55, 46, 81, 22, 58, -3, 2,

979 52, 31, -7, 51, 15, 44, 74, 30, 85, -17, 10, 33, 18, 80, 28, 62,

980 10, 32, 23, 69, 72, 26, 35, 17, 73, 60, 8, 56, 2, 6, -2, -5,

981 51, 4, 11, 50, 66, 76, 21, 44, 33, 47, 1, 26, 64, 48, 57, 40,

982 38, 16, -10, -28, 92, 22, -18, 29, -10, 5, -13, 49, 19, 24, 70, 34,

983 61, 48, 30, 14, -6, 25, 58, 33, 42, 60, 67, 17, 54, 17, 22, 30,

984 67, 44, -9, 50, -11, 43, 40, 32, 59, 82, 13, 49, -14, 55, 60, 36,

985 48, 49, 31, 47, 15, 12, 4, 65, 1, 23, 29, 39, 45, -2, 84, 69,

986 0, 72, 37, 57, 27, 41, -15, -16, 35, 31, 14, 61, 24, 0, 27, 24,

987 16, 41, 55, 34, 53, 9, 56, 12, 25, 29, 53, 5, 20, -20, -8, 20,

988 13, 28, -3, 78, 38, 16, 11, 62, 46, 29, 21, 24, 46, 65, 43, -23,

989 89, 18, 74, 21, 38, -12, 19, 12, -19, 8, 15, 33, 4, 57, 9, -8,

990 36, 35, 26, 28, 7, 83, 63, 79, 75, 11, 3, 87, 37, 47, 34, 40,

991 39, 19, 20, 42, 27, 34, 39, 77, 13, 42, 59, 64, 45, -1, 32, 37,

992 45, -5, 53, -6, 7, 36, 50, 23, 6, 32, 9, -21, 18, 71, 27, 52,

993 -25, 31, 35, 42, -1, 68, 63, 52, 26, 43, 66, 37, 41, 25, 40, 70,

994 };

995

996 /** Noise generation functions.

997 * I'm not sure what these are for - they seem to be some kind of pseudorandom

998 * sequence generators, used to generate noise data which is used when the

999 * channels are rematrixed. I'm not sure if they provide a practical benefit

1000 * to compression, or just obfuscate the decoder. Are they for some kind of

1001 * dithering? */

1002

1003 /** Generate two channels of noise, used in the matrix when

1004 * restart sync word == 0x31ea. */

1005

1006 static void generate_2_noise_channels(MLPDecodeContext *m, unsigned int substr)

1007 {

1008 SubStream *s = &m->substream[substr];

1009 unsigned int i;

1010 uint32_t seed = s->noisegen_seed;

1011 unsigned int maxchan = s->max_matrix_channel;

1012

1013 for (i = 0; i < s->blockpos; i++) {

1014 uint16_t seed_shr7 = seed >> 7;

1015 m->sample_buffer[i][maxchan+1] = ((int8_t)(seed >> 15)) << s->noise_shift;

1016 m->sample_buffer[i][maxchan+2] = ((int8_t) seed_shr7) << s->noise_shift;

1017

1018 seed = (seed << 16) ^ seed_shr7 ^ (seed_shr7 << 5);

1019 }

1020

1021 s->noisegen_seed = seed;

1022 }

1023

1024 /** Generate a block of noise, used when restart sync word == 0x31eb. */

1025

1026 static void fill_noise_buffer(MLPDecodeContext *m, unsigned int substr)

1027 {

1028 SubStream *s = &m->substream[substr];

1029 unsigned int i;

1030 uint32_t seed = s->noisegen_seed;

1031

1032 for (i = 0; i < m->access_unit_size_pow2; i++) {

1033 uint8_t seed_shr15 = seed >> 15;

1034 m->noise_buffer[i] = noise_table[seed_shr15];

1035 seed = (seed << 8) ^ seed_shr15 ^ (seed_shr15 << 5);

1036 }

1037

1038 s->noisegen_seed = seed;

1039 }

1040

1041 /** Write the audio data into the output buffer. */

1042

1043 static int output_data(MLPDecodeContext *m, unsigned int substr,

1044 AVFrame *frame, int *got_frame_ptr)

1045 {

1046 AVCodecContext *avctx = m->avctx;

1047 SubStream *s = &m->substream[substr];

1048 unsigned int mat;

1049 unsigned int maxchan;

1050 int ret;

1051 int is32 = (m->avctx->sample_fmt == AV_SAMPLE_FMT_S32);

1052

1053 if (m->avctx->channels != s->max_matrix_channel + 1) {

1054 av_log(m->avctx, AV_LOG_ERROR, "channel count mismatch\n");

1055 return AVERROR_INVALIDDATA;

1056 }

1057

1058 if (!s->blockpos) {

1059 av_log(avctx, AV_LOG_ERROR, "No samples to output.\n");

1060 return AVERROR_INVALIDDATA;

1061 }

1062

1063 maxchan = s->max_matrix_channel;

1064 if (!s->noise_type) {

1065 generate_2_noise_channels(m, substr);

1066 maxchan += 2;

1067 } else {

1068 fill_noise_buffer(m, substr);

1069 }

1070

1071 /* Apply the channel matrices in turn to reconstruct the original audio

1072 * samples. */

1073 for (mat = 0; mat < s->num_primitive_matrices; mat++) {

1074 unsigned int dest_ch = s->matrix_out_ch[mat];

1075 m->dsp.mlp_rematrix_channel(&m->sample_buffer[0][0],

1076 s->matrix_coeff[mat],

1077 &m->bypassed_lsbs[0][mat],

1078 m->noise_buffer,

1079 s->num_primitive_matrices - mat,

1080 dest_ch,

1081 s->blockpos,

1082 maxchan,

1083 s->matrix_noise_shift[mat],

1084 m->access_unit_size_pow2,

1085 MSB_MASK(s->quant_step_size[dest_ch]));

1086 }

1087

1088 /* get output buffer */

1089 frame->nb_samples = s->blockpos;

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

1091 return ret;

1092 s->lossless_check_data = m->dsp.mlp_pack_output(s->lossless_check_data,

1093 s->blockpos,

1094 m->sample_buffer,

1095 frame->data[0],

1096 s->ch_assign,

1097 s->output_shift,

1098 s->max_matrix_channel,

1099 is32);

1100

1101 /* Update matrix encoding side data */

1102 if ((ret = ff_side_data_update_matrix_encoding(frame, s->matrix_encoding)) < 0)

1103 return ret;

1104

1105 *got_frame_ptr = 1;

1106

1107 return 0;

1108 }

1109

1110 /** Read an access unit from the stream.

1111 * @return negative on error, 0 if not enough data is present in the input stream,

1112 * otherwise the number of bytes consumed. */

1113

1114 static int read_access_unit(AVCodecContext *avctx, void* data,

1115 int *got_frame_ptr, AVPacket *avpkt)

1116 {

1117 const uint8_t *buf = avpkt->data;

1118 int buf_size = avpkt->size;

1119 MLPDecodeContext *m = avctx->priv_data;

1120 GetBitContext gb;

1121 unsigned int length, substr;

1122 unsigned int substream_start;

1123 unsigned int header_size = 4;

1124 unsigned int substr_header_size = 0;

1125 uint8_t substream_parity_present[MAX_SUBSTREAMS];

1126 uint16_t substream_data_len[MAX_SUBSTREAMS];

1127 uint8_t parity_bits;

1128 int ret;

1129

1130 if (buf_size < 4)

1131 return AVERROR_INVALIDDATA;

1132

1133 length = (AV_RB16(buf) & 0xfff) * 2;

1134

1135 if (length < 4 || length > buf_size)

1136 return AVERROR_INVALIDDATA;

1137

1138 init_get_bits(&gb, (buf + 4), (length - 4) * 8);

1139

1140 m->is_major_sync_unit = 0;

1141 if (show_bits_long(&gb, 31) == (0xf8726fba >> 1)) {

1142 if (read_major_sync(m, &gb) < 0)

1143 goto error;

1144 m->is_major_sync_unit = 1;

1145 header_size += m->major_sync_header_size;

1146 }

1147

1148 if (!m->params_valid) {

1149 av_log(m->avctx, AV_LOG_WARNING,

1150 "Stream parameters not seen; skipping frame.\n");

1151 *got_frame_ptr = 0;

1152 return length;

1153 }

1154

1155 substream_start = 0;

1156

1157 for (substr = 0; substr < m->num_substreams; substr++) {

1158 int extraword_present, checkdata_present, end, nonrestart_substr;

1159

1160 extraword_present = get_bits1(&gb);

1161 nonrestart_substr = get_bits1(&gb);

1162 checkdata_present = get_bits1(&gb);

1163 skip_bits1(&gb);

1164

1165 end = get_bits(&gb, 12) * 2;

1166

1167 substr_header_size += 2;

1168

1169 if (extraword_present) {

1170 if (m->avctx->codec_id == AV_CODEC_ID_MLP) {

1171 av_log(m->avctx, AV_LOG_ERROR, "There must be no extraword for MLP.\n");

1172 goto error;

1173 }

1174 skip_bits(&gb, 16);

1175 substr_header_size += 2;

1176 }

1177

1178 if (!(nonrestart_substr ^ m->is_major_sync_unit)) {

1179 av_log(m->avctx, AV_LOG_ERROR, "Invalid nonrestart_substr.\n");

1180 goto error;

1181 }

1182

1183 if (end + header_size + substr_header_size > length) {

1184 av_log(m->avctx, AV_LOG_ERROR,

1185 "Indicated length of substream %d data goes off end of "

1186 "packet.\n", substr);

1187 end = length - header_size - substr_header_size;

1188 }

1189

1190 if (end < substream_start) {

1191 av_log(avctx, AV_LOG_ERROR,

1192 "Indicated end offset of substream %d data "

1193 "is smaller than calculated start offset.\n",

1194 substr);

1195 goto error;

1196 }

1197

1198 if (substr > m->max_decoded_substream)

1199 continue;

1200

1201 substream_parity_present[substr] = checkdata_present;

1202 substream_data_len[substr] = end - substream_start;

1203 substream_start = end;

1204 }

1205

1206 parity_bits = ff_mlp_calculate_parity(buf, 4);

1207 parity_bits ^= ff_mlp_calculate_parity(buf + header_size, substr_header_size);

1208

1209 if ((((parity_bits >> 4) ^ parity_bits) & 0xF) != 0xF) {

1210 av_log(avctx, AV_LOG_ERROR, "Parity check failed.\n");

1211 goto error;

1212 }

1213

1214 buf += header_size + substr_header_size;

1215

1216 for (substr = 0; substr <= m->max_decoded_substream; substr++) {

1217 SubStream *s = &m->substream[substr];

1218 init_get_bits(&gb, buf, substream_data_len[substr] * 8);

1219

1220 m->matrix_changed = 0;

1221 memset(m->filter_changed, 0, sizeof(m->filter_changed));

1222

1223 s->blockpos = 0;

1224 do {

1225 if (get_bits1(&gb)) {

1226 if (get_bits1(&gb)) {

1227 /* A restart header should be present. */

1228 if (read_restart_header(m, &gb, buf, substr) < 0)

1229 goto next_substr;

1230 s->restart_seen = 1;

1231 }

1232

1233 if (!s->restart_seen)

1234 goto next_substr;

1235 if (read_decoding_params(m, &gb, substr) < 0)

1236 goto next_substr;

1237 }

1238

1239 if (!s->restart_seen)

1240 goto next_substr;

1241

1242 if ((ret = read_block_data(m, &gb, substr)) < 0)

1243 return ret;

1244

1245 if (get_bits_count(&gb) >= substream_data_len[substr] * 8)

1246 goto substream_length_mismatch;

1247

1248 } while (!get_bits1(&gb));

1249

1250 skip_bits(&gb, (-get_bits_count(&gb)) & 15);

1251

1252 if (substream_data_len[substr] * 8 - get_bits_count(&gb) >= 32) {

1253 int shorten_by;

1254

1255 if (get_bits(&gb, 16) != 0xD234)

1256 return AVERROR_INVALIDDATA;

1257

1258 shorten_by = get_bits(&gb, 16);

1259 if (m->avctx->codec_id == AV_CODEC_ID_TRUEHD && shorten_by & 0x2000)

1260 s->blockpos -= FFMIN(shorten_by & 0x1FFF, s->blockpos);

1261 else if (m->avctx->codec_id == AV_CODEC_ID_MLP && shorten_by != 0xD234)

1262 return AVERROR_INVALIDDATA;

1263

1264 if (substr == m->max_decoded_substream)

1265 av_log(m->avctx, AV_LOG_INFO, "End of stream indicated.\n");

1266 }

1267

1268 if (substream_parity_present[substr]) {

1269 uint8_t parity, checksum;

1270

1271 if (substream_data_len[substr] * 8 - get_bits_count(&gb) != 16)

1272 goto substream_length_mismatch;

1273

1274 parity = ff_mlp_calculate_parity(buf, substream_data_len[substr] - 2);

1275 checksum = ff_mlp_checksum8 (buf, substream_data_len[substr] - 2);

1276

1277 if ((get_bits(&gb, 8) ^ parity) != 0xa9 )

1278 av_log(m->avctx, AV_LOG_ERROR, "Substream %d parity check failed.\n", substr);

1279 if ( get_bits(&gb, 8) != checksum)

1280 av_log(m->avctx, AV_LOG_ERROR, "Substream %d checksum failed.\n" , substr);

1281 }

1282

1283 if (substream_data_len[substr] * 8 != get_bits_count(&gb))

1284 goto substream_length_mismatch;

1285

1286 next_substr:

1287 if (!s->restart_seen)

1288 av_log(m->avctx, AV_LOG_ERROR,

1289 "No restart header present in substream %d.\n", substr);

1290

1291 buf += substream_data_len[substr];

1292 }

1293

1294 if ((ret = output_data(m, m->max_decoded_substream, data, got_frame_ptr)) < 0)

1295 return ret;

1296

1297 return length;

1298

1299 substream_length_mismatch:

1300 av_log(m->avctx, AV_LOG_ERROR, "substream %d length mismatch\n", substr);

1301 return AVERROR_INVALIDDATA;

1302

1303 error:

1304 m->params_valid = 0;

1305 return AVERROR_INVALIDDATA;

1306 }

1307

1308 #if CONFIG_MLP_DECODER

1309 AVCodec ff_mlp_decoder = {

1310 .name = "mlp",

1311 .long_name = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),

1312 .type = AVMEDIA_TYPE_AUDIO,

1313 .id = AV_CODEC_ID_MLP,

1314 .priv_data_size = sizeof(MLPDecodeContext),

1315 .init = mlp_decode_init,

1316 .decode = read_access_unit,

1317 .capabilities = CODEC_CAP_DR1,

1318 };

1319 #endif

1320 #if CONFIG_TRUEHD_DECODER

1321 AVCodec ff_truehd_decoder = {

1322 .name = "truehd",

1323 .long_name = NULL_IF_CONFIG_SMALL("TrueHD"),

1324 .type = AVMEDIA_TYPE_AUDIO,

1325 .id = AV_CODEC_ID_TRUEHD,

1326 .priv_data_size = sizeof(MLPDecodeContext),

1327 .init = mlp_decode_init,

1328 .decode = read_access_unit,

1329 .capabilities = CODEC_CAP_DR1,

1330 };

1331 #endif /* CONFIG_TRUEHD_DECODER */

Generated on Sun Mar 8 2015 02:34:56 for FFmpeg by doxygen 1.8.2