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/channel_layout.h"

38 #include "libavutil/crc.h"

39 #include "avcodec.h"

40 #include "internal.h"

41 #include "get_bits.h"

42 #include "bytestream.h"

43 #include "golomb.h"

44 #include "flac.h"

45 #include "flacdata.h"

46 #include "flacdsp.h"

47 #include "thread.h"

49 typedef struct FLACContext {

50 FLACSTREAMINFO

52 AVCodecContext *avctx; ///< parent AVCodecContext

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

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

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

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

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

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

61 uint8_t *decoded_buffer;

62 unsigned int decoded_buffer_size;

64 FLACDSPContext dsp;

65 } FLACContext;

67 static int allocate_buffers(FLACContext *s);

69 static void flac_set_bps(FLACContext *s)

70 {

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

72 int need32 = s->bps > 16;

73 int want32 = av_get_bytes_per_sample(req) > 2;

74 int planar = av_sample_fmt_is_planar(req);

76 if (need32 || want32) {

77 if (planar)

78 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;

79 else

80 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;

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

82 } else {

83 if (planar)

84 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

85 else

86 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;

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

88 }

89 }

91 static av_cold int flac_decode_init(AVCodecContext *avctx)

92 {

93 enum FLACExtradataFormat format;

94 uint8_t *streaminfo;

95 int ret;

96 FLACContext *s = avctx->priv_data;

97 s->avctx = avctx;

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

100 frame data instead of extradata. */

101 if (!avctx->extradata)

102 return 0;

103

104 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))

105 return AVERROR_INVALIDDATA;

106

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

108 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);

109 ret = allocate_buffers(s);

110 if (ret < 0)

111 return ret;

112 flac_set_bps(s);

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

114 s->got_streaminfo = 1;

115

116 return 0;

117 }

118

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

120 {

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

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

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

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

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

126 }

127

128 static int allocate_buffers(FLACContext *s)

129 {

130 int buf_size;

131

132 av_assert0(s->max_blocksize);

133

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

135 AV_SAMPLE_FMT_S32P, 0);

136 if (buf_size < 0)

137 return buf_size;

138

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

140 if (!s->decoded_buffer)

141 return AVERROR(ENOMEM);

142

143 return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,

144 s->decoded_buffer, s->channels,

145 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);

146 }

147

148 /**

149 * Parse the STREAMINFO from an inline header.

150 * @param s the flac decoding context

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

152 * @param buf_size buffer size

153 * @return non-zero if metadata is invalid

154 */

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

156 {

157 int metadata_type, metadata_size, ret;

158

159 if (buf_size < FLAC_STREAMINFO_SIZE+8) {

160 /* need more data */

161 return 0;

162 }

163 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);

164 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||

165 metadata_size != FLAC_STREAMINFO_SIZE) {

166 return AVERROR_INVALIDDATA;

167 }

168 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);

169 ret = allocate_buffers(s);

170 if (ret < 0)

171 return ret;

172 flac_set_bps(s);

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

174 s->got_streaminfo = 1;

175

176 return 0;

177 }

178

179 /**

180 * Determine the size of an inline header.

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

182 * @param buf_size buffer size

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

184 */

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

186 {

187 int metadata_last, metadata_size;

188 const uint8_t *buf_end = buf + buf_size;

189

190 buf += 4;

191 do {

192 if (buf_end - buf < 4)

193 return 0;

194 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);

195 buf += 4;

196 if (buf_end - buf < metadata_size) {

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

198 return 0;

199 }

200 buf += metadata_size;

201 } while (!metadata_last);

202

203 return buf_size - (buf_end - buf);

204 }

205

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

207 {

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

209 int rice_bits, rice_esc;

210 int samples;

211

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

213 if (method_type > 1) {

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

215 method_type);

216 return AVERROR_INVALIDDATA;

217 }

218

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

220

221 samples= s->blocksize >> rice_order;

222 if (pred_order > samples) {

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

224 pred_order, samples);

225 return AVERROR_INVALIDDATA;

226 }

227

228 rice_bits = 4 + method_type;

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

230

231 decoded += pred_order;

232 i= pred_order;

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

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

235 if (tmp == rice_esc) {

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

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

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

239 } else {

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

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

242 }

243 }

244 i= 0;

245 }

246

247 return 0;

248 }

249

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

251 int pred_order, int bps)

252 {

253 const int blocksize = s->blocksize;

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

255 int ret;

256

257 /* warm up samples */

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

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

260 }

261

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

263 return ret;

264

265 if (pred_order > 0)

266 a = decoded[pred_order-1];

267 if (pred_order > 1)

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

269 if (pred_order > 2)

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

271 if (pred_order > 3)

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

273

274 switch (pred_order) {

275 case 0:

276 break;

277 case 1:

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

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

280 break;

281 case 2:

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

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

284 break;

285 case 3:

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

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

288 break;

289 case 4:

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

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

292 break;

293 default:

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

295 return AVERROR_INVALIDDATA;

296 }

297

298 return 0;

299 }

300

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

302 int bps)

303 {

304 int i, ret;

305 int coeff_prec, qlevel;

306 int coeffs[32];

307

308 /* warm up samples */

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

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

311 }

312

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

314 if (coeff_prec == 16) {

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

316 return AVERROR_INVALIDDATA;

317 }

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

319 if (qlevel < 0) {

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

321 qlevel);

322 return AVERROR_INVALIDDATA;

323 }

324

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

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

327 }

328

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

330 return ret;

331

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

333

334 return 0;

335 }

336

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

