1/* 2 * FLAC (Free Lossless Audio Codec) decoder 3 * Copyright (c) 2003 Alex Beregszaszi 4 * 5 * This file is part of Libav. 6 * 7 * Libav 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 * Libav 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 Libav; 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/crc.h" 37#include "avcodec.h" 38#include "internal.h" 39#include "get_bits.h" 40#include "bytestream.h" 41#include "golomb.h" 42#include "flac.h" 43#include "flacdata.h" 44 45#undef NDEBUG 46#include <assert.h> 47 48typedef struct FLACContext { 49 FLACSTREAMINFO 50 51 AVCodecContext *avctx; ///< parent AVCodecContext 52 AVFrame frame; 53 GetBitContext gb; ///< GetBitContext initialized to start at the current frame 54 55 int blocksize; ///< number of samples in the current frame 56 int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits 57 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit 58 int is32; ///< flag to indicate if output should be 32-bit instead of 16-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} FLACContext; 64 65static void allocate_buffers(FLACContext *s); 66 67int avpriv_flac_is_extradata_valid(AVCodecContext *avctx, 68 enum FLACExtradataFormat *format, 69 uint8_t **streaminfo_start) 70{ 71 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) { 72 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n"); 73 return 0; 74 } 75 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) { 76 /* extradata contains STREAMINFO only */ 77 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) { 78 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n", 79 FLAC_STREAMINFO_SIZE-avctx->extradata_size); 80 } 81 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO; 82 *streaminfo_start = avctx->extradata; 83 } else { 84 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) { 85 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n"); 86 return 0; 87 } 88 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER; 89 *streaminfo_start = &avctx->extradata[8]; 90 } 91 return 1; 92} 93 94static av_cold int flac_decode_init(AVCodecContext *avctx) 95{ 96 enum FLACExtradataFormat format; 97 uint8_t *streaminfo; 98 FLACContext *s = avctx->priv_data; 99 s->avctx = avctx; 100 101 avctx->sample_fmt = AV_SAMPLE_FMT_S16; 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 (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo)) 109 return -1; 110 111 /* initialize based on the demuxer-supplied streamdata header */ 112 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo); 113 if (s->bps > 16) 114 avctx->sample_fmt = AV_SAMPLE_FMT_S32; 115 else 116 avctx->sample_fmt = AV_SAMPLE_FMT_S16; 117 allocate_buffers(s); 118 s->got_streaminfo = 1; 119 120 avcodec_get_frame_defaults(&s->frame); 121 avctx->coded_frame = &s->frame; 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 void allocate_buffers(FLACContext *s) 136{ 137 int i; 138 139 assert(s->max_blocksize); 140 141 for (i = 0; i < s->channels; i++) { 142 s->decoded[i] = av_realloc(s->decoded[i], 143 sizeof(int32_t)*s->max_blocksize); 144 } 145} 146 147void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s, 148 const uint8_t *buffer) 149{ 150 GetBitContext gb; 151 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8); 152 153 skip_bits(&gb, 16); /* skip min blocksize */ 154 s->max_blocksize = get_bits(&gb, 16); 155 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) { 156 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n", 157 s->max_blocksize); 158 s->max_blocksize = 16; 159 } 160 161 skip_bits(&gb, 24); /* skip min frame size */ 162 s->max_framesize = get_bits_long(&gb, 24); 163 164 s->samplerate = get_bits_long(&gb, 20); 165 s->channels = get_bits(&gb, 3) + 1; 166 s->bps = get_bits(&gb, 5) + 1; 167 168 avctx->channels = s->channels; 169 avctx->sample_rate = s->samplerate; 170 avctx->bits_per_raw_sample = s->bps; 171 172 s->samples = get_bits_long(&gb, 32) << 4; 173 s->samples |= get_bits(&gb, 4); 174 175 skip_bits_long(&gb, 64); /* md5 sum */ 176 skip_bits_long(&gb, 64); /* md5 sum */ 177 178 dump_headers(avctx, s); 179} 180 181void avpriv_flac_parse_block_header(const uint8_t *block_header, 182 int *last, int *type, int *size) 183{ 184 int tmp = bytestream_get_byte(&block_header); 185 if (last) 186 *last = tmp & 0x80; 187 if (type) 188 *type = tmp & 0x7F; 189 if (size) 190 *size = bytestream_get_be24(&block_header); 191} 192 193/** 194 * Parse the STREAMINFO from an inline header. 195 * @param s the flac decoding context 196 * @param buf input buffer, starting with the "fLaC" marker 197 * @param buf_size buffer size 198 * @return non-zero if metadata is invalid 199 */ 200static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size) 201{ 202 int metadata_type, metadata_size; 203 204 if (buf_size < FLAC_STREAMINFO_SIZE+8) { 205 /* need more data */ 206 return 0; 207 } 208 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size); 209 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO || 210 metadata_size != FLAC_STREAMINFO_SIZE) { 211 return AVERROR_INVALIDDATA; 212 } 213 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]); 214 allocate_buffers(s); 215 s->got_streaminfo = 1; 216 217 return 0; 218} 219 220/** 221 * Determine the size of an inline header. 222 * @param buf input buffer, starting with the "fLaC" marker 223 * @param buf_size buffer size 224 * @return number of bytes in the header, or 0 if more data is needed 225 */ 226static int get_metadata_size(const uint8_t *buf, int buf_size) 227{ 228 int metadata_last, metadata_size; 229 const uint8_t *buf_end = buf + buf_size; 230 231 buf += 4; 232 do { 233 if (buf_end - buf < 4) 234 return 0; 235 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size); 236 buf += 4; 237 if (buf_end - buf < metadata_size) { 238 /* need more data in order to read the complete header */ 239 return 0; 240 } 241 buf += metadata_size; 242 } while (!metadata_last); 243 244 return buf_size - (buf_end - buf); 245} 246 247static int decode_residuals(FLACContext *s, int channel, int pred_order) 248{ 249 int i, tmp, partition, method_type, rice_order; 250 int sample = 0, samples; 251 252 method_type = get_bits(&s->gb, 2); 253 if (method_type > 1) { 254 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n", 255 method_type); 256 return -1; 257 } 258 259 rice_order = get_bits(&s->gb, 4); 260 261 samples= s->blocksize >> rice_order; 262 if (pred_order > samples) { 263 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n", 264 pred_order, samples); 265 return -1; 266 } 267 268 sample= 269 i= pred_order; 270 for (partition = 0; partition < (1 << rice_order); partition++) { 271 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5); 272 if (tmp == (method_type == 0 ? 15 : 31)) { 273 tmp = get_bits(&s->gb, 5); 274 for (; i < samples; i++, sample++) 275 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp); 276 } else { 277 for (; i < samples; i++, sample++) { 278 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0); 279 } 280 } 281 i= 0; 282 } 283 284 return 0; 285} 286 287static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order) 288{ 289 const int blocksize = s->blocksize; 290 int32_t *decoded = s->decoded[channel]; 291 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i; 292 293 /* warm up samples */ 294 for (i = 0; i < pred_order; i++) { 295 decoded[i] = get_sbits_long(&s->gb, s->curr_bps); 296 } 297 298 if (decode_residuals(s, channel, pred_order) < 0) 299 return -1; 300 301 if (pred_order > 0) 302 a = decoded[pred_order-1]; 303 if (pred_order > 1) 304 b = a - decoded[pred_order-2]; 305 if (pred_order > 2) 306 c = b - decoded[pred_order-2] + decoded[pred_order-3]; 307 if (pred_order > 3) 308 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4]; 309 310 switch (pred_order) { 311 case 0: 312 break; 313 case 1: 314 for (i = pred_order; i < blocksize; i++) 315 decoded[i] = a += decoded[i]; 316 break; 317 case 2: 318 for (i = pred_order; i < blocksize; i++) 319 decoded[i] = a += b += decoded[i]; 320 break; 321 case 3: 322 for (i = pred_order; i < blocksize; i++) 323 decoded[i] = a += b += c += decoded[i]; 324 break; 325 case 4: 326 for (i = pred_order; i < blocksize; i++) 327 decoded[i] = a += b += c += d += decoded[i]; 328 break; 329 default: 330 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order); 331 return -1; 332 } 333 334 return 0; 335} 336 337static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order) 338{ 339 int i, j; 340 int coeff_prec, qlevel; 341 int coeffs[32]; 342 int32_t *decoded = s->decoded[channel]; 343 344 /* warm up samples */ 345 for (i = 0; i < pred_order; i++) { 346 decoded[i] = get_sbits_long(&s->gb, s->curr_bps); 347 } 348 349 coeff_prec = get_bits(&s->gb, 4) + 1; 350 if (coeff_prec == 16) { 351 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n"); 352 return -1; 353 } 354 qlevel = get_sbits(&s->gb, 5); 355 if (qlevel < 0) { 356 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n", 357 qlevel); 358 return -1; 359 } 360 361 for (i = 0; i < pred_order; i++) { 362 coeffs[i] = get_sbits(&s->gb, coeff_prec); 363 } 364 365 if (decode_residuals(s, channel, pred_order) < 0) 366 return -1; 367 368 if (s->bps > 16) { 369 int64_t sum; 370 for (i = pred_order; i < s->blocksize; i++) { 371 sum = 0; 372 for (j = 0; j < pred_order; j++) 373 sum += (int64_t)coeffs[j] * decoded[i-j-1]; 374 decoded[i] += sum >> qlevel; 375 } 376 } else { 377 for (i = pred_order; i < s->blocksize-1; i += 2) { 378 int c; 379 int d = decoded[i-pred_order]; 380 int s0 = 0, s1 = 0; 381 for (j = pred_order-1; j > 0; j--) { 382 c = coeffs[j]; 383 s0 += c*d; 384 d = decoded[i-j]; 385 s1 += c*d; 386 } 387 c = coeffs[0]; 388 s0 += c*d; 389 d = decoded[i] += s0 >> qlevel; 390 s1 += c*d; 391 decoded[i+1] += s1 >> qlevel; 392 } 393 if (i < s->blocksize) { 394 int sum = 0; 395 for (j = 0; j < pred_order; j++) 396 sum += coeffs[j] * decoded[i-j-1]; 397 decoded[i] += sum >> qlevel; 398 } 399 } 400 401 return 0; 402} 403 404static inline int decode_subframe(FLACContext *s, int channel) 405{ 406 int type, wasted = 0; 407 int i, tmp; 408 409 s->curr_bps = s->bps; 410 if (channel == 0) { 411 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE) 412 s->curr_bps++; 413 } else { 414 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE) 415 s->curr_bps++; 416 } 417 418 if (get_bits1(&s->gb)) { 419 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n"); 420 return -1; 421 } 422 type = get_bits(&s->gb, 6); 423 424 if (get_bits1(&s->gb)) { 425 int left = get_bits_left(&s->gb); 426 wasted = 1; 427 if ( left < 0 || 428 (left < s->curr_bps && !show_bits_long(&s->gb, left)) || 429 !show_bits_long(&s->gb, s->curr_bps)) { 430 av_log(s->avctx, AV_LOG_ERROR, 431 "Invalid number of wasted bits > available bits (%d) - left=%d\n", 432 s->curr_bps, left); 433 return AVERROR_INVALIDDATA; 434 } 435 while (!get_bits1(&s->gb)) 436 wasted++; 437 s->curr_bps -= wasted; 438 } 439 if (s->curr_bps > 32) { 440 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0); 441 return -1; 442 } 443 444//FIXME use av_log2 for types 445 if (type == 0) { 446 tmp = get_sbits_long(&s->gb, s->curr_bps); 447 for (i = 0; i < s->blocksize; i++) 448 s->decoded[channel][i] = tmp; 449 } else if (type == 1) { 450 for (i = 0; i < s->blocksize; i++) 451 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps); 452 } else if ((type >= 8) && (type <= 12)) { 453 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0) 454 return -1; 455 } else if (type >= 32) { 456 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0) 457 return -1; 458 } else { 459 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n"); 460 return -1; 461 } 462 463 if (wasted) { 464 int i; 465 for (i = 0; i < s->blocksize; i++) 466 s->decoded[channel][i] <<= wasted; 467 } 468 469 return 0; 470} 471 472static int decode_frame(FLACContext *s) 473{ 474 int i; 475 GetBitContext *gb = &s->gb; 476 FLACFrameInfo fi; 477 478 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) { 479 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n"); 480 return -1; 481 } 482 483 if (s->channels && fi.channels != s->channels) { 484 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream " 485 "is not supported\n"); 486 return -1; 487 } 488 s->channels = s->avctx->channels = fi.channels; 489 s->ch_mode = fi.ch_mode; 490 491 if (!s->bps && !fi.bps) { 492 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n"); 493 return -1; 494 } 495 if (!fi.bps) { 496 fi.bps = s->bps; 497 } else if (s->bps && fi.bps != s->bps) { 498 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not " 499 "supported\n"); 500 return -1; 501 } 502 s->bps = s->avctx->bits_per_raw_sample = fi.bps; 503 504 if (s->bps > 16) { 505 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32; 506 s->sample_shift = 32 - s->bps; 507 s->is32 = 1; 508 } else { 509 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16; 510 s->sample_shift = 16 - s->bps; 511 s->is32 = 0; 512 } 513 514 if (!s->max_blocksize) 515 s->max_blocksize = FLAC_MAX_BLOCKSIZE; 516 if (fi.blocksize > s->max_blocksize) { 517 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize, 518 s->max_blocksize); 519 return -1; 520 } 521 s->blocksize = fi.blocksize; 522 523 if (!s->samplerate && !fi.samplerate) { 524 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO" 525 " or frame header\n"); 526 return -1; 527 } 528 if (fi.samplerate == 0) { 529 fi.samplerate = s->samplerate; 530 } else if (s->samplerate && fi.samplerate != s->samplerate) { 531 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n", 532 s->samplerate, fi.samplerate); 533 } 534 s->samplerate = s->avctx->sample_rate = fi.samplerate; 535 536 if (!s->got_streaminfo) { 537 allocate_buffers(s); 538 s->got_streaminfo = 1; 539 dump_headers(s->avctx, (FLACStreaminfo *)s); 540 } 541 542// dump_headers(s->avctx, (FLACStreaminfo *)s); 543 544 /* subframes */ 545 for (i = 0; i < s->channels; i++) { 546 if (decode_subframe(s, i) < 0) 547 return -1; 548 } 549 550 align_get_bits(gb); 551 552 /* frame footer */ 553 skip_bits(gb, 16); /* data crc */ 554 555 return 0; 556} 557 558static int flac_decode_frame(AVCodecContext *avctx, void *data, 559 int *got_frame_ptr, AVPacket *avpkt) 560{ 561 const uint8_t *buf = avpkt->data; 562 int buf_size = avpkt->size; 563 FLACContext *s = avctx->priv_data; 564 int i, j = 0, bytes_read = 0; 565 int16_t *samples_16; 566 int32_t *samples_32; 567 int ret; 568 569 *got_frame_ptr = 0; 570 571 if (s->max_framesize == 0) { 572 s->max_framesize = 573 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE, 574 FLAC_MAX_CHANNELS, 32); 575 } 576 577 /* check that there is at least the smallest decodable amount of data. 578 this amount corresponds to the smallest valid FLAC frame possible. 579 FF F8 69 02 00 00 9A 00 00 34 46 */ 580 if (buf_size < FLAC_MIN_FRAME_SIZE) 581 return buf_size; 582 583 /* check for inline header */ 584 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) { 585 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) { 586 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n"); 587 return -1; 588 } 589 return get_metadata_size(buf, buf_size); 590 } 591 592 /* decode frame */ 593 init_get_bits(&s->gb, buf, buf_size*8); 594 if (decode_frame(s) < 0) { 595 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n"); 596 return -1; 597 } 598 bytes_read = (get_bits_count(&s->gb)+7)/8; 599 600 /* get output buffer */ 601 s->frame.nb_samples = s->blocksize; 602 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) { 603 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 604 return ret; 605 } 606 samples_16 = (int16_t *)s->frame.data[0]; 607 samples_32 = (int32_t *)s->frame.data[0]; 608 609#define DECORRELATE(left, right)\ 610 assert(s->channels == 2);\ 611 for (i = 0; i < s->blocksize; i++) {\ 612 int a= s->decoded[0][i];\ 613 int b= s->decoded[1][i];\ 614 if (s->is32) {\ 615 *samples_32++ = (left) << s->sample_shift;\ 616 *samples_32++ = (right) << s->sample_shift;\ 617 } else {\ 618 *samples_16++ = (left) << s->sample_shift;\ 619 *samples_16++ = (right) << s->sample_shift;\ 620 }\ 621 }\ 622 break; 623 624 switch (s->ch_mode) { 625 case FLAC_CHMODE_INDEPENDENT: 626 for (j = 0; j < s->blocksize; j++) { 627 for (i = 0; i < s->channels; i++) { 628 if (s->is32) 629 *samples_32++ = s->decoded[i][j] << s->sample_shift; 630 else 631 *samples_16++ = s->decoded[i][j] << s->sample_shift; 632 } 633 } 634 break; 635 case FLAC_CHMODE_LEFT_SIDE: 636 DECORRELATE(a,a-b) 637 case FLAC_CHMODE_RIGHT_SIDE: 638 DECORRELATE(a+b,b) 639 case FLAC_CHMODE_MID_SIDE: 640 DECORRELATE( (a-=b>>1) + b, a) 641 } 642 643 if (bytes_read > buf_size) { 644 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size); 645 return -1; 646 } 647 if (bytes_read < buf_size) { 648 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n", 649 buf_size - bytes_read, buf_size); 650 } 651 652 *got_frame_ptr = 1; 653 *(AVFrame *)data = s->frame; 654 655 return bytes_read; 656} 657 658static av_cold int flac_decode_close(AVCodecContext *avctx) 659{ 660 FLACContext *s = avctx->priv_data; 661 int i; 662 663 for (i = 0; i < s->channels; i++) { 664 av_freep(&s->decoded[i]); 665 } 666 667 return 0; 668} 669 670AVCodec ff_flac_decoder = { 671 .name = "flac", 672 .type = AVMEDIA_TYPE_AUDIO, 673 .id = CODEC_ID_FLAC, 674 .priv_data_size = sizeof(FLACContext), 675 .init = flac_decode_init, 676 .close = flac_decode_close, 677 .decode = flac_decode_frame, 678 .capabilities = CODEC_CAP_DR1, 679 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"), 680}; 681