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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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.
37 #include "bitstream.h"
44 #define MAX_CHANNELS 8
45 #define MAX_BLOCKSIZE 65535
46 #define FLAC_STREAMINFO_SIZE 34
48 enum decorrelation_type
{
55 typedef struct FLACContext
{
56 AVCodecContext
*avctx
;
59 int min_blocksize
, max_blocksize
;
60 int min_framesize
, max_framesize
;
61 int samplerate
, channels
;
62 int blocksize
/*, last_blocksize*/;
64 enum decorrelation_type decorrelation
;
66 int32_t *decoded
[MAX_CHANNELS
];
70 unsigned int allocated_bitstream_size
;
73 #define METADATA_TYPE_STREAMINFO 0
75 static int sample_rate_table
[] =
77 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
80 static int sample_size_table
[] =
81 { 0, 8, 12, 0, 16, 20, 24, 0 };
83 static int blocksize_table
[] = {
84 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0,
85 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
88 static int64_t get_utf8(GetBitContext
*gb
)
97 else if(ones
==1) return -1;
100 val
= get_bits(gb
, 7-ones
);
102 const int tmp
= get_bits(gb
, 8);
113 static int skip_utf8(GetBitContext
*gb
)
120 if (ones
==0) bytes
=0;
121 else if(ones
==1) return -1;
122 else bytes
= ones
- 1;
124 skip_bits(gb
, 7-ones
);
126 const int tmp
= get_bits(gb
, 8);
135 static void metadata_streaminfo(FLACContext
*s
);
136 static void dump_headers(FLACContext
*s
);
138 static int flac_decode_init(AVCodecContext
* avctx
)
140 FLACContext
*s
= avctx
->priv_data
;
143 /* initialize based on the demuxer-supplied streamdata header */
144 if (avctx
->extradata_size
== FLAC_STREAMINFO_SIZE
) {
145 init_get_bits(&s
->gb
, avctx
->extradata
, avctx
->extradata_size
*8);
146 metadata_streaminfo(s
);
153 static void dump_headers(FLACContext
*s
)
155 av_log(s
->avctx
, AV_LOG_DEBUG
, " Blocksize: %d .. %d (%d)\n", s
->min_blocksize
, s
->max_blocksize
, s
->blocksize
);
156 av_log(s
->avctx
, AV_LOG_DEBUG
, " Framesize: %d .. %d\n", s
->min_framesize
, s
->max_framesize
);
157 av_log(s
->avctx
, AV_LOG_DEBUG
, " Samplerate: %d\n", s
->samplerate
);
158 av_log(s
->avctx
, AV_LOG_DEBUG
, " Channels: %d\n", s
->channels
);
159 av_log(s
->avctx
, AV_LOG_DEBUG
, " Bits: %d\n", s
->bps
);
162 static void allocate_buffers(FLACContext
*s
){
165 assert(s
->max_blocksize
);
167 if(s
->max_framesize
== 0 && s
->max_blocksize
){
168 s
->max_framesize
= (s
->channels
* s
->bps
* s
->max_blocksize
+ 7)/ 8; //FIXME header overhead
171 for (i
= 0; i
< s
->channels
; i
++)
173 s
->decoded
[i
] = av_realloc(s
->decoded
[i
], sizeof(int32_t)*s
->max_blocksize
);
176 s
->bitstream
= av_fast_realloc(s
->bitstream
, &s
->allocated_bitstream_size
, s
->max_framesize
);
179 static void metadata_streaminfo(FLACContext
*s
)
181 /* mandatory streaminfo */
182 s
->min_blocksize
= get_bits(&s
->gb
, 16);
183 s
->max_blocksize
= get_bits(&s
->gb
, 16);
185 s
->min_framesize
= get_bits_long(&s
->gb
, 24);
186 s
->max_framesize
= get_bits_long(&s
->gb
, 24);
188 s
->samplerate
= get_bits_long(&s
->gb
, 20);
189 s
->channels
= get_bits(&s
->gb
, 3) + 1;
190 s
->bps
= get_bits(&s
->gb
, 5) + 1;
192 s
->avctx
->channels
= s
->channels
;
193 s
->avctx
->sample_rate
= s
->samplerate
;
195 skip_bits(&s
->gb
, 36); /* total num of samples */
197 skip_bits(&s
->gb
, 64); /* md5 sum */
198 skip_bits(&s
->gb
, 64); /* md5 sum */
203 static int decode_residuals(FLACContext
*s
, int channel
, int pred_order
)
205 int i
, tmp
, partition
, method_type
, rice_order
;
206 int sample
= 0, samples
;
208 method_type
= get_bits(&s
->gb
, 2);
209 if (method_type
!= 0){
210 av_log(s
->avctx
, AV_LOG_DEBUG
, "illegal residual coding method %d\n", method_type
);
214 rice_order
= get_bits(&s
->gb
, 4);
216 samples
= s
->blocksize
>> rice_order
;
220 for (partition
= 0; partition
< (1 << rice_order
); partition
++)
222 tmp
= get_bits(&s
->gb
, 4);
225 av_log(s
->avctx
, AV_LOG_DEBUG
, "fixed len partition\n");
226 tmp
= get_bits(&s
->gb
, 5);
227 for (; i
< samples
; i
++, sample
++)
228 s
->decoded
[channel
][sample
] = get_sbits(&s
->gb
, tmp
);
232 // av_log(s->avctx, AV_LOG_DEBUG, "rice coded partition k=%d\n", tmp);
233 for (; i
< samples
; i
++, sample
++){
234 s
->decoded
[channel
][sample
] = get_sr_golomb_flac(&s
->gb
, tmp
, INT_MAX
, 0);
240 // av_log(s->avctx, AV_LOG_DEBUG, "partitions: %d, samples: %d\n", 1 << rice_order, sample);
245 static int decode_subframe_fixed(FLACContext
*s
, int channel
, int pred_order
)
249 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME FIXED\n");
251 /* warm up samples */
252 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
254 for (i
= 0; i
< pred_order
; i
++)
256 s
->decoded
[channel
][i
] = get_sbits(&s
->gb
, s
->curr_bps
);
257 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]);
260 if (decode_residuals(s
, channel
, pred_order
) < 0)
268 for (i
= pred_order
; i
< s
->blocksize
; i
++)
269 s
->decoded
[channel
][i
] += s
->decoded
[channel
][i
-1];
272 for (i
= pred_order
; i
< s
->blocksize
; i
++)
273 s
->decoded
[channel
][i
] += 2*s
->decoded
[channel
][i
-1]
274 - s
->decoded
[channel
][i
-2];
277 for (i
= pred_order
; i
< s
->blocksize
; i
++)
278 s
->decoded
[channel
][i
] += 3*s
->decoded
[channel
][i
-1]
279 - 3*s
->decoded
[channel
][i
-2]
280 + s
->decoded
[channel
][i
-3];
283 for (i
= pred_order
; i
< s
->blocksize
; i
++)
284 s
->decoded
[channel
][i
] += 4*s
->decoded
[channel
][i
-1]
285 - 6*s
->decoded
[channel
][i
-2]
286 + 4*s
->decoded
[channel
][i
-3]
287 - s
->decoded
[channel
][i
-4];
290 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal pred order %d\n", pred_order
);
297 static int decode_subframe_lpc(FLACContext
*s
, int channel
, int pred_order
)
300 int coeff_prec
, qlevel
;
301 int coeffs
[pred_order
];
303 // av_log(s->avctx, AV_LOG_DEBUG, " SUBFRAME LPC\n");
305 /* warm up samples */
306 // av_log(s->avctx, AV_LOG_DEBUG, " warm up samples: %d\n", pred_order);
308 for (i
= 0; i
< pred_order
; i
++)
310 s
->decoded
[channel
][i
] = get_sbits(&s
->gb
, s
->curr_bps
);
311 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, s->decoded[channel][i]);
314 coeff_prec
= get_bits(&s
->gb
, 4) + 1;
315 if (coeff_prec
== 16)
317 av_log(s
->avctx
, AV_LOG_DEBUG
, "invalid coeff precision\n");
320 // av_log(s->avctx, AV_LOG_DEBUG, " qlp coeff prec: %d\n", coeff_prec);
321 qlevel
= get_sbits(&s
->gb
, 5);
322 // av_log(s->avctx, AV_LOG_DEBUG, " quant level: %d\n", qlevel);
324 av_log(s
->avctx
, AV_LOG_DEBUG
, "qlevel %d not supported, maybe buggy stream\n", qlevel
);
328 for (i
= 0; i
< pred_order
; i
++)
330 coeffs
[i
] = get_sbits(&s
->gb
, coeff_prec
);
331 // av_log(s->avctx, AV_LOG_DEBUG, " %d: %d\n", i, coeffs[i]);
334 if (decode_residuals(s
, channel
, pred_order
) < 0)
337 for (i
= pred_order
; i
< s
->blocksize
; i
++)
340 for (j
= 0; j
< pred_order
; j
++)
341 sum
+= coeffs
[j
] * s
->decoded
[channel
][i
-j
-1];
342 s
->decoded
[channel
][i
] += sum
>> qlevel
;
348 static inline int decode_subframe(FLACContext
*s
, int channel
)
350 int type
, wasted
= 0;
353 s
->curr_bps
= s
->bps
;
355 if(s
->decorrelation
== RIGHT_SIDE
)
358 if(s
->decorrelation
== LEFT_SIDE
|| s
->decorrelation
== MID_SIDE
)
362 if (get_bits1(&s
->gb
))
364 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid subframe padding\n");
367 type
= get_bits(&s
->gb
, 6);
368 // wasted = get_bits1(&s->gb);
372 // while (!get_bits1(&s->gb))
376 // s->curr_bps -= wasted;
379 wasted
= 16 - av_log2(show_bits(&s
->gb
, 17));
380 skip_bits(&s
->gb
, wasted
+1);
381 s
->curr_bps
-= wasted
;
383 if (get_bits1(&s
->gb
))
386 while (!get_bits1(&s
->gb
))
388 s
->curr_bps
-= wasted
;
389 av_log(s
->avctx
, AV_LOG_DEBUG
, "%d wasted bits\n", wasted
);
392 //FIXME use av_log2 for types
395 av_log(s
->avctx
, AV_LOG_DEBUG
, "coding type: constant\n");
396 tmp
= get_sbits(&s
->gb
, s
->curr_bps
);
397 for (i
= 0; i
< s
->blocksize
; i
++)
398 s
->decoded
[channel
][i
] = tmp
;
402 av_log(s
->avctx
, AV_LOG_DEBUG
, "coding type: verbatim\n");
403 for (i
= 0; i
< s
->blocksize
; i
++)
404 s
->decoded
[channel
][i
] = get_sbits(&s
->gb
, s
->curr_bps
);
406 else if ((type
>= 8) && (type
<= 12))
408 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: fixed\n");
409 if (decode_subframe_fixed(s
, channel
, type
& ~0x8) < 0)
414 // av_log(s->avctx, AV_LOG_DEBUG, "coding type: lpc\n");
415 if (decode_subframe_lpc(s
, channel
, (type
& ~0x20)+1) < 0)
420 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coding type\n");
427 for (i
= 0; i
< s
->blocksize
; i
++)
428 s
->decoded
[channel
][i
] <<= wasted
;
434 static int decode_frame(FLACContext
*s
)
436 int blocksize_code
, sample_rate_code
, sample_size_code
, assignment
, i
, crc8
;
437 int decorrelation
, bps
, blocksize
, samplerate
;
439 blocksize_code
= get_bits(&s
->gb
, 4);
441 sample_rate_code
= get_bits(&s
->gb
, 4);
443 assignment
= get_bits(&s
->gb
, 4); /* channel assignment */
444 if (assignment
< 8 && s
->channels
== assignment
+1)
445 decorrelation
= INDEPENDENT
;
446 else if (assignment
>=8 && assignment
< 11 && s
->channels
== 2)
447 decorrelation
= LEFT_SIDE
+ assignment
- 8;
450 av_log(s
->avctx
, AV_LOG_ERROR
, "unsupported channel assignment %d (channels=%d)\n", assignment
, s
->channels
);
454 sample_size_code
= get_bits(&s
->gb
, 3);
455 if(sample_size_code
== 0)
457 else if((sample_size_code
!= 3) && (sample_size_code
!= 7))
458 bps
= sample_size_table
[sample_size_code
];
461 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid sample size code (%d)\n", sample_size_code
);
465 if (get_bits1(&s
->gb
))
467 av_log(s
->avctx
, AV_LOG_ERROR
, "broken stream, invalid padding\n");
471 if(get_utf8(&s
->gb
) < 0){
472 av_log(s
->avctx
, AV_LOG_ERROR
, "utf8 fscked\n");
476 if (/*((blocksize_code == 6) || (blocksize_code == 7)) &&*/
477 (s
->min_blocksize
!= s
->max_blocksize
)){
482 if (blocksize_code
== 0)
483 blocksize
= s
->min_blocksize
;
484 else if (blocksize_code
== 6)
485 blocksize
= get_bits(&s
->gb
, 8)+1;
486 else if (blocksize_code
== 7)
487 blocksize
= get_bits(&s
->gb
, 16)+1;
489 blocksize
= blocksize_table
[blocksize_code
];
491 if(blocksize
> s
->max_blocksize
){
492 av_log(s
->avctx
, AV_LOG_ERROR
, "blocksize %d > %d\n", blocksize
, s
->max_blocksize
);
496 if (sample_rate_code
== 0){
497 samplerate
= s
->samplerate
;
498 }else if ((sample_rate_code
> 3) && (sample_rate_code
< 12))
499 samplerate
= sample_rate_table
[sample_rate_code
];
500 else if (sample_rate_code
== 12)
501 samplerate
= get_bits(&s
->gb
, 8) * 1000;
502 else if (sample_rate_code
== 13)
503 samplerate
= get_bits(&s
->gb
, 16);
504 else if (sample_rate_code
== 14)
505 samplerate
= get_bits(&s
->gb
, 16) * 10;
507 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal sample rate code %d\n", sample_rate_code
);
511 skip_bits(&s
->gb
, 8);
512 crc8
= av_crc(av_crc07
, 0, s
->gb
.buffer
, get_bits_count(&s
->gb
)/8);
514 av_log(s
->avctx
, AV_LOG_ERROR
, "header crc mismatch crc=%2X\n", crc8
);
518 s
->blocksize
= blocksize
;
519 s
->samplerate
= samplerate
;
521 s
->decorrelation
= decorrelation
;
526 for (i
= 0; i
< s
->channels
; i
++)
528 // av_log(s->avctx, AV_LOG_DEBUG, "decoded: %x residual: %x\n", s->decoded[i], s->residual[i]);
529 if (decode_subframe(s
, i
) < 0)
533 align_get_bits(&s
->gb
);
536 skip_bits(&s
->gb
, 16); /* data crc */
541 static int flac_decode_frame(AVCodecContext
*avctx
,
542 void *data
, int *data_size
,
543 uint8_t *buf
, int buf_size
)
545 FLACContext
*s
= avctx
->priv_data
;
546 int metadata_last
, metadata_type
, metadata_size
;
547 int tmp
= 0, i
, j
= 0, input_buf_size
= 0;
548 int16_t *samples
= data
;
550 if(s
->max_framesize
== 0){
551 s
->max_framesize
= 65536; // should hopefully be enough for the first header
552 s
->bitstream
= av_fast_realloc(s
->bitstream
, &s
->allocated_bitstream_size
, s
->max_framesize
);
555 if(1 && s
->max_framesize
){//FIXME truncated
556 buf_size
= FFMAX(FFMIN(buf_size
, s
->max_framesize
- s
->bitstream_size
), 0);
557 input_buf_size
= buf_size
;
559 if(s
->bitstream_index
+ s
->bitstream_size
+ buf_size
> s
->allocated_bitstream_size
){
560 // printf("memmove\n");
561 memmove(s
->bitstream
, &s
->bitstream
[s
->bitstream_index
], s
->bitstream_size
);
562 s
->bitstream_index
=0;
564 memcpy(&s
->bitstream
[s
->bitstream_index
+ s
->bitstream_size
], buf
, buf_size
);
565 buf
= &s
->bitstream
[s
->bitstream_index
];
566 buf_size
+= s
->bitstream_size
;
567 s
->bitstream_size
= buf_size
;
569 if(buf_size
< s
->max_framesize
){
570 // printf("wanna more data ...\n");
571 return input_buf_size
;
575 init_get_bits(&s
->gb
, buf
, buf_size
*8);
577 /* fLaC signature (be) */
578 if (show_bits_long(&s
->gb
, 32) == bswap_32(ff_get_fourcc("fLaC")))
580 skip_bits(&s
->gb
, 32);
582 av_log(s
->avctx
, AV_LOG_DEBUG
, "STREAM HEADER\n");
584 metadata_last
= get_bits(&s
->gb
, 1);
585 metadata_type
= get_bits(&s
->gb
, 7);
586 metadata_size
= get_bits_long(&s
->gb
, 24);
588 av_log(s
->avctx
, AV_LOG_DEBUG
, " metadata block: flag = %d, type = %d, size = %d\n",
589 metadata_last
, metadata_type
,
592 switch(metadata_type
)
594 case METADATA_TYPE_STREAMINFO
:{
595 metadata_streaminfo(s
);
597 /* Buffer might have been reallocated, reinit bitreader */
598 if(buf
!= &s
->bitstream
[s
->bitstream_index
])
600 int bits_count
= get_bits_count(&s
->gb
);
601 buf
= &s
->bitstream
[s
->bitstream_index
];
602 init_get_bits(&s
->gb
, buf
, buf_size
*8);
603 skip_bits(&s
->gb
, bits_count
);
609 for(i
=0; i
<metadata_size
; i
++)
610 skip_bits(&s
->gb
, 8);
613 } while(!metadata_last
);
618 tmp
= show_bits(&s
->gb
, 16);
620 av_log(s
->avctx
, AV_LOG_ERROR
, "FRAME HEADER not here\n");
621 while(get_bits_count(&s
->gb
)/8+2 < buf_size
&& show_bits(&s
->gb
, 16) != 0xFFF8)
622 skip_bits(&s
->gb
, 8);
623 goto end
; // we may not have enough bits left to decode a frame, so try next time
625 skip_bits(&s
->gb
, 16);
626 if (decode_frame(s
) < 0){
627 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_frame() failed\n");
629 s
->bitstream_index
=0;
636 /* fix the channel order here */
637 if (s
->order
== MID_SIDE
)
639 short *left
= samples
;
640 short *right
= samples
+ s
->blocksize
;
641 for (i
= 0; i
< s
->blocksize
; i
+= 2)
643 uint32_t x
= s
->decoded
[0][i
];
644 uint32_t y
= s
->decoded
[0][i
+1];
646 right
[i
] = x
- (y
/ 2);
647 left
[i
] = right
[i
] + y
;
649 *data_size
= 2 * s
->blocksize
;
653 for (i
= 0; i
< s
->channels
; i
++)
658 for (j
= 0; j
< s
->blocksize
; j
++)
659 samples
[(s
->blocksize
*i
)+j
] = s
->decoded
[i
][j
];
664 for (j
= 0; j
< s
->blocksize
; j
++)
665 samples
[(s
->blocksize
*i
)+j
] = s
->decoded
[0][j
];
667 for (j
= 0; j
< s
->blocksize
; j
++)
668 samples
[(s
->blocksize
*i
)+j
] = s
->decoded
[0][j
] - s
->decoded
[i
][j
];
671 // av_log(s->avctx, AV_LOG_DEBUG, "mid-side unsupported\n");
673 *data_size
+= s
->blocksize
;
677 switch(s
->decorrelation
)
680 for (j
= 0; j
< s
->blocksize
; j
++)
682 for (i
= 0; i
< s
->channels
; i
++)
683 *(samples
++) = s
->decoded
[i
][j
];
687 assert(s
->channels
== 2);
688 for (i
= 0; i
< s
->blocksize
; i
++)
690 *(samples
++) = s
->decoded
[0][i
];
691 *(samples
++) = s
->decoded
[0][i
] - s
->decoded
[1][i
];
695 assert(s
->channels
== 2);
696 for (i
= 0; i
< s
->blocksize
; i
++)
698 *(samples
++) = s
->decoded
[0][i
] + s
->decoded
[1][i
];
699 *(samples
++) = s
->decoded
[1][i
];
703 assert(s
->channels
== 2);
704 for (i
= 0; i
< s
->blocksize
; i
++)
707 mid
= s
->decoded
[0][i
];
708 side
= s
->decoded
[1][i
];
710 #if 1 //needs to be checked but IMHO it should be binary identical
712 *(samples
++) = mid
+ side
;
719 *(samples
++) = (mid
+ side
) >> 1;
720 *(samples
++) = (mid
- side
) >> 1;
727 *data_size
= (int8_t *)samples
- (int8_t *)data
;
728 // av_log(s->avctx, AV_LOG_DEBUG, "data size: %d\n", *data_size);
730 // s->last_blocksize = s->blocksize;
732 i
= (get_bits_count(&s
->gb
)+7)/8;;
734 av_log(s
->avctx
, AV_LOG_ERROR
, "overread: %d\n", i
- buf_size
);
736 s
->bitstream_index
=0;
740 if(s
->bitstream_size
){
741 s
->bitstream_index
+= i
;
742 s
->bitstream_size
-= i
;
743 return input_buf_size
;
748 static int flac_decode_close(AVCodecContext
*avctx
)
750 FLACContext
*s
= avctx
->priv_data
;
753 for (i
= 0; i
< s
->channels
; i
++)
755 av_freep(&s
->decoded
[i
]);
757 av_freep(&s
->bitstream
);
762 static void flac_flush(AVCodecContext
*avctx
){
763 FLACContext
*s
= avctx
->priv_data
;
766 s
->bitstream_index
= 0;
769 AVCodec flac_decoder
= {