2 * FLAC (Free Lossless Audio Codec) decoder
3 * Copyright (c) 2003 Alex Beregszaszi
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.
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.
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
22 * FLAC (Free Lossless Audio Codec) decoder
23 * @author Alex Beregszaszi
25 * For more information on the FLAC format, visit:
26 * http://flac.sourceforge.net/
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.
42 #define MAX_CHANNELS 8
43 #define MAX_BLOCKSIZE 65535
44 #define FLAC_STREAMINFO_SIZE 34
46 enum decorrelation_type {
53 typedef struct FLACContext {
54 AVCodecContext *avctx;
57 int min_blocksize, max_blocksize;
58 int min_framesize, max_framesize;
59 int samplerate, channels;
60 int blocksize/*, last_blocksize*/;
62 enum decorrelation_type decorrelation;
64 int32_t *decoded[MAX_CHANNELS];
68 int allocated_bitstream_size;
71 #define METADATA_TYPE_STREAMINFO 0
73 static int sample_rate_table[] =
75 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
78 static int sample_size_table[] =
79 { 0, 8, 12, 0, 16, 20, 24, 0 };
81 static int blocksize_table[] = {
82 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0,
83 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
86 static const uint8_t table_crc8[256] = {
87 0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15,
88 0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d,
89 0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65,
90 0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d,
91 0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5,
92 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd,
93 0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85,
94 0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd,
95 0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2,
96 0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea,
97 0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2,
98 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a,
99 0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32,
100 0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a,
101 0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42,
102 0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a,
103 0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c,
104 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4,
105 0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec,
106 0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4,
107 0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c,
108 0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44,
109 0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c,
110 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34,
111 0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b,
112 0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63,
113 0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b,
114 0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13,
115 0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb,
116 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83,
117 0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb,
118 0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3
121 static int64_t get_utf8(GetBitContext *gb)
129 if (ones==0) bytes=0;
130 else if(ones==1) return -1;
131 else bytes= ones - 1;
133 val= get_bits(gb, 7-ones);
135 const int tmp = get_bits(gb, 8);
145 static int get_crc8(const uint8_t *buf, int count){
149 for(i=0; i<count; i++){
150 crc = table_crc8[crc ^ buf[i]];
156 static void metadata_streaminfo(FLACContext *s);
157 static void dump_headers(FLACContext *s);
159 static int flac_decode_init(AVCodecContext * avctx)
161 FLACContext *s = avctx->priv_data;
164 /* initialize based on the demuxer-supplied streamdata header */
165 if (avctx->extradata_size == FLAC_STREAMINFO_SIZE) {
166 init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size*8);
167 metadata_streaminfo(s);
174 static void dump_headers(FLACContext *s)
176 av_log(s->avctx, AV_LOG_DEBUG, " Blocksize: %d .. %d (%d)\n", s->min_blocksize, s->max_blocksize, s->blocksize);
177 av_log(s->avctx, AV_LOG_DEBUG, " Framesize: %d .. %d\n", s->min_framesize, s->max_framesize);
178 av_log(s->avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
179 av_log(s->avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
180 av_log(s->avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
183 static void allocate_buffers(FLACContext *s){
186 assert(s->max_blocksize);
188 if(s->max_framesize == 0 && s->max_blocksize){
189 s->max_framesize= (s->channels * s->bps * s->max_blocksize + 7)/ 8; //FIXME header overhead
192 for (i = 0; i < s->channels; i++)
194 s->decoded[i] = av_realloc(s->decoded[i], sizeof(int32_t)*s->max_blocksize);
197 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
200 static void metadata_streaminfo(FLACContext *s)
202 /* mandatory streaminfo */
203 s->min_blocksize = get_bits(&s->gb, 16);
204 s->max_blocksize = get_bits(&s->gb, 16);
206 s->min_framesize = get_bits_long(&s->gb, 24);
207 s->max_framesize = get_bits_long(&s->gb, 24);
209 s->samplerate = get_bits_long(&s->gb, 20);
210 s->channels = get_bits(&s->gb, 3) + 1;
211 s->bps = get_bits(&s->gb, 5) + 1;
213 s->avctx->channels = s->channels;
214 s->avctx->sample_rate = s->samplerate;
216 skip_bits(&s->gb, 36); /* total num of samples */
218 skip_bits(&s->gb, 64); /* md5 sum */
219 skip_bits(&s->gb, 64); /* md5 sum */
224 static int decode_residuals(FLACContext *s, int channel, int pred_order)
226 int i, tmp, partition, method_type, rice_order;
227 int sample = 0, samples;
229 method_type = get_bits(&s->gb, 2);
230 if (method_type != 0){
231 av_log(s->avctx, AV_LOG_DEBUG, "illegal residual coding method %d\n", method_type);
235 rice_order = get_bits(&s->gb, 4);
237 samples= s->blocksize >> rice_order;
241 for (partition = 0; partition < (1 << rice_order); partition++)
243 tmp = get_bits(&s->gb, 4);
246 av_log(s->avctx, AV_LOG_DEBUG, "fixed len partition\n");
247 tmp = get_bits(&s->gb, 5);
248 for (; i < samples; i++, sample++)
249 s->decoded[channel][sample] = get_sbits(&s->gb, tmp);
253 // av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
254 for (; i < samples; i++, sample++){
255 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
261 // av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
266 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
270 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME FIXED\n");
272 /* warm up samples */
273 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
275 for (i = 0; i < pred_order; i++)
277 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
278 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]);
281 if (decode_residuals(s, channel, pred_order) < 0)
289 for (i = pred_order; i < s->blocksize; i++)
290 s->decoded[channel][i] += s->decoded[channel][i-1];
293 for (i = pred_order; i < s->blocksize; i++)
294 s->decoded[channel][i] += 2*s->decoded[channel][i-1]
295 - s->decoded[channel][i-2];
298 for (i = pred_order; i < s->blocksize; i++)
299 s->decoded[channel][i] += 3*s->decoded[channel][i-1]
300 - 3*s->decoded[channel][i-2]
301 + s->decoded[channel][i-3];
304 for (i = pred_order; i < s->blocksize; i++)
305 s->decoded[channel][i] += 4*s->decoded[channel][i-1]
306 - 6*s->decoded[channel][i-2]
307 + 4*s->decoded[channel][i-3]
308 - s->decoded[channel][i-4];
311 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
318 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
321 int coeff_prec, qlevel;
322 int coeffs[pred_order];
324 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME LPC\n");
326 /* warm up samples */
327 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
329 for (i = 0; i < pred_order; i++)
331 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
332 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]);
335 coeff_prec = get_bits(&s->gb, 4) + 1;
336 if (coeff_prec == 16)
338 av_log(s->avctx, AV_LOG_DEBUG, "invalid coeff precision\n");
341 // av_log(s->avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec);
342 qlevel = get_sbits(&s->gb, 5);
343 // av_log(s->avctx, AV_LOG_DEBUG, " quant level: %d\n", qlevel);
345 av_log(s->avctx, AV_LOG_DEBUG, "qlevel %d not supported, maybe buggy stream\n", qlevel);
349 for (i = 0; i < pred_order; i++)
351 coeffs[i] = get_sbits(&s->gb, coeff_prec);
352 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, coeffs[i]);
355 if (decode_residuals(s, channel, pred_order) < 0)
358 for (i = pred_order; i < s->blocksize; i++)
361 for (j = 0; j < pred_order; j++)
362 sum += coeffs[j] * s->decoded[channel][i-j-1];
363 s->decoded[channel][i] += sum >> qlevel;
369 static inline int decode_subframe(FLACContext *s, int channel)
371 int type, wasted = 0;
374 s->curr_bps = s->bps;
376 if(s->decorrelation == RIGHT_SIDE)
379 if(s->decorrelation == LEFT_SIDE || s->decorrelation == MID_SIDE)
383 if (get_bits1(&s->gb))
385 av_log(s->avctx, AV_LOG_DEBUG, "invalid subframe padding\n");
388 type = get_bits(&s->gb, 6);
389 // wasted = get_bits1(&s->gb);
393 // while (!get_bits1(&s->gb))
397 // s->curr_bps -= wasted;
400 wasted= 16 - av_log2(show_bits(&s->gb, 17));
401 skip_bits(&s->gb, wasted+1);
402 s->curr_bps -= wasted;
404 if (get_bits1(&s->gb))
407 while (!get_bits1(&s->gb))
409 s->curr_bps -= wasted;
410 av_log(s->avctx, AV_LOG_DEBUG, "%d wasted bits\n", wasted);
413 //FIXME use av_log2 for types
416 av_log(s->avctx, AV_LOG_DEBUG, "coding type: constant\n");
417 tmp = get_sbits(&s->gb, s->curr_bps);
418 for (i = 0; i < s->blocksize; i++)
419 s->decoded[channel][i] = tmp;
423 av_log(s->avctx, AV_LOG_DEBUG, "coding type: verbatim\n");
424 for (i = 0; i < s->blocksize; i++)
425 s->decoded[channel][i] = get_sbits(&s->gb, s->curr_bps);
427 else if ((type >= 8) && (type <= 12))
429 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
430 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
435 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
436 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
441 av_log(s->avctx, AV_LOG_DEBUG, "invalid coding type\n");
448 for (i = 0; i < s->blocksize; i++)
449 s->decoded[channel][i] <<= wasted;
455 static int decode_frame(FLACContext *s)
457 int blocksize_code, sample_rate_code, sample_size_code, assignment, i, crc8;
458 int decorrelation, bps, blocksize, samplerate;
460 blocksize_code = get_bits(&s->gb, 4);
462 sample_rate_code = get_bits(&s->gb, 4);
464 assignment = get_bits(&s->gb, 4); /* channel assignment */
465 if (assignment < 8 && s->channels == assignment+1)
466 decorrelation = INDEPENDENT;
467 else if (assignment >=8 && assignment < 11 && s->channels == 2)
468 decorrelation = LEFT_SIDE + assignment - 8;
471 av_log(s->avctx, AV_LOG_DEBUG, "unsupported channel assignment %d (channels=%d)\n", assignment, s->channels);
475 sample_size_code = get_bits(&s->gb, 3);
476 if(sample_size_code == 0)
478 else if((sample_size_code != 3) && (sample_size_code != 7))
479 bps = sample_size_table[sample_size_code];
482 av_log(s->avctx, AV_LOG_DEBUG, "invalid sample size code (%d)\n", sample_size_code);
486 if (get_bits1(&s->gb))
488 av_log(s->avctx, AV_LOG_DEBUG, "broken stream, invalid padding\n");
492 if(get_utf8(&s->gb) < 0){
493 av_log(s->avctx, AV_LOG_ERROR, "utf8 fscked\n");
497 if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
498 (s->min_blocksize != s->max_blocksize)){
503 if (blocksize_code == 0)
504 blocksize = s->min_blocksize;
505 else if (blocksize_code == 6)
506 blocksize = get_bits(&s->gb, 8)+1;
507 else if (blocksize_code == 7)
508 blocksize = get_bits(&s->gb, 16)+1;
510 blocksize = blocksize_table[blocksize_code];
512 if(blocksize > s->max_blocksize){
513 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", blocksize, s->max_blocksize);
517 if (sample_rate_code == 0){
518 samplerate= s->samplerate;
519 }else if ((sample_rate_code > 3) && (sample_rate_code < 12))
520 samplerate = sample_rate_table[sample_rate_code];
521 else if (sample_rate_code == 12)
522 samplerate = get_bits(&s->gb, 8) * 1000;
523 else if (sample_rate_code == 13)
524 samplerate = get_bits(&s->gb, 16);
525 else if (sample_rate_code == 14)
526 samplerate = get_bits(&s->gb, 16) * 10;
528 av_log(s->avctx, AV_LOG_ERROR, "illegal sample rate code %d\n", sample_rate_code);
532 skip_bits(&s->gb, 8);
533 crc8= get_crc8(s->gb.buffer, get_bits_count(&s->gb)/8);
535 av_log(s->avctx, AV_LOG_ERROR, "header crc missmatch crc=%2X\n", crc8);
539 s->blocksize = blocksize;
540 s->samplerate = samplerate;
542 s->decorrelation= decorrelation;
547 for (i = 0; i < s->channels; i++)
549 // av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
550 if (decode_subframe(s, i) < 0)
554 align_get_bits(&s->gb);
557 skip_bits(&s->gb, 16); /* data crc */
562 static int flac_decode_frame(AVCodecContext *avctx,
563 void *data, int *data_size,
564 uint8_t *buf, int buf_size)
566 FLACContext *s = avctx->priv_data;
567 int metadata_last, metadata_type, metadata_size;
568 int tmp = 0, i, j = 0, input_buf_size = 0;
569 int16_t *samples = data;
571 if(s->max_framesize == 0){
572 s->max_framesize= 8192; // should hopefully be enough for the first header
573 s->bitstream= av_fast_realloc(s->bitstream, &s->allocated_bitstream_size, s->max_framesize);
576 if(1 && s->max_framesize){//FIXME truncated
577 buf_size= FFMIN(buf_size, s->max_framesize - s->bitstream_size);
578 input_buf_size= buf_size;
580 if(s->bitstream_index + s->bitstream_size + buf_size > s->allocated_bitstream_size){
581 // printf("memmove\n");
582 memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
583 s->bitstream_index=0;
585 memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], buf, buf_size);
586 buf= &s->bitstream[s->bitstream_index];
587 buf_size += s->bitstream_size;
588 s->bitstream_size= buf_size;
590 if(buf_size < s->max_framesize){
591 // printf("wanna more data ...\n");
592 return input_buf_size;
596 init_get_bits(&s->gb, buf, buf_size*8);
598 /* fLaC signature (be) */
599 if (show_bits_long(&s->gb, 32) == bswap_32(ff_get_fourcc("fLaC")))
601 skip_bits(&s->gb, 32);
603 av_log(s->avctx, AV_LOG_DEBUG, "STREAM HEADER\n");
605 metadata_last = get_bits(&s->gb, 1);
606 metadata_type = get_bits(&s->gb, 7);
607 metadata_size = get_bits_long(&s->gb, 24);
609 av_log(s->avctx, AV_LOG_DEBUG, " metadata block: flag = %d, type = %d, size = %d\n",
610 metadata_last, metadata_type,
613 switch(metadata_type)
615 case METADATA_TYPE_STREAMINFO:
616 metadata_streaminfo(s);
620 for(i=0; i<metadata_size; i++)
621 skip_bits(&s->gb, 8);
624 } while(!metadata_last);
629 tmp = show_bits(&s->gb, 16);
631 av_log(s->avctx, AV_LOG_ERROR, "FRAME HEADER not here\n");
632 while(get_bits_count(&s->gb)/8+2 < buf_size && show_bits(&s->gb, 16) != 0xFFF8)
633 skip_bits(&s->gb, 8);
634 goto end; // we may not have enough bits left to decode a frame, so try next time
636 skip_bits(&s->gb, 16);
637 if (decode_frame(s) < 0){
638 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
640 s->bitstream_index=0;
647 /* fix the channel order here */
648 if (s->order == MID_SIDE)
650 short *left = samples;
651 short *right = samples + s->blocksize;
652 for (i = 0; i < s->blocksize; i += 2)
654 uint32_t x = s->decoded[0][i];
655 uint32_t y = s->decoded[0][i+1];
657 right[i] = x - (y / 2);
658 left[i] = right[i] + y;
660 *data_size = 2 * s->blocksize;
664 for (i = 0; i < s->channels; i++)
669 for (j = 0; j < s->blocksize; j++)
670 samples[(s->blocksize*i)+j] = s->decoded[i][j];
675 for (j = 0; j < s->blocksize; j++)
676 samples[(s->blocksize*i)+j] = s->decoded[0][j];
678 for (j = 0; j < s->blocksize; j++)
679 samples[(s->blocksize*i)+j] = s->decoded[0][j] - s->decoded[i][j];
682 // av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
684 *data_size += s->blocksize;
688 switch(s->decorrelation)
691 for (j = 0; j < s->blocksize; j++)
693 for (i = 0; i < s->channels; i++)
694 *(samples++) = s->decoded[i][j];
698 assert(s->channels == 2);
699 for (i = 0; i < s->blocksize; i++)
701 *(samples++) = s->decoded[0][i];
702 *(samples++) = s->decoded[0][i] - s->decoded[1][i];
706 assert(s->channels == 2);
707 for (i = 0; i < s->blocksize; i++)
709 *(samples++) = s->decoded[0][i] + s->decoded[1][i];
710 *(samples++) = s->decoded[1][i];
714 assert(s->channels == 2);
715 for (i = 0; i < s->blocksize; i++)
718 mid = s->decoded[0][i];
719 side = s->decoded[1][i];
721 #if 1 //needs to be checked but IMHO it should be binary identical
723 *(samples++) = mid + side;
730 *(samples++) = (mid + side) >> 1;
731 *(samples++) = (mid - side) >> 1;
738 *data_size = (int8_t *)samples - (int8_t *)data;
739 // av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
741 // s->last_blocksize = s->blocksize;
743 i= (get_bits_count(&s->gb)+7)/8;;
745 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", i - buf_size);
747 s->bitstream_index=0;
751 if(s->bitstream_size){
752 s->bitstream_index += i;
753 s->bitstream_size -= i;
754 return input_buf_size;
759 static int flac_decode_close(AVCodecContext *avctx)
761 FLACContext *s = avctx->priv_data;
764 for (i = 0; i < s->channels; i++)
766 av_freep(&s->decoded[i]);
768 av_freep(&s->bitstream);
773 static void flac_flush(AVCodecContext *avctx){
774 FLACContext *s = avctx->priv_data;
777 s->bitstream_index= 0;
780 AVCodec flac_decoder = {