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/avassert.h"
38 #include "libavutil/crc.h"
42 #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 sample_shift; ///< shift required to make output samples 16-bit or 32-bit
57 int ch_mode; ///< channel decorrelation type in the current frame
58 int got_streaminfo; ///< indicates if the STREAMINFO has been read
60 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
65 static const int64_t flac_channel_layouts[6] = {
68 AV_CH_LAYOUT_SURROUND,
74 static void allocate_buffers(FLACContext *s);
76 static void flac_set_bps(FLACContext *s)
78 enum AVSampleFormat req = s->avctx->request_sample_fmt;
79 int need32 = s->bps > 16;
80 int want32 = av_get_bytes_per_sample(req) > 2;
81 int planar = av_sample_fmt_is_planar(req);
83 if (need32 || want32) {
85 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
87 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
88 s->sample_shift = 32 - s->bps;
91 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
93 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
94 s->sample_shift = 16 - s->bps;
98 static av_cold int flac_decode_init(AVCodecContext *avctx)
100 enum FLACExtradataFormat format;
102 FLACContext *s = avctx->priv_data;
105 /* for now, the raw FLAC header is allowed to be passed to the decoder as
106 frame data instead of extradata. */
107 if (!avctx->extradata)
110 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
113 /* initialize based on the demuxer-supplied streamdata header */
114 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
117 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
118 s->got_streaminfo = 1;
120 avcodec_get_frame_defaults(&s->frame);
121 avctx->coded_frame = &s->frame;
123 if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
124 avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
129 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
131 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
132 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
133 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
134 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
135 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
138 static void allocate_buffers(FLACContext *s)
142 av_assert0(s->max_blocksize);
144 for (i = 0; i < s->channels; i++) {
145 s->decoded[i] = av_malloc(sizeof(int32_t)*s->max_blocksize);
150 * Parse the STREAMINFO from an inline header.
151 * @param s the flac decoding context
152 * @param buf input buffer, starting with the "fLaC" marker
153 * @param buf_size buffer size
154 * @return non-zero if metadata is invalid
156 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
158 int metadata_type, metadata_size;
160 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
164 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
165 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
166 metadata_size != FLAC_STREAMINFO_SIZE) {
167 return AVERROR_INVALIDDATA;
169 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
172 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
173 s->got_streaminfo = 1;
179 * Determine the size of an inline header.
180 * @param buf input buffer, starting with the "fLaC" marker
181 * @param buf_size buffer size
182 * @return number of bytes in the header, or 0 if more data is needed
184 static int get_metadata_size(const uint8_t *buf, int buf_size)
186 int metadata_last, metadata_size;
187 const uint8_t *buf_end = buf + buf_size;
191 if (buf_end - buf < 4)
193 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
195 if (buf_end - buf < metadata_size) {
196 /* need more data in order to read the complete header */
199 buf += metadata_size;
200 } while (!metadata_last);
202 return buf_size - (buf_end - buf);
205 static int decode_residuals(FLACContext *s, int channel, int pred_order)
207 int i, tmp, partition, method_type, rice_order;
208 int sample = 0, samples;
210 method_type = get_bits(&s->gb, 2);
211 if (method_type > 1) {
212 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
217 rice_order = get_bits(&s->gb, 4);
219 samples= s->blocksize >> rice_order;
220 if (pred_order > samples) {
221 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
222 pred_order, samples);
228 for (partition = 0; partition < (1 << rice_order); partition++) {
229 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
230 if (tmp == (method_type == 0 ? 15 : 31)) {
231 tmp = get_bits(&s->gb, 5);
232 for (; i < samples; i++, sample++)
233 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
235 for (; i < samples; i++, sample++) {
236 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
245 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order,
248 const int blocksize = s->blocksize;
249 int32_t *decoded = s->decoded[channel];
252 /* warm up samples */
253 for (i = 0; i < pred_order; i++) {
254 decoded[i] = get_sbits_long(&s->gb, bps);
257 if (decode_residuals(s, channel, pred_order) < 0)
261 a = decoded[pred_order-1];
263 b = a - decoded[pred_order-2];
265 c = b - decoded[pred_order-2] + decoded[pred_order-3];
267 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
269 switch (pred_order) {
273 for (i = pred_order; i < blocksize; i++)
274 decoded[i] = a += decoded[i];
277 for (i = pred_order; i < blocksize; i++)
278 decoded[i] = a += b += decoded[i];
281 for (i = pred_order; i < blocksize; i++)
282 decoded[i] = a += b += c += decoded[i];
285 for (i = pred_order; i < blocksize; i++)
286 decoded[i] = a += b += c += d += decoded[i];
289 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
296 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order,
300 int coeff_prec, qlevel;
302 int32_t *decoded = s->decoded[channel];
304 /* warm up samples */
305 for (i = 0; i < pred_order; i++) {
306 decoded[i] = get_sbits_long(&s->gb, bps);
309 coeff_prec = get_bits(&s->gb, 4) + 1;
310 if (coeff_prec == 16) {
311 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
314 qlevel = get_sbits(&s->gb, 5);
316 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
321 for (i = 0; i < pred_order; i++) {
322 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
325 if (decode_residuals(s, channel, pred_order) < 0)
328 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
333 static inline int decode_subframe(FLACContext *s, int channel)
335 int type, wasted = 0;
340 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
343 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
347 if (get_bits1(&s->gb)) {
348 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
351 type = get_bits(&s->gb, 6);
353 if (get_bits1(&s->gb)) {
354 int left = get_bits_left(&s->gb);
357 (left < bps && !show_bits_long(&s->gb, left)) ||
358 !show_bits_long(&s->gb, bps)) {
359 av_log(s->avctx, AV_LOG_ERROR,
360 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
362 return AVERROR_INVALIDDATA;
364 while (!get_bits1(&s->gb))
369 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
373 //FIXME use av_log2 for types
375 tmp = get_sbits_long(&s->gb, bps);
376 for (i = 0; i < s->blocksize; i++)
377 s->decoded[channel][i] = tmp;
378 } else if (type == 1) {
379 for (i = 0; i < s->blocksize; i++)
380 s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
381 } else if ((type >= 8) && (type <= 12)) {
382 if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
384 } else if (type >= 32) {
385 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
388 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
394 for (i = 0; i < s->blocksize; i++)
395 s->decoded[channel][i] <<= wasted;
401 static int decode_frame(FLACContext *s)
404 GetBitContext *gb = &s->gb;
407 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
408 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
412 if (s->channels && fi.channels != s->channels) {
413 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
414 "is not supported\n");
417 s->channels = s->avctx->channels = fi.channels;
418 s->ch_mode = fi.ch_mode;
420 if (!s->bps && !fi.bps) {
421 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
426 } else if (s->bps && fi.bps != s->bps) {
427 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
433 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
437 if (!s->max_blocksize)
438 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
439 if (fi.blocksize > s->max_blocksize) {
440 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
444 s->blocksize = fi.blocksize;
446 if (!s->samplerate && !fi.samplerate) {
447 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
448 " or frame header\n");
451 if (fi.samplerate == 0) {
452 fi.samplerate = s->samplerate;
453 } else if (s->samplerate && fi.samplerate != s->samplerate) {
454 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
455 s->samplerate, fi.samplerate);
457 s->samplerate = s->avctx->sample_rate = fi.samplerate;
459 if (!s->got_streaminfo) {
461 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
462 s->got_streaminfo = 1;
463 dump_headers(s->avctx, (FLACStreaminfo *)s);
466 // dump_headers(s->avctx, (FLACStreaminfo *)s);
469 for (i = 0; i < s->channels; i++) {
470 if (decode_subframe(s, i) < 0)
477 skip_bits(gb, 16); /* data crc */
482 static int flac_decode_frame(AVCodecContext *avctx, void *data,
483 int *got_frame_ptr, AVPacket *avpkt)
485 const uint8_t *buf = avpkt->data;
486 int buf_size = avpkt->size;
487 FLACContext *s = avctx->priv_data;
493 if (s->max_framesize == 0) {
495 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
496 FLAC_MAX_CHANNELS, 32);
499 /* check that there is at least the smallest decodable amount of data.
500 this amount corresponds to the smallest valid FLAC frame possible.
501 FF F8 69 02 00 00 9A 00 00 34 46 */
502 if (buf_size < FLAC_MIN_FRAME_SIZE)
505 /* check for inline header */
506 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
507 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
508 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
511 return get_metadata_size(buf, buf_size);
515 init_get_bits(&s->gb, buf, buf_size*8);
516 if (decode_frame(s) < 0) {
517 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
520 bytes_read = (get_bits_count(&s->gb)+7)/8;
522 /* get output buffer */
523 s->frame.nb_samples = s->blocksize;
524 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
525 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
529 s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
530 s->blocksize, s->sample_shift);
532 if (bytes_read > buf_size) {
533 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
536 if (bytes_read < buf_size) {
537 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
538 buf_size - bytes_read, buf_size);
542 *(AVFrame *)data = s->frame;
547 static av_cold int flac_decode_close(AVCodecContext *avctx)
549 FLACContext *s = avctx->priv_data;
552 for (i = 0; i < s->channels; i++) {
553 av_freep(&s->decoded[i]);
559 AVCodec ff_flac_decoder = {
561 .type = AVMEDIA_TYPE_AUDIO,
563 .priv_data_size = sizeof(FLACContext),
564 .init = flac_decode_init,
565 .close = flac_decode_close,
566 .decode = flac_decode_frame,
567 .capabilities = CODEC_CAP_DR1,
568 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
569 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,