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 libavcodec/flacdec.c 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#define ALT_BITSTREAM_READER 39#include "libavutil/crc.h" 40#include "avcodec.h" 41#include "bitstream.h" 42#include "golomb.h" 43#include "flac.h" 44 45#undef NDEBUG 46#include <assert.h> 47 48#define MAX_CHANNELS 8 49#define MAX_BLOCKSIZE 65535 50 51enum decorrelation_type { 52 INDEPENDENT, 53 LEFT_SIDE, 54 RIGHT_SIDE, 55 MID_SIDE, 56}; 57 58typedef struct FLACContext { 59 FLACSTREAMINFO 60 61 AVCodecContext *avctx; ///< parent AVCodecContext 62 GetBitContext gb; ///< GetBitContext initialized to start at the current frame 63 64 int blocksize; ///< number of samples in the current frame 65 int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits 66 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit 67 int is32; ///< flag to indicate if output should be 32-bit instead of 16-bit 68 enum decorrelation_type decorrelation; ///< channel decorrelation type in the current frame 69 70 int32_t *decoded[MAX_CHANNELS]; ///< decoded samples 71 uint8_t *bitstream; 72 unsigned int bitstream_size; 73 unsigned int bitstream_index; 74 unsigned int allocated_bitstream_size; 75} FLACContext; 76 77static const int sample_rate_table[] = 78{ 0, 79 88200, 176400, 192000, 80 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000, 81 0, 0, 0, 0 }; 82 83static const int sample_size_table[] = 84{ 0, 8, 12, 0, 16, 20, 24, 0 }; 85 86static const int blocksize_table[] = { 87 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0, 88256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 89}; 90 91static int64_t get_utf8(GetBitContext *gb) 92{ 93 int64_t val; 94 GET_UTF8(val, get_bits(gb, 8), return -1;) 95 return val; 96} 97 98static void allocate_buffers(FLACContext *s); 99 100int ff_flac_is_extradata_valid(AVCodecContext *avctx, 101 enum FLACExtradataFormat *format, 102 uint8_t **streaminfo_start) 103{ 104 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) { 105 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n"); 106 return 0; 107 } 108 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) { 109 /* extradata contains STREAMINFO only */ 110 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) { 111 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n", 112 FLAC_STREAMINFO_SIZE-avctx->extradata_size); 113 } 114 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO; 115 *streaminfo_start = avctx->extradata; 116 } else { 117 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) { 118 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n"); 119 return 0; 120 } 121 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER; 122 *streaminfo_start = &avctx->extradata[8]; 123 } 124 return 1; 125} 126 127static av_cold int flac_decode_init(AVCodecContext *avctx) 128{ 129 enum FLACExtradataFormat format; 130 uint8_t *streaminfo; 131 FLACContext *s = avctx->priv_data; 132 s->avctx = avctx; 133 134 avctx->sample_fmt = SAMPLE_FMT_S16; 135 136 /* for now, the raw FLAC header is allowed to be passed to the decoder as 137 frame data instead of extradata. */ 138 if (!avctx->extradata) 139 return 0; 140 141 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo)) 142 return -1; 143 144 /* initialize based on the demuxer-supplied streamdata header */ 145 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo); 146 allocate_buffers(s); 147 148 return 0; 149} 150 151static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s) 152{ 153 av_log(avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d\n", s->min_blocksize, 154 s->max_blocksize); 155 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize); 156 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate); 157 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels); 158 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps); 159} 160 161static void allocate_buffers(FLACContext *s) 162{ 163 int i; 164 165 assert(s->max_blocksize); 166 167 if (s->max_framesize == 0 && s->max_blocksize) { 168 // FIXME header overhead 169 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; 170 } 171 172 for (i = 0; i < s->channels; i++) { 173 s->decoded[i] = av_realloc(s->decoded[i], 174 sizeof(int32_t)*s->max_blocksize); 175 } 176 177 if (s->allocated_bitstream_size < s->max_framesize) 178 s->bitstream= av_fast_realloc(s->bitstream, 179 &s->allocated_bitstream_size, 180 s->max_framesize); 181} 182 183void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, 184 const uint8_t *buffer) 185{ 186 GetBitContext gb; 187 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8); 188 189 /* mandatory streaminfo */ 190 s->min_blocksize = get_bits(&gb, 16); 191 s->max_blocksize = get_bits(&gb, 16); 192 193 skip_bits(&gb, 24); /* skip min frame size */ 194 s->max_framesize = get_bits_long(&gb, 24); 195 196 s->samplerate = get_bits_long(&gb, 20); 197 s->channels = get_bits(&gb, 3) + 1; 198 s->bps = get_bits(&gb, 5) + 1; 199 200 avctx->channels = s->channels; 201 avctx->sample_rate = s->samplerate; 202 avctx->bits_per_raw_sample = s->bps; 203 if (s->bps > 16) 204 avctx->sample_fmt = SAMPLE_FMT_S32; 205 else 206 avctx->sample_fmt = SAMPLE_FMT_S16; 207 208 s->samples = get_bits_long(&gb, 32) << 4; 209 s->samples |= get_bits_long(&gb, 4); 210 211 skip_bits(&gb, 64); /* md5 sum */ 212 skip_bits(&gb, 64); /* md5 sum */ 213 214 dump_headers(avctx, s); 215} 216 217/** 218 * Parse a list of metadata blocks. This list of blocks must begin with 219 * the fLaC marker. 220 * @param s the flac decoding context containing the gb bit reader used to 221 * parse metadata 222 * @return 1 if some metadata was read, 0 if no fLaC marker was found 223 */ 224static int metadata_parse(FLACContext *s) 225{ 226 int i, metadata_last, metadata_type, metadata_size, streaminfo_updated=0; 227 int initial_pos= get_bits_count(&s->gb); 228 229 if (show_bits_long(&s->gb, 32) == MKBETAG('f','L','a','C')) { 230 skip_bits(&s->gb, 32); 231 232 do { 233 metadata_last = get_bits1(&s->gb); 234 metadata_type = get_bits(&s->gb, 7); 235 metadata_size = get_bits_long(&s->gb, 24); 236 237 if (get_bits_count(&s->gb) + 8*metadata_size > s->gb.size_in_bits) { 238 skip_bits_long(&s->gb, initial_pos - get_bits_count(&s->gb)); 239 break; 240 } 241 242 if (metadata_size) { 243 switch (metadata_type) { 244 case FLAC_METADATA_TYPE_STREAMINFO: 245 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, 246 s->gb.buffer+get_bits_count(&s->gb)/8); 247 streaminfo_updated = 1; 248 249 default: 250 for (i = 0; i < metadata_size; i++) 251 skip_bits(&s->gb, 8); 252 } 253 } 254 } while (!metadata_last); 255 256 if (streaminfo_updated) 257 allocate_buffers(s); 258 return 1; 259 } 260 return 0; 261} 262 263static int decode_residuals(FLACContext *s, int channel, int pred_order) 264{ 265 int i, tmp, partition, method_type, rice_order; 266 int sample = 0, samples; 267 268 method_type = get_bits(&s->gb, 2); 269 if (method_type > 1) { 270 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", 271 method_type); 272 return -1; 273 } 274 275 rice_order = get_bits(&s->gb, 4); 276 277 samples= s->blocksize >> rice_order; 278 if (pred_order > samples) { 279 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", 280 pred_order, samples); 281 return -1; 282 } 283 284 sample= 285 i= pred_order; 286 for (partition = 0; partition < (1 << rice_order); partition++) { 287 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5); 288 if (tmp == (method_type == 0 ? 15 : 31)) { 289 tmp = get_bits(&s->gb, 5); 290 for (; i < samples; i++, sample++) 291 s->decoded[channel][sample] = get_sbits(&s->gb, tmp); 292 } else { 293 for (; i < samples; i++, sample++) { 294 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); 295 } 296 } 297 i= 0; 298 } 299 300 return 0; 301} 302 303static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 304{ 305 const int blocksize = s->blocksize; 306 int32_t *decoded = s->decoded[channel]; 307 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i; 308 309 /* warm up samples */ 310 for (i = 0; i < pred_order; i++) { 311 decoded[i] = get_sbits(&s->gb, s->curr_bps); 312 } 313 314 if (decode_residuals(s, channel, pred_order) < 0) 315 return -1; 316 317 if (pred_order > 0) 318 a = decoded[pred_order-1]; 319 if (pred_order > 1) 320 b = a - decoded[pred_order-2]; 321 if (pred_order > 2) 322 c = b - decoded[pred_order-2] + decoded[pred_order-3]; 323 if (pred_order > 3) 324 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; 325 326 switch (pred_order) { 327 case 0: 328 break; 329 case 1: 330 for (i = pred_order; i < blocksize; i++) 331 decoded[i] = a += decoded[i]; 332 break; 333 case 2: 334 for (i = pred_order; i < blocksize; i++) 335 decoded[i] = a += b += decoded[i]; 336 break; 337 case 3: 338 for (i = pred_order; i < blocksize; i++) 339 decoded[i] = a += b += c += decoded[i]; 340 break; 341 case 4: 342 for (i = pred_order; i < blocksize; i++) 343 decoded[i] = a += b += c += d += decoded[i]; 344 break; 345 default: 346 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); 347 return -1; 348 } 349 350 return 0; 351} 352 353static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) 354{ 355 int i, j; 356 int coeff_prec, qlevel; 357 int coeffs[pred_order]; 358 int32_t *decoded = s->decoded[channel]; 359 360 /* warm up samples */ 361 for (i = 0; i < pred_order; i++) { 362 decoded[i] = get_sbits(&s->gb, s->curr_bps); 363 } 364 365 coeff_prec = get_bits(&s->gb, 4) + 1; 366 if (coeff_prec == 16) { 367 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); 368 return -1; 369 } 370 qlevel = get_sbits(&s->gb, 5); 371 if (qlevel < 0) { 372 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", 373 qlevel); 374 return -1; 375 } 376 377 for (i = 0; i < pred_order; i++) { 378 coeffs[i] = get_sbits(&s->gb, coeff_prec); 379 } 380 381 if (decode_residuals(s, channel, pred_order) < 0) 382 return -1; 383 384 if (s->bps > 16) { 385 int64_t sum; 386 for (i = pred_order; i < s->blocksize; i++) { 387 sum = 0; 388 for (j = 0; j < pred_order; j++) 389 sum += (int64_t)coeffs[j] * decoded[i-j-1]; 390 decoded[i] += sum >> qlevel; 391 } 392 } else { 393 for (i = pred_order; i < s->blocksize-1; i += 2) { 394 int c; 395 int d = decoded[i-pred_order]; 396 int s0 = 0, s1 = 0; 397 for (j = pred_order-1; j > 0; j--) { 398 c = coeffs[j]; 399 s0 += c*d; 400 d = decoded[i-j]; 401 s1 += c*d; 402 } 403 c = coeffs[0]; 404 s0 += c*d; 405 d = decoded[i] += s0 >> qlevel; 406 s1 += c*d; 407 decoded[i+1] += s1 >> qlevel; 408 } 409 if (i < s->blocksize) { 410 int sum = 0; 411 for (j = 0; j < pred_order; j++) 412 sum += coeffs[j] * decoded[i-j-1]; 413 decoded[i] += sum >> qlevel; 414 } 415 } 416 417 return 0; 418} 419 420static inline int decode_subframe(FLACContext *s, int channel) 421{ 422 int type, wasted = 0; 423 int i, tmp; 424 425 s->curr_bps = s->bps; 426 if (channel == 0) { 427 if (s->decorrelation == RIGHT_SIDE) 428 s->curr_bps++; 429 } else { 430 if (s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE) 431 s->curr_bps++; 432 } 433 434 if (get_bits1(&s->gb)) { 435 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); 436 return -1; 437 } 438 type = get_bits(&s->gb, 6); 439 440 if (get_bits1(&s->gb)) { 441 wasted = 1; 442 while (!get_bits1(&s->gb)) 443 wasted++; 444 s->curr_bps -= wasted; 445 } 446 447//FIXME use av_log2 for types 448 if (type == 0) { 449 tmp = get_sbits(&s->gb, s->curr_bps); 450 for (i = 0; i < s->blocksize; i++) 451 s->decoded[channel][i] = tmp; 452 } else if (type == 1) { 453 for (i = 0; i < s->blocksize; i++) 454 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps); 455 } else if ((type >= 8) && (type <= 12)) { 456 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) 457 return -1; 458 } else if (type >= 32) { 459 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) 460 return -1; 461 } else { 462 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); 463 return -1; 464 } 465 466 if (wasted) { 467 int i; 468 for (i = 0; i < s->blocksize; i++) 469 s->decoded[channel][i] <<= wasted; 470 } 471 472 return 0; 473} 474 475static int decode_frame(FLACContext *s, int alloc_data_size) 476{ 477 int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8; 478 int decorrelation, bps, blocksize, samplerate; 479 480 blocksize_code = get_bits(&s->gb, 4); 481 482 sample_rate_code = get_bits(&s->gb, 4); 483 484 assignment = get_bits(&s->gb, 4); /* channel assignment */ 485 if (assignment < 8 && s->channels == assignment+1) 486 decorrelation = INDEPENDENT; 487 else if (assignment >=8 && assignment < 11 && s->channels == 2) 488 decorrelation = LEFT_SIDE + assignment - 8; 489 else { 490 av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", 491 assignment, s->channels); 492 return -1; 493 } 494 495 sample_size_code = get_bits(&s->gb, 3); 496 if (sample_size_code == 0) 497 bps= s->bps; 498 else if ((sample_size_code != 3) && (sample_size_code != 7)) 499 bps = sample_size_table[sample_size_code]; 500 else { 501 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", 502 sample_size_code); 503 return -1; 504 } 505 if (bps > 16) { 506 s->avctx->sample_fmt = SAMPLE_FMT_S32; 507 s->sample_shift = 32 - bps; 508 s->is32 = 1; 509 } else { 510 s->avctx->sample_fmt = SAMPLE_FMT_S16; 511 s->sample_shift = 16 - bps; 512 s->is32 = 0; 513 } 514 s->bps = s->avctx->bits_per_raw_sample = bps; 515 516 if (get_bits1(&s->gb)) { 517 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n"); 518 return -1; 519 } 520 521 if (get_utf8(&s->gb) < 0) { 522 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n"); 523 return -1; 524 } 525 526 if (blocksize_code == 0) 527 blocksize = s->min_blocksize; 528 else if (blocksize_code == 6) 529 blocksize = get_bits(&s->gb, 8)+1; 530 else if (blocksize_code == 7) 531 blocksize = get_bits(&s->gb, 16)+1; 532 else 533 blocksize = blocksize_table[blocksize_code]; 534 535 if (blocksize > s->max_blocksize) { 536 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, 537 s->max_blocksize); 538 return -1; 539 } 540 541 if (blocksize * s->channels * sizeof(int16_t) > alloc_data_size) 542 return -1; 543 544 if (sample_rate_code == 0) 545 samplerate= s->samplerate; 546 else if (sample_rate_code < 12) 547 samplerate = sample_rate_table[sample_rate_code]; 548 else if (sample_rate_code == 12) 549 samplerate = get_bits(&s->gb, 8) * 1000; 550 else if (sample_rate_code == 13) 551 samplerate = get_bits(&s->gb, 16); 552 else if (sample_rate_code == 14) 553 samplerate = get_bits(&s->gb, 16) * 10; 554 else { 555 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", 556 sample_rate_code); 557 return -1; 558 } 559 560 skip_bits(&s->gb, 8); 561 crc8 = av_crc(av_crc_get_table(AV_CRC_8_ATM), 0, 562 s->gb.buffer, get_bits_count(&s->gb)/8); 563 if (crc8) { 564 av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8); 565 return -1; 566 } 567 568 s->blocksize = blocksize; 569 s->samplerate = samplerate; 570 s->bps = bps; 571 s->decorrelation= decorrelation; 572 573// dump_headers(s->avctx, (FLACStreaminfo *)s); 574 575 /* subframes */ 576 for (i = 0; i < s->channels; i++) { 577 if (decode_subframe(s, i) < 0) 578 return -1; 579 } 580 581 align_get_bits(&s->gb); 582 583 /* frame footer */ 584 skip_bits(&s->gb, 16); /* data crc */ 585 586 return 0; 587} 588 589static int flac_decode_frame(AVCodecContext *avctx, 590 void *data, int *data_size, 591 const uint8_t *buf, int buf_size) 592{ 593 FLACContext *s = avctx->priv_data; 594 int tmp = 0, i, j = 0, input_buf_size = 0; 595 int16_t *samples_16 = data; 596 int32_t *samples_32 = data; 597 int alloc_data_size= *data_size; 598 599 *data_size=0; 600 601 if (s->max_framesize == 0) { 602 s->max_framesize= FFMAX(4, buf_size); // should hopefully be enough for the first header 603 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize); 604 } 605 606 if (1 && s->max_framesize) { //FIXME truncated 607 if (s->bitstream_size < 4 || AV_RL32(s->bitstream) != MKTAG('f','L','a','C')) 608 buf_size= FFMIN(buf_size, s->max_framesize - FFMIN(s->bitstream_size, s->max_framesize)); 609 input_buf_size= buf_size; 610 611 if (s->bitstream_size + buf_size < buf_size || s->bitstream_index + s->bitstream_size + buf_size < s->bitstream_index) 612 return -1; 613 614 if (s->allocated_bitstream_size < s->bitstream_size + buf_size) 615 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->bitstream_size + buf_size); 616 617 if (s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size) { 618 memmove(s->bitstream, &s->bitstream[s->bitstream_index], 619 s->bitstream_size); 620 s->bitstream_index=0; 621 } 622 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], 623 buf, buf_size); 624 buf= &s->bitstream[s->bitstream_index]; 625 buf_size += s->bitstream_size; 626 s->bitstream_size= buf_size; 627 628 if (buf_size < s->max_framesize && input_buf_size) { 629 return input_buf_size; 630 } 631 } 632 633 init_get_bits(&s->gb, buf, buf_size*8); 634 635 if (metadata_parse(s)) 636 goto end; 637 638 tmp = show_bits(&s->gb, 16); 639 if ((tmp & 0xFFFE) != 0xFFF8) { 640 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n"); 641 while (get_bits_count(&s->gb)/8+2 < buf_size && (show_bits(&s->gb, 16) & 0xFFFE) != 0xFFF8) 642 skip_bits(&s->gb, 8); 643 goto end; // we may not have enough bits left to decode a frame, so try next time 644 } 645 skip_bits(&s->gb, 16); 646 if (decode_frame(s, alloc_data_size) < 0) { 647 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); 648 s->bitstream_size=0; 649 s->bitstream_index=0; 650 return -1; 651 } 652 653#define DECORRELATE(left, right)\ 654 assert(s->channels == 2);\ 655 for (i = 0; i < s->blocksize; i++) {\ 656 int a= s->decoded[0][i];\ 657 int b= s->decoded[1][i];\ 658 if (s->is32) {\ 659 *samples_32++ = (left) << s->sample_shift;\ 660 *samples_32++ = (right) << s->sample_shift;\ 661 } else {\ 662 *samples_16++ = (left) << s->sample_shift;\ 663 *samples_16++ = (right) << s->sample_shift;\ 664 }\ 665 }\ 666 break; 667 668 switch (s->decorrelation) { 669 case INDEPENDENT: 670 for (j = 0; j < s->blocksize; j++) { 671 for (i = 0; i < s->channels; i++) { 672 if (s->is32) 673 *samples_32++ = s->decoded[i][j] << s->sample_shift; 674 else 675 *samples_16++ = s->decoded[i][j] << s->sample_shift; 676 } 677 } 678 break; 679 case LEFT_SIDE: 680 DECORRELATE(a,a-b) 681 case RIGHT_SIDE: 682 DECORRELATE(a+b,b) 683 case MID_SIDE: 684 DECORRELATE( (a-=b>>1) + b, a) 685 } 686 687 *data_size = s->blocksize * s->channels * (s->is32 ? 4 : 2); 688 689end: 690 i= (get_bits_count(&s->gb)+7)/8; 691 if (i > buf_size) { 692 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size); 693 s->bitstream_size=0; 694 s->bitstream_index=0; 695 return -1; 696 } 697 698 if (s->bitstream_size) { 699 s->bitstream_index += i; 700 s->bitstream_size -= i; 701 return input_buf_size; 702 } else 703 return i; 704} 705 706static av_cold int flac_decode_close(AVCodecContext *avctx) 707{ 708 FLACContext *s = avctx->priv_data; 709 int i; 710 711 for (i = 0; i < s->channels; i++) { 712 av_freep(&s->decoded[i]); 713 } 714 av_freep(&s->bitstream); 715 716 return 0; 717} 718 719static void flac_flush(AVCodecContext *avctx) 720{ 721 FLACContext *s = avctx->priv_data; 722 723 s->bitstream_size= 724 s->bitstream_index= 0; 725} 726 727AVCodec flac_decoder = { 728 "flac", 729 CODEC_TYPE_AUDIO, 730 CODEC_ID_FLAC, 731 sizeof(FLACContext), 732 flac_decode_init, 733 NULL, 734 flac_decode_close, 735 flac_decode_frame, 736 CODEC_CAP_DELAY, 737 .flush= flac_flush, 738 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), 739}; 740