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 * 27 * For more information on the FLAC format, visit: 28 * http://flac.sourceforge.net/ 29 * 30 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed 31 * through, starting from the initial 'fLaC' signature; or by passing the 32 * 34-byte streaminfo structure through avctx->extradata[_size] followed 33 * by data starting with the 0xFFF8 marker. 34 */ 35 36#include <limits.h> 37 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 47#undef NDEBUG 48#include <assert.h> 49 50typedef struct FLACContext { 51 FLACSTREAMINFO 52 53 AVCodecContext *avctx; ///< parent AVCodecContext 54 GetBitContext gb; ///< GetBitContext initialized to start at the current frame 55 56 int blocksize; ///< number of samples in the current frame 57 int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits 58 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit 59 int is32; ///< flag to indicate if output should be 32-bit instead of 16-bit 60 int ch_mode; ///< channel decorrelation type in the current frame 61 int got_streaminfo; ///< indicates if the STREAMINFO has been read 62 63 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples 64 uint8_t *bitstream; 65 unsigned int bitstream_size; 66 unsigned int bitstream_index; 67 unsigned int allocated_bitstream_size; 68} FLACContext; 69 70static const int sample_size_table[] = 71{ 0, 8, 12, 0, 16, 20, 24, 0 }; 72 73static int64_t get_utf8(GetBitContext *gb) 74{ 75 int64_t val; 76 GET_UTF8(val, get_bits(gb, 8), return -1;) 77 return val; 78} 79 80static void allocate_buffers(FLACContext *s); 81 82int ff_flac_is_extradata_valid(AVCodecContext *avctx, 83 enum FLACExtradataFormat *format, 84 uint8_t **streaminfo_start) 85{ 86 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) { 87 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n"); 88 return 0; 89 } 90 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) { 91 /* extradata contains STREAMINFO only */ 92 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) { 93 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n", 94 FLAC_STREAMINFO_SIZE-avctx->extradata_size); 95 } 96 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO; 97 *streaminfo_start = avctx->extradata; 98 } else { 99 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) { 100 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n"); 101 return 0; 102 } 103 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER; 104 *streaminfo_start = &avctx->extradata[8]; 105 } 106 return 1; 107} 108 109static av_cold int flac_decode_init(AVCodecContext *avctx) 110{ 111 enum FLACExtradataFormat format; 112 uint8_t *streaminfo; 113 FLACContext *s = avctx->priv_data; 114 s->avctx = avctx; 115 116 avctx->sample_fmt = SAMPLE_FMT_S16; 117 118 /* for now, the raw FLAC header is allowed to be passed to the decoder as 119 frame data instead of extradata. */ 120 if (!avctx->extradata) 121 return 0; 122 123 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo)) 124 return -1; 125 126 /* initialize based on the demuxer-supplied streamdata header */ 127 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo); 128 if (s->bps > 16) 129 avctx->sample_fmt = SAMPLE_FMT_S32; 130 else 131 avctx->sample_fmt = SAMPLE_FMT_S16; 132 allocate_buffers(s); 133 s->got_streaminfo = 1; 134 135 return 0; 136} 137 138static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s) 139{ 140 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize); 141 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize); 142 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate); 143 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels); 144 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); 145} 146 147static void allocate_buffers(FLACContext *s) 148{ 149 int i; 150 151 assert(s->max_blocksize); 152 153 if (s->max_framesize == 0 && s->max_blocksize) { 154 s->max_framesize = ff_flac_get_max_frame_size(s->max_blocksize, 155 s->channels, s->bps); 156 } 157 158 for (i = 0; i < s->channels; i++) { 159 s->decoded[i] = av_realloc(s->decoded[i], 160 sizeof(int32_t)*s->max_blocksize); 161 } 162 163 if (s->allocated_bitstream_size < s->max_framesize) 164 s->bitstream= av_fast_realloc(s->bitstream, 165 &s->allocated_bitstream_size, 166 s->max_framesize); 167} 168 169void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, 170 const uint8_t *buffer) 171{ 172 GetBitContext gb; 173 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8); 174 175 skip_bits(&gb, 16); /* skip min blocksize */ 176 s->max_blocksize = get_bits(&gb, 16); 177 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) { 178 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n", 179 s->max_blocksize); 180 s->max_blocksize = 16; 181 } 182 183 skip_bits(&gb, 24); /* skip min frame size */ 184 s->max_framesize = get_bits_long(&gb, 24); 185 186 s->samplerate = get_bits_long(&gb, 20); 187 s->channels = get_bits(&gb, 3) + 1; 188 s->bps = get_bits(&gb, 5) + 1; 189 190 avctx->channels = s->channels; 191 avctx->sample_rate = s->samplerate; 192 avctx->bits_per_raw_sample = s->bps; 193 194 s->samples = get_bits_long(&gb, 32) << 4; 195 s->samples |= get_bits(&gb, 4); 196 197 skip_bits_long(&gb, 64); /* md5 sum */ 198 skip_bits_long(&gb, 64); /* md5 sum */ 199 200 dump_headers(avctx, s); 201} 202 203void ff_flac_parse_block_header(const uint8_t *block_header, 204 int *last, int *type, int *size) 205{ 206 int tmp = bytestream_get_byte(&block_header); 207 if (last) 208 *last = tmp & 0x80; 209 if (type) 210 *type = tmp & 0x7F; 211 if (size) 212 *size = bytestream_get_be24(&block_header); 213} 214 215/** 216 * Parse the STREAMINFO from an inline header. 217 * @param s the flac decoding context 218 * @param buf input buffer, starting with the "fLaC" marker 219 * @param buf_size buffer size 220 * @return non-zero if metadata is invalid 221 */ 222static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size) 223{ 224 int metadata_type, metadata_size; 225 226 if (buf_size < FLAC_STREAMINFO_SIZE+8) { 227 /* need more data */ 228 return 0; 229 } 230 ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size); 231 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO || 232 metadata_size != FLAC_STREAMINFO_SIZE) { 233 return AVERROR_INVALIDDATA; 234 } 235 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]); 236 allocate_buffers(s); 237 s->got_streaminfo = 1; 238 239 return 0; 240} 241 242/** 243 * Determine the size of an inline header. 244 * @param buf input buffer, starting with the "fLaC" marker 245 * @param buf_size buffer size 246 * @return number of bytes in the header, or 0 if more data is needed 247 */ 248static int get_metadata_size(const uint8_t *buf, int buf_size) 249{ 250 int metadata_last, metadata_size; 251 const uint8_t *buf_end = buf + buf_size; 252 253 buf += 4; 254 do { 255 ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size); 256 buf += 4; 257 if (buf + metadata_size > buf_end) { 258 /* need more data in order to read the complete header */ 259 return 0; 260 } 261 buf += metadata_size; 262 } while (!metadata_last); 263 264 return buf_size - (buf_end - buf); 265} 266 267static int decode_residuals(FLACContext *s, int channel, int pred_order) 268{ 269 int i, tmp, partition, method_type, rice_order; 270 int sample = 0, samples; 271 272 method_type = get_bits(&s->gb, 2); 273 if (method_type > 1) { 274 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", 275 method_type); 276 return -1; 277 } 278 279 rice_order = get_bits(&s->gb, 4); 280 281 samples= s->blocksize >> rice_order; 282 if (pred_order > samples) { 283 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", 284 pred_order, samples); 285 return -1; 286 } 287 288 sample= 289 i= pred_order; 290 for (partition = 0; partition < (1 << rice_order); partition++) { 291 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5); 292 if (tmp == (method_type == 0 ? 15 : 31)) { 293 tmp = get_bits(&s->gb, 5); 294 for (; i < samples; i++, sample++) 295 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp); 296 } else { 297 for (; i < samples; i++, sample++) { 298 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); 299 } 300 } 301 i= 0; 302 } 303 304 return 0; 305} 306 307static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 308{ 309 const int blocksize = s->blocksize; 310 int32_t *decoded = s->decoded[channel]; 311 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i; 312 313 /* warm up samples */ 314 for (i = 0; i < pred_order; i++) { 315 decoded[i] = get_sbits_long(&s->gb, s->curr_bps); 316 } 317 318 if (decode_residuals(s, channel, pred_order) < 0) 319 return -1; 320 321 if (pred_order > 0) 322 a = decoded[pred_order-1]; 323 if (pred_order > 1) 324 b = a - decoded[pred_order-2]; 325 if (pred_order > 2) 326 c = b - decoded[pred_order-2] + decoded[pred_order-3]; 327 if (pred_order > 3) 328 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; 329 330 switch (pred_order) { 331 case 0: 332 break; 333 case 1: 334 for (i = pred_order; i < blocksize; i++) 335 decoded[i] = a += decoded[i]; 336 break; 337 case 2: 338 for (i = pred_order; i < blocksize; i++) 339 decoded[i] = a += b += decoded[i]; 340 break; 341 case 3: 342 for (i = pred_order; i < blocksize; i++) 343 decoded[i] = a += b += c += decoded[i]; 344 break; 345 case 4: 346 for (i = pred_order; i < blocksize; i++) 347 decoded[i] = a += b += c += d += decoded[i]; 348 break; 349 default: 350 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); 351 return -1; 352 } 353 354 return 0; 355} 356 357static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) 358{ 359 int i, j; 360 int coeff_prec, qlevel; 361 int coeffs[32]; 362 int32_t *decoded = s->decoded[channel]; 363 364 /* warm up samples */ 365 for (i = 0; i < pred_order; i++) { 366 decoded[i] = get_sbits_long(&s->gb, s->curr_bps); 367 } 368 369 coeff_prec = get_bits(&s->gb, 4) + 1; 370 if (coeff_prec == 16) { 371 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); 372 return -1; 373 } 374 qlevel = get_sbits(&s->gb, 5); 375 if (qlevel < 0) { 376 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", 377 qlevel); 378 return -1; 379 } 380 381 for (i = 0; i < pred_order; i++) { 382 coeffs[i] = get_sbits(&s->gb, coeff_prec); 383 } 384 385 if (decode_residuals(s, channel, pred_order) < 0) 386 return -1; 387 388 if (s->bps > 16) { 389 int64_t sum; 390 for (i = pred_order; i < s->blocksize; i++) { 391 sum = 0; 392 for (j = 0; j < pred_order; j++) 393 sum += (int64_t)coeffs[j] * decoded[i-j-1]; 394 decoded[i] += sum >> qlevel; 395 } 396 } else { 397 for (i = pred_order; i < s->blocksize-1; i += 2) { 398 int c; 399 int d = decoded[i-pred_order]; 400 int s0 = 0, s1 = 0; 401 for (j = pred_order-1; j > 0; j--) { 402 c = coeffs[j]; 403 s0 += c*d; 404 d = decoded[i-j]; 405 s1 += c*d; 406 } 407 c = coeffs[0]; 408 s0 += c*d; 409 d = decoded[i] += s0 >> qlevel; 410 s1 += c*d; 411 decoded[i+1] += s1 >> qlevel; 412 } 413 if (i < s->blocksize) { 414 int sum = 0; 415 for (j = 0; j < pred_order; j++) 416 sum += coeffs[j] * decoded[i-j-1]; 417 decoded[i] += sum >> qlevel; 418 } 419 } 420 421 return 0; 422} 423 424static inline int decode_subframe(FLACContext *s, int channel) 425{ 426 int type, wasted = 0; 427 int i, tmp; 428 429 s->curr_bps = s->bps; 430 if (channel == 0) { 431 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE) 432 s->curr_bps++; 433 } else { 434 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE) 435 s->curr_bps++; 436 } 437 438 if (get_bits1(&s->gb)) { 439 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); 440 return -1; 441 } 442 type = get_bits(&s->gb, 6); 443 444 if (get_bits1(&s->gb)) { 445 wasted = 1; 446 while (!get_bits1(&s->gb)) 447 wasted++; 448 s->curr_bps -= wasted; 449 } 450 if (s->curr_bps > 32) { 451 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0); 452 return -1; 453 } 454 455//FIXME use av_log2 for types 456 if (type == 0) { 457 tmp = get_sbits_long(&s->gb, s->curr_bps); 458 for (i = 0; i < s->blocksize; i++) 459 s->decoded[channel][i] = tmp; 460 } else if (type == 1) { 461 for (i = 0; i < s->blocksize; i++) 462 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps); 463 } else if ((type >= 8) && (type <= 12)) { 464 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) 465 return -1; 466 } else if (type >= 32) { 467 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) 468 return -1; 469 } else { 470 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); 471 return -1; 472 } 473 474 if (wasted) { 475 int i; 476 for (i = 0; i < s->blocksize; i++) 477 s->decoded[channel][i] <<= wasted; 478 } 479 480 return 0; 481} 482 483/** 484 * Validate and decode a frame header. 485 * @param avctx AVCodecContext to use as av_log() context 486 * @param gb GetBitContext from which to read frame header 487 * @param[out] fi frame information 488 * @return non-zero on error, 0 if ok 489 */ 490static int decode_frame_header(AVCodecContext *avctx, GetBitContext *gb, 491 FLACFrameInfo *fi) 492{ 493 int bs_code, sr_code, bps_code; 494 495 /* frame sync code */ 496 skip_bits(gb, 16); 497 498 /* block size and sample rate codes */ 499 bs_code = get_bits(gb, 4); 500 sr_code = get_bits(gb, 4); 501 502 /* channels and decorrelation */ 503 fi->ch_mode = get_bits(gb, 4); 504 if (fi->ch_mode < FLAC_MAX_CHANNELS) { 505 fi->channels = fi->ch_mode + 1; 506 fi->ch_mode = FLAC_CHMODE_INDEPENDENT; 507 } else if (fi->ch_mode <= FLAC_CHMODE_MID_SIDE) { 508 fi->channels = 2; 509 } else { 510 av_log(avctx, AV_LOG_ERROR, "invalid channel mode: %d\n", fi->ch_mode); 511 return -1; 512 } 513 514 /* bits per sample */ 515 bps_code = get_bits(gb, 3); 516 if (bps_code == 3 || bps_code == 7) { 517 av_log(avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", 518 bps_code); 519 return -1; 520 } 521 fi->bps = sample_size_table[bps_code]; 522 523 /* reserved bit */ 524 if (get_bits1(gb)) { 525 av_log(avctx, AV_LOG_ERROR, "broken stream, invalid padding\n"); 526 return -1; 527 } 528 529 /* sample or frame count */ 530 if (get_utf8(gb) < 0) { 531 av_log(avctx, AV_LOG_ERROR, "utf8 fscked\n"); 532 return -1; 533 } 534 535 /* blocksize */ 536 if (bs_code == 0) { 537 av_log(avctx, AV_LOG_ERROR, "reserved blocksize code: 0\n"); 538 return -1; 539 } else if (bs_code == 6) { 540 fi->blocksize = get_bits(gb, 8) + 1; 541 } else if (bs_code == 7) { 542 fi->blocksize = get_bits(gb, 16) + 1; 543 } else { 544 fi->blocksize = ff_flac_blocksize_table[bs_code]; 545 } 546 547 /* sample rate */ 548 if (sr_code < 12) { 549 fi->samplerate = ff_flac_sample_rate_table[sr_code]; 550 } else if (sr_code == 12) { 551 fi->samplerate = get_bits(gb, 8) * 1000; 552 } else if (sr_code == 13) { 553 fi->samplerate = get_bits(gb, 16); 554 } else if (sr_code == 14) { 555 fi->samplerate = get_bits(gb, 16) * 10; 556 } else { 557 av_log(avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", 558 sr_code); 559 return -1; 560 } 561 562 /* header CRC-8 check */ 563 skip_bits(gb, 8); 564 if (av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, gb->buffer, 565 get_bits_count(gb)/8)) { 566 av_log(avctx, AV_LOG_ERROR, "header crc mismatch\n"); 567 return -1; 568 } 569 570 return 0; 571} 572 573static int decode_frame(FLACContext *s) 574{ 575 int i; 576 GetBitContext *gb = &s->gb; 577 FLACFrameInfo fi; 578 579 if (decode_frame_header(s->avctx, gb, &fi)) { 580 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n"); 581 return -1; 582 } 583 584 if (fi.channels != s->channels) { 585 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream " 586 "is not supported\n"); 587 return -1; 588 } 589 s->ch_mode = fi.ch_mode; 590 591 if (fi.bps && fi.bps != s->bps) { 592 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not " 593 "supported\n"); 594 return -1; 595 } 596 if (s->bps > 16) { 597 s->avctx->sample_fmt = SAMPLE_FMT_S32; 598 s->sample_shift = 32 - s->bps; 599 s->is32 = 1; 600 } else { 601 s->avctx->sample_fmt = SAMPLE_FMT_S16; 602 s->sample_shift = 16 - s->bps; 603 s->is32 = 0; 604 } 605 606 if (fi.blocksize > s->max_blocksize) { 607 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize, 608 s->max_blocksize); 609 return -1; 610 } 611 s->blocksize = fi.blocksize; 612 613 if (fi.samplerate == 0) { 614 fi.samplerate = s->samplerate; 615 } else if (fi.samplerate != s->samplerate) { 616 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n", 617 s->samplerate, fi.samplerate); 618 } 619 s->samplerate = s->avctx->sample_rate = fi.samplerate; 620 621// dump_headers(s->avctx, (FLACStreaminfo *)s); 622 623 /* subframes */ 624 for (i = 0; i < s->channels; i++) { 625 if (decode_subframe(s, i) < 0) 626 return -1; 627 } 628 629 align_get_bits(gb); 630 631 /* frame footer */ 632 skip_bits(gb, 16); /* data crc */ 633 634 return 0; 635} 636 637static int flac_decode_frame(AVCodecContext *avctx, 638 void *data, int *data_size, 639 AVPacket *avpkt) 640{ 641 const uint8_t *buf = avpkt->data; 642 int buf_size = avpkt->size; 643 FLACContext *s = avctx->priv_data; 644 int i, j = 0, input_buf_size = 0, bytes_read = 0; 645 int16_t *samples_16 = data; 646 int32_t *samples_32 = data; 647 int alloc_data_size= *data_size; 648 int output_size; 649 650 *data_size=0; 651 652 if (s->max_framesize == 0) { 653 s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header 654 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); 655 } 656 657 if (1 && s->max_framesize) { //FIXME truncated 658 if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C')) 659 buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize)); 660 input_buf_size= buf_size; 661 662 if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index) 663 return -1; 664 665 if (s->allocated_bitstream_size < s->bitstream_size + buf_size) 666 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size); 667 668 if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) { 669 memmove(s->bitstream, &s->bitstream[s->bitstream_index], 670 s->bitstream_size); 671 s->bitstream_index=0; 672 } 673 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], 674 buf, buf_size); 675 buf= &s->bitstream[s->bitstream_index]; 676 buf_size += s->bitstream_size; 677 s->bitstream_size= buf_size; 678 679 if (buf_size < s->max_framesize && input_buf_size) { 680 return input_buf_size; 681 } 682 } 683 684 /* check that there is at least the smallest decodable amount of data. 685 this amount corresponds to the smallest valid FLAC frame possible. 686 FF F8 69 02 00 00 9A 00 00 34 46 */ 687 if (buf_size < 11) 688 goto end; 689 690 /* check for inline header */ 691 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) { 692 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) { 693 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n"); 694 return -1; 695 } 696 bytes_read = get_metadata_size(buf, buf_size); 697 goto end; 698 } 699 700 /* check for frame sync code and resync stream if necessary */ 701 if ((AV_RB16(buf) & 0xFFFE) != 0xFFF8) { 702 const uint8_t *buf_end = buf + buf_size; 703 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n"); 704 while (buf+2 < buf_end && (AV_RB16(buf) & 0xFFFE) != 0xFFF8) 705 buf++; 706 bytes_read = buf_size - (buf_end - buf); 707 goto end; // we may not have enough bits left to decode a frame, so try next time 708 } 709 710 /* decode frame */ 711 init_get_bits(&s->gb, buf, buf_size*8); 712 if (decode_frame(s) < 0) { 713 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); 714 s->bitstream_size=0; 715 s->bitstream_index=0; 716 return -1; 717 } 718 bytes_read = (get_bits_count(&s->gb)+7)/8; 719 720 /* check if allocated data size is large enough for output */ 721 output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2); 722 if (output_size > alloc_data_size) { 723 av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than " 724 "allocated data size\n"); 725 goto end; 726 } 727 *data_size = output_size; 728 729#define DECORRELATE(left, right)\ 730 assert(s->channels == 2);\ 731 for (i = 0; i < s->blocksize; i++) {\ 732 int a= s->decoded[0][i];\ 733 int b= s->decoded[1][i];\ 734 if (s->is32) {\ 735 *samples_32++ = (left) << s->sample_shift;\ 736 *samples_32++ = (right) << s->sample_shift;\ 737 } else {\ 738 *samples_16++ = (left) << s->sample_shift;\ 739 *samples_16++ = (right) << s->sample_shift;\ 740 }\ 741 }\ 742 break; 743 744 switch (s->ch_mode) { 745 case FLAC_CHMODE_INDEPENDENT: 746 for (j = 0; j < s->blocksize; j++) { 747 for (i = 0; i < s->channels; i++) { 748 if (s->is32) 749 *samples_32++ = s->decoded[i][j] << s->sample_shift; 750 else 751 *samples_16++ = s->decoded[i][j] << s->sample_shift; 752 } 753 } 754 break; 755 case FLAC_CHMODE_LEFT_SIDE: 756 DECORRELATE(a,a-b) 757 case FLAC_CHMODE_RIGHT_SIDE: 758 DECORRELATE(a+b,b) 759 case FLAC_CHMODE_MID_SIDE: 760 DECORRELATE( (a-=b>>1) + b, a) 761 } 762 763end: 764 if (bytes_read > buf_size) { 765 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size); 766 s->bitstream_size=0; 767 s->bitstream_index=0; 768 return -1; 769 } 770 771 if (s->bitstream_size) { 772 s->bitstream_index += bytes_read; 773 s->bitstream_size -= bytes_read; 774 return input_buf_size; 775 } else 776 return bytes_read; 777} 778 779static av_cold int flac_decode_close(AVCodecContext *avctx) 780{ 781 FLACContext *s = avctx->priv_data; 782 int i; 783 784 for (i = 0; i < s->channels; i++) { 785 av_freep(&s->decoded[i]); 786 } 787 av_freep(&s->bitstream); 788 789 return 0; 790} 791 792static void flac_flush(AVCodecContext *avctx) 793{ 794 FLACContext *s = avctx->priv_data; 795 796 s->bitstream_size= 797 s->bitstream_index= 0; 798} 799 800AVCodec flac_decoder = { 801 "flac", 802 AVMEDIA_TYPE_AUDIO, 803 CODEC_ID_FLAC, 804 sizeof(FLACContext), 805 flac_decode_init, 806 NULL, 807 flac_decode_close, 808 flac_decode_frame, 809 CODEC_CAP_DELAY | CODEC_CAP_SUBFRAMES, /* FIXME: add a FLAC parser so that 810 we will not need to use either 811 of these capabilities */ 812 .flush= flac_flush, 813 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), 814}; 815