2 * FLAC (Free Lossless Audio Codec) decoder
3 * Copyright (c) 2003 Alex Beregszaszi
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * FLAC (Free Lossless Audio Codec) decoder
23 * @author Alex Beregszaszi
25 * For more information on the FLAC format, visit:
26 * http://flac.sourceforge.net/
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.
37 #include "bitstream.h"
43 #define MAX_CHANNELS 8
44 #define MAX_BLOCKSIZE 65535
45 #define FLAC_STREAMINFO_SIZE 34
47 enum decorrelation_type {
54 typedef struct FLACContext {
55 AVCodecContext *avctx;
58 int min_blocksize, max_blocksize;
59 int min_framesize, max_framesize;
60 int samplerate, channels;
61 int blocksize/*, last_blocksize*/;
63 enum decorrelation_type decorrelation;
65 int32_t *decoded[MAX_CHANNELS];
69 int allocated_bitstream_size;
72 #define METADATA_TYPE_STREAMINFO 0
74 static int sample_rate_table[] =
76 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
79 static int sample_size_table[] =
80 { 0, 8, 12, 0, 16, 20, 24, 0 };
82 static int blocksize_table[] = {
83 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0,
84 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
87 static const uint8_t table_crc8[256] = {
88 0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
89 0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
90 0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
91 0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
92 0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
93 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
94 0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
95 0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
96 0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
97 0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
98 0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
99 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
100 0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
101 0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
102 0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
103 0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
104 0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
105 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
106 0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
107 0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
108 0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
109 0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
110 0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
111 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
112 0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
113 0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
114 0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
115 0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
116 0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
117 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
118 0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
119 0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
122 static int64_t get_utf8(GetBitContext *gb)
130 if (ones==0) bytes=0;
131 else if(ones==1) return -1;
132 else bytes= ones - 1;
134 val= get_bits(gb, 7-ones);
136 const int tmp = get_bits(gb, 8);
147 static int skip_utf8(GetBitContext *gb)
154 if (ones==0) bytes=0;
155 else if(ones==1) return -1;
156 else bytes= ones - 1;
158 skip_bits(gb, 7-ones);
160 const int tmp = get_bits(gb, 8);
169 static int get_crc8(const uint8_t *buf, int count){
173 for(i=0; i<count; i++){
174 crc = table_crc8[crc ^ buf[i]];
180 static void metadata_streaminfo(FLACContext *s);
181 static void dump_headers(FLACContext *s);
183 static int flac_decode_init(AVCodecContext * avctx)
185 FLACContext *s = avctx->priv_data;
188 /* initialize based on the demuxer-supplied streamdata header */
189 if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
190 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
191 metadata_streaminfo(s);
198 static void dump_headers(FLACContext *s)
200 av_log(s->avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
201 av_log(s->avctx, AV_LOG_DEBUG, " Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
202 av_log(s->avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
203 av_log(s->avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
204 av_log(s->avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
207 static void allocate_buffers(FLACContext *s){
210 assert(s->max_blocksize);
212 if(s->max_framesize == 0 && s->max_blocksize){
213 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
216 for (i = 0; i < s->channels; i++)
218 s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
221 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
224 static void metadata_streaminfo(FLACContext *s)
226 /* mandatory streaminfo */
227 s->min_blocksize = get_bits(&s->gb, 16);
228 s->max_blocksize = get_bits(&s->gb, 16);
230 s->min_framesize = get_bits_long(&s->gb, 24);
231 s->max_framesize = get_bits_long(&s->gb, 24);
233 s->samplerate = get_bits_long(&s->gb, 20);
234 s->channels = get_bits(&s->gb, 3) + 1;
235 s->bps = get_bits(&s->gb, 5) + 1;
237 s->avctx->channels = s->channels;
238 s->avctx->sample_rate = s->samplerate;
240 skip_bits(&s->gb, 36); /* total num of samples */
242 skip_bits(&s->gb, 64); /* md5 sum */
243 skip_bits(&s->gb, 64); /* md5 sum */
248 static int decode_residuals(FLACContext *s, int channel, int pred_order)
250 int i, tmp, partition, method_type, rice_order;
251 int sample = 0, samples;
253 method_type = get_bits(&s->gb, 2);
254 if (method_type != 0){
255 av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
259 rice_order = get_bits(&s->gb, 4);
261 samples= s->blocksize >> rice_order;
265 for (partition = 0; partition < (1 << rice_order); partition++)
267 tmp = get_bits(&s->gb, 4);
270 av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
271 tmp = get_bits(&s->gb, 5);
272 for (; i < samples; i++, sample++)
273 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
277 // av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
278 for (; i < samples; i++, sample++){
279 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
285 // av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
290 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
294 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME FIXED\n");
296 /* warm up samples */
297 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
299 for (i = 0; i < pred_order; i++)
301 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
302 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]);
305 if (decode_residuals(s, channel, pred_order) < 0)
313 for (i = pred_order; i < s->blocksize; i++)
314 s->decoded[channel][i] += s->decoded[channel][i-1];
317 for (i = pred_order; i < s->blocksize; i++)
318 s->decoded[channel][i] += 2*s->decoded[channel][i-1]
319 - s->decoded[channel][i-2];
322 for (i = pred_order; i < s->blocksize; i++)
323 s->decoded[channel][i] += 3*s->decoded[channel][i-1]
324 - 3*s->decoded[channel][i-2]
325 + s->decoded[channel][i-3];
328 for (i = pred_order; i < s->blocksize; i++)
329 s->decoded[channel][i] += 4*s->decoded[channel][i-1]
330 - 6*s->decoded[channel][i-2]
331 + 4*s->decoded[channel][i-3]
332 - s->decoded[channel][i-4];
335 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
342 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
345 int coeff_prec, qlevel;
346 int coeffs[pred_order];
348 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME LPC\n");
350 /* warm up samples */
351 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
353 for (i = 0; i < pred_order; i++)
355 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
356 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]);
359 coeff_prec = get_bits(&s->gb, 4) + 1;
360 if (coeff_prec == 16)
362 av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
365 // av_log(s->avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec);
366 qlevel = get_sbits(&s->gb, 5);
367 // av_log(s->avctx, AV_LOG_DEBUG, " quant level: %d\n", qlevel);
369 av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
373 for (i = 0; i < pred_order; i++)
375 coeffs[i] = get_sbits(&s->gb, coeff_prec);
376 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, coeffs[i]);
379 if (decode_residuals(s, channel, pred_order) < 0)
382 for (i = pred_order; i < s->blocksize; i++)
385 for (j = 0; j < pred_order; j++)
386 sum += coeffs[j] * s->decoded[channel][i-j-1];
387 s->decoded[channel][i] += sum >> qlevel;
393 static inline int decode_subframe(FLACContext *s, int channel)
395 int type, wasted = 0;
398 s->curr_bps = s->bps;
400 if(s->decorrelation == RIGHT_SIDE)
403 if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
407 if (get_bits1(&s->gb))
409 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
412 type = get_bits(&s->gb, 6);
413 // wasted = get_bits1(&s->gb);
417 // while (!get_bits1(&s->gb))
421 // s->curr_bps -= wasted;
424 wasted= 16 - av_log2(show_bits(&s->gb, 17));
425 skip_bits(&s->gb, wasted+1);
426 s->curr_bps -= wasted;
428 if (get_bits1(&s->gb))
431 while (!get_bits1(&s->gb))
433 s->curr_bps -= wasted;
434 av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
437 //FIXME use av_log2 for types
440 av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
441 tmp = get_sbits(&s->gb, s->curr_bps);
442 for (i = 0; i < s->blocksize; i++)
443 s->decoded[channel][i] = tmp;
447 av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
448 for (i = 0; i < s->blocksize; i++)
449 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
451 else if ((type >= 8) && (type <= 12))
453 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
454 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
459 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
460 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
465 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
472 for (i = 0; i < s->blocksize; i++)
473 s->decoded[channel][i] <<= wasted;
479 static int decode_frame(FLACContext *s)
481 int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
482 int decorrelation, bps, blocksize, samplerate;
484 blocksize_code = get_bits(&s->gb, 4);
486 sample_rate_code = get_bits(&s->gb, 4);
488 assignment = get_bits(&s->gb, 4); /* channel assignment */
489 if (assignment < 8 && s->channels == assignment+1)
490 decorrelation = INDEPENDENT;
491 else if (assignment >=8 && assignment < 11 && s->channels == 2)
492 decorrelation = LEFT_SIDE + assignment - 8;
495 av_log(s->avctx, AV_LOG_ERROR, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
499 sample_size_code = get_bits(&s->gb, 3);
500 if(sample_size_code == 0)
502 else if((sample_size_code != 3) && (sample_size_code != 7))
503 bps = sample_size_table[sample_size_code];
506 av_log(s->avctx, AV_LOG_ERROR, "invalid sample size code (%d)\n", sample_size_code);
510 if (get_bits1(&s->gb))
512 av_log(s->avctx, AV_LOG_ERROR, "broken stream, invalid padding\n");
516 if(get_utf8(&s->gb) < 0){
517 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
521 if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
522 (s->min_blocksize != s->max_blocksize)){
527 if (blocksize_code == 0)
528 blocksize = s->min_blocksize;
529 else if (blocksize_code == 6)
530 blocksize = get_bits(&s->gb, 8)+1;
531 else if (blocksize_code == 7)
532 blocksize = get_bits(&s->gb, 16)+1;
534 blocksize = blocksize_table[blocksize_code];
536 if(blocksize > s->max_blocksize){
537 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
541 if (sample_rate_code == 0){
542 samplerate= s->samplerate;
543 }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
544 samplerate = sample_rate_table[sample_rate_code];
545 else if (sample_rate_code == 12)
546 samplerate = get_bits(&s->gb, 8) * 1000;
547 else if (sample_rate_code == 13)
548 samplerate = get_bits(&s->gb, 16);
549 else if (sample_rate_code == 14)
550 samplerate = get_bits(&s->gb, 16) * 10;
552 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
556 skip_bits(&s->gb, 8);
557 crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
559 av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
563 s->blocksize = blocksize;
564 s->samplerate = samplerate;
566 s->decorrelation= decorrelation;
571 for (i = 0; i < s->channels; i++)
573 // av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
574 if (decode_subframe(s, i) < 0)
578 align_get_bits(&s->gb);
581 skip_bits(&s->gb, 16); /* data crc */
586 static int flac_decode_frame(AVCodecContext *avctx,
587 void *data, int *data_size,
588 uint8_t *buf, int buf_size)
590 FLACContext *s = avctx->priv_data;
591 int metadata_last, metadata_type, metadata_size;
592 int tmp = 0, i, j = 0, input_buf_size = 0;
593 int16_t *samples = data;
595 if(s->max_framesize == 0){
596 s->max_framesize= 65536; // should hopefully be enough for the first header
597 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
600 if(1 && s->max_framesize){//FIXME truncated
601 buf_size= FFMAX(FFMIN(buf_size, s->max_framesize - s->bitstream_size), 0);
602 input_buf_size= buf_size;
604 if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
605 // printf("memmove\n");
606 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
607 s->bitstream_index=0;
609 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
610 buf= &s->bitstream[s->bitstream_index];
611 buf_size += s->bitstream_size;
612 s->bitstream_size= buf_size;
614 if(buf_size < s->max_framesize){
615 // printf("wanna more data ...\n");
616 return input_buf_size;
620 init_get_bits(&s->gb, buf, buf_size*8);
622 /* fLaC signature (be) */
623 if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
625 skip_bits(&s->gb, 32);
627 av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
629 metadata_last = get_bits(&s->gb, 1);
630 metadata_type = get_bits(&s->gb, 7);
631 metadata_size = get_bits_long(&s->gb, 24);
633 av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
634 metadata_last, metadata_type,
637 switch(metadata_type)
639 case METADATA_TYPE_STREAMINFO:{
640 metadata_streaminfo(s);
642 /* Buffer might have been reallocated, reinit bitreader */
643 if(buf != &s->bitstream[s->bitstream_index])
645 int bits_count = get_bits_count(&s->gb);
646 buf= &s->bitstream[s->bitstream_index];
647 init_get_bits(&s->gb, buf, buf_size*8);
648 skip_bits(&s->gb, bits_count);
654 for(i=0; i<metadata_size; i++)
655 skip_bits(&s->gb, 8);
658 } while(!metadata_last);
663 tmp = show_bits(&s->gb, 16);
665 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
666 while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
667 skip_bits(&s->gb, 8);
668 goto end; // we may not have enough bits left to decode a frame, so try next time
670 skip_bits(&s->gb, 16);
671 if (decode_frame(s) < 0){
672 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
674 s->bitstream_index=0;
681 /* fix the channel order here */
682 if (s->order == MID_SIDE)
684 short *left = samples;
685 short *right = samples + s->blocksize;
686 for (i = 0; i < s->blocksize; i += 2)
688 uint32_t x = s->decoded[0][i];
689 uint32_t y = s->decoded[0][i+1];
691 right[i] = x - (y / 2);
692 left[i] = right[i] + y;
694 *data_size = 2 * s->blocksize;
698 for (i = 0; i < s->channels; i++)
703 for (j = 0; j < s->blocksize; j++)
704 samples[(s->blocksize*i)+j] = s->decoded[i][j];
709 for (j = 0; j < s->blocksize; j++)
710 samples[(s->blocksize*i)+j] = s->decoded[0][j];
712 for (j = 0; j < s->blocksize; j++)
713 samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
716 // av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
718 *data_size += s->blocksize;
722 switch(s->decorrelation)
725 for (j = 0; j < s->blocksize; j++)
727 for (i = 0; i < s->channels; i++)
728 *(samples++) = s->decoded[i][j];
732 assert(s->channels == 2);
733 for (i = 0; i < s->blocksize; i++)
735 *(samples++) = s->decoded[0][i];
736 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
740 assert(s->channels == 2);
741 for (i = 0; i < s->blocksize; i++)
743 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
744 *(samples++) = s->decoded[1][i];
748 assert(s->channels == 2);
749 for (i = 0; i < s->blocksize; i++)
752 mid = s->decoded[0][i];
753 side = s->decoded[1][i];
755 #if 1 //needs to be checked but IMHO it should be binary identical
757 *(samples++) = mid + side;
764 *(samples++) = (mid + side) >> 1;
765 *(samples++) = (mid - side) >> 1;
772 *data_size = (int8_t *)samples - (int8_t *)data;
773 // av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
775 // s->last_blocksize = s->blocksize;
777 i= (get_bits_count(&s->gb)+7)/8;;
779 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
781 s->bitstream_index=0;
785 if(s->bitstream_size){
786 s->bitstream_index += i;
787 s->bitstream_size -= i;
788 return input_buf_size;
793 static int flac_decode_close(AVCodecContext *avctx)
795 FLACContext *s = avctx->priv_data;
798 for (i = 0; i < s->channels; i++)
800 av_freep(&s->decoded[i]);
802 av_freep(&s->bitstream);
807 static void flac_flush(AVCodecContext *avctx){
808 FLACContext *s = avctx->priv_data;
811 s->bitstream_index= 0;
814 AVCodec flac_decoder = {