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
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"
42 #include "bytestream.h"
50 typedef struct FLACContext {
53 AVCodecContext *avctx; ///< parent AVCodecContext
54 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
56 int blocksize; ///< number of samples in the current frame
57 int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits
58 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
59 int is32; ///< flag to indicate if output should be 32-bit instead of 16-bit
60 int ch_mode; ///< channel decorrelation type in the current frame
61 int got_streaminfo; ///< indicates if the STREAMINFO has been read
63 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
66 static void allocate_buffers(FLACContext *s);
68 int ff_flac_is_extradata_valid(AVCodecContext *avctx,
69 enum FLACExtradataFormat *format,
70 uint8_t **streaminfo_start)
72 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
73 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
76 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
77 /* extradata contains STREAMINFO only */
78 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
79 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
80 FLAC_STREAMINFO_SIZE-avctx->extradata_size);
82 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
83 *streaminfo_start = avctx->extradata;
85 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
86 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
89 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
90 *streaminfo_start = &avctx->extradata[8];
95 static av_cold int flac_decode_init(AVCodecContext *avctx)
97 enum FLACExtradataFormat format;
99 FLACContext *s = avctx->priv_data;
102 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
104 /* for now, the raw FLAC header is allowed to be passed to the decoder as
105 frame data instead of extradata. */
106 if (!avctx->extradata)
109 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
112 /* initialize based on the demuxer-supplied streamdata header */
113 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
115 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
117 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
119 s->got_streaminfo = 1;
124 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
126 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
127 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
128 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
129 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
130 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
133 static void allocate_buffers(FLACContext *s)
137 assert(s->max_blocksize);
139 for (i = 0; i < s->channels; i++) {
140 s->decoded[i] = av_realloc(s->decoded[i],
141 sizeof(int32_t)*s->max_blocksize);
145 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
146 const uint8_t *buffer)
149 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
151 skip_bits(&gb, 16); /* skip min blocksize */
152 s->max_blocksize = get_bits(&gb, 16);
153 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
154 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
156 s->max_blocksize = 16;
159 skip_bits(&gb, 24); /* skip min frame size */
160 s->max_framesize = get_bits_long(&gb, 24);
162 s->samplerate = get_bits_long(&gb, 20);
163 s->channels = get_bits(&gb, 3) + 1;
164 s->bps = get_bits(&gb, 5) + 1;
166 avctx->channels = s->channels;
167 avctx->sample_rate = s->samplerate;
168 avctx->bits_per_raw_sample = s->bps;
170 s->samples = get_bits_long(&gb, 32) << 4;
171 s->samples |= get_bits(&gb, 4);
173 skip_bits_long(&gb, 64); /* md5 sum */
174 skip_bits_long(&gb, 64); /* md5 sum */
176 dump_headers(avctx, s);
179 void ff_flac_parse_block_header(const uint8_t *block_header,
180 int *last, int *type, int *size)
182 int tmp = bytestream_get_byte(&block_header);
188 *size = bytestream_get_be24(&block_header);
192 * Parse the STREAMINFO from an inline header.
193 * @param s the flac decoding context
194 * @param buf input buffer, starting with the "fLaC" marker
195 * @param buf_size buffer size
196 * @return non-zero if metadata is invalid
198 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
200 int metadata_type, metadata_size;
202 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
206 ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
207 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
208 metadata_size != FLAC_STREAMINFO_SIZE) {
209 return AVERROR_INVALIDDATA;
211 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
213 s->got_streaminfo = 1;
219 * Determine the size of an inline header.
220 * @param buf input buffer, starting with the "fLaC" marker
221 * @param buf_size buffer size
222 * @return number of bytes in the header, or 0 if more data is needed
224 static int get_metadata_size(const uint8_t *buf, int buf_size)
226 int metadata_last, metadata_size;
227 const uint8_t *buf_end = buf + buf_size;
231 ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
233 if (buf + metadata_size > buf_end) {
234 /* need more data in order to read the complete header */
237 buf += metadata_size;
238 } while (!metadata_last);
240 return buf_size - (buf_end - buf);
243 static int decode_residuals(FLACContext *s, int channel, int pred_order)
245 int i, tmp, partition, method_type, rice_order;
246 int sample = 0, samples;
248 method_type = get_bits(&s->gb, 2);
249 if (method_type > 1) {
250 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
255 rice_order = get_bits(&s->gb, 4);
257 samples= s->blocksize >> rice_order;
258 if (pred_order > samples) {
259 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
260 pred_order, samples);
266 for (partition = 0; partition < (1 << rice_order); partition++) {
267 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
268 if (tmp == (method_type == 0 ? 15 : 31)) {
269 tmp = get_bits(&s->gb, 5);
270 for (; i < samples; i++, sample++)
271 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
273 for (; i < samples; i++, sample++) {
274 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
283 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
285 const int blocksize = s->blocksize;
286 int32_t *decoded = s->decoded[channel];
287 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
289 /* warm up samples */
290 for (i = 0; i < pred_order; i++) {
291 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
294 if (decode_residuals(s, channel, pred_order) < 0)
298 a = decoded[pred_order-1];
300 b = a - decoded[pred_order-2];
302 c = b - decoded[pred_order-2] + decoded[pred_order-3];
304 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
306 switch (pred_order) {
310 for (i = pred_order; i < blocksize; i++)
311 decoded[i] = a += decoded[i];
314 for (i = pred_order; i < blocksize; i++)
315 decoded[i] = a += b += decoded[i];
318 for (i = pred_order; i < blocksize; i++)
319 decoded[i] = a += b += c += decoded[i];
322 for (i = pred_order; i < blocksize; i++)
323 decoded[i] = a += b += c += d += decoded[i];
326 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
333 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
336 int coeff_prec, qlevel;
338 int32_t *decoded = s->decoded[channel];
340 /* warm up samples */
341 for (i = 0; i < pred_order; i++) {
342 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
345 coeff_prec = get_bits(&s->gb, 4) + 1;
346 if (coeff_prec == 16) {
347 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
350 qlevel = get_sbits(&s->gb, 5);
352 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
357 for (i = 0; i < pred_order; i++) {
358 coeffs[i] = get_sbits(&s->gb, coeff_prec);
361 if (decode_residuals(s, channel, pred_order) < 0)
366 for (i = pred_order; i < s->blocksize; i++) {
368 for (j = 0; j < pred_order; j++)
369 sum += (int64_t)coeffs[j] * decoded[i-j-1];
370 decoded[i] += sum >> qlevel;
373 for (i = pred_order; i < s->blocksize-1; i += 2) {
375 int d = decoded[i-pred_order];
377 for (j = pred_order-1; j > 0; j--) {
385 d = decoded[i] += s0 >> qlevel;
387 decoded[i+1] += s1 >> qlevel;
389 if (i < s->blocksize) {
391 for (j = 0; j < pred_order; j++)
392 sum += coeffs[j] * decoded[i-j-1];
393 decoded[i] += sum >> qlevel;
400 static inline int decode_subframe(FLACContext *s, int channel)
402 int type, wasted = 0;
405 s->curr_bps = s->bps;
407 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
410 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
414 if (get_bits1(&s->gb)) {
415 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
418 type = get_bits(&s->gb, 6);
420 if (get_bits1(&s->gb)) {
422 while (!get_bits1(&s->gb))
424 s->curr_bps -= wasted;
426 if (s->curr_bps > 32) {
427 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
431 //FIXME use av_log2 for types
433 tmp = get_sbits_long(&s->gb, s->curr_bps);
434 for (i = 0; i < s->blocksize; i++)
435 s->decoded[channel][i] = tmp;
436 } else if (type == 1) {
437 for (i = 0; i < s->blocksize; i++)
438 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
439 } else if ((type >= 8) && (type <= 12)) {
440 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
442 } else if (type >= 32) {
443 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
446 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
452 for (i = 0; i < s->blocksize; i++)
453 s->decoded[channel][i] <<= wasted;
459 static int decode_frame(FLACContext *s)
462 GetBitContext *gb = &s->gb;
465 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
466 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
470 if (s->channels && fi.channels != s->channels) {
471 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
472 "is not supported\n");
475 s->channels = s->avctx->channels = fi.channels;
476 s->ch_mode = fi.ch_mode;
478 if (!s->bps && !fi.bps) {
479 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
484 } else if (s->bps && fi.bps != s->bps) {
485 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
489 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
492 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
493 s->sample_shift = 32 - s->bps;
496 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
497 s->sample_shift = 16 - s->bps;
501 if (!s->max_blocksize)
502 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
503 if (fi.blocksize > s->max_blocksize) {
504 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
508 s->blocksize = fi.blocksize;
510 if (!s->samplerate && !fi.samplerate) {
511 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
512 " or frame header\n");
515 if (fi.samplerate == 0) {
516 fi.samplerate = s->samplerate;
517 } else if (s->samplerate && fi.samplerate != s->samplerate) {
518 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
519 s->samplerate, fi.samplerate);
521 s->samplerate = s->avctx->sample_rate = fi.samplerate;
523 if (!s->got_streaminfo) {
525 s->got_streaminfo = 1;
526 dump_headers(s->avctx, (FLACStreaminfo *)s);
529 // dump_headers(s->avctx, (FLACStreaminfo *)s);
532 for (i = 0; i < s->channels; i++) {
533 if (decode_subframe(s, i) < 0)
540 skip_bits(gb, 16); /* data crc */
545 static int flac_decode_frame(AVCodecContext *avctx,
546 void *data, int *data_size,
549 const uint8_t *buf = avpkt->data;
550 int buf_size = avpkt->size;
551 FLACContext *s = avctx->priv_data;
552 int i, j = 0, bytes_read = 0;
553 int16_t *samples_16 = data;
554 int32_t *samples_32 = data;
555 int alloc_data_size= *data_size;
560 if (s->max_framesize == 0) {
562 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
563 FLAC_MAX_CHANNELS, 32);
566 /* check that there is at least the smallest decodable amount of data.
567 this amount corresponds to the smallest valid FLAC frame possible.
568 FF F8 69 02 00 00 9A 00 00 34 46 */
569 if (buf_size < FLAC_MIN_FRAME_SIZE)
572 /* check for inline header */
573 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
574 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
575 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
578 return get_metadata_size(buf, buf_size);
582 init_get_bits(&s->gb, buf, buf_size*8);
583 if (decode_frame(s) < 0) {
584 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
587 bytes_read = (get_bits_count(&s->gb)+7)/8;
589 /* check if allocated data size is large enough for output */
590 output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
591 if (output_size > alloc_data_size) {
592 av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
593 "allocated data size\n");
596 *data_size = output_size;
598 #define DECORRELATE(left, right)\
599 assert(s->channels == 2);\
600 for (i = 0; i < s->blocksize; i++) {\
601 int a= s->decoded[0][i];\
602 int b= s->decoded[1][i];\
604 *samples_32++ = (left) << s->sample_shift;\
605 *samples_32++ = (right) << s->sample_shift;\
607 *samples_16++ = (left) << s->sample_shift;\
608 *samples_16++ = (right) << s->sample_shift;\
613 switch (s->ch_mode) {
614 case FLAC_CHMODE_INDEPENDENT:
615 for (j = 0; j < s->blocksize; j++) {
616 for (i = 0; i < s->channels; i++) {
618 *samples_32++ = s->decoded[i][j] << s->sample_shift;
620 *samples_16++ = s->decoded[i][j] << s->sample_shift;
624 case FLAC_CHMODE_LEFT_SIDE:
626 case FLAC_CHMODE_RIGHT_SIDE:
628 case FLAC_CHMODE_MID_SIDE:
629 DECORRELATE( (a-=b>>1) + b, a)
632 if (bytes_read > buf_size) {
633 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
636 if (bytes_read < buf_size) {
637 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
638 buf_size - bytes_read, buf_size);
644 static av_cold int flac_decode_close(AVCodecContext *avctx)
646 FLACContext *s = avctx->priv_data;
649 for (i = 0; i < s->channels; i++) {
650 av_freep(&s->decoded[i]);
656 AVCodec ff_flac_decoder = {
665 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),