FFmpeg: libavcodec/flacdec.c Source File

FFmpeg

[フレーム]

libavcodec

flacdec.c

Go to the documentation of this file.

1 /*

2 * FLAC (Free Lossless Audio Codec) 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 * FLAC (Free Lossless Audio Codec) decoder

25 * @author Alex Beregszaszi

26 * @see http://flac.sourceforge.net/

27 *

28 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed

29 * through, starting from the initial 'fLaC' signature; or by passing the

30 * 34-byte streaminfo structure through avctx->extradata[_size] followed

31 * by data starting with the 0xFFF8 marker.

32 */

34 #include <limits.h>

36 #include "libavutil/avassert.h"

37 #include "libavutil/crc.h"

38 #include "avcodec.h"

39 #include "internal.h"

40 #include "get_bits.h"

41 #include "bytestream.h"

42 #include "golomb.h"

43 #include "flac.h"

44 #include "flacdata.h"

45 #include "flacdsp.h"

46 #include "thread.h"

47 #include "unary.h"

50 typedef struct FLACContext {

51 FLACSTREAMINFO

53 AVCodecContext *avctx; ///< parent AVCodecContext

54 GetBitContext gb; ///< GetBitContext initialized to start at the current frame

56 int blocksize; ///< number of samples in the current frame

57 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit

58 int ch_mode; ///< channel decorrelation type in the current frame

59 int got_streaminfo; ///< indicates if the STREAMINFO has been read

61 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples

62 uint8_t *decoded_buffer;

63 unsigned int decoded_buffer_size;

65 FLACDSPContext dsp;

66 } FLACContext;

68 static int allocate_buffers(FLACContext *s);

70 static void flac_set_bps(FLACContext *s)

71 {

72 enum AVSampleFormat req = s->avctx->request_sample_fmt;

73 int need32 = s->bps > 16;

74 int want32 = av_get_bytes_per_sample(req) > 2;

75 int planar = av_sample_fmt_is_planar(req);

77 if (need32 || want32) {

78 if (planar)

79 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;

80 else

81 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;

82 s->sample_shift = 32 - s->bps;

83 } else {

84 if (planar)

85 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

86 else

87 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;

88 s->sample_shift = 16 - s->bps;

89 }

90 }

92 static av_cold int flac_decode_init(AVCodecContext *avctx)

93 {

94 enum FLACExtradataFormat format;

95 uint8_t *streaminfo;

96 int ret;

97 FLACContext *s = avctx->priv_data;

98 s->avctx = avctx;

100 /* for now, the raw FLAC header is allowed to be passed to the decoder as

101 frame data instead of extradata. */

102 if (!avctx->extradata)

103 return 0;

104

105 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))

106 return AVERROR_INVALIDDATA;

107

108 /* initialize based on the demuxer-supplied streamdata header */

109 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);

110 ret = allocate_buffers(s);

111 if (ret < 0)

112 return ret;

113 flac_set_bps(s);

114 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->channels, s->bps);

115 s->got_streaminfo = 1;

116

117 return 0;

118 }

119

120 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)

121 {

122 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);

123 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);

124 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);

125 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);

126 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);

127 }

128

129 static int allocate_buffers(FLACContext *s)

130 {

131 int buf_size;

132 int ret;

133

134 av_assert0(s->max_blocksize);

135

136 buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,

137 AV_SAMPLE_FMT_S32P, 0);

138 if (buf_size < 0)

139 return buf_size;

140

141 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);

142 if (!s->decoded_buffer)

143 return AVERROR(ENOMEM);

144

145 ret = av_samples_fill_arrays((uint8_t **)s->decoded, NULL,

146 s->decoded_buffer, s->channels,

147 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);

148 return ret < 0 ? ret : 0;

149 }

150

151 /**

152 * Parse the STREAMINFO from an inline header.

153 * @param s the flac decoding context

154 * @param buf input buffer, starting with the "fLaC" marker

155 * @param buf_size buffer size

156 * @return non-zero if metadata is invalid

157 */

158 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)

159 {

160 int metadata_type, metadata_size, ret;

161

162 if (buf_size < FLAC_STREAMINFO_SIZE+8) {

163 /* need more data */

164 return 0;

165 }

166 flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);

