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
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
61 uint8_t *decoded_buffer;
62 unsigned int decoded_buffer_size;
67 static int allocate_buffers(FLACContext *s);
69 static void flac_set_bps(FLACContext *s)
71 enum AVSampleFormat req = s->avctx->request_sample_fmt;
72 int need32 = s->bps > 16;
73 int want32 = av_get_bytes_per_sample(req) > 2;
74 int planar = av_sample_fmt_is_planar(req);
76 if (need32 || want32) {
78 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
80 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
81 s->sample_shift = 32 - s->bps;
84 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
86 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
87 s->sample_shift = 16 - s->bps;
91 static av_cold int flac_decode_init(AVCodecContext *avctx)
93 enum FLACExtradataFormat format;
96 FLACContext *s = avctx->priv_data;
99 /* for now, the raw FLAC header is allowed to be passed to the decoder as
100 frame data instead of extradata. */
101 if (!avctx->extradata)
104 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
107 /* initialize based on the demuxer-supplied streamdata header */
108 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
109 ret = allocate_buffers(s);
113 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
114 s->got_streaminfo = 1;
116 avcodec_get_frame_defaults(&s->frame);
117 avctx->coded_frame = &s->frame;
122 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
124 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
125 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
126 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
127 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
128 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
131 static int allocate_buffers(FLACContext *s)
135 av_assert0(s->max_blocksize);
137 buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
138 AV_SAMPLE_FMT_S32P, 0);
142 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
143 if (!s->decoded_buffer)
144 return AVERROR(ENOMEM);
146 return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
147 s->decoded_buffer, s->channels,
148 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
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, ret;
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]);
172 ret = allocate_buffers(s);
176 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
177 s->got_streaminfo = 1;
183 * Determine the size of an inline header.
184 * @param buf input buffer, starting with the "fLaC" marker
185 * @param buf_size buffer size
186 * @return number of bytes in the header, or 0 if more data is needed
188 static int get_metadata_size(const uint8_t *buf, int buf_size)
190 int metadata_last, metadata_size;
191 const uint8_t *buf_end = buf + buf_size;
195 if (buf_end - buf < 4)
197 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
199 if (buf_end - buf < metadata_size) {
200 /* need more data in order to read the complete header */
203 buf += metadata_size;
204 } while (!metadata_last);
206 return buf_size - (buf_end - buf);
209 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
211 int i, tmp, partition, method_type, rice_order;
212 int rice_bits, rice_esc;
215 method_type = get_bits(&s->gb, 2);
216 if (method_type > 1) {
217 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
222 rice_order = get_bits(&s->gb, 4);
224 samples= s->blocksize >> rice_order;
225 if (pred_order > samples) {
226 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
227 pred_order, samples);
231 rice_bits = 4 + method_type;
232 rice_esc = (1 << rice_bits) - 1;
234 decoded += pred_order;
236 for (partition = 0; partition < (1 << rice_order); partition++) {
237 tmp = get_bits(&s->gb, rice_bits);
238 if (tmp == rice_esc) {
239 tmp = get_bits(&s->gb, 5);
240 for (; i < samples; i++)
241 *decoded++ = get_sbits_long(&s->gb, tmp);
243 for (; i < samples; i++) {
244 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
253 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
254 int pred_order, int bps)
256 const int blocksize = s->blocksize;
259 /* warm up samples */
260 for (i = 0; i < pred_order; i++) {
261 decoded[i] = get_sbits_long(&s->gb, bps);
264 if (decode_residuals(s, decoded, pred_order) < 0)
268 a = decoded[pred_order-1];
270 b = a - decoded[pred_order-2];
272 c = b - decoded[pred_order-2] + decoded[pred_order-3];
274 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
276 switch (pred_order) {
280 for (i = pred_order; i < blocksize; i++)
281 decoded[i] = a += decoded[i];
284 for (i = pred_order; i < blocksize; i++)
285 decoded[i] = a += b += decoded[i];
288 for (i = pred_order; i < blocksize; i++)
289 decoded[i] = a += b += c += decoded[i];
292 for (i = pred_order; i < blocksize; i++)
293 decoded[i] = a += b += c += d += decoded[i];
296 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
303 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
307 int coeff_prec, qlevel;
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, decoded, 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 int32_t *decoded = s->decoded[channel];
342 int type, wasted = 0;
347 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
350 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
354 if (get_bits1(&s->gb)) {
355 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
358 type = get_bits(&s->gb, 6);
360 if (get_bits1(&s->gb)) {
361 int left = get_bits_left(&s->gb);
364 (left < bps && !show_bits_long(&s->gb, left)) ||
365 !show_bits_long(&s->gb, bps)) {
366 av_log(s->avctx, AV_LOG_ERROR,
367 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
369 return AVERROR_INVALIDDATA;
371 while (!get_bits1(&s->gb))
376 av_log_missing_feature(s->avctx, "Decorrelated bit depth > 32", 0);
377 return AVERROR_PATCHWELCOME;
380 //FIXME use av_log2 for types
382 tmp = get_sbits_long(&s->gb, bps);
383 for (i = 0; i < s->blocksize; i++)
385 } else if (type == 1) {
386 for (i = 0; i < s->blocksize; i++)
387 decoded[i] = get_sbits_long(&s->gb, bps);
388 } else if ((type >= 8) && (type <= 12)) {
389 if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
391 } else if (type >= 32) {
392 if (decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps) < 0)
395 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
401 for (i = 0; i < s->blocksize; i++)
402 decoded[i] <<= wasted;
408 static int decode_frame(FLACContext *s)
411 GetBitContext *gb = &s->gb;
414 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
415 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
419 if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
420 s->channels = s->avctx->channels = fi.channels;
421 ff_flac_set_channel_layout(s->avctx);
422 ret = allocate_buffers(s);
426 s->channels = s->avctx->channels = fi.channels;
427 if (!s->avctx->channel_layout && s->channels <= 6)
428 ff_flac_set_channel_layout(s->avctx);
429 s->ch_mode = fi.ch_mode;
431 if (!s->bps && !fi.bps) {
432 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
437 } else if (s->bps && fi.bps != s->bps) {
438 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
444 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
448 if (!s->max_blocksize)
449 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
450 if (fi.blocksize > s->max_blocksize) {
451 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
455 s->blocksize = fi.blocksize;
457 if (!s->samplerate && !fi.samplerate) {
458 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
459 " or frame header\n");
462 if (fi.samplerate == 0)
463 fi.samplerate = s->samplerate;
464 s->samplerate = s->avctx->sample_rate = fi.samplerate;
466 if (!s->got_streaminfo) {
467 ret = allocate_buffers(s);
470 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
471 s->got_streaminfo = 1;
472 dump_headers(s->avctx, (FLACStreaminfo *)s);
475 // dump_headers(s->avctx, (FLACStreaminfo *)s);
478 for (i = 0; i < s->channels; i++) {
479 if (decode_subframe(s, i) < 0)
486 skip_bits(gb, 16); /* data crc */
491 static int flac_decode_frame(AVCodecContext *avctx, void *data,
492 int *got_frame_ptr, AVPacket *avpkt)
494 const uint8_t *buf = avpkt->data;
495 int buf_size = avpkt->size;
496 FLACContext *s = avctx->priv_data;
502 if (s->max_framesize == 0) {
504 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
505 FLAC_MAX_CHANNELS, 32);
508 /* check that there is at least the smallest decodable amount of data.
509 this amount corresponds to the smallest valid FLAC frame possible.
510 FF F8 69 02 00 00 9A 00 00 34 46 */
511 if (buf_size < FLAC_MIN_FRAME_SIZE)
514 /* check for inline header */
515 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
516 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
517 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
520 return get_metadata_size(buf, buf_size);
524 init_get_bits(&s->gb, buf, buf_size*8);
525 if (decode_frame(s) < 0) {
526 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
529 bytes_read = (get_bits_count(&s->gb)+7)/8;
531 /* get output buffer */
532 s->frame.nb_samples = s->blocksize;
533 if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
534 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
538 s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
539 s->blocksize, s->sample_shift);
541 if (bytes_read > buf_size) {
542 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
545 if (bytes_read < buf_size) {
546 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
547 buf_size - bytes_read, buf_size);
551 *(AVFrame *)data = s->frame;
556 static av_cold int flac_decode_close(AVCodecContext *avctx)
558 FLACContext *s = avctx->priv_data;
560 av_freep(&s->decoded_buffer);
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,
579 AV_SAMPLE_FMT_NONE },