* const warn elimintation
[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     *data_size = 0;
550
551     s->avctx = avctx;
552     
553     if(s->max_framesize == 0){
554         s->max_framesize= 8192; // should hopefully be enough for the first header
555         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
556     }
557
558     if(1 && s->max_framesize){//FIXME truncated
559             buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
560             input_buf_size= buf_size;
561
562             if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
563 //                printf("memmove\n");
564                 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
565                 s->bitstream_index=0;
566             }
567             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
568             buf= &s->bitstream[s->bitstream_index];
569             buf_size += s->bitstream_size;
570             s->bitstream_size= buf_size;
571             
572             if(buf_size < s->max_framesize){
573 //                printf("wanna more data ...\n");
574                 return input_buf_size;
575             }
576     }
577
578     init_get_bits(&s->gb, buf, buf_size*8);
579     
580     /* fLaC signature (be) */
581     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
582     {
583         skip_bits(&s->gb, 32);
584
585         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
586         do {
587             metadata_last = get_bits(&s->gb, 1);
588             metadata_type = get_bits(&s->gb, 7);
589             metadata_size = get_bits_long(&s->gb, 24);
590             
591             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
592                 metadata_last, metadata_type,
593                 metadata_size);
594             if(metadata_size){
595                 switch(metadata_type)
596                 {
597                 case METADATA_TYPE_STREAMINFO:
598                     metadata_streaminfo(s);
599                     dump_headers(s);
600                     break;
601                 default:
602                     for(i=0; i<metadata_size; i++)
603                         skip_bits(&s->gb, 8);
604                 }
605             }
606         } while(!metadata_last);
607     }
608     else
609     {
610         
611         tmp = show_bits(&s->gb, 16);
612         if(tmp != 0xFFF8){
613             av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
614             while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
615                 skip_bits(&s->gb, 8);
616             goto end; // we may not have enough bits left to decode a frame, so try next time
617         }
618         skip_bits(&s->gb, 16);
619         if (decode_frame(s) < 0){
620             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
621             s->bitstream_size=0;
622             s->bitstream_index=0;
623             return -1;
624         }
625     }
626
627     
628 #if 0
629     /* fix the channel order here */
630     if (s->order == MID_SIDE)
631     {
632         short *left = samples;
633         short *right = samples + s->blocksize;
634         for (i = 0; i < s->blocksize; i += 2)
635         {
636             uint32_t x = s->decoded[0][i];
637             uint32_t y = s->decoded[0][i+1];
638
639             right[i] = x - (y / 2);
640             left[i] = right[i] + y;
641         }
642         *data_size = 2 * s->blocksize;
643     }
644     else
645     {
646     for (i = 0; i < s->channels; i++)
647     {
648         switch(s->order)
649         {
650             case INDEPENDENT:
651                 for (j = 0; j < s->blocksize; j++)
652                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
653                 break;
654             case LEFT_SIDE:
655             case RIGHT_SIDE:
656                 if (i == 0)
657                     for (j = 0; j < s->blocksize; j++)
658                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
659                 else
660                     for (j = 0; j < s->blocksize; j++)
661                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
662                 break;
663 //            case MID_SIDE:
664 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
665         }
666         *data_size += s->blocksize;
667     }
668     }
669 #else
670     switch(s->decorrelation)
671     {
672         case INDEPENDENT:
673             for (j = 0; j < s->blocksize; j++)
674             {
675                 for (i = 0; i < s->channels; i++)
676                     *(samples++) = s->decoded[i][j];
677             }
678             break;
679         case LEFT_SIDE:
680             assert(s->channels == 2);
681             for (i = 0; i < s->blocksize; i++)
682             {
683                 *(samples++) = s->decoded[0][i];
684                 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
685             }
686             break;
687         case RIGHT_SIDE:
688             assert(s->channels == 2);
689             for (i = 0; i < s->blocksize; i++)
690             {
691                 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
692                 *(samples++) = s->decoded[1][i];
693             }
694             break;
695         case MID_SIDE:
696             assert(s->channels == 2);
697             for (i = 0; i < s->blocksize; i++)
698             {
699                 int mid, side;
700                 mid = s->decoded[0][i];
701                 side = s->decoded[1][i];
702
703 #if 1 //needs to be checked but IMHO it should be binary identical
704                 mid -= side>>1;
705                 *(samples++) = mid + side;
706                 *(samples++) = mid;
707 #else
708                 
709                 mid <<= 1;
710                 if (side & 1)
711                     mid++;
712                 *(samples++) = (mid + side) >> 1;
713                 *(samples++) = (mid - side) >> 1;
714 #endif
715             }
716             break;
717     }
718 #endif
719
720     *data_size = (int8_t *)samples - (int8_t *)data;
721 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
722
723 //    s->last_blocksize = s->blocksize;
724 end:
725     i= (get_bits_count(&s->gb)+7)/8;;
726     if(i > buf_size){
727         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
728         s->bitstream_size=0;
729         s->bitstream_index=0;
730         return -1;
731     }
732
733     if(s->bitstream_size){
734         s->bitstream_index += i;
735         s->bitstream_size  -= i;
736         return input_buf_size;
737     }else 
738         return i;
739 }
740
741 static int flac_decode_close(AVCodecContext *avctx)
742 {
743     FLACContext *s = avctx->priv_data;
744     int i;
745     
746     for (i = 0; i < s->channels; i++)
747     {
748         av_freep(&s->decoded[i]);
749     }
750     av_freep(&s->bitstream);
751     
752     return 0;
753 }
754
755 static void flac_flush(AVCodecContext *avctx){
756     int i;
757     FLACContext *s = avctx->priv_data;
758
759     s->bitstream_size=
760     s->bitstream_index= 0;
761 }
762
763 AVCodec flac_decoder = {
764     "flac",
765     CODEC_TYPE_AUDIO,
766     CODEC_ID_FLAC,
767     sizeof(FLACContext),
768     flac_decode_init,
769     NULL,
770     flac_decode_close,
771     flac_decode_frame,
772     .flush= flac_flush,    
773 };