167 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||

168 metadata_size != FLAC_STREAMINFO_SIZE) {

169 return AVERROR_INVALIDDATA;

170 }

171 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);

172 ret = allocate_buffers(s);

173 if (ret < 0)

174 return ret;

175 flac_set_bps(s);

176 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->channels, s->bps);

177 s->got_streaminfo = 1;

178

179 return 0;

180 }

181

182 /**

183 * Determine the size of an inline header.

184 * @param buf input buffer, starting with the "fLaC" marker

185 * @param buf_size buffer size

186 * @return number of bytes in the header, or 0 if more data is needed

187 */

188 static int get_metadata_size(const uint8_t *buf, int buf_size)

189 {

190 int metadata_last, metadata_size;

191 const uint8_t *buf_end = buf + buf_size;

192

193 buf += 4;

194 do {

195 if (buf_end - buf < 4)

196 return 0;

197 flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);

198 buf += 4;

199 if (buf_end - buf < metadata_size) {

200 /* need more data in order to read the complete header */

201 return 0;

202 }

203 buf += metadata_size;

204 } while (!metadata_last);

205

206 return buf_size - (buf_end - buf);

207 }

208

209 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)

210 {

211 int i, tmp, partition, method_type, rice_order;

212 int rice_bits, rice_esc;

213 int samples;

214

215 method_type = get_bits(&s->gb, 2);

216 if (method_type > 1) {

217 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",

218 method_type);

219 return AVERROR_INVALIDDATA;

220 }

221

222 rice_order = get_bits(&s->gb, 4);

223

224 samples= s->blocksize >> rice_order;

225 if (samples << rice_order != s->blocksize) {

226 av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",

227 rice_order, s->blocksize);

228 return AVERROR_INVALIDDATA;

229 }

230

231 if (pred_order > samples) {

232 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",

233 pred_order, samples);

234 return AVERROR_INVALIDDATA;

235 }

236

237 rice_bits = 4 + method_type;

238 rice_esc = (1 << rice_bits) - 1;

239

240 decoded += pred_order;

241 i= pred_order;

242 for (partition = 0; partition < (1 << rice_order); partition++) {

243 tmp = get_bits(&s->gb, rice_bits);

244 if (tmp == rice_esc) {

245 tmp = get_bits(&s->gb, 5);

246 for (; i < samples; i++)

247 *decoded++ = get_sbits_long(&s->gb, tmp);

248 } else {

249 for (; i < samples; i++) {

250 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);

251 }

252 }

253 i= 0;

254 }

255

256 return 0;

257 }

258

259 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,

260 int pred_order, int bps)

261 {

262 const int blocksize = s->blocksize;

263 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;

264 int ret;

265

266 /* warm up samples */

267 for (i = 0; i < pred_order; i++) {

268 decoded[i] = get_sbits_long(&s->gb, bps);

269 }

270

271 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)

272 return ret;

273

274 if (pred_order > 0)

275 a = decoded[pred_order-1];

276 if (pred_order > 1)

277 b = a - decoded[pred_order-2];

278 if (pred_order > 2)

279 c = b - decoded[pred_order-2] + decoded[pred_order-3];

280 if (pred_order > 3)

281 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];

282

283 switch (pred_order) {

284 case 0:

285 break;

286 case 1:

287 for (i = pred_order; i < blocksize; i++)

288 decoded[i] = a += decoded[i];

289 break;

290 case 2:

291 for (i = pred_order; i < blocksize; i++)

292 decoded[i] = a += b += decoded[i];

293 break;

294 case 3:

295 for (i = pred_order; i < blocksize; i++)

296 decoded[i] = a += b += c += decoded[i];

297 break;

298 case 4:

299 for (i = pred_order; i < blocksize; i++)

300 decoded[i] = a += b += c += d += decoded[i];

301 break;

302 default:

303 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);

304 return AVERROR_INVALIDDATA;

305 }

306

307 return 0;

308 }

309

310 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,

311 int bps)

