2 * FLAC (Free Lossless Audio Codec) decoder
3 * Copyright (c) 2003 Alex Beregszaszi
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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"
50 typedef struct FLACContext {
53 AVCodecContext *avctx; ///< parent AVCodecContext
55 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
57 int blocksize; ///< number of samples in the current frame
58 int sample_shift; ///< shift required to make output samples 16-bit or 32-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
67 static const int64_t flac_channel_layouts[6] = {
70 AV_CH_LAYOUT_SURROUND,
76 static void allocate_buffers(FLACContext *s);
78 static void flac_set_bps(FLACContext *s)
80 enum AVSampleFormat req = s->avctx->request_sample_fmt;
81 int need32 = s->bps > 16;
82 int want32 = av_get_bytes_per_sample(req) > 2;
83 int planar = av_sample_fmt_is_planar(req);
85 if (need32 || want32) {
87 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
89 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
90 s->sample_shift = 32 - s->bps;
93 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
95 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
96 s->sample_shift = 16 - s->bps;
100 static av_cold int flac_decode_init(AVCodecContext *avctx)
102 enum FLACExtradataFormat format;
104 FLACContext *s = avctx->priv_data;
107 /* for now, the raw FLAC header is allowed to be passed to the decoder as
108 frame data instead of extradata. */
109 if (!avctx->extradata)
112 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
115 /* initialize based on the demuxer-supplied streamdata header */
116 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
119 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
120 s->got_streaminfo = 1;
122 avcodec_get_frame_defaults(&s->frame);
123 avctx->coded_frame = &s->frame;
125 if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
126 avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
131 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
133 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
134 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
135 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
136 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
137 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
140 static void allocate_buffers(FLACContext *s)
144 assert(s->max_blocksize);
146 for (i = 0; i < s->channels; i++) {
147 s->decoded[i] = av_malloc(sizeof(int32_t)*s->max_blocksize);
152 * Parse the STREAMINFO from an inline header.
153 * @param s the flac decoding context
154 * @param buf input buffer, starting with the "fLaC" marker
155 * @param buf_size buffer size
156 * @return non-zero if metadata is invalid
158 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
160 int metadata_type, metadata_size;
162 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
166 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
167 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
168 metadata_size != FLAC_STREAMINFO_SIZE) {
169 return AVERROR_INVALIDDATA;
171 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
174 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
175 s->got_streaminfo = 1;
181 * Determine the size of an inline header.
182 * @param buf input buffer, starting with the "fLaC" marker
183 * @param buf_size buffer size
184 * @return number of bytes in the header, or 0 if more data is needed
186 static int get_metadata_size(const uint8_t *buf, int buf_size)
188 int metadata_last, metadata_size;
189 const uint8_t *buf_end = buf + buf_size;
193 if (buf_end - buf < 4)
195 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
197 if (buf_end - buf < metadata_size) {
198 /* need more data in order to read the complete header */
201 buf += metadata_size;
202 } while (!metadata_last);
204 return buf_size - (buf_end - buf);
207 static int decode_residuals(FLACContext *s, int channel, int pred_order)
209 int i, tmp, partition, method_type, rice_order;
210 int rice_bits, rice_esc;
211 int sample = 0, samples;
213 method_type = get_bits(&s->gb, 2);
214 if (method_type > 1) {
215 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
220 rice_order = get_bits(&s->gb, 4);
222 samples= s->blocksize >> rice_order;
223 if (pred_order > samples) {
224 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
225 pred_order, samples);
229 rice_bits = 4 + method_type;
230 rice_esc = (1 << rice_bits) - 1;
234 for (partition = 0; partition < (1 << rice_order); partition++) {
235 tmp = get_bits(&s->gb, rice_bits);
236 if (tmp == rice_esc) {
237 tmp = get_bits(&s->gb, 5);
238 for (; i < samples; i++, sample++)
239 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
241 for (; i < samples; i++, sample++) {
242 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
251 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order,
254 const int blocksize = s->blocksize;
255 int32_t *decoded = s->decoded[channel];
258 /* warm up samples */
259 for (i = 0; i < pred_order; i++) {
260 decoded[i] = get_sbits_long(&s->gb, bps);
263 if (decode_residuals(s, channel, pred_order) < 0)
267 a = decoded[pred_order-1];
269 b = a - decoded[pred_order-2];
271 c = b - decoded[pred_order-2] + decoded[pred_order-3];
273 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
275 switch (pred_order) {
279 for (i = pred_order; i < blocksize; i++)
280 decoded[i] = a += decoded[i];
283 for (i = pred_order; i < blocksize; i++)
284 decoded[i] = a += b += decoded[i];
287 for (i = pred_order; i < blocksize; i++)
288 decoded[i] = a += b += c += decoded[i];
291 for (i = pred_order; i < blocksize; i++)
292 decoded[i] = a += b += c += d += decoded[i];
295 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
302 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order,
306 int coeff_prec, qlevel;
308 int32_t *decoded = s->decoded[channel];
310 /* warm up samples */
311 for (i = 0; i < pred_order; i++) {
312 decoded[i] = get_sbits_long(&s->gb, bps);
315 coeff_prec = get_bits(&s->gb, 4) + 1;
316 if (coeff_prec == 16) {
317 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
320 qlevel = get_sbits(&s->gb, 5);
322 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
327 for (i = 0; i < pred_order; i++) {
328 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
331 if (decode_residuals(s, channel, pred_order) < 0)
334 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
339 static inline int decode_subframe(FLACContext *s, int channel)
341 int type, wasted = 0;
346 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
349 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
353 if (get_bits1(&s->gb)) {
354 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
357 type = get_bits(&s->gb, 6);
359 if (get_bits1(&s->gb)) {
360 int left = get_bits_left(&s->gb);
363 (left < bps && !show_bits_long(&s->gb, left)) ||
364 !show_bits_long(&s->gb, bps)) {
365 av_log(s->avctx, AV_LOG_ERROR,
366 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
368 return AVERROR_INVALIDDATA;
370 while (!get_bits1(&s->gb))
375 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
379 //FIXME use av_log2 for types
381 tmp = get_sbits_long(&s->gb, bps);
382 for (i = 0; i < s->blocksize; i++)
383 s->decoded[channel][i] = tmp;
384 } else if (type == 1) {
385 for (i = 0; i < s->blocksize; i++)
386 s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
387 } else if ((type >= 8) && (type <= 12)) {
388 if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
390 } else if (type >= 32) {
391 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
394 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
400 for (i = 0; i < s->blocksize; i++)
401 s->decoded[channel][i] <<= wasted;
407 static int decode_frame(FLACContext *s)
410 GetBitContext *gb = &s->gb;
413 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
414 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
418 if (s->channels && fi.channels != s->channels) {
419 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
420 "is not supported\n");
423 s->channels = s->avctx->channels = fi.channels;
424 s->ch_mode = fi.ch_mode;
426 if (!s->bps && !fi.bps) {
427 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
432 } else if (s->bps && fi.bps != s->bps) {
433 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
439 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
443 if (!s->max_blocksize)
444 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
445 if (fi.blocksize > s->max_blocksize) {
446 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
450 s->blocksize = fi.blocksize;
452 if (!s->samplerate && !fi.samplerate) {
453 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
454 " or frame header\n");
457 if (fi.samplerate == 0) {
458 fi.samplerate = s->samplerate;
459 } else if (s->samplerate && fi.samplerate != s->samplerate) {
460 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
461 s->samplerate, fi.samplerate);
463 s->samplerate = s->avctx->sample_rate = fi.samplerate;
465 if (!s->got_streaminfo) {
467 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
468 s->got_streaminfo = 1;
469 dump_headers(s->avctx, (FLACStreaminfo *)s);
472 // dump_headers(s->avctx, (FLACStreaminfo *)s);
475 for (i = 0; i < s->channels; i++) {
476 if (decode_subframe(s, i) < 0)
483 skip_bits(gb, 16); /* data crc */
488 static int flac_decode_frame(AVCodecContext *avctx, void *data,
489 int *got_frame_ptr, AVPacket *avpkt)
491 const uint8_t *buf = avpkt->data;
492 int buf_size = avpkt->size;
493 FLACContext *s = avctx->priv_data;
499 if (s->max_framesize == 0) {
501 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
502 FLAC_MAX_CHANNELS, 32);
505 /* check that there is at least the smallest decodable amount of data.
506 this amount corresponds to the smallest valid FLAC frame possible.
507 FF F8 69 02 00 00 9A 00 00 34 46 */
508 if (buf_size < FLAC_MIN_FRAME_SIZE)
511 /* check for inline header */
512 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
513 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
514 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
517 return get_metadata_size(buf, buf_size);
521 init_get_bits(&s->gb, buf, buf_size*8);
522 if (decode_frame(s) < 0) {
523 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
526 bytes_read = (get_bits_count(&s->gb)+7)/8;
528 /* get output buffer */
529 s->frame.nb_samples = s->blocksize;
530 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
531 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
535 s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
536 s->blocksize, s->sample_shift);
538 if (bytes_read > buf_size) {
539 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
542 if (bytes_read < buf_size) {
543 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
544 buf_size - bytes_read, buf_size);
548 *(AVFrame *)data = s->frame;
553 static av_cold int flac_decode_close(AVCodecContext *avctx)
555 FLACContext *s = avctx->priv_data;
558 for (i = 0; i < s->channels; i++) {
559 av_freep(&s->decoded[i]);
565 AVCodec ff_flac_decoder = {
567 .type = AVMEDIA_TYPE_AUDIO,
568 .id = AV_CODEC_ID_FLAC,
569 .priv_data_size = sizeof(FLACContext),
570 .init = flac_decode_init,
571 .close = flac_decode_close,
572 .decode = flac_decode_frame,
573 .capabilities = CODEC_CAP_DR1,
574 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
575 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,