7e92fa59ec1923ee0849432ae72515ddd3ed43ba
[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  
26 #include <limits.h>
27  
28 #include "avcodec.h"
29 #include "golomb.h"
30
31 #undef NDEBUG
32 #include <assert.h>
33
34 #define MAX_CHANNELS 8
35 #define MAX_BLOCKSIZE 65535
36
37 enum decorrelation_type {
38     INDEPENDENT,
39     LEFT_SIDE,
40     RIGHT_SIDE,
41     MID_SIDE,
42 };
43
44 typedef struct FLACContext {
45     AVCodecContext *avctx;
46     GetBitContext gb;
47
48     int min_blocksize, max_blocksize;
49     int min_framesize, max_framesize;
50     int samplerate, channels;
51     int blocksize/*, last_blocksize*/;
52     int bps, curr_bps;
53     enum decorrelation_type decorrelation;
54
55     int32_t *decoded[MAX_CHANNELS];
56     uint8_t *bitstream;
57     int bitstream_size;
58     int bitstream_index;
59     int allocated_bitstream_size;
60 } FLACContext;
61
62 #define METADATA_TYPE_STREAMINFO 0
63
64 static int sample_rate_table[] =
65 { 0, 0, 0, 0,
66   8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
67   0, 0, 0, 0 }; 
68
69 static int sample_size_table[] = 
70 { 0, 8, 12, 0, 16, 20, 24, 0 };
71
72 static int blocksize_table[] = {
73      0,    192, 576<<0, 576<<1, 576<<2, 576<<3,      0,      0, 
74 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7 
75 };
76
77 static const uint8_t table_crc8[256] = {
78     0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
79     0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
80     0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
81     0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
82     0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
83     0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
84     0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
85     0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
86     0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
87     0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
88     0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
89     0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
90     0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
91     0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
92     0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
93     0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
94     0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
95     0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
96     0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
97     0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
98     0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
99     0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
100     0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
101     0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
102     0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
103     0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
104     0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
105     0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
106     0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
107     0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
108     0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
109     0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
110 };
111
112 static int64_t get_utf8(GetBitContext *gb)
113 {
114     uint64_t val;
115     int ones=0, bytes;
116     
117     while(get_bits1(gb))
118         ones++;
119
120     if     (ones==0) bytes=0;
121     else if(ones==1) return -1;
122     else             bytes= ones - 1;
123     
124     val= get_bits(gb, 7-ones);
125     while(bytes--){
126         const int tmp = get_bits(gb, 8);
127         
128         if((tmp>>6) != 2)
129             return -1;
130         val<<=6;
131         val|= tmp&0x3F;
132     }
133     return val;
134 }
135
136 static int get_crc8(const uint8_t *buf, int count){
137     int crc=0;
138     int i;
139     
140     for(i=0; i<count; i++){
141         crc = table_crc8[crc ^ buf[i]];
142     }
143
144     return crc;
145 }
146
147 static int flac_decode_init(AVCodecContext * avctx)
148 {
149     return 0;
150 }
151
152 static void dump_headers(FLACContext *s)
153 {
154     av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
155     av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
156     av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
157     av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
158     av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
159 }
160
161 static void allocate_buffers(FLACContext *s){
162     int i;
163
164     assert(s->max_blocksize);
165
166     if(s->max_framesize == 0 && s->max_blocksize){
167         s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
168     }
169
170     for (i = 0; i < s->channels; i++)
171     {
172         s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
173     }
174
175     s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
176 }
177
178 static void metadata_streaminfo(FLACContext *s)
179 {
180     /* mandatory streaminfo */
181     s->min_blocksize = get_bits(&s->gb, 16);
182     s->max_blocksize = get_bits(&s->gb, 16);
183
184     s->min_framesize = get_bits_long(&s->gb, 24);
185     s->max_framesize = get_bits_long(&s->gb, 24);
186     
187     s->samplerate = get_bits_long(&s->gb, 20);
188     s->channels = get_bits(&s->gb, 3) + 1;
189     s->bps = get_bits(&s->gb, 5) + 1;
190     
191     s->avctx->channels = s->channels;
192     s->avctx->sample_rate = s->samplerate;
193
194     skip_bits(&s->gb, 36); /* total num of samples */
195     
196     skip_bits(&s->gb, 64); /* md5 sum */
197     skip_bits(&s->gb, 64); /* md5 sum */
198     
199     allocate_buffers(s);
200 }
201
202 static int decode_residuals(FLACContext *s, int channel, int pred_order)
203 {
204     int i, tmp, partition, method_type, rice_order;
205     int sample = 0, samples;
206
207     method_type = get_bits(&s->gb, 2);
208     if (method_type != 0){
209         av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
210         return -1;
211     }
212     
213     rice_order = get_bits(&s->gb, 4);
214
215     samples= s->blocksize >> rice_order;
216
217     sample= 
218     i= pred_order;
219     for (partition = 0; partition < (1 << rice_order); partition++)
220     {
221         tmp = get_bits(&s->gb, 4);
222         if (tmp == 15)
223         {
224             av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
225             tmp = get_bits(&s->gb, 5);
226             for (; i < samples; i++, sample++)
227                 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
228         }
229         else
230         {
231 //            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
232             for (; i < samples; i++, sample++){
233                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
234             }
235         }
236         i= 0;
237     }
238
239 //    av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
240
241     return 0;
242 }    
243
244 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
245 {
246     int i;
247         
248 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME FIXED\n");
249         
250     /* warm up samples */
251 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
252         
253     for (i = 0; i < pred_order; i++)
254     {
255         s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
256 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
257     }
258     
259     if (decode_residuals(s, channel, pred_order) < 0)
260         return -1;
261
262     switch(pred_order)
263     {
264         case 0:
265             break;
266         case 1:
267             for (i = pred_order; i < s->blocksize; i++)
268                 s->decoded[channel][i] +=   s->decoded[channel][i-1];
269             break;
270         case 2:
271             for (i = pred_order; i < s->blocksize; i++)
272                 s->decoded[channel][i] += 2*s->decoded[channel][i-1]
273                                           - s->decoded[channel][i-2];
274             break;
275         case 3:
276             for (i = pred_order; i < s->blocksize; i++)
277                 s->decoded[channel][i] += 3*s->decoded[channel][i-1] 
278                                         - 3*s->decoded[channel][i-2]
279                                         +   s->decoded[channel][i-3];
280             break;
281         case 4:
282             for (i = pred_order; i < s->blocksize; i++)
283                 s->decoded[channel][i] += 4*s->decoded[channel][i-1] 
284                                         - 6*s->decoded[channel][i-2]
285                                         + 4*s->decoded[channel][i-3]
286                                         -   s->decoded[channel][i-4];
287             break;
288         default:
289             av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
290             return -1;
291     }
292
293     return 0;
294 }
295
296 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
297 {
298     int sum, i, j;
299     int coeff_prec, qlevel;
300     int coeffs[pred_order];
301         
302 //    av_log(s->avctx, AV_LOG_DEBUG, "  SUBFRAME LPC\n");
303         
304     /* warm up samples */
305 //    av_log(s->avctx, AV_LOG_DEBUG, "   warm up samples: %d\n", pred_order);
306         
307     for (i = 0; i < pred_order; i++)
308     {
309         s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
310 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, s->decoded[channel][i]);
311     }
312     
313     coeff_prec = get_bits(&s->gb, 4) + 1;
314     if (coeff_prec == 16)
315     {
316         av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
317         return -1;
318     }
319 //    av_log(s->avctx, AV_LOG_DEBUG, "   qlp coeff prec: %d\n", coeff_prec);
320     qlevel = get_sbits(&s->gb, 5);
321 //    av_log(s->avctx, AV_LOG_DEBUG, "   quant level: %d\n", qlevel);
322     if(qlevel < 0){
323         av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
324         return -1;
325     }
326
327     for (i = 0; i < pred_order; i++)
328     {
329         coeffs[i] = get_sbits(&s->gb, coeff_prec);
330 //        av_log(s->avctx, AV_LOG_DEBUG, "    %d: %d\n", i, coeffs[i]);
331     }
332     
333     if (decode_residuals(s, channel, pred_order) < 0)
334         return -1;
335
336     for (i = pred_order; i < s->blocksize; i++)
337     {
338         sum = 0;
339         for (j = 0; j < pred_order; j++)
340             sum += coeffs[j] * s->decoded[channel][i-j-1];
341         s->decoded[channel][i] += sum >> qlevel;
342     }
343     
344     return 0;
345 }
346
347 static inline int decode_subframe(FLACContext *s, int channel)
348 {
349     int type, wasted = 0;
350     int i, tmp;
351     
352     s->curr_bps = s->bps;
353     if(channel == 0){
354         if(s->decorrelation == RIGHT_SIDE)
355             s->curr_bps++;
356     }else{
357         if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
358             s->curr_bps++;
359     }
360
361     if (get_bits1(&s->gb))
362     {
363         av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
364         return -1;
365     }
366     type = get_bits(&s->gb, 6);
367 //    wasted = get_bits1(&s->gb);
368     
369 //    if (wasted)
370 //    {
371 //        while (!get_bits1(&s->gb))
372 //            wasted++;
373 //        if (wasted)
374 //            wasted++;
375 //        s->curr_bps -= wasted;
376 //    }
377 #if 0
378     wasted= 16 - av_log2(show_bits(&s->gb, 17));
379     skip_bits(&s->gb, wasted+1);
380     s->curr_bps -= wasted;
381 #else
382     if (get_bits1(&s->gb))
383     {
384         wasted = 1;
385         while (!get_bits1(&s->gb))
386             wasted++;
387         s->curr_bps -= wasted;
388         av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
389     }
390 #endif
391 //FIXME use av_log2 for types
392     if (type == 0)
393     {
394         av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
395         tmp = get_sbits(&s->gb, s->curr_bps);
396         for (i = 0; i < s->blocksize; i++)
397             s->decoded[channel][i] = tmp;
398     }
399     else if (type == 1)
400     {
401         av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
402         for (i = 0; i < s->blocksize; i++)
403             s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
404     }
405     else if ((type >= 8) && (type <= 12))
406     {
407 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
408         if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
409             return -1;
410     }
411     else if (type >= 32)
412     {
413 //        av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
414         if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
415             return -1;
416     }
417     else
418     {
419         av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
420         return -1;
421     }
422         
423     if (wasted)
424     {
425         int i;
426         for (i = 0; i < s->blocksize; i++)
427             s->decoded[channel][i] <<= wasted;
428     }
429
430     return 0;
431 }
432
433 static int decode_frame(FLACContext *s)
434 {
435     int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
436     int decorrelation, bps, blocksize, samplerate;
437     
438     blocksize_code = get_bits(&s->gb, 4);
439
440     sample_rate_code = get_bits(&s->gb, 4);
441     
442     assignment = get_bits(&s->gb, 4); /* channel assignment */
443     if (assignment < 8 && s->channels == assignment+1)
444         decorrelation = INDEPENDENT;
445     else if (assignment >=8 && assignment < 11 && s->channels == 2)
446         decorrelation = LEFT_SIDE + assignment - 8;
447     else
448     {
449         av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
450         return -1;
451     }
452         
453     sample_size_code = get_bits(&s->gb, 3);
454     if(sample_size_code == 0)
455         bps= s->bps;
456     else if((sample_size_code != 3) && (sample_size_code != 7))
457         bps = sample_size_table[sample_size_code];
458     else 
459     {
460         av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
461         return -1;
462     }
463
464     if (get_bits1(&s->gb))
465     {
466         av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
467         return -1;
468     }
469     
470     if(get_utf8(&s->gb) < 0){
471         av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
472         return -1;
473     }
474 #if 0    
475     if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
476         (s->min_blocksize != s->max_blocksize)){
477     }else{
478     }
479 #endif
480     
481     if (blocksize_code == 0)
482         blocksize = s->min_blocksize;
483     else if (blocksize_code == 6)
484         blocksize = get_bits(&s->gb, 8)+1;
485     else if (blocksize_code == 7)
486         blocksize = get_bits(&s->gb, 16)+1;
487     else 
488         blocksize = blocksize_table[blocksize_code];
489
490     if(blocksize > s->max_blocksize){
491         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
492         return -1;
493     }
494
495     if (sample_rate_code == 0){
496         samplerate= s->samplerate;
497     }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
498         samplerate = sample_rate_table[sample_rate_code];
499     else if (sample_rate_code == 12)
500         samplerate = get_bits(&s->gb, 8) * 1000;
501     else if (sample_rate_code == 13)
502         samplerate = get_bits(&s->gb, 16);
503     else if (sample_rate_code == 14)
504         samplerate = get_bits(&s->gb, 16) * 10;
505     else{
506         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
507         return -1;
508     }
509
510     skip_bits(&s->gb, 8);
511     crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
512     if(crc8){
513         av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
514         return -1;
515     }
516     
517     s->blocksize    = blocksize;
518     s->samplerate   = samplerate;
519     s->bps          = bps;
520     s->decorrelation= decorrelation;
521
522 //    dump_headers(s);
523
524     /* subframes */
525     for (i = 0; i < s->channels; i++)
526     {
527 //        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
528         if (decode_subframe(s, i) < 0)
529             return -1;
530     }
531     
532     align_get_bits(&s->gb);
533
534     /* frame footer */
535     skip_bits(&s->gb, 16); /* data crc */
536
537     return 0;
538 }
539
540 static int flac_decode_frame(AVCodecContext *avctx,
541                             void *data, int *data_size,
542                             uint8_t *buf, int buf_size)
543 {
544     FLACContext *s = avctx->priv_data;
545     int metadata_last, metadata_type, metadata_size;
546     int tmp = 0, i, j = 0, input_buf_size;
547     int16_t *samples = data, *left, *right;
548
549     s->avctx = avctx;
550     
551     if(s->max_framesize == 0){
552         s->max_framesize= 8192; // should hopefully be enough for the first header
553         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
554     }
555
556     if(1 && s->max_framesize){//FIXME truncated
557             buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
558             input_buf_size= buf_size;
559
560             if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
561 //                printf("memmove\n");
562                 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
563                 s->bitstream_index=0;
564             }
565             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
566             buf= &s->bitstream[s->bitstream_index];
567             buf_size += s->bitstream_size;
568             s->bitstream_size= buf_size;
569             
570             if(buf_size < s->max_framesize){
571 //                printf("wanna more data ...\n");
572                 return input_buf_size;
573             }
574     }
575
576     init_get_bits(&s->gb, buf, buf_size*8);
577     
578     /* fLaC signature (be) */
579     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
580     {
581         skip_bits(&s->gb, 32);
582
583         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
584         do {
585             metadata_last = get_bits(&s->gb, 1);
586             metadata_type = get_bits(&s->gb, 7);
587             metadata_size = get_bits_long(&s->gb, 24);
588             
589             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
590                 metadata_last, metadata_type,
591                 metadata_size);
592             if(metadata_size){
593                 switch(metadata_type)
594                 {
595                 case METADATA_TYPE_STREAMINFO:
596                     metadata_streaminfo(s);
597                     dump_headers(s);
598                     break;
599                 default:
600                     for(i=0; i<metadata_size; i++)
601                         skip_bits(&s->gb, 8);
602                 }
603             }
604         } while(!metadata_last);
605     }
606     else
607     {
608         
609         tmp = show_bits(&s->gb, 16);
610         if(tmp != 0xFFF8){
611             av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
612             while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
613                 skip_bits(&s->gb, 8);
614             goto end; // we may not have enough bits left to decode a frame, so try next time
615         }
616         skip_bits(&s->gb, 16);
617         if (decode_frame(s) < 0){
618             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
619             s->bitstream_size=0;
620             s->bitstream_index=0;
621             return -1;
622         }
623     }
624
625     
626 #if 0
627     /* fix the channel order here */
628     if (s->order == MID_SIDE)
629     {
630         short *left = samples;
631         short *right = samples + s->blocksize;
632         for (i = 0; i < s->blocksize; i += 2)
633         {
634             uint32_t x = s->decoded[0][i];
635             uint32_t y = s->decoded[0][i+1];
636
637             right[i] = x - (y / 2);
638             left[i] = right[i] + y;
639         }
640         *data_size = 2 * s->blocksize;
641     }
642     else
643     {
644     for (i = 0; i < s->channels; i++)
645     {
646         switch(s->order)
647         {
648             case INDEPENDENT:
649                 for (j = 0; j < s->blocksize; j++)
650                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
651                 break;
652             case LEFT_SIDE:
653             case RIGHT_SIDE:
654                 if (i == 0)
655                     for (j = 0; j < s->blocksize; j++)
656                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
657                 else
658                     for (j = 0; j < s->blocksize; j++)
659                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
660                 break;
661 //            case MID_SIDE:
662 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
663         }
664         *data_size += s->blocksize;
665     }
666     }
667 #else
668     switch(s->decorrelation)
669     {
670         case INDEPENDENT:
671             for (j = 0; j < s->blocksize; j++)
672             {
673                 for (i = 0; i < s->channels; i++)
674                     *(samples++) = s->decoded[i][j];
675             }
676             break;
677         case LEFT_SIDE:
678             assert(s->channels == 2);
679             for (i = 0; i < s->blocksize; i++)
680             {
681                 *(samples++) = s->decoded[0][i];
682                 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
683             }
684             break;
685         case RIGHT_SIDE:
686             assert(s->channels == 2);
687             for (i = 0; i < s->blocksize; i++)
688             {
689                 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
690                 *(samples++) = s->decoded[1][i];
691             }
692             break;
693         case MID_SIDE:
694             assert(s->channels == 2);
695             for (i = 0; i < s->blocksize; i++)
696             {
697                 int mid, side;
698                 mid = s->decoded[0][i];
699                 side = s->decoded[1][i];
700
701 #if 1 //needs to be checked but IMHO it should be binary identical
702                 mid -= side>>1;
703                 *(samples++) = mid + side;
704                 *(samples++) = mid;
705 #else
706                 
707                 mid <<= 1;
708                 if (side & 1)
709                     mid++;
710                 *(samples++) = (mid + side) >> 1;
711                 *(samples++) = (mid - side) >> 1;
712 #endif
713             }
714             break;
715     }
716 #endif
717
718     *data_size = (int8_t *)samples - (int8_t *)data;
719 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
720
721 //    s->last_blocksize = s->blocksize;
722 end:
723     i= (get_bits_count(&s->gb)+7)/8;;
724     if(i > buf_size){
725         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
726         s->bitstream_size=0;
727         s->bitstream_index=0;
728         return -1;
729     }
730
731     if(s->bitstream_size){
732         s->bitstream_index += i;
733         s->bitstream_size  -= i;
734         return input_buf_size;
735     }else 
736         return i;
737 }
738
739 static int flac_decode_close(AVCodecContext *avctx)
740 {
741     FLACContext *s = avctx->priv_data;
742     int i;
743     
744     for (i = 0; i < s->channels; i++)
745     {
746         av_freep(&s->decoded[i]);
747     }
748     av_freep(&s->bitstream);
749     
750     return 0;
751 }
752
753 static void flac_flush(AVCodecContext *avctx){
754     FLACContext *s = avctx->priv_data;
755
756     s->bitstream_size=
757     s->bitstream_index= 0;
758 }
759
760 AVCodec flac_decoder = {
761     "flac",
762     CODEC_TYPE_AUDIO,
763     CODEC_ID_FLAC,
764     sizeof(FLACContext),
765     flac_decode_init,
766     NULL,
767     flac_decode_close,
768     flac_decode_frame,
769     .flush= flac_flush,    
770 };