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);
146 static int skip_utf8(GetBitContext *gb)
153 if (ones==0) bytes=0;
154 else if(ones==1) return -1;
155 else bytes= ones - 1;
157 skip_bits(gb, 7-ones);
159 const int tmp = get_bits(gb, 8);
167 static int get_crc8(const uint8_t *buf, int count){
171 for(i=0; i<count; i++){
172 crc = table_crc8[crc ^ buf[i]];
178 static void metadata_streaminfo(FLACContext *s);
179 static void dump_headers(FLACContext *s);
181 static int flac_decode_init(AVCodecContext * avctx)
183 FLACContext *s = avctx->priv_data;
186 /* initialize based on the demuxer-supplied streamdata header */
187 if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
188 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
189 metadata_streaminfo(s);
196 static void dump_headers(FLACContext *s)
198 av_log(s->avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
199 av_log(s->avctx, AV_LOG_DEBUG, " Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
200 av_log(s->avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
201 av_log(s->avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
202 av_log(s->avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
205 static void allocate_buffers(FLACContext *s){
208 assert(s->max_blocksize);
210 if(s->max_framesize == 0 && s->max_blocksize){
211 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
214 for (i = 0; i < s->channels; i++)
216 s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
219 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
222 static void metadata_streaminfo(FLACContext *s)
224 /* mandatory streaminfo */
225 s->min_blocksize = get_bits(&s->gb, 16);
226 s->max_blocksize = get_bits(&s->gb, 16);
228 s->min_framesize = get_bits_long(&s->gb, 24);
229 s->max_framesize = get_bits_long(&s->gb, 24);
231 s->samplerate = get_bits_long(&s->gb, 20);
232 s->channels = get_bits(&s->gb, 3) + 1;
233 s->bps = get_bits(&s->gb, 5) + 1;
235 s->avctx->channels = s->channels;
236 s->avctx->sample_rate = s->samplerate;
238 skip_bits(&s->gb, 36); /* total num of samples */
240 skip_bits(&s->gb, 64); /* md5 sum */
241 skip_bits(&s->gb, 64); /* md5 sum */
246 static int decode_residuals(FLACContext *s, int channel, int pred_order)
248 int i, tmp, partition, method_type, rice_order;
249 int sample = 0, samples;
251 method_type = get_bits(&s->gb, 2);
252 if (method_type != 0){
253 av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
257 rice_order = get_bits(&s->gb, 4);
259 samples= s->blocksize >> rice_order;
263 for (partition = 0; partition < (1 << rice_order); partition++)
265 tmp = get_bits(&s->gb, 4);
268 av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
269 tmp = get_bits(&s->gb, 5);
270 for (; i < samples; i++, sample++)
271 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
275 // av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
276 for (; i < samples; i++, sample++){
277 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
283 // av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
288 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
292 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME FIXED\n");
294 /* warm up samples */
295 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
297 for (i = 0; i < pred_order; i++)
299 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
300 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]);
303 if (decode_residuals(s, channel, pred_order) < 0)
311 for (i = pred_order; i < s->blocksize; i++)
312 s->decoded[channel][i] += s->decoded[channel][i-1];
315 for (i = pred_order; i < s->blocksize; i++)
316 s->decoded[channel][i] += 2*s->decoded[channel][i-1]
317 - s->decoded[channel][i-2];
320 for (i = pred_order; i < s->blocksize; i++)
321 s->decoded[channel][i] += 3*s->decoded[channel][i-1]
322 - 3*s->decoded[channel][i-2]
323 + s->decoded[channel][i-3];
326 for (i = pred_order; i < s->blocksize; i++)
327 s->decoded[channel][i] += 4*s->decoded[channel][i-1]
328 - 6*s->decoded[channel][i-2]
329 + 4*s->decoded[channel][i-3]
330 - s->decoded[channel][i-4];
333 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
340 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
343 int coeff_prec, qlevel;
344 int coeffs[pred_order];
346 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME LPC\n");
348 /* warm up samples */
349 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
351 for (i = 0; i < pred_order; i++)
353 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
354 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]);
357 coeff_prec = get_bits(&s->gb, 4) + 1;
358 if (coeff_prec == 16)
360 av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
363 // av_log(s->avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec);
364 qlevel = get_sbits(&s->gb, 5);
365 // av_log(s->avctx, AV_LOG_DEBUG, " quant level: %d\n", qlevel);
367 av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
371 for (i = 0; i < pred_order; i++)
373 coeffs[i] = get_sbits(&s->gb, coeff_prec);
374 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, coeffs[i]);
377 if (decode_residuals(s, channel, pred_order) < 0)
380 for (i = pred_order; i < s->blocksize; i++)
383 for (j = 0; j < pred_order; j++)
384 sum += coeffs[j] * s->decoded[channel][i-j-1];
385 s->decoded[channel][i] += sum >> qlevel;
391 static inline int decode_subframe(FLACContext *s, int channel)
393 int type, wasted = 0;
396 s->curr_bps = s->bps;
398 if(s->decorrelation == RIGHT_SIDE)
401 if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
405 if (get_bits1(&s->gb))
407 av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
410 type = get_bits(&s->gb, 6);
411 // wasted = get_bits1(&s->gb);
415 // while (!get_bits1(&s->gb))
419 // s->curr_bps -= wasted;
422 wasted= 16 - av_log2(show_bits(&s->gb, 17));
423 skip_bits(&s->gb, wasted+1);
424 s->curr_bps -= wasted;
426 if (get_bits1(&s->gb))
429 while (!get_bits1(&s->gb))
431 s->curr_bps -= wasted;
432 av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
435 //FIXME use av_log2 for types
438 av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
439 tmp = get_sbits(&s->gb, s->curr_bps);
440 for (i = 0; i < s->blocksize; i++)
441 s->decoded[channel][i] = tmp;
445 av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
446 for (i = 0; i < s->blocksize; i++)
447 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
449 else if ((type >= 8) && (type <= 12))
451 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
452 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
457 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
458 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
463 av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
470 for (i = 0; i < s->blocksize; i++)
471 s->decoded[channel][i] <<= wasted;
477 static int decode_frame(FLACContext *s)
479 int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
480 int decorrelation, bps, blocksize, samplerate;
482 blocksize_code = get_bits(&s->gb, 4);
484 sample_rate_code = get_bits(&s->gb, 4);
486 assignment = get_bits(&s->gb, 4); /* channel assignment */
487 if (assignment < 8 && s->channels == assignment+1)
488 decorrelation = INDEPENDENT;
489 else if (assignment >=8 && assignment < 11 && s->channels == 2)
490 decorrelation = LEFT_SIDE + assignment - 8;
493 av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
497 sample_size_code = get_bits(&s->gb, 3);
498 if(sample_size_code == 0)
500 else if((sample_size_code != 3) && (sample_size_code != 7))
501 bps = sample_size_table[sample_size_code];
504 av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
508 if (get_bits1(&s->gb))
510 av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
514 if(get_utf8(&s->gb) < 0){
515 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
519 if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
520 (s->min_blocksize != s->max_blocksize)){
525 if (blocksize_code == 0)
526 blocksize = s->min_blocksize;
527 else if (blocksize_code == 6)
528 blocksize = get_bits(&s->gb, 8)+1;
529 else if (blocksize_code == 7)
530 blocksize = get_bits(&s->gb, 16)+1;
532 blocksize = blocksize_table[blocksize_code];
534 if(blocksize > s->max_blocksize){
535 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
539 if (sample_rate_code == 0){
540 samplerate= s->samplerate;
541 }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
542 samplerate = sample_rate_table[sample_rate_code];
543 else if (sample_rate_code == 12)
544 samplerate = get_bits(&s->gb, 8) * 1000;
545 else if (sample_rate_code == 13)
546 samplerate = get_bits(&s->gb, 16);
547 else if (sample_rate_code == 14)
548 samplerate = get_bits(&s->gb, 16) * 10;
550 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
554 skip_bits(&s->gb, 8);
555 crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
557 av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
561 s->blocksize = blocksize;
562 s->samplerate = samplerate;
564 s->decorrelation= decorrelation;
569 for (i = 0; i < s->channels; i++)
571 // av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
572 if (decode_subframe(s, i) < 0)
576 align_get_bits(&s->gb);
579 skip_bits(&s->gb, 16); /* data crc */
584 static int flac_decode_frame(AVCodecContext *avctx,
585 void *data, int *data_size,
586 uint8_t *buf, int buf_size)
588 FLACContext *s = avctx->priv_data;
589 int metadata_last, metadata_type, metadata_size;
590 int tmp = 0, i, j = 0, input_buf_size = 0;
591 int16_t *samples = data;
593 if(s->max_framesize == 0){
594 s->max_framesize= 8192; // should hopefully be enough for the first header
595 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
598 if(1 && s->max_framesize){//FIXME truncated
599 buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
600 input_buf_size= buf_size;
602 if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
603 // printf("memmove\n");
604 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
605 s->bitstream_index=0;
607 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
608 buf= &s->bitstream[s->bitstream_index];
609 buf_size += s->bitstream_size;
610 s->bitstream_size= buf_size;
612 if(buf_size < s->max_framesize){
613 // printf("wanna more data ...\n");
614 return input_buf_size;
618 init_get_bits(&s->gb, buf, buf_size*8);
620 /* fLaC signature (be) */
621 if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
623 skip_bits(&s->gb, 32);
625 av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
627 metadata_last = get_bits(&s->gb, 1);
628 metadata_type = get_bits(&s->gb, 7);
629 metadata_size = get_bits_long(&s->gb, 24);
631 av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
632 metadata_last, metadata_type,
635 switch(metadata_type)
637 case METADATA_TYPE_STREAMINFO:
638 metadata_streaminfo(s);
642 for(i=0; i<metadata_size; i++)
643 skip_bits(&s->gb, 8);
646 } while(!metadata_last);
651 tmp = show_bits(&s->gb, 16);
653 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
654 while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
655 skip_bits(&s->gb, 8);
656 goto end; // we may not have enough bits left to decode a frame, so try next time
658 skip_bits(&s->gb, 16);
659 if (decode_frame(s) < 0){
660 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
662 s->bitstream_index=0;
669 /* fix the channel order here */
670 if (s->order == MID_SIDE)
672 short *left = samples;
673 short *right = samples + s->blocksize;
674 for (i = 0; i < s->blocksize; i += 2)
676 uint32_t x = s->decoded[0][i];
677 uint32_t y = s->decoded[0][i+1];
679 right[i] = x - (y / 2);
680 left[i] = right[i] + y;
682 *data_size = 2 * s->blocksize;
686 for (i = 0; i < s->channels; i++)
691 for (j = 0; j < s->blocksize; j++)
692 samples[(s->blocksize*i)+j] = s->decoded[i][j];
697 for (j = 0; j < s->blocksize; j++)
698 samples[(s->blocksize*i)+j] = s->decoded[0][j];
700 for (j = 0; j < s->blocksize; j++)
701 samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
704 // av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
706 *data_size += s->blocksize;
710 switch(s->decorrelation)
713 for (j = 0; j < s->blocksize; j++)
715 for (i = 0; i < s->channels; i++)
716 *(samples++) = s->decoded[i][j];
720 assert(s->channels == 2);
721 for (i = 0; i < s->blocksize; i++)
723 *(samples++) = s->decoded[0][i];
724 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
728 assert(s->channels == 2);
729 for (i = 0; i < s->blocksize; i++)
731 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
732 *(samples++) = s->decoded[1][i];
736 assert(s->channels == 2);
737 for (i = 0; i < s->blocksize; i++)
740 mid = s->decoded[0][i];
741 side = s->decoded[1][i];
743 #if 1 //needs to be checked but IMHO it should be binary identical
745 *(samples++) = mid + side;
752 *(samples++) = (mid + side) >> 1;
753 *(samples++) = (mid - side) >> 1;
760 *data_size = (int8_t *)samples - (int8_t *)data;
761 // av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
763 // s->last_blocksize = s->blocksize;
765 i= (get_bits_count(&s->gb)+7)/8;;
767 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
769 s->bitstream_index=0;
773 if(s->bitstream_size){
774 s->bitstream_index += i;
775 s->bitstream_size -= i;
776 return input_buf_size;
781 static int flac_decode_close(AVCodecContext *avctx)
783 FLACContext *s = avctx->priv_data;
786 for (i = 0; i < s->channels; i++)
788 av_freep(&s->decoded[i]);
790 av_freep(&s->bitstream);
795 static void flac_flush(AVCodecContext *avctx){
796 FLACContext *s = avctx->priv_data;
799 s->bitstream_index= 0;
802 AVCodec flac_decoder = {