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