flacdec: factor out code setting avctx->sample_fmt
[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 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 };