common.c -> bitstream.c (and the single non bitstream func -> utils.c)
[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 static int skip_utf8(GetBitContext *gb)
147 {
148     int ones=0, bytes;
149     
150     while(get_bits1(gb))
151         ones++;
152
153     if     (ones==0) bytes=0;
154     else if(ones==1) return -1;
155     else             bytes= ones - 1;
156     
157     skip_bits(gb, 7-ones);
158     while(bytes--){
159         const int tmp = get_bits(gb, 8);
160         
161         if((tmp>>6) != 2)
162             return -1;
163     }
164     return 0;
165 }
166
167 static int get_crc8(const uint8_t *buf, int count){
168     int crc=0;
169     int i;
170     
171     for(i=0; i<count; i++){
172         crc = table_crc8[crc ^ buf[i]];
173     }
174
175     return crc;
176 }
177
178 static void metadata_streaminfo(FLACContext *s);
179 static void dump_headers(FLACContext *s);
180
181 static int flac_decode_init(AVCodecContext * avctx)
182 {
183     FLACContext *s = avctx->priv_data;
184     s->avctx = avctx;
185
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);
190         dump_headers(s);
191     }
192
193     return 0;
194 }
195
196 static void dump_headers(FLACContext *s)
197 {
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);
203 }
204
205 static void allocate_buffers(FLACContext *s){
206     int i;
207
208     assert(s->max_blocksize);
209
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
212     }
213
214     for (i = 0; i < s->channels; i++)
215     {
216         s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
217     }
218
219     s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
220 }
221
222 static void metadata_streaminfo(FLACContext *s)
223 {
224     /* mandatory streaminfo */
225     s->min_blocksize = get_bits(&s->gb, 16);
226     s->max_blocksize = get_bits(&s->gb, 16);
227
228     s->min_framesize = get_bits_long(&s->gb, 24);
229     s->max_framesize = get_bits_long(&s->gb, 24);
230     
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;
234     
235     s->avctx->channels = s->channels;
236     s->avctx->sample_rate = s->samplerate;
237
238     skip_bits(&s->gb, 36); /* total num of samples */
239     
240     skip_bits(&s->gb, 64); /* md5 sum */
241     skip_bits(&s->gb, 64); /* md5 sum */
242     
243     allocate_buffers(s);
244 }
245
246 static int decode_residuals(FLACContext *s, int channel, int pred_order)
247 {
248     int i, tmp, partition, method_type, rice_order;
249     int sample = 0, samples;
250
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);
254         return -1;
255     }
256     
257     rice_order = get_bits(&s->gb, 4);
258
259     samples= s->blocksize >> rice_order;
260
261     sample= 
262     i= pred_order;
263     for (partition = 0; partition < (1 << rice_order); partition++)
264     {
265         tmp = get_bits(&s->gb, 4);
266         if (tmp == 15)
267         {
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);
272         }
273         else
274         {
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);
278             }
279         }
280         i= 0;
281     }
282
283 //    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
284
285     return 0;
286 }    
287
288 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
289 {
290     int i;
291         
292 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
293         
294     /* warm up samples */
295 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
296         
297     for (i = 0; i < pred_order; i++)
298     {
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]);
301     }
302     
303     if (decode_residuals(s, channel, pred_order) < 0)
304         return -1;
305
306     switch(pred_order)
307     {
308         case 0:
309             break;
310         case 1:
311             for (i = pred_order; i < s->blocksize; i++)
312                 s->decoded[channel][i] +=   s->decoded[channel][i-1];
313             break;
314         case 2:
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];
318             break;
319         case 3:
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];
324             break;
325         case 4:
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];
331             break;
332         default:
333             av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
334             return -1;
335     }
336
337     return 0;
338 }
339
340 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
341 {
342     int sum, i, j;
343     int coeff_prec, qlevel;
344     int coeffs[pred_order];
345         
346 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
347         
348     /* warm up samples */
349 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
350         
351     for (i = 0; i < pred_order; i++)
352     {
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]);
355     }
356     
357     coeff_prec = get_bits(&s->gb, 4) + 1;
358     if (coeff_prec == 16)
359     {
360         av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
361         return -1;
362     }
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);
366     if(qlevel < 0){
367         av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
368         return -1;
369     }
370
371     for (i = 0; i < pred_order; i++)
372     {
373         coeffs[i] = get_sbits(&s->gb, coeff_prec);
374 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
375     }
376     
377     if (decode_residuals(s, channel, pred_order) < 0)
378         return -1;
379
380     for (i = pred_order; i < s->blocksize; i++)
381     {
382         sum = 0;
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;
386     }
387     
388     return 0;
389 }
390
391 static inline int decode_subframe(FLACContext *s, int channel)
392 {
393     int type, wasted = 0;
394     int i, tmp;
395     
396     s->curr_bps = s->bps;
397     if(channel == 0){
398         if(s->decorrelation == RIGHT_SIDE)
399             s->curr_bps++;
400     }else{
401         if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
402             s->curr_bps++;
403     }
404
405     if (get_bits1(&s->gb))
406     {
407         av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
408         return -1;
409     }
410     type = get_bits(&s->gb, 6);
411 //    wasted = get_bits1(&s->gb);
412     
413 //    if (wasted)
414 //    {
415 //        while (!get_bits1(&s->gb))
416 //            wasted++;
417 //        if (wasted)
418 //            wasted++;
419 //        s->curr_bps -= wasted;
420 //    }
421 #if 0
422     wasted= 16 - av_log2(show_bits(&s->gb, 17));
423     skip_bits(&s->gb, wasted+1);
424     s->curr_bps -= wasted;
425 #else
426     if (get_bits1(&s->gb))
427     {
428         wasted = 1;
429         while (!get_bits1(&s->gb))
430             wasted++;
431         s->curr_bps -= wasted;
432         av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
433     }
434 #endif
435 //FIXME use av_log2 for types
436     if (type == 0)
437     {
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;
442     }
443     else if (type == 1)
444     {
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);
448     }
449     else if ((type >= 8) && (type <= 12))
450     {
451 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
452         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
453             return -1;
454     }
455     else if (type >= 32)
456     {
457 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
458         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
459             return -1;
460     }
461     else
462     {
463         av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
464         return -1;
465     }
466         
467     if (wasted)
468     {
469         int i;
470         for (i = 0; i < s->blocksize; i++)
471             s->decoded[channel][i] <<= wasted;
472     }
473
474     return 0;
475 }
476
477 static int decode_frame(FLACContext *s)
478 {
479     int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
480     int decorrelation, bps, blocksize, samplerate;
481     
482     blocksize_code = get_bits(&s->gb, 4);
483
484     sample_rate_code = get_bits(&s->gb, 4);
485     
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;
491     else
492     {
493         av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
494         return -1;
495     }
496         
497     sample_size_code = get_bits(&s->gb, 3);
498     if(sample_size_code == 0)
499         bps= s->bps;
500     else if((sample_size_code != 3) && (sample_size_code != 7))
501         bps = sample_size_table[sample_size_code];
502     else 
503     {
504         av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
505         return -1;
506     }
507
508     if (get_bits1(&s->gb))
509     {
510         av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
511         return -1;
512     }
513     
514     if(get_utf8(&s->gb) < 0){
515         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
516         return -1;
517     }
518 #if 0    
519     if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
520         (s->min_blocksize != s->max_blocksize)){
521     }else{
522     }
523 #endif
524     
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;
531     else 
532         blocksize = blocksize_table[blocksize_code];
533
534     if(blocksize > s->max_blocksize){
535         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
536         return -1;
537     }
538
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;
549     else{
550         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
551         return -1;
552     }
553
554     skip_bits(&s->gb, 8);
555     crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
556     if(crc8){
557         av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
558         return -1;
559     }
560     
561     s->blocksize    = blocksize;
562     s->samplerate   = samplerate;
563     s->bps          = bps;
564     s->decorrelation= decorrelation;
565
566 //    dump_headers(s);
567
568     /* subframes */
569     for (i = 0; i < s->channels; i++)
570     {
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)
573             return -1;
574     }
575     
576     align_get_bits(&s->gb);
577
578     /* frame footer */
579     skip_bits(&s->gb, 16); /* data crc */
580
581     return 0;
582 }
583
584 static int flac_decode_frame(AVCodecContext *avctx,
585                             void *data, int *data_size,
586                             uint8_t *buf, int buf_size)
587 {
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;
592
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);
596     }
597
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;
601
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;
606             }
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;
611             
612             if(buf_size < s->max_framesize){
613 //                printf("wanna more data ...\n");
614                 return input_buf_size;
615             }
616     }
617
618     init_get_bits(&s->gb, buf, buf_size*8);
619     
620     /* fLaC signature (be) */
621     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
622     {
623         skip_bits(&s->gb, 32);
624
625         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
626         do {
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);
630             
631             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
632                 metadata_last, metadata_type,
633                 metadata_size);
634             if(metadata_size){
635                 switch(metadata_type)
636                 {
637                 case METADATA_TYPE_STREAMINFO:
638                     metadata_streaminfo(s);
639                     dump_headers(s);
640                     break;
641                 default:
642                     for(i=0; i<metadata_size; i++)
643                         skip_bits(&s->gb, 8);
644                 }
645             }
646         } while(!metadata_last);
647     }
648     else
649     {
650         
651         tmp = show_bits(&s->gb, 16);
652         if(tmp != 0xFFF8){
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
657         }
658         skip_bits(&s->gb, 16);
659         if (decode_frame(s) < 0){
660             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
661             s->bitstream_size=0;
662             s->bitstream_index=0;
663             return -1;
664         }
665     }
666
667     
668 #if 0
669     /* fix the channel order here */
670     if (s->order == MID_SIDE)
671     {
672         short *left = samples;
673         short *right = samples + s->blocksize;
674         for (i = 0; i < s->blocksize; i += 2)
675         {
676             uint32_t x = s->decoded[0][i];
677             uint32_t y = s->decoded[0][i+1];
678
679             right[i] = x - (y / 2);
680             left[i] = right[i] + y;
681         }
682         *data_size = 2 * s->blocksize;
683     }
684     else
685     {
686     for (i = 0; i < s->channels; i++)
687     {
688         switch(s->order)
689         {
690             case INDEPENDENT:
691                 for (j = 0; j < s->blocksize; j++)
692                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
693                 break;
694             case LEFT_SIDE:
695             case RIGHT_SIDE:
696                 if (i == 0)
697                     for (j = 0; j < s->blocksize; j++)
698                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
699                 else
700                     for (j = 0; j < s->blocksize; j++)
701                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
702                 break;
703 //            case MID_SIDE:
704 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
705         }
706         *data_size += s->blocksize;
707     }
708     }
709 #else
710     switch(s->decorrelation)
711     {
712         case INDEPENDENT:
713             for (j = 0; j < s->blocksize; j++)
714             {
715                 for (i = 0; i < s->channels; i++)
716                     *(samples++) = s->decoded[i][j];
717             }
718             break;
719         case LEFT_SIDE:
720             assert(s->channels == 2);
721             for (i = 0; i < s->blocksize; i++)
722             {
723                 *(samples++) = s->decoded[0][i];
724                 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
725             }
726             break;
727         case RIGHT_SIDE:
728             assert(s->channels == 2);
729             for (i = 0; i < s->blocksize; i++)
730             {
731                 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
732                 *(samples++) = s->decoded[1][i];
733             }
734             break;
735         case MID_SIDE:
736             assert(s->channels == 2);
737             for (i = 0; i < s->blocksize; i++)
738             {
739                 int mid, side;
740                 mid = s->decoded[0][i];
741                 side = s->decoded[1][i];
742
743 #if 1 //needs to be checked but IMHO it should be binary identical
744                 mid -= side>>1;
745                 *(samples++) = mid + side;
746                 *(samples++) = mid;
747 #else
748                 
749                 mid <<= 1;
750                 if (side & 1)
751                     mid++;
752                 *(samples++) = (mid + side) >> 1;
753                 *(samples++) = (mid - side) >> 1;
754 #endif
755             }
756             break;
757     }
758 #endif
759
760     *data_size = (int8_t *)samples - (int8_t *)data;
761 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
762
763 //    s->last_blocksize = s->blocksize;
764 end:
765     i= (get_bits_count(&s->gb)+7)/8;;
766     if(i > buf_size){
767         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
768         s->bitstream_size=0;
769         s->bitstream_index=0;
770         return -1;
771     }
772
773     if(s->bitstream_size){
774         s->bitstream_index += i;
775         s->bitstream_size  -= i;
776         return input_buf_size;
777     }else 
778         return i;
779 }
780
781 static int flac_decode_close(AVCodecContext *avctx)
782 {
783     FLACContext *s = avctx->priv_data;
784     int i;
785     
786     for (i = 0; i < s->channels; i++)
787     {
788         av_freep(&s->decoded[i]);
789     }
790     av_freep(&s->bitstream);
791     
792     return 0;
793 }
794
795 static void flac_flush(AVCodecContext *avctx){
796     FLACContext *s = avctx->priv_data;
797
798     s->bitstream_size=
799     s->bitstream_index= 0;
800 }
801
802 AVCodec flac_decoder = {
803     "flac",
804     CODEC_TYPE_AUDIO,
805     CODEC_ID_FLAC,
806     sizeof(FLACContext),
807     flac_decode_init,
808     NULL,
809     flac_decode_close,
810     flac_decode_frame,
811     .flush= flac_flush,    
812 };