Fix a crash when multiple metadata packets are present.
[libav.git] / libavcodec / flac.c
CommitLineData
4f52c312
MN
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
9eda2f94
MM
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.
4f52c312
MN
32 */
33
ac2570a8
MN
34#include <limits.h>
35
4f52c312 36#include "avcodec.h"
caa336b4 37#include "bitstream.h"
4f52c312
MN
38#include "golomb.h"
39
ac2570a8
MN
40#undef NDEBUG
41#include <assert.h>
42
4f52c312
MN
43#define MAX_CHANNELS 8
44#define MAX_BLOCKSIZE 65535
9eda2f94 45#define FLAC_STREAMINFO_SIZE 34
4f52c312 46
9d656110 47enum decorrelation_type {
4f52c312
MN
48 INDEPENDENT,
49 LEFT_SIDE,
50 RIGHT_SIDE,
51 MID_SIDE,
52};
53
54typedef 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;
ac2570a8 61 int blocksize/*, last_blocksize*/;
4f52c312 62 int bps, curr_bps;
9d656110 63 enum decorrelation_type decorrelation;
4f52c312 64
ac2570a8
MN
65 int32_t *decoded[MAX_CHANNELS];
66 uint8_t *bitstream;
67 int bitstream_size;
68 int bitstream_index;
69 int allocated_bitstream_size;
4f52c312
MN
70} FLACContext;
71
72#define METADATA_TYPE_STREAMINFO 0
73
74static int sample_rate_table[] =
75{ 0, 0, 0, 0,
76 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
77 0, 0, 0, 0 };
78
79static int sample_size_table[] =
80{ 0, 8, 12, 0, 16, 20, 24, 0 };
81
0496a034
MN
82static int blocksize_table[] = {
83 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0,
84256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
85};
86
9d656110
MN
87static 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
ac2570a8 122static int64_t get_utf8(GetBitContext *gb)
4f52c312 123{
ac2570a8
MN
124 uint64_t val;
125 int ones=0, bytes;
126
127 while(get_bits1(gb))
128 ones++;
4f52c312 129
ac2570a8
MN
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--){
4f52c312
MN
136 const int tmp = get_bits(gb, 8);
137
ac2570a8
MN
138 if((tmp>>6) != 2)
139 return -1;
140 val<<=6;
141 val|= tmp&0x3F;
4f52c312 142 }
ac2570a8 143 return val;
4f52c312
MN
144}
145
41aecb13
AB
146static 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
62c438a2 167static int get_crc8(const uint8_t *buf, int count){
9d656110
MN
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
9eda2f94
MM
178static void metadata_streaminfo(FLACContext *s);
179static void dump_headers(FLACContext *s);
180
4f52c312
MN
181static int flac_decode_init(AVCodecContext * avctx)
182{
9eda2f94
MM
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
4f52c312
MN
193 return 0;
194}
195
196static void dump_headers(FLACContext *s)
197{
ac2570a8
MN
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);
4f52c312
MN
203}
204
ac2570a8 205static void allocate_buffers(FLACContext *s){
4f52c312
MN
206 int i;
207
ac2570a8
MN
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);
ac2570a8
MN
217 }
218
219 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
ac2570a8
MN
220}
221
222static void metadata_streaminfo(FLACContext *s)
223{
4f52c312
MN
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 */
ac2570a8
MN
242
243 allocate_buffers(s);
4f52c312
MN
244}
245
246static 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);
ac2570a8
MN
252 if (method_type != 0){
253 av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
4f52c312 254 return -1;
ac2570a8 255 }
4f52c312
MN
256
257 rice_order = get_bits(&s->gb, 4);
258
ac2570a8 259 samples= s->blocksize >> rice_order;
4f52c312 260
ac2570a8
MN
261 sample=
262 i= pred_order;
4f52c312
MN
263 for (partition = 0; partition < (1 << rice_order); partition++)
264 {
265 tmp = get_bits(&s->gb, 4);
ac2570a8 266 if (tmp == 15)
4f52c312 267 {
ac2570a8 268 av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
4f52c312 269 tmp = get_bits(&s->gb, 5);
4f52c312 270 for (; i < samples; i++, sample++)
4fd12598 271 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
4f52c312
MN
272 }
273 else
274 {
ac2570a8
MN
275// av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
276 for (; i < samples; i++, sample++){
4fd12598 277 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
ac2570a8 278 }
4f52c312 279 }
ac2570a8 280 i= 0;
4f52c312
MN
281 }
282
ac2570a8 283// av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
4f52c312
MN
284
285 return 0;
286}
287
288static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
289{
290 int i;
291
9d656110 292// av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME FIXED\n");
4f52c312
MN
293
294 /* warm up samples */
9d656110 295// av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
4f52c312
MN
296
297 for (i = 0; i < pred_order; i++)
298 {
ac2570a8
MN
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]);
4f52c312
MN
301 }
302
303 if (decode_residuals(s, channel, pred_order) < 0)
304 return -1;
305
306 switch(pred_order)
307 {
308 case 0:
4f52c312
MN
309 break;
310 case 1:
311 for (i = pred_order; i < s->blocksize; i++)
4fd12598 312 s->decoded[channel][i] += s->decoded[channel][i-1];
4f52c312
MN
313 break;
314 case 2:
315 for (i = pred_order; i < s->blocksize; i++)
4fd12598
MN
316 s->decoded[channel][i] += 2*s->decoded[channel][i-1]
317 - s->decoded[channel][i-2];
4f52c312
MN
318 break;
319 case 3:
320 for (i = pred_order; i < s->blocksize; i++)
4fd12598
MN
321 s->decoded[channel][i] += 3*s->decoded[channel][i-1]
322 - 3*s->decoded[channel][i-2]
323 + s->decoded[channel][i-3];
4f52c312
MN
324 break;
325 case 4:
326 for (i = pred_order; i < s->blocksize; i++)
4fd12598
MN
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];
4f52c312 331 break;
ac2570a8
MN
332 default:
333 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
334 return -1;
4f52c312 335 }
ac2570a8 336
4f52c312
MN
337 return 0;
338}
339
340static 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
ac2570a8 346// av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME LPC\n");
4f52c312
MN
347
348 /* warm up samples */
ac2570a8 349// av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
4f52c312
MN
350
351 for (i = 0; i < pred_order; i++)
352 {
ac2570a8
MN
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]);
4f52c312
MN
355 }
356
357 coeff_prec = get_bits(&s->gb, 4) + 1;
358 if (coeff_prec == 16)
359 {
ac2570a8 360 av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
4f52c312
MN
361 return -1;
362 }
9d656110 363// av_log(s->avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec);
ac2570a8 364 qlevel = get_sbits(&s->gb, 5);
9d656110
MN
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
4f52c312
MN
371 for (i = 0; i < pred_order; i++)
372 {
ac2570a8
MN
373 coeffs[i] = get_sbits(&s->gb, coeff_prec);
374// av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, coeffs[i]);
4f52c312
MN
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];
4fd12598 385 s->decoded[channel][i] += sum >> qlevel;
4f52c312
MN
386 }
387
388 return 0;
389}
390
391static 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;
ac2570a8 397 if(channel == 0){
9d656110 398 if(s->decorrelation == RIGHT_SIDE)
ac2570a8
MN
399 s->curr_bps++;
400 }else{
9d656110 401 if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
ac2570a8
MN
402 s->curr_bps++;
403 }
404
4f52c312
MN
405 if (get_bits1(&s->gb))
406 {
ac2570a8 407 av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
4f52c312
MN
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// }
ac2570a8
MN
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
4f52c312
MN
426 if (get_bits1(&s->gb))
427 {
428 wasted = 1;
429 while (!get_bits1(&s->gb))
430 wasted++;
431 s->curr_bps -= wasted;
ac2570a8 432 av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
4f52c312 433 }
ac2570a8
MN
434#endif
435//FIXME use av_log2 for types
4f52c312
MN
436 if (type == 0)
437 {
ac2570a8
MN
438 av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
439 tmp = get_sbits(&s->gb, s->curr_bps);
4f52c312
MN
440 for (i = 0; i < s->blocksize; i++)
441 s->decoded[channel][i] = tmp;
442 }
443 else if (type == 1)
444 {
ac2570a8 445 av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
4f52c312 446 for (i = 0; i < s->blocksize; i++)
ac2570a8 447 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
4f52c312
MN
448 }
449 else if ((type >= 8) && (type <= 12))
450 {
9d656110 451// av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
4f52c312
MN
452 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
453 return -1;
454 }
455 else if (type >= 32)
456 {
ac2570a8 457// av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
4f52c312
MN
458 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
459 return -1;
460 }
461 else
462 {
ac2570a8 463 av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
4f52c312
MN
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
477static int decode_frame(FLACContext *s)
478{
9d656110 479 int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
0496a034 480 int decorrelation, bps, blocksize, samplerate;
4f52c312
MN
481
482 blocksize_code = get_bits(&s->gb, 4);
4f52c312
MN
483
484 sample_rate_code = get_bits(&s->gb, 4);
4f52c312
MN
485
486 assignment = get_bits(&s->gb, 4); /* channel assignment */
0496a034
MN
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;
4f52c312
MN
491 else
492 {
0496a034 493 av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
4f52c312
MN
494 return -1;
495 }
496
497 sample_size_code = get_bits(&s->gb, 3);
0496a034
MN
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
4f52c312 503 {
ac2570a8 504 av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
4f52c312
MN
505 return -1;
506 }
507
508 if (get_bits1(&s->gb))
509 {
ac2570a8 510 av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
0496a034 511 return -1;
4f52c312
MN
512 }
513
0496a034
MN
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
ac2570a8
MN
519 if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
520 (s->min_blocksize != s->max_blocksize)){
ac2570a8 521 }else{
4f52c312 522 }
0496a034
MN
523#endif
524
ac2570a8 525 if (blocksize_code == 0)
0496a034 526 blocksize = s->min_blocksize;
ac2570a8 527 else if (blocksize_code == 6)
0496a034 528 blocksize = get_bits(&s->gb, 8)+1;
ac2570a8 529 else if (blocksize_code == 7)
0496a034
MN
530 blocksize = get_bits(&s->gb, 16)+1;
531 else
532 blocksize = blocksize_table[blocksize_code];
4f52c312 533
0496a034
MN
534 if(blocksize > s->max_blocksize){
535 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
ac2570a8
MN
536 return -1;
537 }
538
539 if (sample_rate_code == 0){
0496a034 540 samplerate= s->samplerate;
ac2570a8 541 }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
0496a034 542 samplerate = sample_rate_table[sample_rate_code];
ac2570a8 543 else if (sample_rate_code == 12)
0496a034 544 samplerate = get_bits(&s->gb, 8) * 1000;
ac2570a8 545 else if (sample_rate_code == 13)
0496a034 546 samplerate = get_bits(&s->gb, 16);
ac2570a8 547 else if (sample_rate_code == 14)
0496a034 548 samplerate = get_bits(&s->gb, 16) * 10;
ac2570a8
MN
549 else{
550 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
551 return -1;
4f52c312
MN
552 }
553
9d656110
MN
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 }
0496a034
MN
560
561 s->blocksize = blocksize;
562 s->samplerate = samplerate;
563 s->bps = bps;
564 s->decorrelation= decorrelation;
4f52c312 565
ac2570a8 566// dump_headers(s);
4f52c312
MN
567
568 /* subframes */
569 for (i = 0; i < s->channels; i++)
570 {
ac2570a8 571// av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
4f52c312
MN
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
584static 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;
ac2570a8 589 int metadata_last, metadata_type, metadata_size;
3f1899a8
MM
590 int tmp = 0, i, j = 0, input_buf_size = 0;
591 int16_t *samples = data;
4f52c312 592
ac2570a8 593 if(s->max_framesize == 0){
09f20d37 594 s->max_framesize= 65536; // should hopefully be enough for the first header
ac2570a8
MN
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
09f20d37 599 buf_size= FFMAX(FFMIN(buf_size, s->max_framesize - s->bitstream_size), 0);
ac2570a8
MN
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 }
4f52c312
MN
617
618 init_get_bits(&s->gb, buf, buf_size*8);
619
620 /* fLaC signature (be) */
ac2570a8 621 if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
4f52c312 622 {
ac2570a8
MN
623 skip_bits(&s->gb, 32);
624
625 av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
4f52c312 626 do {
ac2570a8 627 metadata_last = get_bits(&s->gb, 1);
4f52c312
MN
628 metadata_type = get_bits(&s->gb, 7);
629 metadata_size = get_bits_long(&s->gb, 24);
630
ac2570a8
MN
631 av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
632 metadata_last, metadata_type,
4f52c312 633 metadata_size);
ac2570a8
MN
634 if(metadata_size){
635 switch(metadata_type)
636 {
db2fcbbd
MN
637 case METADATA_TYPE_STREAMINFO:{
638 int bits_count= get_bits_count(&s->gb);
639
4f52c312 640 metadata_streaminfo(s);
db2fcbbd 641
4f52c312 642 dump_headers(s);
db2fcbbd 643 break;}
4f52c312 644 default:
ac2570a8 645 for(i=0; i<metadata_size; i++)
4f52c312 646 skip_bits(&s->gb, 8);
ac2570a8 647 }
4f52c312 648 }
ac2570a8 649 } while(!metadata_last);
4f52c312
MN
650 }
651 else
652 {
ac2570a8 653
9d656110 654 tmp = show_bits(&s->gb, 16);
ac2570a8
MN
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);
9d656110
MN
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;
4f52c312 666 return -1;
9d656110 667 }
4f52c312 668 }
ac2570a8 669
4f52c312
MN
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:
ac2570a8 707// av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
4f52c312
MN
708 }
709 *data_size += s->blocksize;
710 }
711 }
712#else
9d656110 713 switch(s->decorrelation)
4f52c312
MN
714 {
715 case INDEPENDENT:
ac2570a8 716 for (j = 0; j < s->blocksize; j++)
4f52c312 717 {
ac2570a8 718 for (i = 0; i < s->channels; i++)
4f52c312 719 *(samples++) = s->decoded[i][j];
4f52c312
MN
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 }
4f52c312
MN
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 }
4f52c312
MN
737 break;
738 case MID_SIDE:
739 assert(s->channels == 2);
740 for (i = 0; i < s->blocksize; i++)
741 {
ac2570a8 742 int mid, side;
4f52c312
MN
743 mid = s->decoded[0][i];
744 side = s->decoded[1][i];
9d656110
MN
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
4f52c312
MN
751
752 mid <<= 1;
753 if (side & 1)
754 mid++;
755 *(samples++) = (mid + side) >> 1;
756 *(samples++) = (mid - side) >> 1;
9d656110 757#endif
4f52c312 758 }
4f52c312
MN
759 break;
760 }
761#endif
762
ac2570a8 763 *data_size = (int8_t *)samples - (int8_t *)data;
9d656110 764// av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
4f52c312 765
ac2570a8
MN
766// s->last_blocksize = s->blocksize;
767end:
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);
9d656110
MN
771 s->bitstream_size=0;
772 s->bitstream_index=0;
ac2570a8
MN
773 return -1;
774 }
4f52c312 775
ac2570a8
MN
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;
4f52c312
MN
782}
783
784static 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 {
ac2570a8 791 av_freep(&s->decoded[i]);
4f52c312 792 }
ac2570a8 793 av_freep(&s->bitstream);
4f52c312
MN
794
795 return 0;
796}
797
1e31d32c 798static void flac_flush(AVCodecContext *avctx){
1e31d32c
MN
799 FLACContext *s = avctx->priv_data;
800
801 s->bitstream_size=
802 s->bitstream_index= 0;
803}
804
4f52c312
MN
805AVCodec 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,
1e31d32c 814 .flush= flac_flush,
4f52c312 815};