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
26 * @see 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.
36 #include "libavutil/crc.h"
40 #include "bytestream.h"
48 typedef struct FLACContext {
51 AVCodecContext *avctx; ///< parent AVCodecContext
53 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
55 int blocksize; ///< number of samples in the current frame
56 int curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits
57 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
58 int is32; ///< flag to indicate if output should be 32-bit instead of 16-bit
59 int ch_mode; ///< channel decorrelation type in the current frame
60 int got_streaminfo; ///< indicates if the STREAMINFO has been read
62 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
65 static void allocate_buffers(FLACContext *s);
67 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
68 enum FLACExtradataFormat *format,
69 uint8_t **streaminfo_start)
71 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
72 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
75 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
76 /* extradata contains STREAMINFO only */
77 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
78 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
79 FLAC_STREAMINFO_SIZE-avctx->extradata_size);
81 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
82 *streaminfo_start = avctx->extradata;
84 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
85 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
88 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
89 *streaminfo_start = &avctx->extradata[8];
94 static av_cold int flac_decode_init(AVCodecContext *avctx)
96 enum FLACExtradataFormat format;
98 FLACContext *s = avctx->priv_data;
101 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
103 /* for now, the raw FLAC header is allowed to be passed to the decoder as
104 frame data instead of extradata. */
105 if (!avctx->extradata)
108 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
111 /* initialize based on the demuxer-supplied streamdata header */
112 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
114 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
116 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
118 s->got_streaminfo = 1;
120 avcodec_get_frame_defaults(&s->frame);
121 avctx->coded_frame = &s->frame;
126 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
128 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
129 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
130 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
131 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
132 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
135 static void allocate_buffers(FLACContext *s)
139 assert(s->max_blocksize);
141 for (i = 0; i < s->channels; i++) {
142 s->decoded[i] = av_realloc(s->decoded[i],
143 sizeof(int32_t)*s->max_blocksize);
147 void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
148 const uint8_t *buffer)
151 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
153 skip_bits(&gb, 16); /* skip min blocksize */
154 s->max_blocksize = get_bits(&gb, 16);
155 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
156 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
158 s->max_blocksize = 16;
161 skip_bits(&gb, 24); /* skip min frame size */
162 s->max_framesize = get_bits_long(&gb, 24);
164 s->samplerate = get_bits_long(&gb, 20);
165 s->channels = get_bits(&gb, 3) + 1;
166 s->bps = get_bits(&gb, 5) + 1;
168 avctx->channels = s->channels;
169 avctx->sample_rate = s->samplerate;
170 avctx->bits_per_raw_sample = s->bps;
172 s->samples = get_bits_long(&gb, 32) << 4;
173 s->samples |= get_bits(&gb, 4);
175 skip_bits_long(&gb, 64); /* md5 sum */
176 skip_bits_long(&gb, 64); /* md5 sum */
178 dump_headers(avctx, s);
181 void avpriv_flac_parse_block_header(const uint8_t *block_header,
182 int *last, int *type, int *size)
184 int tmp = bytestream_get_byte(&block_header);
190 *size = bytestream_get_be24(&block_header);
194 * Parse the STREAMINFO from an inline header.
195 * @param s the flac decoding context
196 * @param buf input buffer, starting with the "fLaC" marker
197 * @param buf_size buffer size
198 * @return non-zero if metadata is invalid
200 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
202 int metadata_type, metadata_size;
204 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
208 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
209 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
210 metadata_size != FLAC_STREAMINFO_SIZE) {
211 return AVERROR_INVALIDDATA;
213 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
215 s->got_streaminfo = 1;
221 * Determine the size of an inline header.
222 * @param buf input buffer, starting with the "fLaC" marker
223 * @param buf_size buffer size
224 * @return number of bytes in the header, or 0 if more data is needed
226 static int get_metadata_size(const uint8_t *buf, int buf_size)
228 int metadata_last, metadata_size;
229 const uint8_t *buf_end = buf + buf_size;
233 if (buf_end - buf < 4)
235 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
237 if (buf_end - buf < metadata_size) {
238 /* need more data in order to read the complete header */
241 buf += metadata_size;
242 } while (!metadata_last);
244 return buf_size - (buf_end - buf);
247 static int decode_residuals(FLACContext *s, int channel, int pred_order)
249 int i, tmp, partition, method_type, rice_order;
250 int sample = 0, samples;
252 method_type = get_bits(&s->gb, 2);
253 if (method_type > 1) {
254 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
259 rice_order = get_bits(&s->gb, 4);
261 samples= s->blocksize >> rice_order;
262 if (pred_order > samples) {
263 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
264 pred_order, samples);
270 for (partition = 0; partition < (1 << rice_order); partition++) {
271 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
272 if (tmp == (method_type == 0 ? 15 : 31)) {
273 tmp = get_bits(&s->gb, 5);
274 for (; i < samples; i++, sample++)
275 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
277 for (; i < samples; i++, sample++) {
278 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
287 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
289 const int blocksize = s->blocksize;
290 int32_t *decoded = s->decoded[channel];
291 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
293 /* warm up samples */
294 for (i = 0; i < pred_order; i++) {
295 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
298 if (decode_residuals(s, channel, pred_order) < 0)
302 a = decoded[pred_order-1];
304 b = a - decoded[pred_order-2];
306 c = b - decoded[pred_order-2] + decoded[pred_order-3];
308 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
310 switch (pred_order) {
314 for (i = pred_order; i < blocksize; i++)
315 decoded[i] = a += decoded[i];
318 for (i = pred_order; i < blocksize; i++)
319 decoded[i] = a += b += decoded[i];
322 for (i = pred_order; i < blocksize; i++)
323 decoded[i] = a += b += c += decoded[i];
326 for (i = pred_order; i < blocksize; i++)
327 decoded[i] = a += b += c += d += decoded[i];
330 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
337 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
340 int coeff_prec, qlevel;
342 int32_t *decoded = s->decoded[channel];
344 /* warm up samples */
345 for (i = 0; i < pred_order; i++) {
346 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
349 coeff_prec = get_bits(&s->gb, 4) + 1;
350 if (coeff_prec == 16) {
351 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
354 qlevel = get_sbits(&s->gb, 5);
356 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
361 for (i = 0; i < pred_order; i++) {
362 coeffs[i] = get_sbits(&s->gb, coeff_prec);
365 if (decode_residuals(s, channel, pred_order) < 0)
370 for (i = pred_order; i < s->blocksize; i++) {
372 for (j = 0; j < pred_order; j++)
373 sum += (int64_t)coeffs[j] * decoded[i-j-1];
374 decoded[i] += sum >> qlevel;
377 for (i = pred_order; i < s->blocksize-1; i += 2) {
379 int d = decoded[i-pred_order];
381 for (j = pred_order-1; j > 0; j--) {
389 d = decoded[i] += s0 >> qlevel;
391 decoded[i+1] += s1 >> qlevel;
393 if (i < s->blocksize) {
395 for (j = 0; j < pred_order; j++)
396 sum += coeffs[j] * decoded[i-j-1];
397 decoded[i] += sum >> qlevel;
404 static inline int decode_subframe(FLACContext *s, int channel)
406 int type, wasted = 0;
409 s->curr_bps = s->bps;
411 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
414 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
418 if (get_bits1(&s->gb)) {
419 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
422 type = get_bits(&s->gb, 6);
424 if (get_bits1(&s->gb)) {
426 while (!get_bits1(&s->gb))
428 s->curr_bps -= wasted;
430 if (s->curr_bps > 32) {
431 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
435 //FIXME use av_log2 for types
437 tmp = get_sbits_long(&s->gb, s->curr_bps);
438 for (i = 0; i < s->blocksize; i++)
439 s->decoded[channel][i] = tmp;
440 } else if (type == 1) {
441 for (i = 0; i < s->blocksize; i++)
442 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
443 } else if ((type >= 8) && (type <= 12)) {
444 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
446 } else if (type >= 32) {
447 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
450 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
456 for (i = 0; i < s->blocksize; i++)
457 s->decoded[channel][i] <<= wasted;
463 static int decode_frame(FLACContext *s)
466 GetBitContext *gb = &s->gb;
469 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
470 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
474 if (s->channels && fi.channels != s->channels) {
475 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
476 "is not supported\n");
479 s->channels = s->avctx->channels = fi.channels;
480 s->ch_mode = fi.ch_mode;
482 if (!s->bps && !fi.bps) {
483 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
488 } else if (s->bps && fi.bps != s->bps) {
489 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
493 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
496 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
497 s->sample_shift = 32 - s->bps;
500 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
501 s->sample_shift = 16 - s->bps;
505 if (!s->max_blocksize)
506 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
507 if (fi.blocksize > s->max_blocksize) {
508 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
512 s->blocksize = fi.blocksize;
514 if (!s->samplerate && !fi.samplerate) {
515 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
516 " or frame header\n");
519 if (fi.samplerate == 0) {
520 fi.samplerate = s->samplerate;
521 } else if (s->samplerate && fi.samplerate != s->samplerate) {
522 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
523 s->samplerate, fi.samplerate);
525 s->samplerate = s->avctx->sample_rate = fi.samplerate;
527 if (!s->got_streaminfo) {
529 s->got_streaminfo = 1;
530 dump_headers(s->avctx, (FLACStreaminfo *)s);
533 // dump_headers(s->avctx, (FLACStreaminfo *)s);
536 for (i = 0; i < s->channels; i++) {
537 if (decode_subframe(s, i) < 0)
544 skip_bits(gb, 16); /* data crc */
549 static int flac_decode_frame(AVCodecContext *avctx, void *data,
550 int *got_frame_ptr, AVPacket *avpkt)
552 const uint8_t *buf = avpkt->data;
553 int buf_size = avpkt->size;
554 FLACContext *s = avctx->priv_data;
555 int i, j = 0, bytes_read = 0;
562 if (s->max_framesize == 0) {
564 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
565 FLAC_MAX_CHANNELS, 32);
568 /* check that there is at least the smallest decodable amount of data.
569 this amount corresponds to the smallest valid FLAC frame possible.
570 FF F8 69 02 00 00 9A 00 00 34 46 */
571 if (buf_size < FLAC_MIN_FRAME_SIZE)
574 /* check for inline header */
575 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
576 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
577 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
580 return get_metadata_size(buf, buf_size);
584 init_get_bits(&s->gb, buf, buf_size*8);
585 if (decode_frame(s) < 0) {
586 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
589 bytes_read = (get_bits_count(&s->gb)+7)/8;
591 /* get output buffer */
592 s->frame.nb_samples = s->blocksize;
593 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
594 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
597 samples_16 = (int16_t *)s->frame.data[0];
598 samples_32 = (int32_t *)s->frame.data[0];
600 #define DECORRELATE(left, right)\
601 assert(s->channels == 2);\
602 for (i = 0; i < s->blocksize; i++) {\
603 int a= s->decoded[0][i];\
604 int b= s->decoded[1][i];\
606 *samples_32++ = (left) << s->sample_shift;\
607 *samples_32++ = (right) << s->sample_shift;\
609 *samples_16++ = (left) << s->sample_shift;\
610 *samples_16++ = (right) << s->sample_shift;\
615 switch (s->ch_mode) {
616 case FLAC_CHMODE_INDEPENDENT:
617 for (j = 0; j < s->blocksize; j++) {
618 for (i = 0; i < s->channels; i++) {
620 *samples_32++ = s->decoded[i][j] << s->sample_shift;
622 *samples_16++ = s->decoded[i][j] << s->sample_shift;
626 case FLAC_CHMODE_LEFT_SIDE:
628 case FLAC_CHMODE_RIGHT_SIDE:
630 case FLAC_CHMODE_MID_SIDE:
631 DECORRELATE( (a-=b>>1) + b, a)
634 if (bytes_read > buf_size) {
635 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
638 if (bytes_read < buf_size) {
639 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
640 buf_size - bytes_read, buf_size);
644 *(AVFrame *)data = s->frame;
649 static av_cold int flac_decode_close(AVCodecContext *avctx)
651 FLACContext *s = avctx->priv_data;
654 for (i = 0; i < s->channels; i++) {
655 av_freep(&s->decoded[i]);
661 AVCodec ff_flac_decoder = {
663 .type = AVMEDIA_TYPE_AUDIO,
665 .priv_data_size = sizeof(FLACContext),
666 .init = flac_decode_init,
667 .close = flac_decode_close,
668 .decode = flac_decode_frame,
669 .capabilities = CODEC_CAP_DR1,
670 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),