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 #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
, " Max Blocksize: %d\n", s
->max_blocksize
);
154 av_log(avctx
, AV_LOG_DEBUG
, " Max Framesize: %d\n", s
->max_framesize
);
155 av_log(avctx
, AV_LOG_DEBUG
, " Samplerate: %d\n", s
->samplerate
);
156 av_log(avctx
, AV_LOG_DEBUG
, " Channels: %d\n", s
->channels
);
157 av_log(avctx
, AV_LOG_DEBUG
, " Bits: %d\n", s
->bps
);
160 static void allocate_buffers(FLACContext
*s
)
164 assert(s
->max_blocksize
);
166 if (s
->max_framesize
== 0 && s
->max_blocksize
) {
167 // FIXME header overhead
168 s
->max_framesize
= (s
->channels
* s
->bps
* s
->max_blocksize
+ 7)/ 8;
171 for (i
= 0; i
< s
->channels
; i
++) {
172 s
->decoded
[i
] = av_realloc(s
->decoded
[i
],
173 sizeof(int32_t)*s
->max_blocksize
);
176 if (s
->allocated_bitstream_size
< s
->max_framesize
)
177 s
->bitstream
= av_fast_realloc(s
->bitstream
,
178 &s
->allocated_bitstream_size
,
182 void ff_flac_parse_streaminfo(AVCodecContext
*avctx
, struct FLACStreaminfo
*s
,
183 const uint8_t *buffer
)
186 init_get_bits(&gb
, buffer
, FLAC_STREAMINFO_SIZE
*8);
188 /* mandatory streaminfo */
189 skip_bits(&gb
, 16); /* skip min blocksize */
190 s
->max_blocksize
= get_bits(&gb
, 16);
192 skip_bits(&gb
, 24); /* skip min frame size */
193 s
->max_framesize
= get_bits_long(&gb
, 24);
195 s
->samplerate
= get_bits_long(&gb
, 20);
196 s
->channels
= get_bits(&gb
, 3) + 1;
197 s
->bps
= get_bits(&gb
, 5) + 1;
199 avctx
->channels
= s
->channels
;
200 avctx
->sample_rate
= s
->samplerate
;
201 avctx
->bits_per_raw_sample
= s
->bps
;
203 avctx
->sample_fmt
= SAMPLE_FMT_S32
;
205 avctx
->sample_fmt
= SAMPLE_FMT_S16
;
207 s
->samples
= get_bits_long(&gb
, 32) << 4;
208 s
->samples
|= get_bits(&gb
, 4);
210 skip_bits_long(&gb
, 64); /* md5 sum */
211 skip_bits_long(&gb
, 64); /* md5 sum */
213 dump_headers(avctx
, s
);
217 * Parse a list of metadata blocks. This list of blocks must begin with
219 * @param s the flac decoding context containing the gb bit reader used to
221 * @return 1 if some metadata was read, 0 if no fLaC marker was found
223 static int metadata_parse(FLACContext
*s
)
225 int i
, metadata_last
, metadata_type
, metadata_size
, streaminfo_updated
=0;
226 int initial_pos
= get_bits_count(&s
->gb
);
228 if (show_bits_long(&s
->gb
, 32) == MKBETAG('f','L','a','C')) {
229 skip_bits_long(&s
->gb
, 32);
232 metadata_last
= get_bits1(&s
->gb
);
233 metadata_type
= get_bits(&s
->gb
, 7);
234 metadata_size
= get_bits_long(&s
->gb
, 24);
236 if (get_bits_count(&s
->gb
) + 8*metadata_size
> s
->gb
.size_in_bits
) {
237 skip_bits_long(&s
->gb
, initial_pos
- get_bits_count(&s
->gb
));
242 switch (metadata_type
) {
243 case FLAC_METADATA_TYPE_STREAMINFO
:
244 ff_flac_parse_streaminfo(s
->avctx
, (FLACStreaminfo
*)s
,
245 s
->gb
.buffer
+get_bits_count(&s
->gb
)/8);
246 streaminfo_updated
= 1;
249 for (i
= 0; i
< metadata_size
; i
++)
250 skip_bits(&s
->gb
, 8);
253 } while (!metadata_last
);
255 if (streaminfo_updated
)
262 static int decode_residuals(FLACContext
*s
, int channel
, int pred_order
)
264 int i
, tmp
, partition
, method_type
, rice_order
;
265 int sample
= 0, samples
;
267 method_type
= get_bits(&s
->gb
, 2);
268 if (method_type
> 1) {
269 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal residual coding method %d\n",
274 rice_order
= get_bits(&s
->gb
, 4);
276 samples
= s
->blocksize
>> rice_order
;
277 if (pred_order
> samples
) {
278 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid predictor order: %i > %i\n",
279 pred_order
, samples
);
285 for (partition
= 0; partition
< (1 << rice_order
); partition
++) {
286 tmp
= get_bits(&s
->gb
, method_type
== 0 ? 4 : 5);
287 if (tmp
== (method_type
== 0 ? 15 : 31)) {
288 tmp
= get_bits(&s
->gb
, 5);
289 for (; i
< samples
; i
++, sample
++)
290 s
->decoded
[channel
][sample
] = get_sbits_long(&s
->gb
, tmp
);
292 for (; i
< samples
; i
++, sample
++) {
293 s
->decoded
[channel
][sample
] = get_sr_golomb_flac(&s
->gb
, tmp
, INT_MAX
, 0);
302 static int decode_subframe_fixed(FLACContext
*s
, int channel
, int pred_order
)
304 const int blocksize
= s
->blocksize
;
305 int32_t *decoded
= s
->decoded
[channel
];
306 int av_uninit(a
), av_uninit(b
), av_uninit(c
), av_uninit(d
), i
;
308 /* warm up samples */
309 for (i
= 0; i
< pred_order
; i
++) {
310 decoded
[i
] = get_sbits_long(&s
->gb
, s
->curr_bps
);
313 if (decode_residuals(s
, channel
, pred_order
) < 0)
317 a
= decoded
[pred_order
-1];
319 b
= a
- decoded
[pred_order
-2];
321 c
= b
- decoded
[pred_order
-2] + decoded
[pred_order
-3];
323 d
= c
- decoded
[pred_order
-2] + 2*decoded
[pred_order
-3] - decoded
[pred_order
-4];
325 switch (pred_order
) {
329 for (i
= pred_order
; i
< blocksize
; i
++)
330 decoded
[i
] = a
+= decoded
[i
];
333 for (i
= pred_order
; i
< blocksize
; i
++)
334 decoded
[i
] = a
+= b
+= decoded
[i
];
337 for (i
= pred_order
; i
< blocksize
; i
++)
338 decoded
[i
] = a
+= b
+= c
+= decoded
[i
];
341 for (i
= pred_order
; i
< blocksize
; i
++)
342 decoded
[i
] = a
+= b
+= c
+= d
+= decoded
[i
];
345 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal pred order %d\n", pred_order
);
352 static int decode_subframe_lpc(FLACContext
*s
, int channel
, int pred_order
)
355 int coeff_prec
, qlevel
;
356 int coeffs
[pred_order
];
357 int32_t *decoded
= s
->decoded
[channel
];
359 /* warm up samples */
360 for (i
= 0; i
< pred_order
; i
++) {
361 decoded
[i
] = get_sbits_long(&s
->gb
, s
->curr_bps
);
364 coeff_prec
= get_bits(&s
->gb
, 4) + 1;
365 if (coeff_prec
== 16) {
366 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coeff precision\n");
369 qlevel
= get_sbits(&s
->gb
, 5);
371 av_log(s
->avctx
, AV_LOG_ERROR
, "qlevel %d not supported, maybe buggy stream\n",
376 for (i
= 0; i
< pred_order
; i
++) {
377 coeffs
[i
] = get_sbits(&s
->gb
, coeff_prec
);
380 if (decode_residuals(s
, channel
, pred_order
) < 0)
385 for (i
= pred_order
; i
< s
->blocksize
; i
++) {
387 for (j
= 0; j
< pred_order
; j
++)
388 sum
+= (int64_t)coeffs
[j
] * decoded
[i
-j
-1];
389 decoded
[i
] += sum
>> qlevel
;
392 for (i
= pred_order
; i
< s
->blocksize
-1; i
+= 2) {
394 int d
= decoded
[i
-pred_order
];
396 for (j
= pred_order
-1; j
> 0; j
--) {
404 d
= decoded
[i
] += s0
>> qlevel
;
406 decoded
[i
+1] += s1
>> qlevel
;
408 if (i
< s
->blocksize
) {
410 for (j
= 0; j
< pred_order
; j
++)
411 sum
+= coeffs
[j
] * decoded
[i
-j
-1];
412 decoded
[i
] += sum
>> qlevel
;
419 static inline int decode_subframe(FLACContext
*s
, int channel
)
421 int type
, wasted
= 0;
424 s
->curr_bps
= s
->bps
;
426 if (s
->decorrelation
== RIGHT_SIDE
)
429 if (s
->decorrelation
== LEFT_SIDE
|| s
->decorrelation
== MID_SIDE
)
432 if (s
->curr_bps
> 32) {
433 ff_log_missing_feature(s
->avctx
, "decorrelated bit depth > 32", 0);
437 if (get_bits1(&s
->gb
)) {
438 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid subframe padding\n");
441 type
= get_bits(&s
->gb
, 6);
443 if (get_bits1(&s
->gb
)) {
445 while (!get_bits1(&s
->gb
))
447 s
->curr_bps
-= wasted
;
450 //FIXME use av_log2 for types
452 tmp
= get_sbits_long(&s
->gb
, s
->curr_bps
);
453 for (i
= 0; i
< s
->blocksize
; i
++)
454 s
->decoded
[channel
][i
] = tmp
;
455 } else if (type
== 1) {
456 for (i
= 0; i
< s
->blocksize
; i
++)
457 s
->decoded
[channel
][i
] = get_sbits_long(&s
->gb
, s
->curr_bps
);
458 } else if ((type
>= 8) && (type
<= 12)) {
459 if (decode_subframe_fixed(s
, channel
, type
& ~0x8) < 0)
461 } else if (type
>= 32) {
462 if (decode_subframe_lpc(s
, channel
, (type
& ~0x20)+1) < 0)
465 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coding type\n");
471 for (i
= 0; i
< s
->blocksize
; i
++)
472 s
->decoded
[channel
][i
] <<= wasted
;
478 static int decode_frame(FLACContext
*s
, int alloc_data_size
)
480 int blocksize_code
, sample_rate_code
, sample_size_code
, assignment
, i
, crc8
;
481 int decorrelation
, bps
, blocksize
, samplerate
;
483 blocksize_code
= get_bits(&s
->gb
, 4);
485 sample_rate_code
= get_bits(&s
->gb
, 4);
487 assignment
= get_bits(&s
->gb
, 4); /* channel assignment */
488 if (assignment
< 8 && s
->channels
== assignment
+1)
489 decorrelation
= INDEPENDENT
;
490 else if (assignment
>=8 && assignment
< 11 && s
->channels
== 2)
491 decorrelation
= LEFT_SIDE
+ assignment
- 8;
493 av_log(s
->avctx
, AV_LOG_ERROR
, "unsupported channel assignment %d (channels=%d)\n",
494 assignment
, s
->channels
);
498 sample_size_code
= get_bits(&s
->gb
, 3);
499 if (sample_size_code
== 0)
501 else if ((sample_size_code
!= 3) && (sample_size_code
!= 7))
502 bps
= sample_size_table
[sample_size_code
];
504 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid sample size code (%d)\n",
509 s
->avctx
->sample_fmt
= SAMPLE_FMT_S32
;
510 s
->sample_shift
= 32 - bps
;
513 s
->avctx
->sample_fmt
= SAMPLE_FMT_S16
;
514 s
->sample_shift
= 16 - bps
;
517 s
->bps
= s
->avctx
->bits_per_raw_sample
= bps
;
519 if (get_bits1(&s
->gb
)) {
520 av_log(s
->avctx
, AV_LOG_ERROR
, "broken stream, invalid padding\n");
524 if (get_utf8(&s
->gb
) < 0) {
525 av_log(s
->avctx
, AV_LOG_ERROR
, "utf8 fscked\n");
529 if (blocksize_code
== 0) {
530 av_log(s
->avctx
, AV_LOG_ERROR
, "reserved blocksize code: 0\n");
532 } else if (blocksize_code
== 6)
533 blocksize
= get_bits(&s
->gb
, 8)+1;
534 else if (blocksize_code
== 7)
535 blocksize
= get_bits(&s
->gb
, 16)+1;
537 blocksize
= blocksize_table
[blocksize_code
];
539 if (blocksize
> s
->max_blocksize
) {
540 av_log(s
->avctx
, AV_LOG_ERROR
, "blocksize %d > %d\n", blocksize
,
545 if (blocksize
* s
->channels
* sizeof(int16_t) > alloc_data_size
)
548 if (sample_rate_code
== 0)
549 samplerate
= s
->samplerate
;
550 else if (sample_rate_code
< 12)
551 samplerate
= sample_rate_table
[sample_rate_code
];
552 else if (sample_rate_code
== 12)
553 samplerate
= get_bits(&s
->gb
, 8) * 1000;
554 else if (sample_rate_code
== 13)
555 samplerate
= get_bits(&s
->gb
, 16);
556 else if (sample_rate_code
== 14)
557 samplerate
= get_bits(&s
->gb
, 16) * 10;
559 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal sample rate code %d\n",
564 skip_bits(&s
->gb
, 8);
565 crc8
= av_crc(av_crc_get_table(AV_CRC_8_ATM
), 0,
566 s
->gb
.buffer
, get_bits_count(&s
->gb
)/8);
568 av_log(s
->avctx
, AV_LOG_ERROR
, "header crc mismatch crc=%2X\n", crc8
);
572 s
->blocksize
= blocksize
;
573 s
->samplerate
= samplerate
;
575 s
->decorrelation
= decorrelation
;
577 // dump_headers(s->avctx, (FLACStreaminfo *)s);
580 for (i
= 0; i
< s
->channels
; i
++) {
581 if (decode_subframe(s
, i
) < 0)
585 align_get_bits(&s
->gb
);
588 skip_bits(&s
->gb
, 16); /* data crc */
593 static int flac_decode_frame(AVCodecContext
*avctx
,
594 void *data
, int *data_size
,
595 const uint8_t *buf
, int buf_size
)
597 FLACContext
*s
= avctx
->priv_data
;
598 int tmp
= 0, i
, j
= 0, input_buf_size
= 0;
599 int16_t *samples_16
= data
;
600 int32_t *samples_32
= data
;
601 int alloc_data_size
= *data_size
;
605 if (s
->max_framesize
== 0) {
606 s
->max_framesize
= FFMAX(4, buf_size
); // should hopefully be enough for the first header
607 s
->bitstream
= av_fast_realloc(s
->bitstream
, &s
->allocated_bitstream_size
, s
->max_framesize
);
610 if (1 && s
->max_framesize
) { //FIXME truncated
611 if (s
->bitstream_size
< 4 || AV_RL32(s
->bitstream
) != MKTAG('f','L','a','C'))
612 buf_size
= FFMIN(buf_size
, s
->max_framesize
- FFMIN(s
->bitstream_size
, s
->max_framesize
));
613 input_buf_size
= buf_size
;
615 if (s
->bitstream_size
+ buf_size
< buf_size
|| s
->bitstream_index
+ s
->bitstream_size
+ buf_size
< s
->bitstream_index
)
618 if (s
->allocated_bitstream_size
< s
->bitstream_size
+ buf_size
)
619 s
->bitstream
= av_fast_realloc(s
->bitstream
, &s
->allocated_bitstream_size
, s
->bitstream_size
+ buf_size
);
621 if (s
->bitstream_index
+ s
->bitstream_size
+ buf_size
> s
->allocated_bitstream_size
) {
622 memmove(s
->bitstream
, &s
->bitstream
[s
->bitstream_index
],
624 s
->bitstream_index
=0;
626 memcpy(&s
->bitstream
[s
->bitstream_index
+ s
->bitstream_size
],
628 buf
= &s
->bitstream
[s
->bitstream_index
];
629 buf_size
+= s
->bitstream_size
;
630 s
->bitstream_size
= buf_size
;
632 if (buf_size
< s
->max_framesize
&& input_buf_size
) {
633 return input_buf_size
;
637 init_get_bits(&s
->gb
, buf
, buf_size
*8);
639 if (metadata_parse(s
))
642 tmp
= show_bits(&s
->gb
, 16);
643 if ((tmp
& 0xFFFE) != 0xFFF8) {
644 av_log(s
->avctx
, AV_LOG_ERROR
, "FRAME HEADER not here\n");
645 while (get_bits_count(&s
->gb
)/8+2 < buf_size
&& (show_bits(&s
->gb
, 16) & 0xFFFE) != 0xFFF8)
646 skip_bits(&s
->gb
, 8);
647 goto end
; // we may not have enough bits left to decode a frame, so try next time
649 skip_bits(&s
->gb
, 16);
650 if (decode_frame(s
, alloc_data_size
) < 0) {
651 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_frame() failed\n");
653 s
->bitstream_index
=0;
657 #define DECORRELATE(left, right)\
658 assert(s->channels == 2);\
659 for (i = 0; i < s->blocksize; i++) {\
660 int a= s->decoded[0][i];\
661 int b= s->decoded[1][i];\
663 *samples_32++ = (left) << s->sample_shift;\
664 *samples_32++ = (right) << s->sample_shift;\
666 *samples_16++ = (left) << s->sample_shift;\
667 *samples_16++ = (right) << s->sample_shift;\
672 switch (s
->decorrelation
) {
674 for (j
= 0; j
< s
->blocksize
; j
++) {
675 for (i
= 0; i
< s
->channels
; i
++) {
677 *samples_32
++ = s
->decoded
[i
][j
] << s
->sample_shift
;
679 *samples_16
++ = s
->decoded
[i
][j
] << s
->sample_shift
;
688 DECORRELATE( (a
-=b
>>1) + b
, a
)
691 *data_size
= s
->blocksize
* s
->channels
* (s
->is32
? 4 : 2);
694 i
= (get_bits_count(&s
->gb
)+7)/8;
696 av_log(s
->avctx
, AV_LOG_ERROR
, "overread: %d\n", i
- buf_size
);
698 s
->bitstream_index
=0;
702 if (s
->bitstream_size
) {
703 s
->bitstream_index
+= i
;
704 s
->bitstream_size
-= i
;
705 return input_buf_size
;
710 static av_cold
int flac_decode_close(AVCodecContext
*avctx
)
712 FLACContext
*s
= avctx
->priv_data
;
715 for (i
= 0; i
< s
->channels
; i
++) {
716 av_freep(&s
->decoded
[i
]);
718 av_freep(&s
->bitstream
);
723 static void flac_flush(AVCodecContext
*avctx
)
725 FLACContext
*s
= avctx
->priv_data
;
728 s
->bitstream_index
= 0;
731 AVCodec flac_decoder
= {
742 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),