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/avassert.h"
37 #include "libavutil/channel_layout.h"
38 #include "libavutil/crc.h"
42 #include "bytestream.h"
48 typedef struct FLACContext {
51 AVCodecContext *avctx; ///< parent AVCodecContext
52 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
54 int blocksize; ///< number of samples in the current frame
55 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
56 int ch_mode; ///< channel decorrelation type in the current frame
57 int got_streaminfo; ///< indicates if the STREAMINFO has been read
59 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
60 uint8_t *decoded_buffer;
61 unsigned int decoded_buffer_size;
66 static int allocate_buffers(FLACContext *s);
68 static void flac_set_bps(FLACContext *s)
70 enum AVSampleFormat req = s->avctx->request_sample_fmt;
71 int need32 = s->bps > 16;
72 int want32 = av_get_bytes_per_sample(req) > 2;
73 int planar = av_sample_fmt_is_planar(req);
75 if (need32 || want32) {
77 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
79 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
80 s->sample_shift = 32 - s->bps;
83 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
85 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
86 s->sample_shift = 16 - s->bps;
90 static av_cold int flac_decode_init(AVCodecContext *avctx)
92 enum FLACExtradataFormat format;
95 FLACContext *s = avctx->priv_data;
98 /* for now, the raw FLAC header is allowed to be passed to the decoder as
99 frame data instead of extradata. */
100 if (!avctx->extradata)
103 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
106 /* initialize based on the demuxer-supplied streamdata header */
107 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
108 ret = allocate_buffers(s);
112 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
113 s->got_streaminfo = 1;
118 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
120 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
121 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
122 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
123 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
124 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
127 static int allocate_buffers(FLACContext *s)
131 av_assert0(s->max_blocksize);
133 buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
134 AV_SAMPLE_FMT_S32P, 0);
138 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
139 if (!s->decoded_buffer)
140 return AVERROR(ENOMEM);
142 return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
143 s->decoded_buffer, s->channels,
144 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
148 * Parse the STREAMINFO from an inline header.
149 * @param s the flac decoding context
150 * @param buf input buffer, starting with the "fLaC" marker
151 * @param buf_size buffer size
152 * @return non-zero if metadata is invalid
154 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
156 int metadata_type, metadata_size, ret;
158 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
162 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
163 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
164 metadata_size != FLAC_STREAMINFO_SIZE) {
165 return AVERROR_INVALIDDATA;
167 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
168 ret = allocate_buffers(s);
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, int32_t *decoded, int pred_order)
207 int i, tmp, partition, method_type, rice_order;
208 int rice_bits, rice_esc;
211 method_type = get_bits(&s->gb, 2);
212 if (method_type > 1) {
213 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
218 rice_order = get_bits(&s->gb, 4);
220 samples= s->blocksize >> rice_order;
221 if (pred_order > samples) {
222 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
223 pred_order, samples);
227 rice_bits = 4 + method_type;
228 rice_esc = (1 << rice_bits) - 1;
230 decoded += pred_order;
232 for (partition = 0; partition < (1 << rice_order); partition++) {
233 tmp = get_bits(&s->gb, rice_bits);
234 if (tmp == rice_esc) {
235 tmp = get_bits(&s->gb, 5);
236 for (; i < samples; i++)
237 *decoded++ = get_sbits_long(&s->gb, tmp);
239 for (; i < samples; i++) {
240 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
249 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
250 int pred_order, int bps)
252 const int blocksize = s->blocksize;
253 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
255 /* warm up samples */
256 for (i = 0; i < pred_order; i++) {
257 decoded[i] = get_sbits_long(&s->gb, bps);
260 if (decode_residuals(s, decoded, pred_order) < 0)
264 a = decoded[pred_order-1];
266 b = a - decoded[pred_order-2];
268 c = b - decoded[pred_order-2] + decoded[pred_order-3];
270 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
272 switch (pred_order) {
276 for (i = pred_order; i < blocksize; i++)
277 decoded[i] = a += decoded[i];
280 for (i = pred_order; i < blocksize; i++)
281 decoded[i] = a += b += decoded[i];
284 for (i = pred_order; i < blocksize; i++)
285 decoded[i] = a += b += c += decoded[i];
288 for (i = pred_order; i < blocksize; i++)
289 decoded[i] = a += b += c += d += decoded[i];
292 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
299 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
303 int coeff_prec, qlevel;
306 /* warm up samples */
307 for (i = 0; i < pred_order; i++) {
308 decoded[i] = get_sbits_long(&s->gb, bps);
311 coeff_prec = get_bits(&s->gb, 4) + 1;
312 if (coeff_prec == 16) {
313 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
316 qlevel = get_sbits(&s->gb, 5);
318 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
323 for (i = 0; i < pred_order; i++) {
324 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
327 if (decode_residuals(s, decoded, pred_order) < 0)
330 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
335 static inline int decode_subframe(FLACContext *s, int channel)
337 int32_t *decoded = s->decoded[channel];
338 int type, wasted = 0;
343 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
346 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
350 if (get_bits1(&s->gb)) {
351 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
354 type = get_bits(&s->gb, 6);
356 if (get_bits1(&s->gb)) {
357 int left = get_bits_left(&s->gb);
360 (left < bps && !show_bits_long(&s->gb, left)) ||
361 !show_bits_long(&s->gb, bps)) {
362 av_log(s->avctx, AV_LOG_ERROR,
363 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
365 return AVERROR_INVALIDDATA;
367 while (!get_bits1(&s->gb))
372 av_log_missing_feature(s->avctx, "Decorrelated bit depth > 32", 0);
373 return AVERROR_PATCHWELCOME;
376 //FIXME use av_log2 for types
378 tmp = get_sbits_long(&s->gb, bps);
379 for (i = 0; i < s->blocksize; i++)
381 } else if (type == 1) {
382 for (i = 0; i < s->blocksize; i++)
383 decoded[i] = get_sbits_long(&s->gb, bps);
384 } else if ((type >= 8) && (type <= 12)) {
385 if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
387 } else if (type >= 32) {
388 if (decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps) < 0)
391 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
397 for (i = 0; i < s->blocksize; i++)
398 decoded[i] <<= wasted;
404 static int decode_frame(FLACContext *s)
407 GetBitContext *gb = &s->gb;
410 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
411 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
415 if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
416 s->channels = s->avctx->channels = fi.channels;
417 ff_flac_set_channel_layout(s->avctx);
418 ret = allocate_buffers(s);
422 s->channels = s->avctx->channels = fi.channels;
423 if (!s->avctx->channel_layout)
424 ff_flac_set_channel_layout(s->avctx);
425 s->ch_mode = fi.ch_mode;
427 if (!s->bps && !fi.bps) {
428 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
433 } else if (s->bps && fi.bps != s->bps) {
434 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
440 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
444 if (!s->max_blocksize)
445 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
446 if (fi.blocksize > s->max_blocksize) {
447 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
451 s->blocksize = fi.blocksize;
453 if (!s->samplerate && !fi.samplerate) {
454 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
455 " or frame header\n");
458 if (fi.samplerate == 0)
459 fi.samplerate = s->samplerate;
460 s->samplerate = s->avctx->sample_rate = fi.samplerate;
462 if (!s->got_streaminfo) {
463 ret = allocate_buffers(s);
466 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
467 s->got_streaminfo = 1;
468 dump_headers(s->avctx, (FLACStreaminfo *)s);
471 // dump_headers(s->avctx, (FLACStreaminfo *)s);
474 for (i = 0; i < s->channels; i++) {
475 if (decode_subframe(s, i) < 0)
482 skip_bits(gb, 16); /* data crc */
487 static int flac_decode_frame(AVCodecContext *avctx, void *data,
488 int *got_frame_ptr, AVPacket *avpkt)
490 AVFrame *frame = data;
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 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
506 av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
510 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
511 av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
515 /* check that there is at least the smallest decodable amount of data.
516 this amount corresponds to the smallest valid FLAC frame possible.
517 FF F8 69 02 00 00 9A 00 00 34 46 */
518 if (buf_size < FLAC_MIN_FRAME_SIZE)
521 /* check for inline header */
522 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
523 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
524 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
527 return get_metadata_size(buf, buf_size);
531 init_get_bits(&s->gb, buf, buf_size*8);
532 if (decode_frame(s) < 0) {
533 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
536 bytes_read = (get_bits_count(&s->gb)+7)/8;
538 /* get output buffer */
539 frame->nb_samples = s->blocksize;
540 if ((ret = ff_get_buffer(avctx, frame)) < 0) {
541 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
545 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
546 s->blocksize, s->sample_shift);
548 if (bytes_read > buf_size) {
549 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
552 if (bytes_read < buf_size) {
553 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
554 buf_size - bytes_read, buf_size);
562 static av_cold int flac_decode_close(AVCodecContext *avctx)
564 FLACContext *s = avctx->priv_data;
566 av_freep(&s->decoded_buffer);
571 AVCodec ff_flac_decoder = {
573 .type = AVMEDIA_TYPE_AUDIO,
574 .id = AV_CODEC_ID_FLAC,
575 .priv_data_size = sizeof(FLACContext),
576 .init = flac_decode_init,
577 .close = flac_decode_close,
578 .decode = flac_decode_frame,
579 .capabilities = CODEC_CAP_DR1,
580 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
581 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
585 AV_SAMPLE_FMT_NONE },