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/audioconvert.h"
37 #include "libavutil/crc.h"
41 #include "bytestream.h"
49 typedef struct FLACContext {
52 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 const int64_t flac_channel_layouts[6] = {
69 AV_CH_LAYOUT_SURROUND,
75 static void allocate_buffers(FLACContext *s);
77 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
78 enum FLACExtradataFormat *format,
79 uint8_t **streaminfo_start)
81 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
82 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
85 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
86 /* extradata contains STREAMINFO only */
87 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
88 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
89 FLAC_STREAMINFO_SIZE-avctx->extradata_size);
91 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
92 *streaminfo_start = avctx->extradata;
94 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
95 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
98 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
99 *streaminfo_start = &avctx->extradata[8];
104 static av_cold int flac_decode_init(AVCodecContext *avctx)
106 enum FLACExtradataFormat format;
108 FLACContext *s = avctx->priv_data;
111 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
113 /* for now, the raw FLAC header is allowed to be passed to the decoder as
114 frame data instead of extradata. */
115 if (!avctx->extradata)
118 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
121 /* initialize based on the demuxer-supplied streamdata header */
122 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
124 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
126 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
128 s->got_streaminfo = 1;
130 avcodec_get_frame_defaults(&s->frame);
131 avctx->coded_frame = &s->frame;
133 if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
134 avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
139 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
141 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
142 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
143 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
144 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
145 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
148 static void allocate_buffers(FLACContext *s)
152 assert(s->max_blocksize);
154 for (i = 0; i < s->channels; i++) {
155 s->decoded[i] = av_realloc(s->decoded[i],
156 sizeof(int32_t)*s->max_blocksize);
160 void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
161 const uint8_t *buffer)
164 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
166 skip_bits(&gb, 16); /* skip min blocksize */
167 s->max_blocksize = get_bits(&gb, 16);
168 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
169 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
171 s->max_blocksize = 16;
174 skip_bits(&gb, 24); /* skip min frame size */
175 s->max_framesize = get_bits_long(&gb, 24);
177 s->samplerate = get_bits_long(&gb, 20);
178 s->channels = get_bits(&gb, 3) + 1;
179 s->bps = get_bits(&gb, 5) + 1;
181 avctx->channels = s->channels;
182 avctx->sample_rate = s->samplerate;
183 avctx->bits_per_raw_sample = s->bps;
185 s->samples = get_bits_long(&gb, 32) << 4;
186 s->samples |= get_bits(&gb, 4);
188 skip_bits_long(&gb, 64); /* md5 sum */
189 skip_bits_long(&gb, 64); /* md5 sum */
191 dump_headers(avctx, s);
194 void avpriv_flac_parse_block_header(const uint8_t *block_header,
195 int *last, int *type, int *size)
197 int tmp = bytestream_get_byte(&block_header);
203 *size = bytestream_get_be24(&block_header);
207 * Parse the STREAMINFO from an inline header.
208 * @param s the flac decoding context
209 * @param buf input buffer, starting with the "fLaC" marker
210 * @param buf_size buffer size
211 * @return non-zero if metadata is invalid
213 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
215 int metadata_type, metadata_size;
217 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
221 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
222 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
223 metadata_size != FLAC_STREAMINFO_SIZE) {
224 return AVERROR_INVALIDDATA;
226 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
228 s->got_streaminfo = 1;
234 * Determine the size of an inline header.
235 * @param buf input buffer, starting with the "fLaC" marker
236 * @param buf_size buffer size
237 * @return number of bytes in the header, or 0 if more data is needed
239 static int get_metadata_size(const uint8_t *buf, int buf_size)
241 int metadata_last, metadata_size;
242 const uint8_t *buf_end = buf + buf_size;
246 if (buf_end - buf < 4)
248 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
250 if (buf_end - buf < metadata_size) {
251 /* need more data in order to read the complete header */
254 buf += metadata_size;
255 } while (!metadata_last);
257 return buf_size - (buf_end - buf);
260 static int decode_residuals(FLACContext *s, int channel, int pred_order)
262 int i, tmp, partition, method_type, rice_order;
263 int sample = 0, samples;
265 method_type = get_bits(&s->gb, 2);
266 if (method_type > 1) {
267 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
272 rice_order = get_bits(&s->gb, 4);
274 samples= s->blocksize >> rice_order;
275 if (pred_order > samples) {
276 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
277 pred_order, samples);
283 for (partition = 0; partition < (1 << rice_order); partition++) {
284 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
285 if (tmp == (method_type == 0 ? 15 : 31)) {
286 tmp = get_bits(&s->gb, 5);
287 for (; i < samples; i++, sample++)
288 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
290 for (; i < samples; i++, sample++) {
291 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
300 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
302 const int blocksize = s->blocksize;
303 int32_t *decoded = s->decoded[channel];
306 /* warm up samples */
307 for (i = 0; i < pred_order; i++) {
308 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
311 if (decode_residuals(s, channel, pred_order) < 0)
315 a = decoded[pred_order-1];
317 b = a - decoded[pred_order-2];
319 c = b - decoded[pred_order-2] + decoded[pred_order-3];
321 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
323 switch (pred_order) {
327 for (i = pred_order; i < blocksize; i++)
328 decoded[i] = a += decoded[i];
331 for (i = pred_order; i < blocksize; i++)
332 decoded[i] = a += b += decoded[i];
335 for (i = pred_order; i < blocksize; i++)
336 decoded[i] = a += b += c += decoded[i];
339 for (i = pred_order; i < blocksize; i++)
340 decoded[i] = a += b += c += d += decoded[i];
343 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
350 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
353 int coeff_prec, qlevel;
355 int32_t *decoded = s->decoded[channel];
357 /* warm up samples */
358 for (i = 0; i < pred_order; i++) {
359 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
362 coeff_prec = get_bits(&s->gb, 4) + 1;
363 if (coeff_prec == 16) {
364 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
367 qlevel = get_sbits(&s->gb, 5);
369 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
374 for (i = 0; i < pred_order; i++) {
375 coeffs[i] = get_sbits(&s->gb, coeff_prec);
378 if (decode_residuals(s, channel, pred_order) < 0)
383 for (i = pred_order; i < s->blocksize; i++) {
385 for (j = 0; j < pred_order; j++)
386 sum += (int64_t)coeffs[j] * decoded[i-j-1];
387 decoded[i] += sum >> qlevel;
390 for (i = pred_order; i < s->blocksize-1; i += 2) {
392 int d = decoded[i-pred_order];
394 for (j = pred_order-1; j > 0; j--) {
402 d = decoded[i] += s0 >> qlevel;
404 decoded[i+1] += s1 >> qlevel;
406 if (i < s->blocksize) {
408 for (j = 0; j < pred_order; j++)
409 sum += coeffs[j] * decoded[i-j-1];
410 decoded[i] += sum >> qlevel;
417 static inline int decode_subframe(FLACContext *s, int channel)
419 int type, wasted = 0;
422 s->curr_bps = s->bps;
424 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
427 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
431 if (get_bits1(&s->gb)) {
432 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
435 type = get_bits(&s->gb, 6);
437 if (get_bits1(&s->gb)) {
438 int left = get_bits_left(&s->gb);
441 (left < s->curr_bps && !show_bits_long(&s->gb, left)) ||
442 !show_bits_long(&s->gb, s->curr_bps)) {
443 av_log(s->avctx, AV_LOG_ERROR,
444 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
446 return AVERROR_INVALIDDATA;
448 while (!get_bits1(&s->gb))
450 s->curr_bps -= wasted;
452 if (s->curr_bps > 32) {
453 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
457 //FIXME use av_log2 for types
459 tmp = get_sbits_long(&s->gb, s->curr_bps);
460 for (i = 0; i < s->blocksize; i++)
461 s->decoded[channel][i] = tmp;
462 } else if (type == 1) {
463 for (i = 0; i < s->blocksize; i++)
464 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
465 } else if ((type >= 8) && (type <= 12)) {
466 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
468 } else if (type >= 32) {
469 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
472 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
478 for (i = 0; i < s->blocksize; i++)
479 s->decoded[channel][i] <<= wasted;
485 static int decode_frame(FLACContext *s)
488 GetBitContext *gb = &s->gb;
491 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
492 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
496 if (s->channels && fi.channels != s->channels) {
497 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
498 "is not supported\n");
501 s->channels = s->avctx->channels = fi.channels;
502 s->ch_mode = fi.ch_mode;
504 if (!s->bps && !fi.bps) {
505 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
510 } else if (s->bps && fi.bps != s->bps) {
511 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
515 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
518 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
519 s->sample_shift = 32 - s->bps;
522 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
523 s->sample_shift = 16 - s->bps;
527 if (!s->max_blocksize)
528 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
529 if (fi.blocksize > s->max_blocksize) {
530 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
534 s->blocksize = fi.blocksize;
536 if (!s->samplerate && !fi.samplerate) {
537 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
538 " or frame header\n");
541 if (fi.samplerate == 0) {
542 fi.samplerate = s->samplerate;
543 } else if (s->samplerate && fi.samplerate != s->samplerate) {
544 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
545 s->samplerate, fi.samplerate);
547 s->samplerate = s->avctx->sample_rate = fi.samplerate;
549 if (!s->got_streaminfo) {
551 s->got_streaminfo = 1;
552 dump_headers(s->avctx, (FLACStreaminfo *)s);
555 // dump_headers(s->avctx, (FLACStreaminfo *)s);
558 for (i = 0; i < s->channels; i++) {
559 if (decode_subframe(s, i) < 0)
566 skip_bits(gb, 16); /* data crc */
571 static int flac_decode_frame(AVCodecContext *avctx, void *data,
572 int *got_frame_ptr, AVPacket *avpkt)
574 const uint8_t *buf = avpkt->data;
575 int buf_size = avpkt->size;
576 FLACContext *s = avctx->priv_data;
577 int i, j = 0, bytes_read = 0;
584 if (s->max_framesize == 0) {
586 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
587 FLAC_MAX_CHANNELS, 32);
590 /* check that there is at least the smallest decodable amount of data.
591 this amount corresponds to the smallest valid FLAC frame possible.
592 FF F8 69 02 00 00 9A 00 00 34 46 */
593 if (buf_size < FLAC_MIN_FRAME_SIZE)
596 /* check for inline header */
597 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
598 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
599 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
602 return get_metadata_size(buf, buf_size);
606 init_get_bits(&s->gb, buf, buf_size*8);
607 if (decode_frame(s) < 0) {
608 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
611 bytes_read = (get_bits_count(&s->gb)+7)/8;
613 /* get output buffer */
614 s->frame.nb_samples = s->blocksize;
615 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
616 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
619 samples_16 = (int16_t *)s->frame.data[0];
620 samples_32 = (int32_t *)s->frame.data[0];
622 #define DECORRELATE(left, right)\
623 assert(s->channels == 2);\
624 for (i = 0; i < s->blocksize; i++) {\
625 int a= s->decoded[0][i];\
626 int b= s->decoded[1][i];\
628 *samples_32++ = (left) << s->sample_shift;\
629 *samples_32++ = (right) << s->sample_shift;\
631 *samples_16++ = (left) << s->sample_shift;\
632 *samples_16++ = (right) << s->sample_shift;\
637 switch (s->ch_mode) {
638 case FLAC_CHMODE_INDEPENDENT:
639 for (j = 0; j < s->blocksize; j++) {
640 for (i = 0; i < s->channels; i++) {
642 *samples_32++ = s->decoded[i][j] << s->sample_shift;
644 *samples_16++ = s->decoded[i][j] << s->sample_shift;
648 case FLAC_CHMODE_LEFT_SIDE:
650 case FLAC_CHMODE_RIGHT_SIDE:
652 case FLAC_CHMODE_MID_SIDE:
653 DECORRELATE( (a-=b>>1) + b, a)
656 if (bytes_read > buf_size) {
657 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
660 if (bytes_read < buf_size) {
661 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
662 buf_size - bytes_read, buf_size);
666 *(AVFrame *)data = s->frame;
671 static av_cold int flac_decode_close(AVCodecContext *avctx)
673 FLACContext *s = avctx->priv_data;
676 for (i = 0; i < s->channels; i++) {
677 av_freep(&s->decoded[i]);
683 AVCodec ff_flac_decoder = {
685 .type = AVMEDIA_TYPE_AUDIO,
687 .priv_data_size = sizeof(FLACContext),
688 .init = flac_decode_init,
689 .close = flac_decode_close,
690 .decode = flac_decode_frame,
691 .capabilities = CODEC_CAP_DR1,
692 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),