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