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