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 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 "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
  51 typedef 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
  71 static int allocate_buffers(FLACContext *s);
  72
  73 static 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
  95 static 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
 126 static 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
 135 static 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  */
 167 static 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  */
 200 static 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 0;
 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 0;
 214         }
 215         buf += metadata_size;
 216     } while (!metadata_last);
 217
 218     return buf_size - (buf_end - buf);
 219 }
 220
 221 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
 222 {
 223     int i, tmp, partition, method_type, rice_order;
 224     int rice_bits, rice_esc;
 225     int samples;
 226
 227     method_type = get_bits(&s->gb, 2);
 228     if (method_type > 1) {
 229         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
 230                method_type);
 231         return AVERROR_INVALIDDATA;
 232     }
 233
 234     rice_order = get_bits(&s->gb, 4);
 235
 236     samples= s->blocksize >> rice_order;
 237     if (samples << rice_order != s->blocksize) {
 238         av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
 239                rice_order, s->blocksize);
 240         return AVERROR_INVALIDDATA;
 241     }
 242
 243     if (pred_order > samples) {
 244         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
 245                pred_order, samples);
 246         return AVERROR_INVALIDDATA;
 247     }
 248
 249     rice_bits = 4 + method_type;
 250     rice_esc  = (1 << rice_bits) - 1;
 251
 252     decoded += pred_order;
 253     i= pred_order;
 254     for (partition = 0; partition < (1 << rice_order); partition++) {
 255         tmp = get_bits(&s->gb, rice_bits);
 256         if (tmp == rice_esc) {
 257             tmp = get_bits(&s->gb, 5);
 258             for (; i < samples; i++)
 259                 *decoded++ = get_sbits_long(&s->gb, tmp);
 260         } else {
 261             for (; i < samples; i++) {
 262                 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
 263             }
 264         }
 265         i= 0;
 266     }
 267
 268     return 0;
 269 }
 270
 271 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
 272                                  int pred_order, int bps)
 273 {
 274     const int blocksize = s->blocksize;
 275     unsigned av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d);
 276     int i;
 277     int ret;
 278
 279     /* warm up samples */
 280     for (i = 0; i < pred_order; i++) {
 281         decoded[i] = get_sbits_long(&s->gb, bps);
 282     }
 283
 284     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 285         return ret;
 286
 287     if (pred_order > 0)
 288         a = decoded[pred_order-1];
 289     if (pred_order > 1)
 290         b = a - decoded[pred_order-2];
 291     if (pred_order > 2)
 292         c = b - decoded[pred_order-2] + decoded[pred_order-3];
 293     if (pred_order > 3)
 294         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
 295
 296     switch (pred_order) {
 297     case 0:
 298         break;
 299     case 1:
 300         for (i = pred_order; i < blocksize; i++)
 301             decoded[i] = a += decoded[i];
 302         break;
 303     case 2:
 304         for (i = pred_order; i < blocksize; i++)
 305             decoded[i] = a += b += decoded[i];
 306         break;
 307     case 3:
 308         for (i = pred_order; i < blocksize; i++)
 309             decoded[i] = a += b += c += decoded[i];
 310         break;
 311     case 4:
 312         for (i = pred_order; i < blocksize; i++)
 313             decoded[i] = a += b += c += d += decoded[i];
 314         break;
 315     default:
 316         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
 317         return AVERROR_INVALIDDATA;
 318     }
 319
 320     return 0;
 321 }
 322
 323 static void lpc_analyze_remodulate(int32_t *decoded, const int coeffs[32],
 324                                    int order, int qlevel, int len, int bps)
 325 {
 326     int i, j;
 327     int ebps = 1 << (bps-1);
 328     unsigned sigma = 0;
 329
 330     for (i = order; i < len; i++)
 331         sigma |= decoded[i] + ebps;
 332
 333     if (sigma < 2*ebps)
 334         return;
 335
 336     for (i = len - 1; i >= order; i--) {
 337         int64_t p = 0;
 338         for (j = 0; j < order; j++)
 339             p += coeffs[j] * (int64_t)decoded[i-order+j];
 340         decoded[i] -= p >> qlevel;
 341     }
 342     for (i = order; i < len; i++, decoded++) {
 343         int32_t p = 0;
 344         for (j = 0; j < order; j++)
 345             p += coeffs[j] * (uint32_t)decoded[j];
 346         decoded[j] += p >> qlevel;
 347     }
 348 }
 349
 350 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
 351                                int bps)
 352 {
 353     int i, ret;
 354     int coeff_prec, qlevel;
 355     int coeffs[32];
 356
 357     /* warm up samples */
 358     for (i = 0; i < pred_order; i++) {
 359         decoded[i] = get_sbits_long(&s->gb, bps);
 360     }
 361
 362     coeff_prec = get_bits(&s->gb, 4) + 1;
 363     if (coeff_prec == 16) {
 364         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
 365         return AVERROR_INVALIDDATA;
 366     }
 367     qlevel = get_sbits(&s->gb, 5);
 368     if (qlevel < 0) {
 369         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
 370                qlevel);
 371         return AVERROR_INVALIDDATA;
 372     }
 373
 374     for (i = 0; i < pred_order; i++) {
 375         coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
 376     }
 377
 378     if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
 379         return ret;
 380
 381     if (   (    s->buggy_lpc && s->flac_stream_info.bps <= 16)
 382         || (   !s->buggy_lpc && bps <= 16
 383             && bps + coeff_prec + av_log2(pred_order) <= 32)) {
 384         s->dsp.lpc16(decoded, coeffs, pred_order, qlevel, s->blocksize);
 385     } else {
 386         s->dsp.lpc32(decoded, coeffs, pred_order, qlevel, s->blocksize);
 387         if (s->flac_stream_info.bps <= 16)
 388             lpc_analyze_remodulate(decoded, coeffs, pred_order, qlevel, s->blocksize, bps);
 389     }
 390
 391     return 0;
 392 }
 393
 394 static inline int decode_subframe(FLACContext *s, int channel)
 395 {
 396     int32_t *decoded = s->decoded[channel];
 397     int type, wasted = 0;
 398     int bps = s->flac_stream_info.bps;
 399     int i, tmp, ret;
 400
 401     if (channel == 0) {
 402         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
 403             bps++;
 404     } else {
 405         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
 406             bps++;
 407     }
 408
 409     if (get_bits1(&s->gb)) {
 410         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
 411         return AVERROR_INVALIDDATA;
 412     }
 413     type = get_bits(&s->gb, 6);
 414
 415     if (get_bits1(&s->gb)) {
 416         int left = get_bits_left(&s->gb);
 417         if ( left <= 0 ||
 418             (left < bps && !show_bits_long(&s->gb, left)) ||
 419                            !show_bits_long(&s->gb, bps)) {
 420             av_log(s->avctx, AV_LOG_ERROR,
 421                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
 422                    bps, left);
 423             return AVERROR_INVALIDDATA;
 424         }
 425         wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
 426         bps -= wasted;
 427     }
 428     if (bps > 32) {
 429         avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
 430         return AVERROR_PATCHWELCOME;
 431     }
 432
 433 //FIXME use av_log2 for types
 434     if (type == 0) {
 435         tmp = get_sbits_long(&s->gb, bps);
 436         for (i = 0; i < s->blocksize; i++)
 437             decoded[i] = tmp;
 438     } else if (type == 1) {
 439         for (i = 0; i < s->blocksize; i++)
 440             decoded[i] = get_sbits_long(&s->gb, bps);
 441     } else if ((type >= 8) && (type <= 12)) {
 442         if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
 443             return ret;
 444     } else if (type >= 32) {
 445         if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
 446             return ret;
 447     } else {
 448         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
 449         return AVERROR_INVALIDDATA;
 450     }
 451
 452     if (wasted) {
 453         int i;
 454         for (i = 0; i < s->blocksize; i++)
 455             decoded[i] = (unsigned)decoded[i] << wasted;
 456     }
 457
 458     return 0;
 459 }
 460
 461 static int decode_frame(FLACContext *s)
 462 {
 463     int i, ret;
 464     GetBitContext *gb = &s->gb;
 465     FLACFrameInfo fi;
 466
 467     if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
 468         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
 469         return ret;
 470     }
 471
 472     if (   s->flac_stream_info.channels
 473         && fi.channels != s->flac_stream_info.channels
 474         && s->got_streaminfo) {
 475         s->flac_stream_info.channels = s->avctx->channels = fi.channels;
 476         ff_flac_set_channel_layout(s->avctx);
 477         ret = allocate_buffers(s);
 478         if (ret < 0)
 479             return ret;
 480     }
 481     s->flac_stream_info.channels = s->avctx->channels = fi.channels;
 482     if (!s->avctx->channel_layout)
 483         ff_flac_set_channel_layout(s->avctx);
 484     s->ch_mode = fi.ch_mode;
 485
 486     if (!s->flac_stream_info.bps && !fi.bps) {
 487         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
 488         return AVERROR_INVALIDDATA;
 489     }
 490     if (!fi.bps) {
 491         fi.bps = s->flac_stream_info.bps;
 492     } else if (s->flac_stream_info.bps && fi.bps != s->flac_stream_info.bps) {
 493         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
 494                                        "supported\n");
 495         return AVERROR_INVALIDDATA;
 496     }
 497
 498     if (!s->flac_stream_info.bps) {
 499         s->flac_stream_info.bps = s->avctx->bits_per_raw_sample = fi.bps;
 500         flac_set_bps(s);
 501     }
 502
 503     if (!s->flac_stream_info.max_blocksize)
 504         s->flac_stream_info.max_blocksize = FLAC_MAX_BLOCKSIZE;
 505     if (fi.blocksize > s->flac_stream_info.max_blocksize) {
 506         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
 507                s->flac_stream_info.max_blocksize);
 508         return AVERROR_INVALIDDATA;
 509     }
 510     s->blocksize = fi.blocksize;
 511
 512     if (!s->flac_stream_info.samplerate && !fi.samplerate) {
 513         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
 514                                         " or frame header\n");
 515         return AVERROR_INVALIDDATA;
 516     }
 517     if (fi.samplerate == 0)
 518         fi.samplerate = s->flac_stream_info.samplerate;
 519     s->flac_stream_info.samplerate = s->avctx->sample_rate = fi.samplerate;
 520
 521     if (!s->got_streaminfo) {
 522         ret = allocate_buffers(s);
 523         if (ret < 0)
 524             return ret;
 525         s->got_streaminfo = 1;
 526         dump_headers(s->avctx, &s->flac_stream_info);
 527     }
 528     ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt,
 529                     s->flac_stream_info.channels, s->flac_stream_info.bps);
 530
 531 //    dump_headers(s->avctx, &s->flac_stream_info);
 532
 533     /* subframes */
 534     for (i = 0; i < s->flac_stream_info.channels; i++) {
 535         if ((ret = decode_subframe(s, i)) < 0)
 536             return ret;
 537     }
 538
 539     align_get_bits(gb);
 540
 541     /* frame footer */
 542     skip_bits(gb, 16); /* data crc */
 543
 544     return 0;
 545 }
 546
 547 static int flac_decode_frame(AVCodecContext *avctx, void *data,
 548                              int *got_frame_ptr, AVPacket *avpkt)
 549 {
 550     AVFrame *frame     = data;
 551     ThreadFrame tframe = { .f = data };
 552     const uint8_t *buf = avpkt->data;
 553     int buf_size = avpkt->size;
 554     FLACContext *s = avctx->priv_data;
 555     int bytes_read = 0;
 556     int ret;
 557
 558     *got_frame_ptr = 0;
 559
 560     if (s->flac_stream_info.max_framesize == 0) {
 561         s->flac_stream_info.max_framesize =
 562             ff_flac_get_max_frame_size(s->flac_stream_info.max_blocksize ? s->flac_stream_info.max_blocksize : FLAC_MAX_BLOCKSIZE,
 563                                        FLAC_MAX_CHANNELS, 32);
 564     }
 565
 566     if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
 567         av_log(s->avctx, AV_LOG_DEBUG, "skipping flac header packet 1\n");
 568         return buf_size;
 569     }
 570
 571     if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
 572         av_log(s->avctx, AV_LOG_DEBUG, "skipping vorbis comment\n");
 573         return buf_size;
 574     }
 575
 576     /* check that there is at least the smallest decodable amount of data.
 577        this amount corresponds to the smallest valid FLAC frame possible.
 578        FF F8 69 02 00 00 9A 00 00 34 46 */
 579     if (buf_size < FLAC_MIN_FRAME_SIZE)
 580         return buf_size;
 581
 582     /* check for inline header */
 583     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
 584         if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
 585             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
 586             return ret;
 587         }
 588         return get_metadata_size(buf, buf_size);
 589     }
 590
 591     /* decode frame */
 592     if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
 593         return ret;
 594     if ((ret = decode_frame(s)) < 0) {
 595         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
 596         return ret;
 597     }
 598     bytes_read = get_bits_count(&s->gb)/8;
 599
 600     if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
 601         av_crc(av_crc_get_table(AV_CRC_16_ANSI),
 602                0, buf, bytes_read)) {
 603         av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
 604         if (s->avctx->err_recognition & AV_EF_EXPLODE)
 605             return AVERROR_INVALIDDATA;
 606     }
 607
 608     /* get output buffer */
 609     frame->nb_samples = s->blocksize;
 610     if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
 611         return ret;
 612
 613     s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded,
 614                                    s->flac_stream_info.channels,
 615                                    s->blocksize, s->sample_shift);
 616
 617     if (bytes_read > buf_size) {
 618         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
 619         return AVERROR_INVALIDDATA;
 620     }
 621     if (bytes_read < buf_size) {
 622         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
 623                buf_size - bytes_read, buf_size);
 624     }
 625
 626     *got_frame_ptr = 1;
 627
 628     return bytes_read;
 629 }
 630
 631 #if HAVE_THREADS
 632 static int init_thread_copy(AVCodecContext *avctx)
 633 {
 634     FLACContext *s = avctx->priv_data;
 635     s->decoded_buffer = NULL;
 636     s->decoded_buffer_size = 0;
 637     s->avctx = avctx;
 638     if (s->flac_stream_info.max_blocksize)
 639         return allocate_buffers(s);
 640     return 0;
 641 }
 642 #endif
 643
 644 static av_cold int flac_decode_close(AVCodecContext *avctx)
 645 {
 646     FLACContext *s = avctx->priv_data;
 647
 648     av_freep(&s->decoded_buffer);
 649
 650     return 0;
 651 }
 652
 653 static const AVOption options[] = {
 654 { "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 },
 655 { NULL },
 656 };
 657
 658 static const AVClass flac_decoder_class = {
 659     "FLAC decoder",
 660     av_default_item_name,
 661     options,
 662     LIBAVUTIL_VERSION_INT,
 663 };
 664
 665 AVCodec ff_flac_decoder = {
 666     .name           = "flac",
 667     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
 668     .type           = AVMEDIA_TYPE_AUDIO,
 669     .id             = AV_CODEC_ID_FLAC,
 670     .priv_data_size = sizeof(FLACContext),
 671     .init           = flac_decode_init,
 672     .close          = flac_decode_close,
 673     .decode         = flac_decode_frame,
 674     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
 675     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
 676     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
 677                                                       AV_SAMPLE_FMT_S16P,
 678                                                       AV_SAMPLE_FMT_S32,
 679                                                       AV_SAMPLE_FMT_S32P,
 680                                                       AV_SAMPLE_FMT_NONE },
 681     .priv_class     = &flac_decoder_class,
 682 };