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/channel_layout.h"
37 #include "libavutil/crc.h"
41 #include "bytestream.h"
47 typedef struct FLACContext {
50 AVCodecContext *avctx; ///< parent AVCodecContext
51 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
53 int blocksize; ///< number of samples in the current frame
54 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
55 int ch_mode; ///< channel decorrelation type in the current frame
56 int got_streaminfo; ///< indicates if the STREAMINFO has been read
58 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
59 uint8_t *decoded_buffer;
60 unsigned int decoded_buffer_size;
65 static int allocate_buffers(FLACContext *s);
67 static void flac_set_bps(FLACContext *s)
69 enum AVSampleFormat req = s->avctx->request_sample_fmt;
70 int need32 = s->bps > 16;
71 int want32 = av_get_bytes_per_sample(req) > 2;
72 int planar = av_sample_fmt_is_planar(req);
74 if (need32 || want32) {
76 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
78 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
79 s->sample_shift = 32 - s->bps;
82 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
84 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
85 s->sample_shift = 16 - s->bps;
89 static av_cold int flac_decode_init(AVCodecContext *avctx)
91 enum FLACExtradataFormat format;
94 FLACContext *s = avctx->priv_data;
97 /* for now, the raw FLAC header is allowed to be passed to the decoder as
98 frame data instead of extradata. */
99 if (!avctx->extradata)
102 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
103 return AVERROR_INVALIDDATA;
105 /* initialize based on the demuxer-supplied streamdata header */
106 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
107 ret = allocate_buffers(s);
111 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
112 s->got_streaminfo = 1;
117 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
119 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
120 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
121 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
122 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
123 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
126 static int allocate_buffers(FLACContext *s)
130 buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
131 AV_SAMPLE_FMT_S32P, 0);
135 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
136 if (!s->decoded_buffer)
137 return AVERROR(ENOMEM);
139 return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
140 s->decoded_buffer, s->channels,
141 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
145 * Parse the STREAMINFO from an inline header.
146 * @param s the flac decoding context
147 * @param buf input buffer, starting with the "fLaC" marker
148 * @param buf_size buffer size
149 * @return non-zero if metadata is invalid
151 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
153 int metadata_type, metadata_size, ret;
155 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
159 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
160 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
161 metadata_size != FLAC_STREAMINFO_SIZE) {
162 return AVERROR_INVALIDDATA;
164 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
165 ret = allocate_buffers(s);
169 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
170 s->got_streaminfo = 1;
176 * Determine the size of an inline header.
177 * @param buf input buffer, starting with the "fLaC" marker
178 * @param buf_size buffer size
179 * @return number of bytes in the header, or 0 if more data is needed
181 static int get_metadata_size(const uint8_t *buf, int buf_size)
183 int metadata_last, metadata_size;
184 const uint8_t *buf_end = buf + buf_size;
188 if (buf_end - buf < 4)
190 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
192 if (buf_end - buf < metadata_size) {
193 /* need more data in order to read the complete header */
196 buf += metadata_size;
197 } while (!metadata_last);
199 return buf_size - (buf_end - buf);
202 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
204 int i, tmp, partition, method_type, rice_order;
205 int rice_bits, rice_esc;
208 method_type = get_bits(&s->gb, 2);
209 if (method_type > 1) {
210 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
212 return AVERROR_INVALIDDATA;
215 rice_order = get_bits(&s->gb, 4);
217 samples= s->blocksize >> rice_order;
218 if (pred_order > samples) {
219 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
220 pred_order, samples);
221 return AVERROR_INVALIDDATA;
224 rice_bits = 4 + method_type;
225 rice_esc = (1 << rice_bits) - 1;
227 decoded += pred_order;
229 for (partition = 0; partition < (1 << rice_order); partition++) {
230 tmp = get_bits(&s->gb, rice_bits);
231 if (tmp == rice_esc) {
232 tmp = get_bits(&s->gb, 5);
233 for (; i < samples; i++)
234 *decoded++ = get_sbits_long(&s->gb, tmp);
236 for (; i < samples; i++) {
237 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
246 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
247 int pred_order, int bps)
249 const int blocksize = s->blocksize;
250 int a, b, c, d, i, ret;
252 /* warm up samples */
253 for (i = 0; i < pred_order; i++) {
254 decoded[i] = get_sbits_long(&s->gb, bps);
257 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
261 a = decoded[pred_order-1];
263 b = a - decoded[pred_order-2];
265 c = b - decoded[pred_order-2] + decoded[pred_order-3];
267 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
269 switch (pred_order) {
273 for (i = pred_order; i < blocksize; i++)
274 decoded[i] = a += decoded[i];
277 for (i = pred_order; i < blocksize; i++)
278 decoded[i] = a += b += decoded[i];
281 for (i = pred_order; i < blocksize; i++)
282 decoded[i] = a += b += c += decoded[i];
285 for (i = pred_order; i < blocksize; i++)
286 decoded[i] = a += b += c += d += decoded[i];
289 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
290 return AVERROR_INVALIDDATA;
296 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
300 int coeff_prec, qlevel;
303 /* warm up samples */
304 for (i = 0; i < pred_order; i++) {
305 decoded[i] = get_sbits_long(&s->gb, bps);
308 coeff_prec = get_bits(&s->gb, 4) + 1;
309 if (coeff_prec == 16) {
310 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
311 return AVERROR_INVALIDDATA;
313 qlevel = get_sbits(&s->gb, 5);
315 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
317 return AVERROR_INVALIDDATA;
320 for (i = 0; i < pred_order; i++) {
321 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
324 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
327 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
332 static inline int decode_subframe(FLACContext *s, int channel)
334 int32_t *decoded = s->decoded[channel];
335 int type, wasted = 0;
340 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
343 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
347 if (get_bits1(&s->gb)) {
348 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
349 return AVERROR_INVALIDDATA;
351 type = get_bits(&s->gb, 6);
353 if (get_bits1(&s->gb)) {
354 int left = get_bits_left(&s->gb);
357 (left < bps && !show_bits_long(&s->gb, left)) ||
358 !show_bits_long(&s->gb, bps)) {
359 av_log(s->avctx, AV_LOG_ERROR,
360 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
362 return AVERROR_INVALIDDATA;
364 while (!get_bits1(&s->gb))
369 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
370 return AVERROR_PATCHWELCOME;
373 //FIXME use av_log2 for types
375 tmp = get_sbits_long(&s->gb, bps);
376 for (i = 0; i < s->blocksize; i++)
378 } else if (type == 1) {
379 for (i = 0; i < s->blocksize; i++)
380 decoded[i] = get_sbits_long(&s->gb, bps);
381 } else if ((type >= 8) && (type <= 12)) {
382 if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
384 } else if (type >= 32) {
385 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
388 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
389 return AVERROR_INVALIDDATA;
394 for (i = 0; i < s->blocksize; i++)
395 decoded[i] <<= wasted;
401 static int decode_frame(FLACContext *s)
404 GetBitContext *gb = &s->gb;
407 if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
408 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
412 if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
413 s->channels = s->avctx->channels = fi.channels;
414 ff_flac_set_channel_layout(s->avctx);
415 ret = allocate_buffers(s);
419 s->channels = s->avctx->channels = fi.channels;
420 if (!s->avctx->channel_layout)
421 ff_flac_set_channel_layout(s->avctx);
422 s->ch_mode = fi.ch_mode;
424 if (!s->bps && !fi.bps) {
425 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
426 return AVERROR_INVALIDDATA;
430 } else if (s->bps && fi.bps != s->bps) {
431 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
433 return AVERROR_INVALIDDATA;
437 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
441 if (!s->max_blocksize)
442 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
443 if (fi.blocksize > s->max_blocksize) {
444 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
446 return AVERROR_INVALIDDATA;
448 s->blocksize = fi.blocksize;
450 if (!s->samplerate && !fi.samplerate) {
451 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
452 " or frame header\n");
453 return AVERROR_INVALIDDATA;
455 if (fi.samplerate == 0)
456 fi.samplerate = s->samplerate;
457 s->samplerate = s->avctx->sample_rate = fi.samplerate;
459 if (!s->got_streaminfo) {
460 ret = allocate_buffers(s);
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 ((ret = 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 AVFrame *frame = data;
488 const uint8_t *buf = avpkt->data;
489 int buf_size = avpkt->size;
490 FLACContext *s = avctx->priv_data;
496 if (s->max_framesize == 0) {
498 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
499 FLAC_MAX_CHANNELS, 32);
502 /* check that there is at least the smallest decodable amount of data.
503 this amount corresponds to the smallest valid FLAC frame possible.
504 FF F8 69 02 00 00 9A 00 00 34 46 */
505 if (buf_size < FLAC_MIN_FRAME_SIZE)
508 /* check for inline header */
509 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
510 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
511 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
514 return get_metadata_size(buf, buf_size);
518 init_get_bits(&s->gb, buf, buf_size*8);
519 if ((ret = decode_frame(s)) < 0) {
520 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
523 bytes_read = (get_bits_count(&s->gb)+7)/8;
525 /* get output buffer */
526 frame->nb_samples = s->blocksize;
527 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
528 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
532 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
533 s->blocksize, s->sample_shift);
535 if (bytes_read > buf_size) {
536 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
537 return AVERROR_INVALIDDATA;
539 if (bytes_read < buf_size) {
540 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
541 buf_size - bytes_read, buf_size);
549 static av_cold int flac_decode_close(AVCodecContext *avctx)
551 FLACContext *s = avctx->priv_data;
553 av_freep(&s->decoded_buffer);
558 AVCodec ff_flac_decoder = {
560 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
561 .type = AVMEDIA_TYPE_AUDIO,
562 .id = AV_CODEC_ID_FLAC,
563 .priv_data_size = sizeof(FLACContext),
564 .init = flac_decode_init,
565 .close = flac_decode_close,
566 .decode = flac_decode_frame,
567 .capabilities = CODEC_CAP_DR1,
568 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,