17082e43284b264a194eed4f90f21f43dccc10e0
[ffmpeg.git] / libavcodec / flac.c
1 /*
2  * FLAC (Free Lossless Audio Codec) decoder
3  * Copyright (c) 2003 Alex Beregszaszi
4  *
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.
9  *
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.
14  *
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
18  */
19
20 /**
21  * @file flac.c
22  * FLAC (Free Lossless Audio Codec) decoder
23  * @author Alex Beregszaszi
24  *
25  * For more information on the FLAC format, visit:
26  *  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 "avcodec.h"
37 #include "bitstream.h"
38 #include "golomb.h"
39
40 #undef NDEBUG
41 #include <assert.h>
42
43 #define MAX_CHANNELS 8
44 #define MAX_BLOCKSIZE 65535
45 #define FLAC_STREAMINFO_SIZE 34
46
47 enum decorrelation_type {
48     INDEPENDENT,
49     LEFT_SIDE,
50     RIGHT_SIDE,
51     MID_SIDE,
52 };
53
54 typedef struct FLACContext {
55     AVCodecContext *avctx;
56     GetBitContext gb;
57
58     int min_blocksize, max_blocksize;
59     int min_framesize, max_framesize;
60     int samplerate, channels;
61     int blocksize/*, last_blocksize*/;
62     int bps, curr_bps;
63     enum decorrelation_type decorrelation;
64
65     int32_t *decoded[MAX_CHANNELS];
66     uint8_t *bitstream;
67     int bitstream_size;
68     int bitstream_index;
69     int allocated_bitstream_size;
70 } FLACContext;
71
72 #define METADATA_TYPE_STREAMINFO 0
73
74 static int sample_rate_table[] =
75 { 0, 0, 0, 0,
76   8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
77   0, 0, 0, 0 }; 
78
79 static int sample_size_table[] = 
80 { 0, 8, 12, 0, 16, 20, 24, 0 };
81
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 
85 };
86
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
120 };
121
122 static int64_t get_utf8(GetBitContext *gb)
123 {
124     uint64_t val;
125     int ones=0, bytes;
126     
127     while(get_bits1(gb))
128         ones++;
129
130     if     (ones==0) bytes=0;
131     else if(ones==1) return -1;
132     else             bytes= ones - 1;
133     
134     val= get_bits(gb, 7-ones);
135     while(bytes--){
136         const int tmp = get_bits(gb, 8);
137         
138         if((tmp>>6) != 2)
139             return -1;
140         val<<=6;
141         val|= tmp&0x3F;
142     }
143     return val;
144 }
145
146 #if 0
147 static int skip_utf8(GetBitContext *gb)
148 {
149     int ones=0, bytes;
150     
151     while(get_bits1(gb))
152         ones++;
153
154     if     (ones==0) bytes=0;
155     else if(ones==1) return -1;
156     else             bytes= ones - 1;
157     
158     skip_bits(gb, 7-ones);
159     while(bytes--){
160         const int tmp = get_bits(gb, 8);
161         
162         if((tmp>>6) != 2)
163             return -1;
164     }
165     return 0;
166 }
167 #endif
168
169 static int get_crc8(const uint8_t *buf, int count){
170     int crc=0;
171     int i;
172     
173     for(i=0; i<count; i++){
174         crc = table_crc8[crc ^ buf[i]];
175     }
176
177     return crc;
178 }
179
180 static void metadata_streaminfo(FLACContext *s);
181 static void dump_headers(FLACContext *s);
182
183 static int flac_decode_init(AVCodecContext * avctx)
184 {
185     FLACContext *s = avctx->priv_data;
186     s->avctx = avctx;
187
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);
192         dump_headers(s);
193     }
194
195     return 0;
196 }
197
198 static void dump_headers(FLACContext *s)
199 {
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);
205 }
206
207 static void allocate_buffers(FLACContext *s){
208     int i;
209
210     assert(s->max_blocksize);
211
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
214     }
215
216     for (i = 0; i < s->channels; i++)
217     {
218         s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
219     }
220
221     s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
222 }
223
224 static void metadata_streaminfo(FLACContext *s)
225 {
226     /* mandatory streaminfo */
227     s->min_blocksize = get_bits(&s->gb, 16);
228     s->max_blocksize = get_bits(&s->gb, 16);
229
230     s->min_framesize = get_bits_long(&s->gb, 24);
231     s->max_framesize = get_bits_long(&s->gb, 24);
232     
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;
236     
237     s->avctx->channels = s->channels;
238     s->avctx->sample_rate = s->samplerate;
239
240     skip_bits(&s->gb, 36); /* total num of samples */
241     
242     skip_bits(&s->gb, 64); /* md5 sum */
243     skip_bits(&s->gb, 64); /* md5 sum */
244     
245     allocate_buffers(s);
246 }
247
248 static int decode_residuals(FLACContext *s, int channel, int pred_order)
249 {
250     int i, tmp, partition, method_type, rice_order;
251     int sample = 0, samples;
252
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);
256         return -1;
257     }
258     
259     rice_order = get_bits(&s->gb, 4);
260
261     samples= s->blocksize >> rice_order;
262
263     sample= 
264     i= pred_order;
265     for (partition = 0; partition < (1 << rice_order); partition++)
266     {
267         tmp = get_bits(&s->gb, 4);
268         if (tmp == 15)
269         {
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);
274         }
275         else
276         {
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);
280             }
281         }
282         i= 0;
283     }
284
285 //    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
286
287     return 0;
288 }    
289
290 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
291 {
292     int i;
293         
294 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
295         
296     /* warm up samples */
297 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
298         
299     for (i = 0; i < pred_order; i++)
300     {
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]);
303     }
304     
305     if (decode_residuals(s, channel, pred_order) < 0)
306         return -1;
307
308     switch(pred_order)
309     {
310         case 0:
311             break;
312         case 1:
313             for (i = pred_order; i < s->blocksize; i++)
314                 s->decoded[channel][i] +=   s->decoded[channel][i-1];
315             break;
316         case 2:
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];
320             break;
321         case 3:
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];
326             break;
327         case 4:
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];
333             break;
334         default:
335             av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
336             return -1;
337     }
338
339     return 0;
340 }
341
342 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
343 {
344     int sum, i, j;
345     int coeff_prec, qlevel;
346     int coeffs[pred_order];
347         
348 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
349         
350     /* warm up samples */
351 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
352         
353     for (i = 0; i < pred_order; i++)
354     {
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]);
357     }
358     
359     coeff_prec = get_bits(&s->gb, 4) + 1;
360     if (coeff_prec == 16)
361     {
362         av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
363         return -1;
364     }
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);
368     if(qlevel < 0){
369         av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
370         return -1;
371     }
372
373     for (i = 0; i < pred_order; i++)
374     {
375         coeffs[i] = get_sbits(&s->gb, coeff_prec);
376 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
377     }
378     
379     if (decode_residuals(s, channel, pred_order) < 0)
380         return -1;
381
382     for (i = pred_order; i < s->blocksize; i++)
383     {
384         sum = 0;
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;
388     }
389     
390     return 0;
391 }
392
393 static inline int decode_subframe(FLACContext *s, int channel)
394 {
395     int type, wasted = 0;
396     int i, tmp;
397     
398     s->curr_bps = s->bps;
399     if(channel == 0){
400         if(s->decorrelation == RIGHT_SIDE)
401             s->curr_bps++;
402     }else{
403         if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
404             s->curr_bps++;
405     }
406
407     if (get_bits1(&s->gb))
408     {
409         av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
410         return -1;
411     }
412     type = get_bits(&s->gb, 6);
413 //    wasted = get_bits1(&s->gb);
414     
415 //    if (wasted)
416 //    {
417 //        while (!get_bits1(&s->gb))
418 //            wasted++;
419 //        if (wasted)
420 //            wasted++;
421 //        s->curr_bps -= wasted;
422 //    }
423 #if 0
424     wasted= 16 - av_log2(show_bits(&s->gb, 17));
425     skip_bits(&s->gb, wasted+1);
426     s->curr_bps -= wasted;
427 #else
428     if (get_bits1(&s->gb))
429     {
430         wasted = 1;
431         while (!get_bits1(&s->gb))
432             wasted++;
433         s->curr_bps -= wasted;
434         av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
435     }
436 #endif
437 //FIXME use av_log2 for types
438     if (type == 0)
439     {
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;
444     }
445     else if (type == 1)
446     {
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);
450     }
451     else if ((type >= 8) && (type <= 12))
452     {
453 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
454         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
455             return -1;
456     }
457     else if (type >= 32)
458     {
459 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
460         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
461             return -1;
462     }
463     else
464     {
465         av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
466         return -1;
467     }
468         
469     if (wasted)
470     {
471         int i;
472         for (i = 0; i < s->blocksize; i++)
473             s->decoded[channel][i] <<= wasted;
474     }
475
476     return 0;
477 }
478
479 static int decode_frame(FLACContext *s)
480 {
481     int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
482     int decorrelation, bps, blocksize, samplerate;
483     
484     blocksize_code = get_bits(&s->gb, 4);
485
486     sample_rate_code = get_bits(&s->gb, 4);
487     
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;
493     else
494     {
495         av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
496         return -1;
497     }
498         
499     sample_size_code = get_bits(&s->gb, 3);
500     if(sample_size_code == 0)
501         bps= s->bps;
502     else if((sample_size_code != 3) && (sample_size_code != 7))
503         bps = sample_size_table[sample_size_code];
504     else 
505     {
506         av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
507         return -1;
508     }
509
510     if (get_bits1(&s->gb))
511     {
512         av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
513         return -1;
514     }
515     
516     if(get_utf8(&s->gb) < 0){
517         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
518         return -1;
519     }
520 #if 0    
521     if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
522         (s->min_blocksize != s->max_blocksize)){
523     }else{
524     }
525 #endif
526     
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;
533     else 
534         blocksize = blocksize_table[blocksize_code];
535
536     if(blocksize > s->max_blocksize){
537         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
538         return -1;
539     }
540
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;
551     else{
552         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
553         return -1;
554     }
555
556     skip_bits(&s->gb, 8);
557     crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
558     if(crc8){
559         av_log(s->avctx, AV_LOG_ERROR, "header crc mismatch crc=%2X\n", crc8);
560         return -1;
561     }
562     
563     s->blocksize    = blocksize;
564     s->samplerate   = samplerate;
565     s->bps          = bps;
566     s->decorrelation= decorrelation;
567
568 //    dump_headers(s);
569
570     /* subframes */
571     for (i = 0; i < s->channels; i++)
572     {
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)
575             return -1;
576     }
577     
578     align_get_bits(&s->gb);
579
580     /* frame footer */
581     skip_bits(&s->gb, 16); /* data crc */
582
583     return 0;
584 }
585
586 static int flac_decode_frame(AVCodecContext *avctx,
587                             void *data, int *data_size,
588                             uint8_t *buf, int buf_size)
589 {
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;
594
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);
598     }
599
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;
603
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;
608             }
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;
613             
614             if(buf_size < s->max_framesize){
615 //                printf("wanna more data ...\n");
616                 return input_buf_size;
617             }
618     }
619
620     init_get_bits(&s->gb, buf, buf_size*8);
621     
622     /* fLaC signature (be) */
623     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
624     {
625         skip_bits(&s->gb, 32);
626
627         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
628         do {
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);
632             
633             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
634                 metadata_last, metadata_type,
635                 metadata_size);
636             if(metadata_size){
637                 switch(metadata_type)
638                 {
639                 case METADATA_TYPE_STREAMINFO:{
640                     metadata_streaminfo(s);
641
642                     /* Buffer might have been reallocated, reinit bitreader */
643                     if(buf != &s->bitstream[s->bitstream_index])
644                     {
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);
649                     }
650  
651                     dump_headers(s);
652                     break;}
653                 default:
654                     for(i=0; i<metadata_size; i++)
655                         skip_bits(&s->gb, 8);
656                 }
657             }
658         } while(!metadata_last);
659     }
660     else
661     {
662         
663         tmp = show_bits(&s->gb, 16);
664         if(tmp != 0xFFF8){
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
669         }
670         skip_bits(&s->gb, 16);
671         if (decode_frame(s) < 0){
672             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
673             s->bitstream_size=0;
674             s->bitstream_index=0;
675             return -1;
676         }
677     }
678
679     
680 #if 0
681     /* fix the channel order here */
682     if (s->order == MID_SIDE)
683     {
684         short *left = samples;
685         short *right = samples + s->blocksize;
686         for (i = 0; i < s->blocksize; i += 2)
687         {
688             uint32_t x = s->decoded[0][i];
689             uint32_t y = s->decoded[0][i+1];
690
691             right[i] = x - (y / 2);
692             left[i] = right[i] + y;
693         }
694         *data_size = 2 * s->blocksize;
695     }
696     else
697     {
698     for (i = 0; i < s->channels; i++)
699     {
700         switch(s->order)
701         {
702             case INDEPENDENT:
703                 for (j = 0; j < s->blocksize; j++)
704                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
705                 break;
706             case LEFT_SIDE:
707             case RIGHT_SIDE:
708                 if (i == 0)
709                     for (j = 0; j < s->blocksize; j++)
710                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
711                 else
712                     for (j = 0; j < s->blocksize; j++)
713                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
714                 break;
715 //            case MID_SIDE:
716 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
717         }
718         *data_size += s->blocksize;
719     }
720     }
721 #else
722     switch(s->decorrelation)
723     {
724         case INDEPENDENT:
725             for (j = 0; j < s->blocksize; j++)
726             {
727                 for (i = 0; i < s->channels; i++)
728                     *(samples++) = s->decoded[i][j];
729             }
730             break;
731         case LEFT_SIDE:
732             assert(s->channels == 2);
733             for (i = 0; i < s->blocksize; i++)
734             {
735                 *(samples++) = s->decoded[0][i];
736                 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
737             }
738             break;
739         case RIGHT_SIDE:
740             assert(s->channels == 2);
741             for (i = 0; i < s->blocksize; i++)
742             {
743                 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
744                 *(samples++) = s->decoded[1][i];
745             }
746             break;
747         case MID_SIDE:
748             assert(s->channels == 2);
749             for (i = 0; i < s->blocksize; i++)
750             {
751                 int mid, side;
752                 mid = s->decoded[0][i];
753                 side = s->decoded[1][i];
754
755 #if 1 //needs to be checked but IMHO it should be binary identical
756                 mid -= side>>1;
757                 *(samples++) = mid + side;
758                 *(samples++) = mid;
759 #else
760                 
761                 mid <<= 1;
762                 if (side & 1)
763                     mid++;
764                 *(samples++) = (mid + side) >> 1;
765                 *(samples++) = (mid - side) >> 1;
766 #endif
767             }
768             break;
769     }
770 #endif
771
772     *data_size = (int8_t *)samples - (int8_t *)data;
773 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
774
775 //    s->last_blocksize = s->blocksize;
776 end:
777     i= (get_bits_count(&s->gb)+7)/8;;
778     if(i > buf_size){
779         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
780         s->bitstream_size=0;
781         s->bitstream_index=0;
782         return -1;
783     }
784
785     if(s->bitstream_size){
786         s->bitstream_index += i;
787         s->bitstream_size  -= i;
788         return input_buf_size;
789     }else 
790         return i;
791 }
792
793 static int flac_decode_close(AVCodecContext *avctx)
794 {
795     FLACContext *s = avctx->priv_data;
796     int i;
797     
798     for (i = 0; i < s->channels; i++)
799     {
800         av_freep(&s->decoded[i]);
801     }
802     av_freep(&s->bitstream);
803     
804     return 0;
805 }
806
807 static void flac_flush(AVCodecContext *avctx){
808     FLACContext *s = avctx->priv_data;
809
810     s->bitstream_size=
811     s->bitstream_index= 0;
812 }
813
814 AVCodec flac_decoder = {
815     "flac",
816     CODEC_TYPE_AUDIO,
817     CODEC_ID_FLAC,
818     sizeof(FLACContext),
819     flac_decode_init,
820     NULL,
821     flac_decode_close,
822     flac_decode_frame,
823     .flush= flac_flush,    
824 };