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"
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 sample = 0, samples;
212 method_type = get_bits(&s->gb, 2);
213 if (method_type > 1) {
214 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
219 rice_order = get_bits(&s->gb, 4);
221 samples= s->blocksize >> rice_order;
222 if (pred_order > samples) {
223 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
224 pred_order, samples);
230 for (partition = 0; partition < (1 << rice_order); partition++) {
231 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
232 if (tmp == (method_type == 0 ? 15 : 31)) {
233 tmp = get_bits(&s->gb, 5);
234 for (; i < samples; i++, sample++)
235 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
237 for (; i < samples; i++, sample++) {
238 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
247 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order,
250 const int blocksize = s->blocksize;
251 int32_t *decoded = s->decoded[channel];
254 /* warm up samples */
255 for (i = 0; i < pred_order; i++) {
256 decoded[i] = get_sbits_long(&s->gb, bps);
259 if (decode_residuals(s, channel, pred_order) < 0)
263 a = decoded[pred_order-1];
265 b = a - decoded[pred_order-2];
267 c = b - decoded[pred_order-2] + decoded[pred_order-3];
269 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
271 switch (pred_order) {
275 for (i = pred_order; i < blocksize; i++)
276 decoded[i] = a += decoded[i];
279 for (i = pred_order; i < blocksize; i++)
280 decoded[i] = a += b += decoded[i];
283 for (i = pred_order; i < blocksize; i++)
284 decoded[i] = a += b += c += decoded[i];
287 for (i = pred_order; i < blocksize; i++)
288 decoded[i] = a += b += c += d += decoded[i];
291 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
298 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order,
302 int coeff_prec, qlevel;
304 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, 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[i] = get_sbits(&s->gb, coeff_prec);
327 if (decode_residuals(s, channel, 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 int type, wasted = 0;
342 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
345 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
349 if (get_bits1(&s->gb)) {
350 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
353 type = get_bits(&s->gb, 6);
355 if (get_bits1(&s->gb)) {
356 int left = get_bits_left(&s->gb);
359 (left < bps && !show_bits_long(&s->gb, left)) ||
360 !show_bits_long(&s->gb, bps)) {
361 av_log(s->avctx, AV_LOG_ERROR,
362 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
364 return AVERROR_INVALIDDATA;
366 while (!get_bits1(&s->gb))
371 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
375 //FIXME use av_log2 for types
377 tmp = get_sbits_long(&s->gb, bps);
378 for (i = 0; i < s->blocksize; i++)
379 s->decoded[channel][i] = tmp;
380 } else if (type == 1) {
381 for (i = 0; i < s->blocksize; i++)
382 s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
383 } else if ((type >= 8) && (type <= 12)) {
384 if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
386 } else if (type >= 32) {
387 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
390 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
396 for (i = 0; i < s->blocksize; i++)
397 s->decoded[channel][i] <<= wasted;
403 static int decode_frame(FLACContext *s)
406 GetBitContext *gb = &s->gb;
409 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
410 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
414 if (s->channels && fi.channels != s->channels) {
415 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
416 "is not supported\n");
419 s->channels = s->avctx->channels = fi.channels;
420 s->ch_mode = fi.ch_mode;
422 if (!s->bps && !fi.bps) {
423 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
428 } else if (s->bps && fi.bps != s->bps) {
429 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
435 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
439 if (!s->max_blocksize)
440 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
441 if (fi.blocksize > s->max_blocksize) {
442 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
446 s->blocksize = fi.blocksize;
448 if (!s->samplerate && !fi.samplerate) {
449 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
450 " or frame header\n");
453 if (fi.samplerate == 0) {
454 fi.samplerate = s->samplerate;
455 } else if (s->samplerate && fi.samplerate != s->samplerate) {
456 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
457 s->samplerate, fi.samplerate);
459 s->samplerate = s->avctx->sample_rate = fi.samplerate;
461 if (!s->got_streaminfo) {
463 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
464 s->got_streaminfo = 1;
465 dump_headers(s->avctx, (FLACStreaminfo *)s);
468 // dump_headers(s->avctx, (FLACStreaminfo *)s);
471 for (i = 0; i < s->channels; i++) {
472 if (decode_subframe(s, i) < 0)
479 skip_bits(gb, 16); /* data crc */
484 static int flac_decode_frame(AVCodecContext *avctx, void *data,
485 int *got_frame_ptr, AVPacket *avpkt)
487 const uint8_t *buf = avpkt->data;
488 int buf_size = avpkt->size;
489 FLACContext *s = avctx->priv_data;
495 if (s->max_framesize == 0) {
497 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
498 FLAC_MAX_CHANNELS, 32);
501 /* check that there is at least the smallest decodable amount of data.
502 this amount corresponds to the smallest valid FLAC frame possible.
503 FF F8 69 02 00 00 9A 00 00 34 46 */
504 if (buf_size < FLAC_MIN_FRAME_SIZE)
507 /* check for inline header */
508 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
509 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
510 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
513 return get_metadata_size(buf, buf_size);
517 init_get_bits(&s->gb, buf, buf_size*8);
518 if (decode_frame(s) < 0) {
519 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
522 bytes_read = (get_bits_count(&s->gb)+7)/8;
524 /* get output buffer */
525 s->frame.nb_samples = s->blocksize;
526 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
527 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
531 s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
532 s->blocksize, s->sample_shift);
534 if (bytes_read > buf_size) {
535 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
538 if (bytes_read < buf_size) {
539 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
540 buf_size - bytes_read, buf_size);
544 *(AVFrame *)data = s->frame;
549 static av_cold int flac_decode_close(AVCodecContext *avctx)
551 FLACContext *s = avctx->priv_data;
554 for (i = 0; i < s->channels; i++) {
555 av_freep(&s->decoded[i]);
561 AVCodec ff_flac_decoder = {
563 .type = AVMEDIA_TYPE_AUDIO,
565 .priv_data_size = sizeof(FLACContext),
566 .init = flac_decode_init,
567 .close = flac_decode_close,
568 .decode = flac_decode_frame,
569 .capabilities = CODEC_CAP_DR1,
570 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
571 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,