1/* 2 * FLAC (Free Lossless Audio Codec) decoder 3 * Copyright (c) 2003 Alex Beregszaszi 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 */ 21 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 */ 33 34#include <limits.h> 35 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" 48#include "unary.h" 49 50 51typedef struct FLACContext { 52 FLACSTREAMINFO 53 54 AVCodecContext *avctx; ///< parent AVCodecContext 55 GetBitContext gb; ///< GetBitContext initialized to start at the current frame 56 57 int blocksize; ///< number of samples in the current frame 58 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit 59 int ch_mode; ///< channel decorrelation type in the current frame 60 int got_streaminfo; ///< indicates if the STREAMINFO has been read 61 62 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples 63 uint8_t *decoded_buffer; 64 unsigned int decoded_buffer_size; 65 66 FLACDSPContext dsp; 67} FLACContext; 68 69static int allocate_buffers(FLACContext *s); 70 71static void flac_set_bps(FLACContext *s) 72{ 73 enum AVSampleFormat req = s->avctx->request_sample_fmt; 74 int need32 = s->bps > 16; 75 int want32 = av_get_bytes_per_sample(req) > 2; 76 int planar = av_sample_fmt_is_planar(req); 77 78 if (need32 || want32) { 79 if (planar) 80 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P; 81 else 82 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32; 83 s->sample_shift = 32 - s->bps; 84 } else { 85 if (planar) 86 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P; 87 else 88 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16; 89 s->sample_shift = 16 - s->bps; 90 } 91} 92 93static av_cold int flac_decode_init(AVCodecContext *avctx) 94{ 95 enum FLACExtradataFormat format; 96 uint8_t *streaminfo; 97 int ret; 98 FLACContext *s = avctx->priv_data; 99 s->avctx = avctx; 100 101 /* for now, the raw FLAC header is allowed to be passed to the decoder as 102 frame data instead of extradata. */ 103 if (!avctx->extradata) 104 return 0; 105 106 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo)) 107 return AVERROR_INVALIDDATA; 108 109 /* initialize based on the demuxer-supplied streamdata header */ 110 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo); 111 ret = allocate_buffers(s); 112 if (ret < 0) 113 return ret; 114 flac_set_bps(s); 115 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps); 116 s->got_streaminfo = 1; 117 118 return 0; 119} 120 121static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s) 122{ 123 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize); 124 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize); 125 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate); 126 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels); 127 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); 128} 129 130static int allocate_buffers(FLACContext *s) 131{ 132 int buf_size; 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 return 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} 149 150/** 151 * Parse the STREAMINFO from an inline header. 152 * @param s the flac decoding context 153 * @param buf input buffer, starting with the "fLaC" marker 154 * @param buf_size buffer size 155 * @return non-zero if metadata is invalid 156 */ 157static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size) 158{ 159 int metadata_type, metadata_size, ret; 160 161 if (buf_size < FLAC_STREAMINFO_SIZE+8) { 162 /* need more data */ 163 return 0; 164 } 165 flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size); 166 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO || 167 metadata_size != FLAC_STREAMINFO_SIZE) { 168 return AVERROR_INVALIDDATA; 169 } 170 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]); 171 ret = allocate_buffers(s); 172 if (ret < 0) 173 return ret; 174 flac_set_bps(s); 175 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps); 176 s->got_streaminfo = 1; 177 178 return 0; 179} 180 181/** 182 * Determine the size of an inline header. 183 * @param buf input buffer, starting with the "fLaC" marker 184 * @param buf_size buffer size 185 * @return number of bytes in the header, or 0 if more data is needed 186 */ 187static int get_metadata_size(const uint8_t *buf, int buf_size) 188{ 189 int metadata_last, metadata_size; 190 const uint8_t *buf_end = buf + buf_size; 191 192 buf += 4; 193 do { 194 if (buf_end - buf < 4) 195 return 0; 196 flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size); 197 buf += 4; 198 if (buf_end - buf < metadata_size) { 199 /* need more data in order to read the complete header */ 200 return 0; 201 } 202 buf += metadata_size; 203 } while (!metadata_last); 204 205 return buf_size - (buf_end - buf); 206} 207 208static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order) 209{ 210 int i, tmp, partition, method_type, rice_order; 211 int rice_bits, rice_esc; 212 int samples; 213 214 method_type = get_bits(&s->gb, 2); 215 if (method_type > 1) { 216 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", 217 method_type); 218 return AVERROR_INVALIDDATA; 219 } 220 221 rice_order = get_bits(&s->gb, 4); 222 223 samples= s->blocksize >> rice_order; 224 if (samples << rice_order != s->blocksize) { 225 av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n", 226 rice_order, s->blocksize); 227 return AVERROR_INVALIDDATA; 228 } 229 230 if (pred_order > samples) { 231 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", 232 pred_order, samples); 233 return AVERROR_INVALIDDATA; 234 } 235 236 rice_bits = 4 + method_type; 237 rice_esc = (1 << rice_bits) - 1; 238 239 decoded += pred_order; 240 i= pred_order; 241 for (partition = 0; partition < (1 << rice_order); partition++) { 242 tmp = get_bits(&s->gb, rice_bits); 243 if (tmp == rice_esc) { 244 tmp = get_bits(&s->gb, 5); 245 for (; i < samples; i++) 246 *decoded++ = get_sbits_long(&s->gb, tmp); 247 } else { 248 for (; i < samples; i++) { 249 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); 250 } 251 } 252 i= 0; 253 } 254 255 return 0; 256} 257 258static int decode_subframe_fixed(FLACContext *s, int32_t *decoded, 259 int pred_order, int bps) 260{ 261 const int blocksize = s->blocksize; 262 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i; 263 int ret; 264 265 /* warm up samples */ 266 for (i = 0; i < pred_order; i++) { 267 decoded[i] = get_sbits_long(&s->gb, bps); 268 } 269 270 if ((ret = decode_residuals(s, decoded, pred_order)) < 0) 271 return ret; 272 273 if (pred_order > 0) 274 a = decoded[pred_order-1]; 275 if (pred_order > 1) 276 b = a - decoded[pred_order-2]; 277 if (pred_order > 2) 278 c = b - decoded[pred_order-2] + decoded[pred_order-3]; 279 if (pred_order > 3) 280 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; 281 282 switch (pred_order) { 283 case 0: 284 break; 285 case 1: 286 for (i = pred_order; i < blocksize; i++) 287 decoded[i] = a += decoded[i]; 288 break; 289 case 2: 290 for (i = pred_order; i < blocksize; i++) 291 decoded[i] = a += b += decoded[i]; 292 break; 293 case 3: 294 for (i = pred_order; i < blocksize; i++) 295 decoded[i] = a += b += c += decoded[i]; 296 break; 297 case 4: 298 for (i = pred_order; i < blocksize; i++) 299 decoded[i] = a += b += c += d += decoded[i]; 300 break; 301 default: 302 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); 303 return AVERROR_INVALIDDATA; 304 } 305 306 return 0; 307} 308 309static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order, 310 int bps) 311{ 312 int i, ret; 313 int coeff_prec, qlevel; 314 int coeffs[32]; 315 316 /* warm up samples */ 317 for (i = 0; i < pred_order; i++) { 318 decoded[i] = get_sbits_long(&s->gb, bps); 319 } 320 321 coeff_prec = get_bits(&s->gb, 4) + 1; 322 if (coeff_prec == 16) { 323 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); 324 return AVERROR_INVALIDDATA; 325 } 326 qlevel = get_sbits(&s->gb, 5); 327 if (qlevel < 0) { 328 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", 329 qlevel); 330 return AVERROR_INVALIDDATA; 331 } 332 333 for (i = 0; i < pred_order; i++) { 334 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec); 335 } 336 337 if ((ret = decode_residuals(s, decoded, pred_order)) < 0) 338 return ret; 339 340 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize); 341 342 return 0; 343} 344 345static inline int decode_subframe(FLACContext *s, int channel) 346{ 347 int32_t *decoded = s->decoded[channel]; 348 int type, wasted = 0; 349 int bps = s->bps; 350 int i, tmp, ret; 351 352 if (channel == 0) { 353 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE) 354 bps++; 355 } else { 356 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE) 357 bps++; 358 } 359 360 if (get_bits1(&s->gb)) { 361 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); 362 return AVERROR_INVALIDDATA; 363 } 364 type = get_bits(&s->gb, 6); 365 366 if (get_bits1(&s->gb)) { 367 int left = get_bits_left(&s->gb); 368 if ( left < 0 || 369 (left < bps && !show_bits_long(&s->gb, left)) || 370 !show_bits_long(&s->gb, bps)) { 371 av_log(s->avctx, AV_LOG_ERROR, 372 "Invalid number of wasted bits > available bits (%d) - left=%d\n", 373 bps, left); 374 return AVERROR_INVALIDDATA; 375 } 376 wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb)); 377 bps -= wasted; 378 } 379 if (bps > 32) { 380 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32"); 381 return AVERROR_PATCHWELCOME; 382 } 383 384//FIXME use av_log2 for types 385 if (type == 0) { 386 tmp = get_sbits_long(&s->gb, bps); 387 for (i = 0; i < s->blocksize; i++) 388 decoded[i] = tmp; 389 } else if (type == 1) { 390 for (i = 0; i < s->blocksize; i++) 391 decoded[i] = get_sbits_long(&s->gb, bps); 392 } else if ((type >= 8) && (type <= 12)) { 393 if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0) 394 return ret; 395 } else if (type >= 32) { 396 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0) 397 return ret; 398 } else { 399 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); 400 return AVERROR_INVALIDDATA; 401 } 402 403 if (wasted) { 404 int i; 405 for (i = 0; i < s->blocksize; i++) 406 decoded[i] <<= wasted; 407 } 408 409 return 0; 410} 411 412static int decode_frame(FLACContext *s) 413{ 414 int i, ret; 415 GetBitContext *gb = &s->gb; 416 FLACFrameInfo fi; 417 418 if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) { 419 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n"); 420 return ret; 421 } 422 423 if (s->channels && fi.channels != s->channels && s->got_streaminfo) { 424 s->channels = s->avctx->channels = fi.channels; 425 ff_flac_set_channel_layout(s->avctx); 426 ret = allocate_buffers(s); 427 if (ret < 0) 428 return ret; 429 } 430 s->channels = s->avctx->channels = fi.channels; 431 if (!s->avctx->channel_layout) 432 ff_flac_set_channel_layout(s->avctx); 433 s->ch_mode = fi.ch_mode; 434 435 if (!s->bps && !fi.bps) { 436 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n"); 437 return AVERROR_INVALIDDATA; 438 } 439 if (!fi.bps) { 440 fi.bps = s->bps; 441 } else if (s->bps && fi.bps != s->bps) { 442 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not " 443 "supported\n"); 444 return AVERROR_INVALIDDATA; 445 } 446 447 if (!s->bps) { 448 s->bps = s->avctx->bits_per_raw_sample = fi.bps; 449 flac_set_bps(s); 450 } 451 452 if (!s->max_blocksize) 453 s->max_blocksize = FLAC_MAX_BLOCKSIZE; 454 if (fi.blocksize > s->max_blocksize) { 455 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize, 456 s->max_blocksize); 457 return AVERROR_INVALIDDATA; 458 } 459 s->blocksize = fi.blocksize; 460 461 if (!s->samplerate && !fi.samplerate) { 462 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO" 463 " or frame header\n"); 464 return AVERROR_INVALIDDATA; 465 } 466 if (fi.samplerate == 0) 467 fi.samplerate = s->samplerate; 468 s->samplerate = s->avctx->sample_rate = fi.samplerate; 469 470 if (!s->got_streaminfo) { 471 ret = allocate_buffers(s); 472 if (ret < 0) 473 return ret; 474 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps); 475 s->got_streaminfo = 1; 476 dump_headers(s->avctx, (FLACStreaminfo *)s); 477 } 478 479// dump_headers(s->avctx, (FLACStreaminfo *)s); 480 481 /* subframes */ 482 for (i = 0; i < s->channels; i++) { 483 if ((ret = decode_subframe(s, i)) < 0) 484 return ret; 485 } 486 487 align_get_bits(gb); 488 489 /* frame footer */ 490 skip_bits(gb, 16); /* data crc */ 491 492 return 0; 493} 494 495static int flac_decode_frame(AVCodecContext *avctx, void *data, 496 int *got_frame_ptr, AVPacket *avpkt) 497{ 498 AVFrame *frame = data; 499 ThreadFrame tframe = { .f = data }; 500 const uint8_t *buf = avpkt->data; 501 int buf_size = avpkt->size; 502 FLACContext *s = avctx->priv_data; 503 int bytes_read = 0; 504 int ret; 505 506 *got_frame_ptr = 0; 507 508 if (s->max_framesize == 0) { 509 s->max_framesize = 510 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE, 511 FLAC_MAX_CHANNELS, 32); 512 } 513 514 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) { 515 av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n"); 516 return buf_size; 517 } 518 519 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) { 520 av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n"); 521 return buf_size; 522 } 523 524 /* check that there is at least the smallest decodable amount of data. 525 this amount corresponds to the smallest valid FLAC frame possible. 526 FF F8 69 02 00 00 9A 00 00 34 46 */ 527 if (buf_size < FLAC_MIN_FRAME_SIZE) 528 return buf_size; 529 530 /* check for inline header */ 531 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) { 532 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) { 533 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n"); 534 return ret; 535 } 536 return get_metadata_size(buf, buf_size); 537 } 538 539 /* decode frame */ 540 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0) 541 return ret; 542 if ((ret = decode_frame(s)) < 0) { 543 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); 544 return ret; 545 } 546 bytes_read = get_bits_count(&s->gb)/8; 547 548 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) && 549 av_crc(av_crc_get_table(AV_CRC_16_ANSI), 550 0, buf, bytes_read)) { 551 av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts); 552 if (s->avctx->err_recognition & AV_EF_EXPLODE) 553 return AVERROR_INVALIDDATA; 554 } 555 556 /* get output buffer */ 557 frame->nb_samples = s->blocksize; 558 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0) 559 return ret; 560 561 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels, 562 s->blocksize, s->sample_shift); 563 564 if (bytes_read > buf_size) { 565 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size); 566 return AVERROR_INVALIDDATA; 567 } 568 if (bytes_read < buf_size) { 569 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n", 570 buf_size - bytes_read, buf_size); 571 } 572 573 *got_frame_ptr = 1; 574 575 return bytes_read; 576} 577 578static int init_thread_copy(AVCodecContext *avctx) 579{ 580 FLACContext *s = avctx->priv_data; 581 s->decoded_buffer = NULL; 582 s->decoded_buffer_size = 0; 583 s->avctx = avctx; 584 if (s->max_blocksize) 585 return allocate_buffers(s); 586 return 0; 587} 588 589static av_cold int flac_decode_close(AVCodecContext *avctx) 590{ 591 FLACContext *s = avctx->priv_data; 592 593 av_freep(&s->decoded_buffer); 594 595 return 0; 596} 597 598AVCodec ff_flac_decoder = { 599 .name = "flac", 600 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), 601 .type = AVMEDIA_TYPE_AUDIO, 602 .id = AV_CODEC_ID_FLAC, 603 .priv_data_size = sizeof(FLACContext), 604 .init = flac_decode_init, 605 .close = flac_decode_close, 606 .decode = flac_decode_frame, 607 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy), 608 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS, 609 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16, 610 AV_SAMPLE_FMT_S16P, 611 AV_SAMPLE_FMT_S32, 612 AV_SAMPLE_FMT_S32P, 613 AV_SAMPLE_FMT_NONE }, 614}; 615