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