avcodec/wmaprodec: cleanup extradata dumping
[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                 *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 };