312 {

313 int i, ret;

314 int coeff_prec, qlevel;

315 int coeffs[32];

316

317 /* warm up samples */

318 for (i = 0; i < pred_order; i++) {

319 decoded[i] = get_sbits_long(&s->gb, bps);

320 }

321

322 coeff_prec = get_bits(&s->gb, 4) + 1;

323 if (coeff_prec == 16) {

324 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");

325 return AVERROR_INVALIDDATA;

326 }

327 qlevel = get_sbits(&s->gb, 5);

328 if (qlevel < 0) {

329 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",

330 qlevel);

331 return AVERROR_INVALIDDATA;

332 }

333

334 for (i = 0; i < pred_order; i++) {

335 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);

336 }

337

338 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)

339 return ret;

340

341 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);

342

343 return 0;

344 }

345

346 static inline int decode_subframe(FLACContext *s, int channel)

347 {

348 int32_t *decoded = s->decoded[channel];

349 int type, wasted = 0;

350 int bps = s->bps;

351 int i, tmp, ret;

352

353 if (channel == 0) {

354 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)

355 bps++;

356 } else {

357 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)

358 bps++;

359 }

360

361 if (get_bits1(&s->gb)) {

362 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");

363 return AVERROR_INVALIDDATA;

364 }

365 type = get_bits(&s->gb, 6);

366

367 if (get_bits1(&s->gb)) {

368 int left = get_bits_left(&s->gb);

369 if ( left <= 0 ||

370 (left < bps && !show_bits_long(&s->gb, left)) ||

371 !show_bits_long(&s->gb, bps)) {

372 av_log(s->avctx, AV_LOG_ERROR,

373 "Invalid number of wasted bits > available bits (%d) - left=%d\n",

374 bps, left);

375 return AVERROR_INVALIDDATA;

376 }

377 wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));

378 bps -= wasted;

379 }

380 if (bps > 32) {

381 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");

382 return AVERROR_PATCHWELCOME;

383 }

384

385 //FIXME use av_log2 for types

386 if (type == 0) {

387 tmp = get_sbits_long(&s->gb, bps);

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

389 decoded[i] = tmp;

390 } else if (type == 1) {

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

392 decoded[i] = get_sbits_long(&s->gb, bps);

393 } else if ((type >= 8) && (type <= 12)) {

394 if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)

395 return ret;

396 } else if (type >= 32) {

397 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)

398 return ret;

399 } else {

400 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");

401 return AVERROR_INVALIDDATA;

402 }

403

404 if (wasted) {

405 int i;

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

407 decoded[i] <<= wasted;

408 }

409

410 return 0;

411 }

412

413 static int decode_frame(FLACContext *s)

414 {

415 int i, ret;

416 GetBitContext *gb = &s->gb;

417 FLACFrameInfo fi;

418

419 if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {

420 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");

421 return ret;

422 }

423

424 if (s->channels && fi.channels != s->channels && s->got_streaminfo) {

425 s->channels = s->avctx->channels = fi.channels;

426 ff_flac_set_channel_layout(s->avctx);

427 ret = allocate_buffers(s);

428 if (ret < 0)

429 return ret;

430 }

431 s->channels = s->avctx->channels = fi.channels;

432 if (!s->avctx->channel_layout)

433 ff_flac_set_channel_layout(s->avctx);

434 s->ch_mode = fi.ch_mode;

435

436 if (!s->bps && !fi.bps) {

437 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");

438 return AVERROR_INVALIDDATA;

439 }

440 if (!fi.bps) {

441 fi.bps = s->bps;

442 } else if (s->bps && fi.bps != s->bps) {

443 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "

444 "supported\n");

445 return AVERROR_INVALIDDATA;

446 }

447

448 if (!s->bps) {

449 s->bps = s->avctx->bits_per_raw_sample = fi.bps;

450 flac_set_bps(s);

451 }

452

453 if (!s->max_blocksize)

454 s->max_blocksize = FLAC_MAX_BLOCKSIZE;

455 if (fi.blocksize > s->max_blocksize) {

456 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,

457 s->max_blocksize);

458 return AVERROR_INVALIDDATA;

459 }

460 s->blocksize = fi.blocksize;

461

462 if (!s->samplerate && !fi.samplerate) {

463 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"

464 " or frame header\n");

465 return AVERROR_INVALIDDATA;

466 }

467 if (fi.samplerate == 0)

468 fi.samplerate = s->samplerate;

469 s->samplerate = s->avctx->sample_rate = fi.samplerate;

