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, int32_t *decoded, int pred_order)
209 int i, tmp, partition, method_type, rice_order;
210 int rice_bits, rice_esc;
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;
232 decoded += pred_order;
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++)
239 *decoded++ = get_sbits_long(&s->gb, tmp);
241 for (; i < samples; i++) {
242 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
251 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
252 int pred_order, int bps)
254 const int blocksize = s->blocksize;
257 /* warm up samples */
258 for (i = 0; i < pred_order; i++) {
259 decoded[i] = get_sbits_long(&s->gb, bps);
262 if (decode_residuals(s, decoded, pred_order) < 0)
266 a = decoded[pred_order-1];
268 b = a - decoded[pred_order-2];
270 c = b - decoded[pred_order-2] + decoded[pred_order-3];
272 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
274 switch (pred_order) {
278 for (i = pred_order; i < blocksize; i++)
279 decoded[i] = a += decoded[i];
282 for (i = pred_order; i < blocksize; i++)
283 decoded[i] = a += b += decoded[i];
286 for (i = pred_order; i < blocksize; i++)
287 decoded[i] = a += b += c += decoded[i];
290 for (i = pred_order; i < blocksize; i++)
291 decoded[i] = a += b += c += d += decoded[i];
294 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
301 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
305 int coeff_prec, qlevel;
308 /* warm up samples */
309 for (i = 0; i < pred_order; i++) {
310 decoded[i] = get_sbits_long(&s->gb, bps);
313 coeff_prec = get_bits(&s->gb, 4) + 1;
314 if (coeff_prec == 16) {
315 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
318 qlevel = get_sbits(&s->gb, 5);
320 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
325 for (i = 0; i < pred_order; i++) {
326 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
329 if (decode_residuals(s, decoded, pred_order) < 0)
332 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
337 static inline int decode_subframe(FLACContext *s, int channel)
339 int32_t *decoded = s->decoded[channel];
340 int type, wasted = 0;
345 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
348 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
352 if (get_bits1(&s->gb)) {
353 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
356 type = get_bits(&s->gb, 6);
358 if (get_bits1(&s->gb)) {
359 int left = get_bits_left(&s->gb);
362 (left < bps && !show_bits_long(&s->gb, left)) ||
363 !show_bits_long(&s->gb, bps)) {
364 av_log(s->avctx, AV_LOG_ERROR,
365 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
367 return AVERROR_INVALIDDATA;
369 while (!get_bits1(&s->gb))
374 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
378 //FIXME use av_log2 for types
380 tmp = get_sbits_long(&s->gb, bps);
381 for (i = 0; i < s->blocksize; i++)
383 } else if (type == 1) {
384 for (i = 0; i < s->blocksize; i++)
385 decoded[i] = get_sbits_long(&s->gb, bps);
386 } else if ((type >= 8) && (type <= 12)) {
387 if (decode_subframe_fixed(s, decoded, type & ~0x8, bps) < 0)
389 } else if (type >= 32) {
390 if (decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps) < 0)
393 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
399 for (i = 0; i < s->blocksize; i++)
400 decoded[i] <<= wasted;
406 static int decode_frame(FLACContext *s)
409 GetBitContext *gb = &s->gb;
412 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
413 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
417 if (s->channels && fi.channels != s->channels) {
418 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
419 "is not supported\n");
422 s->channels = s->avctx->channels = fi.channels;
423 s->ch_mode = fi.ch_mode;
425 if (!s->bps && !fi.bps) {
426 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
431 } else if (s->bps && fi.bps != s->bps) {
432 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
438 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
442 if (!s->max_blocksize)
443 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
444 if (fi.blocksize > s->max_blocksize) {
445 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
449 s->blocksize = fi.blocksize;
451 if (!s->samplerate && !fi.samplerate) {
452 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
453 " or frame header\n");
456 if (fi.samplerate == 0) {
457 fi.samplerate = s->samplerate;
458 } else if (s->samplerate && fi.samplerate != s->samplerate) {
459 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
460 s->samplerate, fi.samplerate);
462 s->samplerate = s->avctx->sample_rate = fi.samplerate;
464 if (!s->got_streaminfo) {
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 const uint8_t *buf = avpkt->data;
491 int buf_size = avpkt->size;
492 FLACContext *s = avctx->priv_data;
498 if (s->max_framesize == 0) {
500 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
501 FLAC_MAX_CHANNELS, 32);
504 /* check that there is at least the smallest decodable amount of data.
505 this amount corresponds to the smallest valid FLAC frame possible.
506 FF F8 69 02 00 00 9A 00 00 34 46 */
507 if (buf_size < FLAC_MIN_FRAME_SIZE)
510 /* check for inline header */
511 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
512 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
513 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
516 return get_metadata_size(buf, buf_size);
520 init_get_bits(&s->gb, buf, buf_size*8);
521 if (decode_frame(s) < 0) {
522 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
525 bytes_read = (get_bits_count(&s->gb)+7)/8;
527 /* get output buffer */
528 s->frame.nb_samples = s->blocksize;
529 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
530 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
534 s->dsp.decorrelate[s->ch_mode](s->frame.data, s->decoded, s->channels,
535 s->blocksize, s->sample_shift);
537 if (bytes_read > buf_size) {
538 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
541 if (bytes_read < buf_size) {
542 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
543 buf_size - bytes_read, buf_size);
547 *(AVFrame *)data = s->frame;
552 static av_cold int flac_decode_close(AVCodecContext *avctx)
554 FLACContext *s = avctx->priv_data;
557 for (i = 0; i < s->channels; i++) {
558 av_freep(&s->decoded[i]);
564 AVCodec ff_flac_decoder = {
566 .type = AVMEDIA_TYPE_AUDIO,
567 .id = AV_CODEC_ID_FLAC,
568 .priv_data_size = sizeof(FLACContext),
569 .init = flac_decode_init,
570 .close = flac_decode_close,
571 .decode = flac_decode_frame,
572 .capabilities = CODEC_CAP_DR1,
573 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
574 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,