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