470

471 if (!s->got_streaminfo) {

472 ret = allocate_buffers(s);

473 if (ret < 0)

474 return ret;

475 s->got_streaminfo = 1;

476 dump_headers(s->avctx, (FLACStreaminfo *)s);

477 }

478 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->channels, s->bps);

479

480 // dump_headers(s->avctx, (FLACStreaminfo *)s);

481

482 /* subframes */

483 for (i = 0; i < s->channels; i++) {

484 if ((ret = decode_subframe(s, i)) < 0)

485 return ret;

486 }

487

488 align_get_bits(gb);

489

490 /* frame footer */

491 skip_bits(gb, 16); /* data crc */

492

493 return 0;

494 }

495

496 static int flac_decode_frame(AVCodecContext *avctx, void *data,

497 int *got_frame_ptr, AVPacket *avpkt)

498 {

499 AVFrame *frame = data;

500 ThreadFrame tframe = { .f = data };

501 const uint8_t *buf = avpkt->data;

502 int buf_size = avpkt->size;

503 FLACContext *s = avctx->priv_data;

504 int bytes_read = 0;

505 int ret;

506

507 *got_frame_ptr = 0;

508

509 if (s->max_framesize == 0) {

510 s->max_framesize =

511 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,

512 FLAC_MAX_CHANNELS, 32);

513 }

514

515 if (buf_size > 5 && !memcmp(buf, "177円FLAC", 5)) {

516 av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");

517 return buf_size;

518 }

519

520 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {

521 av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");

522 return buf_size;

523 }

524

525 /* check that there is at least the smallest decodable amount of data.

526 this amount corresponds to the smallest valid FLAC frame possible.

527 FF F8 69 02 00 00 9A 00 00 34 46 */

528 if (buf_size < FLAC_MIN_FRAME_SIZE)

529 return buf_size;

530

531 /* check for inline header */

532 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {

533 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {

534 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");

535 return ret;

536 }

537 return get_metadata_size(buf, buf_size);

538 }

539

540 /* decode frame */

541 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)

542 return ret;

543 if ((ret = decode_frame(s)) < 0) {

544 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");

545 return ret;

546 }

547 bytes_read = get_bits_count(&s->gb)/8;

548

549 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&

550 av_crc(av_crc_get_table(AV_CRC_16_ANSI),

551 0, buf, bytes_read)) {

552 av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);

553 if (s->avctx->err_recognition & AV_EF_EXPLODE)

554 return AVERROR_INVALIDDATA;

555 }

556

557 /* get output buffer */

558 frame->nb_samples = s->blocksize;

559 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)

560 return ret;

561

562 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,

563 s->blocksize, s->sample_shift);

564

565 if (bytes_read > buf_size) {

566 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);

567 return AVERROR_INVALIDDATA;

568 }

569 if (bytes_read < buf_size) {

570 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",

571 buf_size - bytes_read, buf_size);

572 }

573

574 *got_frame_ptr = 1;

575

576 return bytes_read;

577 }

578

579 static int init_thread_copy(AVCodecContext *avctx)

580 {

581 FLACContext *s = avctx->priv_data;

582 s->decoded_buffer = NULL;

583 s->decoded_buffer_size = 0;

584 s->avctx = avctx;

585 if (s->max_blocksize)

586 return allocate_buffers(s);

587 return 0;

588 }

589

590 static av_cold int flac_decode_close(AVCodecContext *avctx)

591 {

592 FLACContext *s = avctx->priv_data;

593

594 av_freep(&s->decoded_buffer);

595

596 return 0;

597 }

598

599 AVCodec ff_flac_decoder = {

600 .name = "flac",

601 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),

602 .type = AVMEDIA_TYPE_AUDIO,

603 .id = AV_CODEC_ID_FLAC,

604 .priv_data_size = sizeof(FLACContext),

605 .init = flac_decode_init,

606 .close = flac_decode_close,

607 .decode = flac_decode_frame,

608 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),

609 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,

610 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,

611 AV_SAMPLE_FMT_S16P,

612 AV_SAMPLE_FMT_S32,

613 AV_SAMPLE_FMT_S32P,

614 AV_SAMPLE_FMT_NONE },

615 };

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