flacdec: factor out code setting avctx->sample_fmt
[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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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/audioconvert.h"
37 #include "libavutil/crc.h"
38 #include "avcodec.h"
39 #include "internal.h"
40 #include "get_bits.h"
41 #include "bytestream.h"
42 #include "golomb.h"
43 #include "flac.h"
44 #include "flacdata.h"
45
46 #undef NDEBUG
47 #include <assert.h>
48
49 typedef struct FLACContext {
50     FLACSTREAMINFO
51
52     AVCodecContext *avctx;                  ///< parent AVCodecContext
53     AVFrame frame;
54     GetBitContext gb;                       ///< GetBitContext initialized to start at the current frame
55
56     int blocksize;                          ///< number of samples in the current frame
57     int sample_shift;                       ///< shift required to make output samples 16-bit or 32-bit
58     int is32;                               ///< flag to indicate if output should be 32-bit instead of 16-bit
59     int ch_mode;                            ///< channel decorrelation type in the current frame
60     int got_streaminfo;                     ///< indicates if the STREAMINFO has been read
61
62     int32_t *decoded[FLAC_MAX_CHANNELS];    ///< decoded samples
63 } FLACContext;
64
65 static const int64_t flac_channel_layouts[6] = {
66     AV_CH_LAYOUT_MONO,
67     AV_CH_LAYOUT_STEREO,
68     AV_CH_LAYOUT_SURROUND,
69     AV_CH_LAYOUT_QUAD,
70     AV_CH_LAYOUT_5POINT0,
71     AV_CH_LAYOUT_5POINT1
72 };
73
74 static void allocate_buffers(FLACContext *s);
75
76 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
77                                enum FLACExtradataFormat *format,
78                                uint8_t **streaminfo_start)
79 {
80     if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
81         av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
82         return 0;
83     }
84     if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
85         /* extradata contains STREAMINFO only */
86         if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
87             av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
88                    FLAC_STREAMINFO_SIZE-avctx->extradata_size);
89         }
90         *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
91         *streaminfo_start = avctx->extradata;
92     } else {
93         if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
94             av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
95             return 0;
96         }
97         *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
98         *streaminfo_start = &avctx->extradata[8];
99     }
100     return 1;
101 }
102
103 static void flac_set_bps(FLACContext *s)
104 {
105     if (s->bps > 16) {
106         s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
107         s->sample_shift = 32 - s->bps;
108         s->is32 = 1;
109     } else {
110         s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
111         s->sample_shift = 16 - s->bps;
112         s->is32 = 0;
113     }
114 }
115
116 static av_cold int flac_decode_init(AVCodecContext *avctx)
117 {
118     enum FLACExtradataFormat format;
119     uint8_t *streaminfo;
120     FLACContext *s = avctx->priv_data;
121     s->avctx = avctx;
122
123     /* for now, the raw FLAC header is allowed to be passed to the decoder as
124        frame data instead of extradata. */
125     if (!avctx->extradata)
126         return 0;
127
128     if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
129         return -1;
130
131     /* initialize based on the demuxer-supplied streamdata header */
132     avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
133     allocate_buffers(s);
134     flac_set_bps(s);
135     s->got_streaminfo = 1;
136
137     avcodec_get_frame_defaults(&s->frame);
138     avctx->coded_frame = &s->frame;
139
140     if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
141         avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
142
143     return 0;
144 }
145
146 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
147 {
148     av_log(avctx, AV_LOG_DEBUG, "  Max Blocksize: %d\n", s->max_blocksize);
149     av_log(avctx, AV_LOG_DEBUG, "  Max Framesize: %d\n", s->max_framesize);
150     av_log(avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
151     av_log(avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
152     av_log(avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
153 }
154
155 static void allocate_buffers(FLACContext *s)
156 {
157     int i;
158
159     assert(s->max_blocksize);
160
161     for (i = 0; i < s->channels; i++) {
162         s->decoded[i] = av_malloc(sizeof(int32_t)*s->max_blocksize);
163     }
164 }
165
166 void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
167                               const uint8_t *buffer)
168 {
169     GetBitContext gb;
170     init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
171
172     skip_bits(&gb, 16); /* skip min blocksize */
173     s->max_blocksize = get_bits(&gb, 16);
174     if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
175         av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
176                s->max_blocksize);
177         s->max_blocksize = 16;
178     }
179
180     skip_bits(&gb, 24); /* skip min frame size */
181     s->max_framesize = get_bits_long(&gb, 24);
182
183     s->samplerate = get_bits_long(&gb, 20);
184     s->channels = get_bits(&gb, 3) + 1;
185     s->bps = get_bits(&gb, 5) + 1;
186
187     avctx->channels = s->channels;
188     avctx->sample_rate = s->samplerate;
189     avctx->bits_per_raw_sample = s->bps;
190
191     s->samples  = get_bits_long(&gb, 32) << 4;
192     s->samples |= get_bits(&gb, 4);
193
194     skip_bits_long(&gb, 64); /* md5 sum */
195     skip_bits_long(&gb, 64); /* md5 sum */
196
197     dump_headers(avctx, s);
198 }
199
200 void avpriv_flac_parse_block_header(const uint8_t *block_header,
201                                 int *last, int *type, int *size)
202 {
203     int tmp = bytestream_get_byte(&block_header);
204     if (last)
205         *last = tmp & 0x80;
206     if (type)
207         *type = tmp & 0x7F;
208     if (size)
209         *size = bytestream_get_be24(&block_header);
210 }
211
212 /**
213  * Parse the STREAMINFO from an inline header.
214  * @param s the flac decoding context
215  * @param buf input buffer, starting with the "fLaC" marker
216  * @param buf_size buffer size
217  * @return non-zero if metadata is invalid
218  */
219 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
220 {
221     int metadata_type, metadata_size;
222
223     if (buf_size < FLAC_STREAMINFO_SIZE+8) {
224         /* need more data */
225         return 0;
226     }
227     avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
228     if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
229         metadata_size != FLAC_STREAMINFO_SIZE) {
230         return AVERROR_INVALIDDATA;
231     }
232     avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
233     allocate_buffers(s);
234     s->got_streaminfo = 1;
235
236     return 0;
237 }
238
239 /**
240  * Determine the size of an inline header.
241  * @param buf input buffer, starting with the "fLaC" marker
242  * @param buf_size buffer size
243  * @return number of bytes in the header, or 0 if more data is needed
244  */
245 static int get_metadata_size(const uint8_t *buf, int buf_size)
246 {
247     int metadata_last, metadata_size;
248     const uint8_t *buf_end = buf + buf_size;
249
250     buf += 4;
251     do {
252         if (buf_end - buf < 4)
253             return 0;
254         avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
255         buf += 4;
256         if (buf_end - buf < metadata_size) {
257             /* need more data in order to read the complete header */
258             return 0;
259         }
260         buf += metadata_size;
261     } while (!metadata_last);
262
263     return buf_size - (buf_end - buf);
264 }
265
266 static int decode_residuals(FLACContext *s, int channel, int pred_order)
267 {
268     int i, tmp, partition, method_type, rice_order;
269     int sample = 0, samples;
270
271     method_type = get_bits(&s->gb, 2);
272     if (method_type > 1) {
273         av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
274                method_type);
275         return -1;
276     }
277
278     rice_order = get_bits(&s->gb, 4);
279
280     samples= s->blocksize >> rice_order;
281     if (pred_order > samples) {
282         av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
283                pred_order, samples);
284         return -1;
285     }
286
287     sample=
288     i= pred_order;
289     for (partition = 0; partition < (1 << rice_order); partition++) {
290         tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
291         if (tmp == (method_type == 0 ? 15 : 31)) {
292             tmp = get_bits(&s->gb, 5);
293             for (; i < samples; i++, sample++)
294                 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
295         } else {
296             for (; i < samples; i++, sample++) {
297                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
298             }
299         }
300         i= 0;
301     }
302
303     return 0;
304 }
305
306 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order,
307                                  int bps)
308 {
309     const int blocksize = s->blocksize;
310     int32_t *decoded = s->decoded[channel];
311     int a, b, c, d, i;
312
313     /* warm up samples */
314     for (i = 0; i < pred_order; i++) {
315         decoded[i] = get_sbits_long(&s->gb, bps);
316     }
317
318     if (decode_residuals(s, channel, pred_order) < 0)
319         return -1;
320
321     if (pred_order > 0)
322         a = decoded[pred_order-1];
323     if (pred_order > 1)
324         b = a - decoded[pred_order-2];
325     if (pred_order > 2)
326         c = b - decoded[pred_order-2] + decoded[pred_order-3];
327     if (pred_order > 3)
328         d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
329
330     switch (pred_order) {
331     case 0:
332         break;
333     case 1:
334         for (i = pred_order; i < blocksize; i++)
335             decoded[i] = a += decoded[i];
336         break;
337     case 2:
338         for (i = pred_order; i < blocksize; i++)
339             decoded[i] = a += b += decoded[i];
340         break;
341     case 3:
342         for (i = pred_order; i < blocksize; i++)
343             decoded[i] = a += b += c += decoded[i];
344         break;
345     case 4:
346         for (i = pred_order; i < blocksize; i++)
347             decoded[i] = a += b += c += d += decoded[i];
348         break;
349     default:
350         av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
351         return -1;
352     }
353
354     return 0;
355 }
356
357 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order,
358                                int bps)
359 {
360     int i, j;
361     int coeff_prec, qlevel;
362     int coeffs[32];
363     int32_t *decoded = s->decoded[channel];
364
365     /* warm up samples */
366     for (i = 0; i < pred_order; i++) {
367         decoded[i] = get_sbits_long(&s->gb, bps);
368     }
369
370     coeff_prec = get_bits(&s->gb, 4) + 1;
371     if (coeff_prec == 16) {
372         av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
373         return -1;
374     }
375     qlevel = get_sbits(&s->gb, 5);
376     if (qlevel < 0) {
377         av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
378                qlevel);
379         return -1;
380     }
381
382     for (i = 0; i < pred_order; i++) {
383         coeffs[i] = get_sbits(&s->gb, coeff_prec);
384     }
385
386     if (decode_residuals(s, channel, pred_order) < 0)
387         return -1;
388
389     if (s->bps > 16) {
390         int64_t sum;
391         for (i = pred_order; i < s->blocksize; i++) {
392             sum = 0;
393             for (j = 0; j < pred_order; j++)
394                 sum += (int64_t)coeffs[j] * decoded[i-j-1];
395             decoded[i] += sum >> qlevel;
396         }
397     } else {
398         for (i = pred_order; i < s->blocksize-1; i += 2) {
399             int c;
400             int d = decoded[i-pred_order];
401             int s0 = 0, s1 = 0;
402             for (j = pred_order-1; j > 0; j--) {
403                 c = coeffs[j];
404                 s0 += c*d;
405                 d = decoded[i-j];
406                 s1 += c*d;
407             }
408             c = coeffs[0];
409             s0 += c*d;
410             d = decoded[i] += s0 >> qlevel;
411             s1 += c*d;
412             decoded[i+1] += s1 >> qlevel;
413         }
414         if (i < s->blocksize) {
415             int sum = 0;
416             for (j = 0; j < pred_order; j++)
417                 sum += coeffs[j] * decoded[i-j-1];
418             decoded[i] += sum >> qlevel;
419         }
420     }
421
422     return 0;
423 }
424
425 static inline int decode_subframe(FLACContext *s, int channel)
426 {
427     int type, wasted = 0;
428     int bps = s->bps;
429     int i, tmp;
430
431     if (channel == 0) {
432         if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
433             bps++;
434     } else {
435         if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
436             bps++;
437     }
438
439     if (get_bits1(&s->gb)) {
440         av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
441         return -1;
442     }
443     type = get_bits(&s->gb, 6);
444
445     if (get_bits1(&s->gb)) {
446         int left = get_bits_left(&s->gb);
447         wasted = 1;
448         if ( left < 0 ||
449             (left < bps && !show_bits_long(&s->gb, left)) ||
450                            !show_bits_long(&s->gb, bps)) {
451             av_log(s->avctx, AV_LOG_ERROR,
452                    "Invalid number of wasted bits > available bits (%d) - left=%d\n",
453                    bps, left);
454             return AVERROR_INVALIDDATA;
455         }
456         while (!get_bits1(&s->gb))
457             wasted++;
458         bps -= wasted;
459     }
460     if (bps > 32) {
461         av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
462         return -1;
463     }
464
465 //FIXME use av_log2 for types
466     if (type == 0) {
467         tmp = get_sbits_long(&s->gb, bps);
468         for (i = 0; i < s->blocksize; i++)
469             s->decoded[channel][i] = tmp;
470     } else if (type == 1) {
471         for (i = 0; i < s->blocksize; i++)
472             s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
473     } else if ((type >= 8) && (type <= 12)) {
474         if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
475             return -1;
476     } else if (type >= 32) {
477         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
478             return -1;
479     } else {
480         av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
481         return -1;
482     }
483
484     if (wasted) {
485         int i;
486         for (i = 0; i < s->blocksize; i++)
487             s->decoded[channel][i] <<= wasted;
488     }
489
490     return 0;
491 }
492
493 static int decode_frame(FLACContext *s)
494 {
495     int i;
496     GetBitContext *gb = &s->gb;
497     FLACFrameInfo fi;
498
499     if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
500         av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
501         return -1;
502     }
503
504     if (s->channels && fi.channels != s->channels) {
505         av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
506                                        "is not supported\n");
507         return -1;
508     }
509     s->channels = s->avctx->channels = fi.channels;
510     s->ch_mode = fi.ch_mode;
511
512     if (!s->bps && !fi.bps) {
513         av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
514         return -1;
515     }
516     if (!fi.bps) {
517         fi.bps = s->bps;
518     } else if (s->bps && fi.bps != s->bps) {
519         av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
520                                        "supported\n");
521         return -1;
522     }
523     s->bps = s->avctx->bits_per_raw_sample = fi.bps;
524
525     flac_set_bps(s);
526
527     if (!s->max_blocksize)
528         s->max_blocksize = FLAC_MAX_BLOCKSIZE;
529     if (fi.blocksize > s->max_blocksize) {
530         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
531                s->max_blocksize);
532         return -1;
533     }
534     s->blocksize = fi.blocksize;
535
536     if (!s->samplerate && !fi.samplerate) {
537         av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
538                                         " or frame header\n");
539         return -1;
540     }
541     if (fi.samplerate == 0) {
542         fi.samplerate = s->samplerate;
543     } else if (s->samplerate && fi.samplerate != s->samplerate) {
544         av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
545                s->samplerate, fi.samplerate);
546     }
547     s->samplerate = s->avctx->sample_rate = fi.samplerate;
548
549     if (!s->got_streaminfo) {
550         allocate_buffers(s);
551         s->got_streaminfo = 1;
552         dump_headers(s->avctx, (FLACStreaminfo *)s);
553     }
554
555 //    dump_headers(s->avctx, (FLACStreaminfo *)s);
556
557     /* subframes */
558     for (i = 0; i < s->channels; i++) {
559         if (decode_subframe(s, i) < 0)
560             return -1;
561     }
562
563     align_get_bits(gb);
564
565     /* frame footer */
566     skip_bits(gb, 16); /* data crc */
567
568     return 0;
569 }
570
571 static int flac_decode_frame(AVCodecContext *avctx, void *data,
572                              int *got_frame_ptr, AVPacket *avpkt)
573 {
574     const uint8_t *buf = avpkt->data;
575     int buf_size = avpkt->size;
576     FLACContext *s = avctx->priv_data;
577     int i, j = 0, bytes_read = 0;
578     int16_t *samples_16;
579     int32_t *samples_32;
580     int ret;
581
582     *got_frame_ptr = 0;
583
584     if (s->max_framesize == 0) {
585         s->max_framesize =
586             ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
587                                        FLAC_MAX_CHANNELS, 32);
588     }
589
590     /* check that there is at least the smallest decodable amount of data.
591        this amount corresponds to the smallest valid FLAC frame possible.
592        FF F8 69 02 00 00 9A 00 00 34 46 */
593     if (buf_size < FLAC_MIN_FRAME_SIZE)
594         return buf_size;
595
596     /* check for inline header */
597     if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
598         if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
599             av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
600             return -1;
601         }
602         return get_metadata_size(buf, buf_size);
603     }
604
605     /* decode frame */
606     init_get_bits(&s->gb, buf, buf_size*8);
607     if (decode_frame(s) < 0) {
608         av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
609         return -1;
610     }
611     bytes_read = (get_bits_count(&s->gb)+7)/8;
612
613     /* get output buffer */
614     s->frame.nb_samples = s->blocksize;
615     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
616         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
617         return ret;
618     }
619     samples_16 = (int16_t *)s->frame.data[0];
620     samples_32 = (int32_t *)s->frame.data[0];
621
622 #define DECORRELATE(left, right)\
623             assert(s->channels == 2);\
624             for (i = 0; i < s->blocksize; i++) {\
625                 int a= s->decoded[0][i];\
626                 int b= s->decoded[1][i];\
627                 if (s->is32) {\
628                     *samples_32++ = (left)  << s->sample_shift;\
629                     *samples_32++ = (right) << s->sample_shift;\
630                 } else {\
631                     *samples_16++ = (left)  << s->sample_shift;\
632                     *samples_16++ = (right) << s->sample_shift;\
633                 }\
634             }\
635             break;
636
637     switch (s->ch_mode) {
638     case FLAC_CHMODE_INDEPENDENT:
639         for (j = 0; j < s->blocksize; j++) {
640             for (i = 0; i < s->channels; i++) {
641                 if (s->is32)
642                     *samples_32++ = s->decoded[i][j] << s->sample_shift;
643                 else
644                     *samples_16++ = s->decoded[i][j] << s->sample_shift;
645             }
646         }
647         break;
648     case FLAC_CHMODE_LEFT_SIDE:
649         DECORRELATE(a,a-b)
650     case FLAC_CHMODE_RIGHT_SIDE:
651         DECORRELATE(a+b,b)
652     case FLAC_CHMODE_MID_SIDE:
653         DECORRELATE( (a-=b>>1) + b, a)
654     }
655
656     if (bytes_read > buf_size) {
657         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
658         return -1;
659     }
660     if (bytes_read < buf_size) {
661         av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
662                buf_size - bytes_read, buf_size);
663     }
664
665     *got_frame_ptr   = 1;
666     *(AVFrame *)data = s->frame;
667
668     return bytes_read;
669 }
670
671 static av_cold int flac_decode_close(AVCodecContext *avctx)
672 {
673     FLACContext *s = avctx->priv_data;
674     int i;
675
676     for (i = 0; i < s->channels; i++) {
677         av_freep(&s->decoded[i]);
678     }
679
680     return 0;
681 }
682
683 AVCodec ff_flac_decoder = {
684     .name           = "flac",
685     .type           = AVMEDIA_TYPE_AUDIO,
686     .id             = CODEC_ID_FLAC,
687     .priv_data_size = sizeof(FLACContext),
688     .init           = flac_decode_init,
689     .close          = flac_decode_close,
690     .decode         = flac_decode_frame,
691     .capabilities   = CODEC_CAP_DR1,
692     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
693 };