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