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