crc8 checking, based upon a patch by (Miroslav Lichvar <lichvarm at phoenix dot inf...
[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 const uint8_t table_crc8[256] = {
73     0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
74     0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
75     0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
76     0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
77     0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
78     0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
79     0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
80     0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
81     0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
82     0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
83     0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
84     0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
85     0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
86     0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
87     0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
88     0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
89     0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
90     0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
91     0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
92     0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
93     0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
94     0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
95     0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
96     0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
97     0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
98     0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
99     0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
100     0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
101     0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
102     0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
103     0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
104     0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
105 };
106
107 static int64_t get_utf8(GetBitContext *gb)
108 {
109     uint64_t val;
110     int ones=0, bytes;
111     
112     while(get_bits1(gb))
113         ones++;
114
115     if     (ones==0) bytes=0;
116     else if(ones==1) return -1;
117     else             bytes= ones - 1;
118     
119     val= get_bits(gb, 7-ones);
120     while(bytes--){
121         const int tmp = get_bits(gb, 8);
122         
123         if((tmp>>6) != 2)
124             return -1;
125         val<<=6;
126         val|= tmp&0x3F;
127     }
128     return val;
129 }
130
131 static int get_crc8(uint8_t *buf, int count){
132     int crc=0;
133     int i;
134     
135     for(i=0; i<count; i++){
136         crc = table_crc8[crc ^ buf[i]];
137     }
138
139     return crc;
140 }
141
142 static int flac_decode_init(AVCodecContext * avctx)
143 {
144     return 0;
145 }
146
147 static void dump_headers(FLACContext *s)
148 {
149     av_log(s->avctx, AV_LOG_DEBUG, "  Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
150     av_log(s->avctx, AV_LOG_DEBUG, "  Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
151     av_log(s->avctx, AV_LOG_DEBUG, "  Samplerate: %d\n", s->samplerate);
152     av_log(s->avctx, AV_LOG_DEBUG, "  Channels: %d\n", s->channels);
153     av_log(s->avctx, AV_LOG_DEBUG, "  Bits: %d\n", s->bps);
154 }
155
156 static void allocate_buffers(FLACContext *s){
157     int i;
158
159     assert(s->max_blocksize);
160
161     if(s->max_framesize == 0 && s->max_blocksize){
162         s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
163     }
164
165     for (i = 0; i < s->channels; i++)
166     {
167         s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
168     }
169
170     s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
171 //    s->bitstream= av_realloc(s->bitstream, s->max_framesize);
172 }
173
174 static void metadata_streaminfo(FLACContext *s)
175 {
176     /* mandatory streaminfo */
177     s->min_blocksize = get_bits(&s->gb, 16);
178     s->max_blocksize = get_bits(&s->gb, 16);
179
180     s->min_framesize = get_bits_long(&s->gb, 24);
181     s->max_framesize = get_bits_long(&s->gb, 24);
182     
183     s->samplerate = get_bits_long(&s->gb, 20);
184     s->channels = get_bits(&s->gb, 3) + 1;
185     s->bps = get_bits(&s->gb, 5) + 1;
186     
187     s->avctx->channels = s->channels;
188     s->avctx->sample_rate = s->samplerate;
189
190     skip_bits(&s->gb, 36); /* total num of samples */
191     
192     skip_bits(&s->gb, 64); /* md5 sum */
193     skip_bits(&s->gb, 64); /* md5 sum */
194     
195     allocate_buffers(s);
196 }
197
198 static int decode_residuals(FLACContext *s, int channel, int pred_order)
199 {
200     int i, tmp, partition, method_type, rice_order;
201     int sample = 0, samples;
202
203     method_type = get_bits(&s->gb, 2);
204     if (method_type != 0){
205         av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
206         return -1;
207     }
208     
209     rice_order = get_bits(&s->gb, 4);
210
211     samples= s->blocksize >> rice_order;
212
213     sample= 
214     i= pred_order;
215     for (partition = 0; partition < (1 << rice_order); partition++)
216     {
217         tmp = get_bits(&s->gb, 4);
218         if (tmp == 15)
219         {
220             av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
221             tmp = get_bits(&s->gb, 5);
222             for (; i < samples; i++, sample++)
223                 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
224         }
225         else
226         {
227 //            av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
228             for (; i < samples; i++, sample++){
229                 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
230                 if(get_bits_count(&s->gb) > s->gb.size_in_bits){
231                     av_log(s->avctx, AV_LOG_ERROR, "fucking FLAC\n");
232                     return -1;
233                 }
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     
437     blocksize_code = get_bits(&s->gb, 4);
438
439     sample_rate_code = get_bits(&s->gb, 4);
440     
441     assignment = get_bits(&s->gb, 4); /* channel assignment */
442     if (assignment < 8)
443     {
444         s->decorrelation = INDEPENDENT;
445         if (s->channels != assignment+1)
446             av_log(s->avctx, AV_LOG_DEBUG, "channel number and number of assigned channels differ!\n");
447 //        av_log(s->avctx, AV_LOG_DEBUG, "channels: %d\n", assignment+1);
448     }
449     else if (assignment < 11)
450     {
451         s->decorrelation= LEFT_SIDE + assignment - 8;
452     }
453     else
454     {
455         av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment\n");
456         return -1;
457     }
458
459     if ((assignment >= 8) && (s->channels != 2))
460     {
461         return -1;
462     }
463         
464     sample_size_code = get_bits(&s->gb, 3);
465     if (sample_size_code != 0)
466         s->bps = sample_size_table[sample_size_code];
467
468     if ((sample_size_code == 3) || (sample_size_code == 7))
469     {
470         av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
471         return -1;
472     }
473
474     if (get_bits1(&s->gb))
475     {
476         av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
477 //        return -1;
478     }
479     
480     if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
481         (s->min_blocksize != s->max_blocksize)){
482         if(get_utf8(&s->gb) < 0){
483             av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
484             return -1;
485         }
486     }else{
487         if(get_utf8(&s->gb) < 0){
488             av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
489             return -1;
490         }
491     }
492
493     if (blocksize_code == 0)
494         s->blocksize = s->min_blocksize;
495     else if (blocksize_code == 1)
496         s->blocksize = 192;
497     else if (blocksize_code <= 5)
498         s->blocksize = 576 << (blocksize_code - 2);
499     else if (blocksize_code == 6)
500         s->blocksize = get_bits(&s->gb, 8)+1;
501     else if (blocksize_code == 7)
502         s->blocksize = get_bits(&s->gb, 16)+1;
503     else if (blocksize_code >= 8)
504         s->blocksize = 256 << (blocksize_code - 8);
505
506     if(s->blocksize > s->max_blocksize){
507         av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", s->blocksize, s->max_blocksize);
508         return -1;
509     }
510
511     if (sample_rate_code == 0){
512         //Streaminfo
513     }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
514         s->samplerate = sample_rate_table[sample_rate_code];
515     else if (sample_rate_code == 12)
516                 s->samplerate = get_bits(&s->gb, 8) * 1000;
517     else if (sample_rate_code == 13)
518                 s->samplerate = get_bits(&s->gb, 16);
519     else if (sample_rate_code == 14)
520                 s->samplerate = get_bits(&s->gb, 16) * 10;
521     else{
522         av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
523         return -1;
524     }
525
526     skip_bits(&s->gb, 8);
527     crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
528     if(crc8){
529         av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
530         return -1;
531     }
532
533 //    dump_headers(s);
534
535     /* subframes */
536     for (i = 0; i < s->channels; i++)
537     {
538 //        av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
539         if (decode_subframe(s, i) < 0)
540             return -1;
541     }
542     
543     align_get_bits(&s->gb);
544
545     /* frame footer */
546     skip_bits(&s->gb, 16); /* data crc */
547
548     return 0;
549 }
550
551 static int flac_decode_frame(AVCodecContext *avctx,
552                             void *data, int *data_size,
553                             uint8_t *buf, int buf_size)
554 {
555     FLACContext *s = avctx->priv_data;
556     int metadata_last, metadata_type, metadata_size;
557     int tmp = 0, i, j = 0, input_buf_size;
558     int16_t *samples = data, *left, *right;
559
560     *data_size = 0;
561
562     s->avctx = avctx;
563     
564     if(s->max_framesize == 0){
565         s->max_framesize= 8192; // should hopefully be enough for the first header
566         s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
567     }
568
569     if(1 && s->max_framesize){//FIXME truncated
570             buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
571             input_buf_size= buf_size;
572
573             if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
574 //                printf("memmove\n");
575                 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
576                 s->bitstream_index=0;
577             }
578             memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
579             buf= &s->bitstream[s->bitstream_index];
580             buf_size += s->bitstream_size;
581             s->bitstream_size= buf_size;
582             
583             if(buf_size < s->max_framesize){
584 //                printf("wanna more data ...\n");
585                 return input_buf_size;
586             }
587     }
588
589     init_get_bits(&s->gb, buf, buf_size*8);
590     
591     /* fLaC signature (be) */
592     if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
593     {
594         skip_bits(&s->gb, 32);
595
596         av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
597         do {
598             metadata_last = get_bits(&s->gb, 1);
599             metadata_type = get_bits(&s->gb, 7);
600             metadata_size = get_bits_long(&s->gb, 24);
601             
602             av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
603                 metadata_last, metadata_type,
604                 metadata_size);
605             if(metadata_size){
606                 switch(metadata_type)
607                 {
608                 case METADATA_TYPE_STREAMINFO:
609                     metadata_streaminfo(s);
610                     dump_headers(s);
611                     break;
612                 default:
613                     for(i=0; i<metadata_size; i++)
614                         skip_bits(&s->gb, 8);
615                 }
616             }
617         } while(!metadata_last);
618     }
619     else
620     {
621         
622         tmp = show_bits(&s->gb, 16);
623         if(tmp != 0xFFF8){
624             av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
625             while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
626                 skip_bits(&s->gb, 8);
627             goto end; // we may not have enough bits left to decode a frame, so try next time
628         }
629         skip_bits(&s->gb, 16);
630         if (decode_frame(s) < 0){
631             av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
632             s->bitstream_size=0;
633             s->bitstream_index=0;
634             return -1;
635         }
636     }
637
638     
639 #if 0
640     /* fix the channel order here */
641     if (s->order == MID_SIDE)
642     {
643         short *left = samples;
644         short *right = samples + s->blocksize;
645         for (i = 0; i < s->blocksize; i += 2)
646         {
647             uint32_t x = s->decoded[0][i];
648             uint32_t y = s->decoded[0][i+1];
649
650             right[i] = x - (y / 2);
651             left[i] = right[i] + y;
652         }
653         *data_size = 2 * s->blocksize;
654     }
655     else
656     {
657     for (i = 0; i < s->channels; i++)
658     {
659         switch(s->order)
660         {
661             case INDEPENDENT:
662                 for (j = 0; j < s->blocksize; j++)
663                     samples[(s->blocksize*i)+j] = s->decoded[i][j];
664                 break;
665             case LEFT_SIDE:
666             case RIGHT_SIDE:
667                 if (i == 0)
668                     for (j = 0; j < s->blocksize; j++)
669                         samples[(s->blocksize*i)+j] = s->decoded[0][j];
670                 else
671                     for (j = 0; j < s->blocksize; j++)
672                         samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
673                 break;
674 //            case MID_SIDE:
675 //                av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
676         }
677         *data_size += s->blocksize;
678     }
679     }
680 #else
681     switch(s->decorrelation)
682     {
683         case INDEPENDENT:
684             for (j = 0; j < s->blocksize; j++)
685             {
686                 for (i = 0; i < s->channels; i++)
687                     *(samples++) = s->decoded[i][j];
688             }
689             break;
690         case LEFT_SIDE:
691             assert(s->channels == 2);
692             for (i = 0; i < s->blocksize; i++)
693             {
694                 *(samples++) = s->decoded[0][i];
695                 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
696             }
697             break;
698         case RIGHT_SIDE:
699             assert(s->channels == 2);
700             for (i = 0; i < s->blocksize; i++)
701             {
702                 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
703                 *(samples++) = s->decoded[1][i];
704             }
705             break;
706         case MID_SIDE:
707             assert(s->channels == 2);
708             for (i = 0; i < s->blocksize; i++)
709             {
710                 int mid, side;
711                 mid = s->decoded[0][i];
712                 side = s->decoded[1][i];
713
714 #if 1 //needs to be checked but IMHO it should be binary identical
715                 mid -= side>>1;
716                 *(samples++) = mid + side;
717                 *(samples++) = mid;
718 #else
719                 
720                 mid <<= 1;
721                 if (side & 1)
722                     mid++;
723                 *(samples++) = (mid + side) >> 1;
724                 *(samples++) = (mid - side) >> 1;
725 #endif
726             }
727             break;
728     }
729 #endif
730
731     *data_size = (int8_t *)samples - (int8_t *)data;
732 //    av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
733
734 //    s->last_blocksize = s->blocksize;
735 end:
736     i= (get_bits_count(&s->gb)+7)/8;;
737     if(i > buf_size){
738         av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
739         s->bitstream_size=0;
740         s->bitstream_index=0;
741         return -1;
742     }
743
744     if(s->bitstream_size){
745         s->bitstream_index += i;
746         s->bitstream_size  -= i;
747         return input_buf_size;
748     }else 
749         return i;
750 }
751
752 static int flac_decode_close(AVCodecContext *avctx)
753 {
754     FLACContext *s = avctx->priv_data;
755     int i;
756     
757     for (i = 0; i < s->channels; i++)
758     {
759         av_freep(&s->decoded[i]);
760     }
761     av_freep(&s->bitstream);
762     
763     return 0;
764 }
765
766 AVCodec flac_decoder = {
767     "flac",
768     CODEC_TYPE_AUDIO,
769     CODEC_ID_FLAC,
770     sizeof(FLACContext),
771     flac_decode_init,
772     NULL,
773     flac_decode_close,
774     flac_decode_frame,
775 };