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