libavcodec/flacdec.c

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