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.
39 #include "bytestream.h"
45 typedef struct FLACContext {
48 AVCodecContext *avctx; ///< parent AVCodecContext
49 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
51 int blocksize; ///< number of samples in the current frame
52 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
53 int ch_mode; ///< channel decorrelation type in the current frame
54 int got_streaminfo; ///< indicates if the STREAMINFO has been read
56 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
57 uint8_t *decoded_buffer;
58 unsigned int decoded_buffer_size;
63 static int allocate_buffers(FLACContext *s);
65 static void flac_set_bps(FLACContext *s)
67 enum AVSampleFormat req = s->avctx->request_sample_fmt;
68 int need32 = s->bps > 16;
69 int want32 = av_get_bytes_per_sample(req) > 2;
70 int planar = av_sample_fmt_is_planar(req);
72 if (need32 || want32) {
74 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
76 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
77 s->sample_shift = 32 - s->bps;
80 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
82 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
83 s->sample_shift = 16 - s->bps;
87 static av_cold int flac_decode_init(AVCodecContext *avctx)
89 enum FLACExtradataFormat format;
92 FLACContext *s = avctx->priv_data;
95 /* for now, the raw FLAC header is allowed to be passed to the decoder as
96 frame data instead of extradata. */
97 if (!avctx->extradata)
100 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
101 return AVERROR_INVALIDDATA;
103 /* initialize based on the demuxer-supplied streamdata header */
104 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
105 ret = allocate_buffers(s);
109 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
110 s->got_streaminfo = 1;
115 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
117 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
118 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
119 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
120 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
121 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
124 static int allocate_buffers(FLACContext *s)
128 buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
129 AV_SAMPLE_FMT_S32P, 0);
133 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
134 if (!s->decoded_buffer)
135 return AVERROR(ENOMEM);
137 return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
138 s->decoded_buffer, s->channels,
139 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
143 * Parse the STREAMINFO from an inline header.
144 * @param s the flac decoding context
145 * @param buf input buffer, starting with the "fLaC" marker
146 * @param buf_size buffer size
147 * @return non-zero if metadata is invalid
149 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
151 int metadata_type, metadata_size, ret;
153 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
157 flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
158 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
159 metadata_size != FLAC_STREAMINFO_SIZE) {
160 return AVERROR_INVALIDDATA;
162 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
163 ret = allocate_buffers(s);
167 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
168 s->got_streaminfo = 1;
174 * Determine the size of an inline header.
175 * @param buf input buffer, starting with the "fLaC" marker
176 * @param buf_size buffer size
177 * @return number of bytes in the header, or 0 if more data is needed
179 static int get_metadata_size(const uint8_t *buf, int buf_size)
181 int metadata_last, metadata_size;
182 const uint8_t *buf_end = buf + buf_size;
186 if (buf_end - buf < 4)
188 flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
190 if (buf_end - buf < metadata_size) {
191 /* need more data in order to read the complete header */
194 buf += metadata_size;
195 } while (!metadata_last);
197 return buf_size - (buf_end - buf);
200 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
202 int i, tmp, partition, method_type, rice_order;
203 int rice_bits, rice_esc;
206 method_type = get_bits(&s->gb, 2);
207 if (method_type > 1) {
208 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
210 return AVERROR_INVALIDDATA;
213 rice_order = get_bits(&s->gb, 4);
215 samples= s->blocksize >> rice_order;
216 if (pred_order > samples) {
217 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
218 pred_order, samples);
219 return AVERROR_INVALIDDATA;
222 rice_bits = 4 + method_type;
223 rice_esc = (1 << rice_bits) - 1;
225 decoded += pred_order;
227 for (partition = 0; partition < (1 << rice_order); partition++) {
228 tmp = get_bits(&s->gb, rice_bits);
229 if (tmp == rice_esc) {
230 tmp = get_bits(&s->gb, 5);
231 for (; i < samples; i++)
232 *decoded++ = get_sbits_long(&s->gb, tmp);
234 for (; i < samples; i++) {
235 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
244 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
245 int pred_order, int bps)
247 const int blocksize = s->blocksize;
248 int a, b, c, d, i, ret;
250 /* warm up samples */
251 for (i = 0; i < pred_order; i++) {
252 decoded[i] = get_sbits_long(&s->gb, bps);
255 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
259 a = decoded[pred_order-1];
261 b = a - decoded[pred_order-2];
263 c = b - decoded[pred_order-2] + decoded[pred_order-3];
265 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
267 switch (pred_order) {
271 for (i = pred_order; i < blocksize; i++)
272 decoded[i] = a += decoded[i];
275 for (i = pred_order; i < blocksize; i++)
276 decoded[i] = a += b += decoded[i];
279 for (i = pred_order; i < blocksize; i++)
280 decoded[i] = a += b += c += decoded[i];
283 for (i = pred_order; i < blocksize; i++)
284 decoded[i] = a += b += c += d += decoded[i];
287 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
288 return AVERROR_INVALIDDATA;
294 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
298 int coeff_prec, qlevel;
301 /* warm up samples */
302 for (i = 0; i < pred_order; i++) {
303 decoded[i] = get_sbits_long(&s->gb, bps);
306 coeff_prec = get_bits(&s->gb, 4) + 1;
307 if (coeff_prec == 16) {
308 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
309 return AVERROR_INVALIDDATA;
311 qlevel = get_sbits(&s->gb, 5);
313 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
315 return AVERROR_INVALIDDATA;
318 for (i = 0; i < pred_order; i++) {
319 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
322 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
325 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
330 static inline int decode_subframe(FLACContext *s, int channel)
332 int32_t *decoded = s->decoded[channel];
333 int type, wasted = 0;
338 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
341 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
345 if (get_bits1(&s->gb)) {
346 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
347 return AVERROR_INVALIDDATA;
349 type = get_bits(&s->gb, 6);
351 if (get_bits1(&s->gb)) {
352 int left = get_bits_left(&s->gb);
355 (left < bps && !show_bits_long(&s->gb, left)) ||
356 !show_bits_long(&s->gb, bps)) {
357 av_log(s->avctx, AV_LOG_ERROR,
358 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
360 return AVERROR_INVALIDDATA;
362 while (!get_bits1(&s->gb))
367 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
368 return AVERROR_PATCHWELCOME;
371 //FIXME use av_log2 for types
373 tmp = get_sbits_long(&s->gb, bps);
374 for (i = 0; i < s->blocksize; i++)
376 } else if (type == 1) {
377 for (i = 0; i < s->blocksize; i++)
378 decoded[i] = get_sbits_long(&s->gb, bps);
379 } else if ((type >= 8) && (type <= 12)) {
380 if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
382 } else if (type >= 32) {
383 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
386 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
387 return AVERROR_INVALIDDATA;
392 for (i = 0; i < s->blocksize; i++)
393 decoded[i] <<= wasted;
399 static int decode_frame(FLACContext *s)
402 GetBitContext *gb = &s->gb;
405 if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
406 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
410 if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
411 s->channels = s->avctx->channels = fi.channels;
412 ff_flac_set_channel_layout(s->avctx);
413 ret = allocate_buffers(s);
417 s->channels = s->avctx->channels = fi.channels;
418 if (!s->avctx->channel_layout)
419 ff_flac_set_channel_layout(s->avctx);
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");
424 return AVERROR_INVALIDDATA;
428 } else if (s->bps && fi.bps != s->bps) {
429 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
431 return AVERROR_INVALIDDATA;
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,
444 return AVERROR_INVALIDDATA;
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");
451 return AVERROR_INVALIDDATA;
453 if (fi.samplerate == 0)
454 fi.samplerate = s->samplerate;
455 s->samplerate = s->avctx->sample_rate = fi.samplerate;
457 if (!s->got_streaminfo) {
458 ret = allocate_buffers(s);
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 ((ret = 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 AVFrame *frame = data;
486 const uint8_t *buf = avpkt->data;
487 int buf_size = avpkt->size;
488 FLACContext *s = avctx->priv_data;
494 if (s->max_framesize == 0) {
496 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
497 FLAC_MAX_CHANNELS, 32);
500 /* check that there is at least the smallest decodable amount of data.
501 this amount corresponds to the smallest valid FLAC frame possible.
502 FF F8 69 02 00 00 9A 00 00 34 46 */
503 if (buf_size < FLAC_MIN_FRAME_SIZE)
506 /* check for inline header */
507 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
508 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
509 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
512 return get_metadata_size(buf, buf_size);
516 init_get_bits(&s->gb, buf, buf_size*8);
517 if ((ret = decode_frame(s)) < 0) {
518 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
521 bytes_read = (get_bits_count(&s->gb)+7)/8;
523 /* get output buffer */
524 frame->nb_samples = s->blocksize;
525 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
526 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
530 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
531 s->blocksize, s->sample_shift);
533 if (bytes_read > buf_size) {
534 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
535 return AVERROR_INVALIDDATA;
537 if (bytes_read < buf_size) {
538 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
539 buf_size - bytes_read, buf_size);
547 static av_cold int flac_decode_close(AVCodecContext *avctx)
549 FLACContext *s = avctx->priv_data;
551 av_freep(&s->decoded_buffer);
556 AVCodec ff_flac_decoder = {
558 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
559 .type = AVMEDIA_TYPE_AUDIO,
560 .id = AV_CODEC_ID_FLAC,
561 .priv_data_size = sizeof(FLACContext),
562 .init = flac_decode_init,
563 .close = flac_decode_close,
564 .decode = flac_decode_frame,
565 .capabilities = CODEC_CAP_DR1,
566 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,