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