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