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