338 {

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

340 int type, wasted = 0;

341 int bps = s->bps;

342 int i, tmp, ret;

343

344 if (channel == 0) {

345 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)

346 bps++;

347 } else {

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

349 bps++;

350 }

351

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

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

354 return AVERROR_INVALIDDATA;

355 }

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

357

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

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

360 wasted = 1;

361 if ( left < 0 ||

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

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

364 av_log(s->avctx, AV_LOG_ERROR,

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

366 bps, left);

367 return AVERROR_INVALIDDATA;

368 }

369 while (!get_bits1(&s->gb))

370 wasted++;

371 bps -= wasted;

372 }

373 if (bps > 32) {

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

375 return AVERROR_PATCHWELCOME;

376 }

377

378 //FIXME use av_log2 for types

379 if (type == 0) {

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

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

382 decoded[i] = tmp;

383 } else if (type == 1) {

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

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

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

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

388 return ret;

389 } else if (type >= 32) {

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

391 return ret;

392 } else {

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

394 return AVERROR_INVALIDDATA;

395 }

396

397 if (wasted) {

398 int i;

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

400 decoded[i] <<= wasted;

401 }

402

403 return 0;

404 }

405

406 static int decode_frame(FLACContext *s)

407 {

408 int i, ret;

409 GetBitContext *gb = &s->gb;

410 FLACFrameInfo fi;

411

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

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

414 return ret;

415 }

416

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

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

419 ff_flac_set_channel_layout(s->avctx);

420 ret = allocate_buffers(s);

421 if (ret < 0)

422 return ret;

423 }

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

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

426 ff_flac_set_channel_layout(s->avctx);

427 s->ch_mode = fi.ch_mode;

428

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

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

431 return AVERROR_INVALIDDATA;

432 }

433 if (!fi.bps) {

434 fi.bps = s->bps;

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

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

437 "supported\n");

438 return AVERROR_INVALIDDATA;

439 }

440

441 if (!s->bps) {

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

443 flac_set_bps(s);

444 }

445

446 if (!s->max_blocksize)

447 s->max_blocksize = FLAC_MAX_BLOCKSIZE;

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

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

450 s->max_blocksize);

451 return AVERROR_INVALIDDATA;

452 }

453 s->blocksize = fi.blocksize;

454

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

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

457 " or frame header\n");

458 return AVERROR_INVALIDDATA;

459 }

460 if (fi.samplerate == 0)

461 fi.samplerate = s->samplerate;

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

463

464 if (!s->got_streaminfo) {

465 ret = allocate_buffers(s);

466 if (ret < 0)

467 return ret;

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

469 s->got_streaminfo = 1;

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

471 }

472

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

474

475 /* subframes */

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

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

478 return ret;

479 }

480

481 align_get_bits(gb);

482

483 /* frame footer */

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

485

486 return 0;

487 }

488

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

490 int *got_frame_ptr, AVPacket *avpkt)

491 {

492 AVFrame *frame = data;

493 ThreadFrame tframe = { .f = data };

494 const uint8_t *buf = avpkt->data;

495 int buf_size = avpkt->size;

496 FLACContext *s = avctx->priv_data;

497 int bytes_read = 0;

498 int ret;

499

500 *got_frame_ptr = 0;

501

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

503 s->max_framesize =

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

505 FLAC_MAX_CHANNELS, 32);

506 }

507

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

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

510 return buf_size;

511 }

512

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

514 av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");

515 return buf_size;

516 }

517

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

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

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

521 if (buf_size < FLAC_MIN_FRAME_SIZE)

522 return buf_size;

523

524 /* check for inline header */

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

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

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

528 return ret;

529 }

530 return get_metadata_size(buf, buf_size);

531 }

532

533 /* decode frame */

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

535 return ret;

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

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

538 return ret;

539 }

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

541

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

543 av_crc(av_crc_get_table(AV_CRC_16_ANSI),

544 0, buf, bytes_read)) {

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

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

547 return AVERROR_INVALIDDATA;

548 }

549

550 /* get output buffer */

551 frame->nb_samples = s->blocksize;

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

553 return ret;

554

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

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

557

558 if (bytes_read > buf_size) {

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

560 return AVERROR_INVALIDDATA;

561 }

562 if (bytes_read < buf_size) {

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

564 buf_size - bytes_read, buf_size);

565 }

566

567 *got_frame_ptr = 1;

568

569 return bytes_read;

570 }

571

572 static int init_thread_copy(AVCodecContext *avctx)

573 {

574 FLACContext *s = avctx->priv_data;

575 s->decoded_buffer = NULL;

576 s->decoded_buffer_size = 0;

577 s->avctx = avctx;

578 if (s->max_blocksize)

579 return allocate_buffers(s);

580 return 0;

581 }

582

583 static av_cold int flac_decode_close(AVCodecContext *avctx)

584 {

585 FLACContext *s = avctx->priv_data;

586

587 av_freep(&s->decoded_buffer);

588

589 return 0;

590 }

591

592 AVCodec ff_flac_decoder = {

593 .name = "flac",

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

595 .type = AVMEDIA_TYPE_AUDIO,

596 .id = AV_CODEC_ID_FLAC,

597 .priv_data_size = sizeof(FLACContext),

598 .init = flac_decode_init,

599 .close = flac_decode_close,

600 .decode = flac_decode_frame,

601 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),

602 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,

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

604 AV_SAMPLE_FMT_S16P,

605 AV_SAMPLE_FMT_S32,

606 AV_SAMPLE_FMT_S32P,

607 AV_SAMPLE_FMT_NONE },

608 };

Generated on Sat Jan 25 2014 19:51:47 for FFmpeg by doxygen 1.8.2