2 * FLAC (Free Lossless Audio Codec) decoder
3 * Copyright (c) 2003 Alex Beregszaszi
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * @file libavcodec/flacdec.c
24 * FLAC (Free Lossless Audio Codec) decoder
25 * @author Alex Beregszaszi
27 * For more information on the FLAC format, visit:
28 * http://flac.sourceforge.net/
30 * This decoder can be used in 1 of 2 ways: Either raw FLAC data can be fed
31 * through, starting from the initial 'fLaC' signature; or by passing the
32 * 34-byte streaminfo structure through avctx->extradata[_size] followed
33 * by data starting with the 0xFFF8 marker.
38 #define ALT_BITSTREAM_READER
39 #include "libavutil/crc.h"
41 #include "bitstream.h"
48 #define MAX_CHANNELS 8
49 #define MAX_BLOCKSIZE 65535
51 enum decorrelation_type
{
58 typedef struct FLACContext
{
61 AVCodecContext
*avctx
; ///< parent AVCodecContext
62 GetBitContext gb
; ///< GetBitContext initialized to start at the current frame
64 int blocksize
; ///< number of samples in the current frame
65 int curr_bps
; ///< bps for current subframe, adjusted for channel correlation and wasted bits
66 int sample_shift
; ///< shift required to make output samples 16-bit or 32-bit
67 int is32
; ///< flag to indicate if output should be 32-bit instead of 16-bit
68 enum decorrelation_type decorrelation
; ///< channel decorrelation type in the current frame
70 int32_t *decoded
[MAX_CHANNELS
]; ///< decoded samples
72 unsigned int bitstream_size
;
73 unsigned int bitstream_index
;
74 unsigned int allocated_bitstream_size
;
77 static const int sample_rate_table
[] =
79 88200, 176400, 192000,
80 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000,
83 static const int sample_size_table
[] =
84 { 0, 8, 12, 0, 16, 20, 24, 0 };
86 static const int blocksize_table
[] = {
87 0, 192, 576<<0, 576<<1, 576<<2, 576<<3, 0, 0,
88 256<<0, 256<<1, 256<<2, 256<<3, 256<<4, 256<<5, 256<<6, 256<<7
91 static int64_t get_utf8(GetBitContext
*gb
)
94 GET_UTF8(val
, get_bits(gb
, 8), return -1;)
98 static void allocate_buffers(FLACContext
*s
);
100 int ff_flac_is_extradata_valid(AVCodecContext
*avctx
,
101 enum FLACExtradataFormat
*format
,
102 uint8_t **streaminfo_start
)
104 if (!avctx
->extradata
|| avctx
->extradata_size
< FLAC_STREAMINFO_SIZE
) {
105 av_log(avctx
, AV_LOG_ERROR
, "extradata NULL or too small.\n");
108 if (AV_RL32(avctx
->extradata
) != MKTAG('f','L','a','C')) {
109 /* extradata contains STREAMINFO only */
110 if (avctx
->extradata_size
!= FLAC_STREAMINFO_SIZE
) {
111 av_log(avctx
, AV_LOG_WARNING
, "extradata contains %d bytes too many.\n",
112 FLAC_STREAMINFO_SIZE
-avctx
->extradata_size
);
114 *format
= FLAC_EXTRADATA_FORMAT_STREAMINFO
;
115 *streaminfo_start
= avctx
->extradata
;
117 if (avctx
->extradata_size
< 8+FLAC_STREAMINFO_SIZE
) {
118 av_log(avctx
, AV_LOG_ERROR
, "extradata too small.\n");
121 *format
= FLAC_EXTRADATA_FORMAT_FULL_HEADER
;
122 *streaminfo_start
= &avctx
->extradata
[8];
127 static av_cold
int flac_decode_init(AVCodecContext
*avctx
)
129 enum FLACExtradataFormat format
;
131 FLACContext
*s
= avctx
->priv_data
;
134 avctx
->sample_fmt
= SAMPLE_FMT_S16
;
136 /* for now, the raw FLAC header is allowed to be passed to the decoder as
137 frame data instead of extradata. */
138 if (!avctx
->extradata
)
141 if (!ff_flac_is_extradata_valid(avctx
, &format
, &streaminfo
))
144 /* initialize based on the demuxer-supplied streamdata header */
145 ff_flac_parse_streaminfo(avctx
, (FLACStreaminfo
*)s
, streaminfo
);
151 static void dump_headers(AVCodecContext
*avctx
, FLACStreaminfo
*s
)
153 av_log(avctx
, AV_LOG_DEBUG
, " Blocksize: %d .. %d\n", s
->min_blocksize
,
155 av_log(avctx
, AV_LOG_DEBUG
, " Max Framesize: %d\n", s
->max_framesize
);
156 av_log(avctx
, AV_LOG_DEBUG
, " Samplerate: %d\n", s
->samplerate
);
157 av_log(avctx
, AV_LOG_DEBUG
, " Channels: %d\n", s
->channels
);
158 av_log(avctx
, AV_LOG_DEBUG
, " Bits: %d\n", s
->bps
);
161 static void allocate_buffers(FLACContext
*s
)
165 assert(s
->max_blocksize
);
167 if (s
->max_framesize
== 0 && s
->max_blocksize
) {
168 // FIXME header overhead
169 s
->max_framesize
= (s
->channels
* s
->bps
* s
->max_blocksize
+ 7)/ 8;
172 for (i
= 0; i
< s
->channels
; i
++) {
173 s
->decoded
[i
] = av_realloc(s
->decoded
[i
],
174 sizeof(int32_t)*s
->max_blocksize
);
177 if (s
->allocated_bitstream_size
< s
->max_framesize
)
178 s
->bitstream
= av_fast_realloc(s
->bitstream
,
179 &s
->allocated_bitstream_size
,
183 void ff_flac_parse_streaminfo(AVCodecContext
*avctx
, struct FLACStreaminfo
*s
,
184 const uint8_t *buffer
)
187 init_get_bits(&gb
, buffer
, FLAC_STREAMINFO_SIZE
*8);
189 /* mandatory streaminfo */
190 s
->min_blocksize
= get_bits(&gb
, 16);
191 s
->max_blocksize
= get_bits(&gb
, 16);
193 skip_bits(&gb
, 24); /* skip min frame size */
194 s
->max_framesize
= get_bits_long(&gb
, 24);
196 s
->samplerate
= get_bits_long(&gb
, 20);
197 s
->channels
= get_bits(&gb
, 3) + 1;
198 s
->bps
= get_bits(&gb
, 5) + 1;
200 avctx
->channels
= s
->channels
;
201 avctx
->sample_rate
= s
->samplerate
;
202 avctx
->bits_per_raw_sample
= s
->bps
;
204 avctx
->sample_fmt
= SAMPLE_FMT_S32
;
206 avctx
->sample_fmt
= SAMPLE_FMT_S16
;
208 s
->samples
= get_bits_long(&gb
, 32) << 4;
209 s
->samples
|= get_bits(&gb
, 4);
211 skip_bits_long(&gb
, 64); /* md5 sum */
212 skip_bits_long(&gb
, 64); /* md5 sum */
214 dump_headers(avctx
, s
);
218 * Parse a list of metadata blocks. This list of blocks must begin with
220 * @param s the flac decoding context containing the gb bit reader used to
222 * @return 1 if some metadata was read, 0 if no fLaC marker was found
224 static int metadata_parse(FLACContext
*s
)
226 int i
, metadata_last
, metadata_type
, metadata_size
, streaminfo_updated
=0;
227 int initial_pos
= get_bits_count(&s
->gb
);
229 if (show_bits_long(&s
->gb
, 32) == MKBETAG('f','L','a','C')) {
230 skip_bits_long(&s
->gb
, 32);
233 metadata_last
= get_bits1(&s
->gb
);
234 metadata_type
= get_bits(&s
->gb
, 7);
235 metadata_size
= get_bits_long(&s
->gb
, 24);
237 if (get_bits_count(&s
->gb
) + 8*metadata_size
> s
->gb
.size_in_bits
) {
238 skip_bits_long(&s
->gb
, initial_pos
- get_bits_count(&s
->gb
));
243 switch (metadata_type
) {
244 case FLAC_METADATA_TYPE_STREAMINFO
:
245 ff_flac_parse_streaminfo(s
->avctx
, (FLACStreaminfo
*)s
,
246 s
->gb
.buffer
+get_bits_count(&s
->gb
)/8);
247 streaminfo_updated
= 1;
250 for (i
= 0; i
< metadata_size
; i
++)
251 skip_bits(&s
->gb
, 8);
254 } while (!metadata_last
);
256 if (streaminfo_updated
)
263 static int decode_residuals(FLACContext
*s
, int channel
, int pred_order
)
265 int i
, tmp
, partition
, method_type
, rice_order
;
266 int sample
= 0, samples
;
268 method_type
= get_bits(&s
->gb
, 2);
269 if (method_type
> 1) {
270 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal residual coding method %d\n",
275 rice_order
= get_bits(&s
->gb
, 4);
277 samples
= s
->blocksize
>> rice_order
;
278 if (pred_order
> samples
) {
279 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid predictor order: %i > %i\n",
280 pred_order
, samples
);
286 for (partition
= 0; partition
< (1 << rice_order
); partition
++) {
287 tmp
= get_bits(&s
->gb
, method_type
== 0 ? 4 : 5);
288 if (tmp
== (method_type
== 0 ? 15 : 31)) {
289 tmp
= get_bits(&s
->gb
, 5);
290 for (; i
< samples
; i
++, sample
++)
291 s
->decoded
[channel
][sample
] = get_sbits(&s
->gb
, tmp
);
293 for (; i
< samples
; i
++, sample
++) {
294 s
->decoded
[channel
][sample
] = get_sr_golomb_flac(&s
->gb
, tmp
, INT_MAX
, 0);
303 static int decode_subframe_fixed(FLACContext
*s
, int channel
, int pred_order
)
305 const int blocksize
= s
->blocksize
;
306 int32_t *decoded
= s
->decoded
[channel
];
307 int av_uninit(a
), av_uninit(b
), av_uninit(c
), av_uninit(d
), i
;
309 /* warm up samples */
310 for (i
= 0; i
< pred_order
; i
++) {
311 decoded
[i
] = get_sbits(&s
->gb
, s
->curr_bps
);
314 if (decode_residuals(s
, channel
, pred_order
) < 0)
318 a
= decoded
[pred_order
-1];
320 b
= a
- decoded
[pred_order
-2];
322 c
= b
- decoded
[pred_order
-2] + decoded
[pred_order
-3];
324 d
= c
- decoded
[pred_order
-2] + 2*decoded
[pred_order
-3] - decoded
[pred_order
-4];
326 switch (pred_order
) {
330 for (i
= pred_order
; i
< blocksize
; i
++)
331 decoded
[i
] = a
+= decoded
[i
];
334 for (i
= pred_order
; i
< blocksize
; i
++)
335 decoded
[i
] = a
+= b
+= decoded
[i
];
338 for (i
= pred_order
; i
< blocksize
; i
++)
339 decoded
[i
] = a
+= b
+= c
+= decoded
[i
];
342 for (i
= pred_order
; i
< blocksize
; i
++)
343 decoded
[i
] = a
+= b
+= c
+= d
+= decoded
[i
];
346 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal pred order %d\n", pred_order
);
353 static int decode_subframe_lpc(FLACContext
*s
, int channel
, int pred_order
)
356 int coeff_prec
, qlevel
;
357 int coeffs
[pred_order
];
358 int32_t *decoded
= s
->decoded
[channel
];
360 /* warm up samples */
361 for (i
= 0; i
< pred_order
; i
++) {
362 decoded
[i
] = get_sbits(&s
->gb
, s
->curr_bps
);
365 coeff_prec
= get_bits(&s
->gb
, 4) + 1;
366 if (coeff_prec
== 16) {
367 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coeff precision\n");
370 qlevel
= get_sbits(&s
->gb
, 5);
372 av_log(s
->avctx
, AV_LOG_ERROR
, "qlevel %d not supported, maybe buggy stream\n",
377 for (i
= 0; i
< pred_order
; i
++) {
378 coeffs
[i
] = get_sbits(&s
->gb
, coeff_prec
);
381 if (decode_residuals(s
, channel
, pred_order
) < 0)
386 for (i
= pred_order
; i
< s
->blocksize
; i
++) {
388 for (j
= 0; j
< pred_order
; j
++)
389 sum
+= (int64_t)coeffs
[j
] * decoded
[i
-j
-1];
390 decoded
[i
] += sum
>> qlevel
;
393 for (i
= pred_order
; i
< s
->blocksize
-1; i
+= 2) {
395 int d
= decoded
[i
-pred_order
];
397 for (j
= pred_order
-1; j
> 0; j
--) {
405 d
= decoded
[i
] += s0
>> qlevel
;
407 decoded
[i
+1] += s1
>> qlevel
;
409 if (i
< s
->blocksize
) {
411 for (j
= 0; j
< pred_order
; j
++)
412 sum
+= coeffs
[j
] * decoded
[i
-j
-1];
413 decoded
[i
] += sum
>> qlevel
;
420 static inline int decode_subframe(FLACContext
*s
, int channel
)
422 int type
, wasted
= 0;
425 s
->curr_bps
= s
->bps
;
427 if (s
->decorrelation
== RIGHT_SIDE
)
430 if (s
->decorrelation
== LEFT_SIDE
|| s
->decorrelation
== MID_SIDE
)
434 if (get_bits1(&s
->gb
)) {
435 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid subframe padding\n");
438 type
= get_bits(&s
->gb
, 6);
440 if (get_bits1(&s
->gb
)) {
442 while (!get_bits1(&s
->gb
))
444 s
->curr_bps
-= wasted
;
447 //FIXME use av_log2 for types
449 tmp
= get_sbits(&s
->gb
, s
->curr_bps
);
450 for (i
= 0; i
< s
->blocksize
; i
++)
451 s
->decoded
[channel
][i
] = tmp
;
452 } else if (type
== 1) {
453 for (i
= 0; i
< s
->blocksize
; i
++)
454 s
->decoded
[channel
][i
] = get_sbits(&s
->gb
, s
->curr_bps
);
455 } else if ((type
>= 8) && (type
<= 12)) {
456 if (decode_subframe_fixed(s
, channel
, type
& ~0x8) < 0)
458 } else if (type
>= 32) {
459 if (decode_subframe_lpc(s
, channel
, (type
& ~0x20)+1) < 0)
462 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coding type\n");
468 for (i
= 0; i
< s
->blocksize
; i
++)
469 s
->decoded
[channel
][i
] <<= wasted
;
475 static int decode_frame(FLACContext
*s
, int alloc_data_size
)
477 int blocksize_code
, sample_rate_code
, sample_size_code
, assignment
, i
, crc8
;
478 int decorrelation
, bps
, blocksize
, samplerate
;
480 blocksize_code
= get_bits(&s
->gb
, 4);
482 sample_rate_code
= get_bits(&s
->gb
, 4);
484 assignment
= get_bits(&s
->gb
, 4); /* channel assignment */
485 if (assignment
< 8 && s
->channels
== assignment
+1)
486 decorrelation
= INDEPENDENT
;
487 else if (assignment
>=8 && assignment
< 11 && s
->channels
== 2)
488 decorrelation
= LEFT_SIDE
+ assignment
- 8;
490 av_log(s
->avctx
, AV_LOG_ERROR
, "unsupported channel assignment %d (channels=%d)\n",
491 assignment
, s
->channels
);
495 sample_size_code
= get_bits(&s
->gb
, 3);
496 if (sample_size_code
== 0)
498 else if ((sample_size_code
!= 3) && (sample_size_code
!= 7))
499 bps
= sample_size_table
[sample_size_code
];
501 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid sample size code (%d)\n",
506 s
->avctx
->sample_fmt
= SAMPLE_FMT_S32
;
507 s
->sample_shift
= 32 - bps
;
510 s
->avctx
->sample_fmt
= SAMPLE_FMT_S16
;
511 s
->sample_shift
= 16 - bps
;
514 s
->bps
= s
->avctx
->bits_per_raw_sample
= bps
;
516 if (get_bits1(&s
->gb
)) {
517 av_log(s
->avctx
, AV_LOG_ERROR
, "broken stream, invalid padding\n");
521 if (get_utf8(&s
->gb
) < 0) {
522 av_log(s
->avctx
, AV_LOG_ERROR
, "utf8 fscked\n");
526 if (blocksize_code
== 0)
527 blocksize
= s
->min_blocksize
;
528 else if (blocksize_code
== 6)
529 blocksize
= get_bits(&s
->gb
, 8)+1;
530 else if (blocksize_code
== 7)
531 blocksize
= get_bits(&s
->gb
, 16)+1;
533 blocksize
= blocksize_table
[blocksize_code
];
535 if (blocksize
> s
->max_blocksize
) {
536 av_log(s
->avctx
, AV_LOG_ERROR
, "blocksize %d > %d\n", blocksize
,
541 if (blocksize
* s
->channels
* sizeof(int16_t) > alloc_data_size
)
544 if (sample_rate_code
== 0)
545 samplerate
= s
->samplerate
;
546 else if (sample_rate_code
< 12)
547 samplerate
= sample_rate_table
[sample_rate_code
];
548 else if (sample_rate_code
== 12)
549 samplerate
= get_bits(&s
->gb
, 8) * 1000;
550 else if (sample_rate_code
== 13)
551 samplerate
= get_bits(&s
->gb
, 16);
552 else if (sample_rate_code
== 14)
553 samplerate
= get_bits(&s
->gb
, 16) * 10;
555 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal sample rate code %d\n",
560 skip_bits(&s
->gb
, 8);
561 crc8
= av_crc(av_crc_get_table(AV_CRC_8_ATM
), 0,
562 s
->gb
.buffer
, get_bits_count(&s
->gb
)/8);
564 av_log(s
->avctx
, AV_LOG_ERROR
, "header crc mismatch crc=%2X\n", crc8
);
568 s
->blocksize
= blocksize
;
569 s
->samplerate
= samplerate
;
571 s
->decorrelation
= decorrelation
;
573 // dump_headers(s->avctx, (FLACStreaminfo *)s);
576 for (i
= 0; i
< s
->channels
; i
++) {
577 if (decode_subframe(s
, i
) < 0)
581 align_get_bits(&s
->gb
);
584 skip_bits(&s
->gb
, 16); /* data crc */
589 static int flac_decode_frame(AVCodecContext
*avctx
,
590 void *data
, int *data_size
,
591 const uint8_t *buf
, int buf_size
)
593 FLACContext
*s
= avctx
->priv_data
;
594 int tmp
= 0, i
, j
= 0, input_buf_size
= 0;
595 int16_t *samples_16
= data
;
596 int32_t *samples_32
= data
;
597 int alloc_data_size
= *data_size
;
601 if (s
->max_framesize
== 0) {
602 s
->max_framesize
= FFMAX(4, buf_size
); // should hopefully be enough for the first header
603 s
->bitstream
= av_fast_realloc(s
->bitstream
, &s
->allocated_bitstream_size
, s
->max_framesize
);
606 if (1 && s
->max_framesize
) { //FIXME truncated
607 if (s
->bitstream_size
< 4 || AV_RL32(s
->bitstream
) != MKTAG('f','L','a','C'))
608 buf_size
= FFMIN(buf_size
, s
->max_framesize
- FFMIN(s
->bitstream_size
, s
->max_framesize
));
609 input_buf_size
= buf_size
;
611 if (s
->bitstream_size
+ buf_size
< buf_size
|| s
->bitstream_index
+ s
->bitstream_size
+ buf_size
< s
->bitstream_index
)
614 if (s
->allocated_bitstream_size
< s
->bitstream_size
+ buf_size
)
615 s
->bitstream
= av_fast_realloc(s
->bitstream
, &s
->allocated_bitstream_size
, s
->bitstream_size
+ buf_size
);
617 if (s
->bitstream_index
+ s
->bitstream_size
+ buf_size
> s
->allocated_bitstream_size
) {
618 memmove(s
->bitstream
, &s
->bitstream
[s
->bitstream_index
],
620 s
->bitstream_index
=0;
622 memcpy(&s
->bitstream
[s
->bitstream_index
+ s
->bitstream_size
],
624 buf
= &s
->bitstream
[s
->bitstream_index
];
625 buf_size
+= s
->bitstream_size
;
626 s
->bitstream_size
= buf_size
;
628 if (buf_size
< s
->max_framesize
&& input_buf_size
) {
629 return input_buf_size
;
633 init_get_bits(&s
->gb
, buf
, buf_size
*8);
635 if (metadata_parse(s
))
638 tmp
= show_bits(&s
->gb
, 16);
639 if ((tmp
& 0xFFFE) != 0xFFF8) {
640 av_log(s
->avctx
, AV_LOG_ERROR
, "FRAME HEADER not here\n");
641 while (get_bits_count(&s
->gb
)/8+2 < buf_size
&& (show_bits(&s
->gb
, 16) & 0xFFFE) != 0xFFF8)
642 skip_bits(&s
->gb
, 8);
643 goto end
; // we may not have enough bits left to decode a frame, so try next time
645 skip_bits(&s
->gb
, 16);
646 if (decode_frame(s
, alloc_data_size
) < 0) {
647 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_frame() failed\n");
649 s
->bitstream_index
=0;
653 #define DECORRELATE(left, right)\
654 assert(s->channels == 2);\
655 for (i = 0; i < s->blocksize; i++) {\
656 int a= s->decoded[0][i];\
657 int b= s->decoded[1][i];\
659 *samples_32++ = (left) << s->sample_shift;\
660 *samples_32++ = (right) << s->sample_shift;\
662 *samples_16++ = (left) << s->sample_shift;\
663 *samples_16++ = (right) << s->sample_shift;\
668 switch (s
->decorrelation
) {
670 for (j
= 0; j
< s
->blocksize
; j
++) {
671 for (i
= 0; i
< s
->channels
; i
++) {
673 *samples_32
++ = s
->decoded
[i
][j
] << s
->sample_shift
;
675 *samples_16
++ = s
->decoded
[i
][j
] << s
->sample_shift
;
684 DECORRELATE( (a
-=b
>>1) + b
, a
)
687 *data_size
= s
->blocksize
* s
->channels
* (s
->is32
? 4 : 2);
690 i
= (get_bits_count(&s
->gb
)+7)/8;
692 av_log(s
->avctx
, AV_LOG_ERROR
, "overread: %d\n", i
- buf_size
);
694 s
->bitstream_index
=0;
698 if (s
->bitstream_size
) {
699 s
->bitstream_index
+= i
;
700 s
->bitstream_size
-= i
;
701 return input_buf_size
;
706 static av_cold
int flac_decode_close(AVCodecContext
*avctx
)
708 FLACContext
*s
= avctx
->priv_data
;
711 for (i
= 0; i
< s
->channels
; i
++) {
712 av_freep(&s
->decoded
[i
]);
714 av_freep(&s
->bitstream
);
719 static void flac_flush(AVCodecContext
*avctx
)
721 FLACContext
*s
= avctx
->priv_data
;
724 s
->bitstream_index
= 0;
727 AVCodec flac_decoder
= {
738 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),