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
52 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
54 int blocksize; ///< number of samples in the current frame
55 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
56 int ch_mode; ///< channel decorrelation type in the current frame
57 int got_streaminfo; ///< indicates if the STREAMINFO has been read
59 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
60 uint8_t *decoded_buffer;
61 unsigned int decoded_buffer_size;
66 static int allocate_buffers(FLACContext *s);
68 static void flac_set_bps(FLACContext *s)
70 enum AVSampleFormat req = s->avctx->request_sample_fmt;
71 int need32 = s->bps > 16;
72 int want32 = av_get_bytes_per_sample(req) > 2;
73 int planar = av_sample_fmt_is_planar(req);
75 if (need32 || want32) {
77 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
79 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
80 s->sample_shift = 32 - s->bps;
83 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
85 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
86 s->sample_shift = 16 - s->bps;
90 static av_cold int flac_decode_init(AVCodecContext *avctx)
92 enum FLACExtradataFormat format;
95 FLACContext *s = avctx->priv_data;
98 /* for now, the raw FLAC header is allowed to be passed to the decoder as
99 frame data instead of extradata. */
100 if (!avctx->extradata)
103 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
104 return AVERROR_INVALIDDATA;
106 /* initialize based on the demuxer-supplied streamdata header */
107 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
108 ret = allocate_buffers(s);
112 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
113 s->got_streaminfo = 1;
118 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
120 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
121 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
122 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
123 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
124 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
127 static int allocate_buffers(FLACContext *s)
131 av_assert0(s->max_blocksize);
133 buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
134 AV_SAMPLE_FMT_S32P, 0);
138 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
139 if (!s->decoded_buffer)
140 return AVERROR(ENOMEM);
142 return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
143 s->decoded_buffer, s->channels,
144 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
148 * Parse the STREAMINFO from an inline header.
149 * @param s the flac decoding context
150 * @param buf input buffer, starting with the "fLaC" marker
151 * @param buf_size buffer size
152 * @return non-zero if metadata is invalid
154 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
156 int metadata_type, metadata_size, ret;
158 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
162 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
163 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
164 metadata_size != FLAC_STREAMINFO_SIZE) {
165 return AVERROR_INVALIDDATA;
167 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
168 ret = allocate_buffers(s);
172 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
173 s->got_streaminfo = 1;
179 * Determine the size of an inline header.
180 * @param buf input buffer, starting with the "fLaC" marker
181 * @param buf_size buffer size
182 * @return number of bytes in the header, or 0 if more data is needed
184 static int get_metadata_size(const uint8_t *buf, int buf_size)
186 int metadata_last, metadata_size;
187 const uint8_t *buf_end = buf + buf_size;
191 if (buf_end - buf < 4)
193 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
195 if (buf_end - buf < metadata_size) {
196 /* need more data in order to read the complete header */
199 buf += metadata_size;
200 } while (!metadata_last);
202 return buf_size - (buf_end - buf);
205 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
207 int i, tmp, partition, method_type, rice_order;
208 int rice_bits, rice_esc;
211 method_type = get_bits(&s->gb, 2);
212 if (method_type > 1) {
213 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
215 return AVERROR_INVALIDDATA;
218 rice_order = get_bits(&s->gb, 4);
220 samples= s->blocksize >> rice_order;
221 if (pred_order > samples) {
222 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
223 pred_order, samples);
224 return AVERROR_INVALIDDATA;
227 rice_bits = 4 + method_type;
228 rice_esc = (1 << rice_bits) - 1;
230 decoded += pred_order;
232 for (partition = 0; partition < (1 << rice_order); partition++) {
233 tmp = get_bits(&s->gb, rice_bits);
234 if (tmp == rice_esc) {
235 tmp = get_bits(&s->gb, 5);
236 for (; i < samples; i++)
237 *decoded++ = get_sbits_long(&s->gb, tmp);
239 for (; i < samples; i++) {
240 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
249 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
250 int pred_order, int bps)
252 const int blocksize = s->blocksize;
253 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
256 /* warm up samples */
257 for (i = 0; i < pred_order; i++) {
258 decoded[i] = get_sbits_long(&s->gb, bps);
261 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
265 a = decoded[pred_order-1];
267 b = a - decoded[pred_order-2];
269 c = b - decoded[pred_order-2] + decoded[pred_order-3];
271 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
273 switch (pred_order) {
277 for (i = pred_order; i < blocksize; i++)
278 decoded[i] = a += decoded[i];
281 for (i = pred_order; i < blocksize; i++)
282 decoded[i] = a += b += decoded[i];
285 for (i = pred_order; i < blocksize; i++)
286 decoded[i] = a += b += c += decoded[i];
289 for (i = pred_order; i < blocksize; i++)
290 decoded[i] = a += b += c += d += decoded[i];
293 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
294 return AVERROR_INVALIDDATA;
300 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
304 int coeff_prec, qlevel;
307 /* warm up samples */
308 for (i = 0; i < pred_order; i++) {
309 decoded[i] = get_sbits_long(&s->gb, bps);
312 coeff_prec = get_bits(&s->gb, 4) + 1;
313 if (coeff_prec == 16) {
314 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
315 return AVERROR_INVALIDDATA;
317 qlevel = get_sbits(&s->gb, 5);
319 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
321 return AVERROR_INVALIDDATA;
324 for (i = 0; i < pred_order; i++) {
325 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
328 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
331 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
336 static inline int decode_subframe(FLACContext *s, int channel)
338 int32_t *decoded = s->decoded[channel];
339 int type, wasted = 0;
344 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
347 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
351 if (get_bits1(&s->gb)) {
352 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
353 return AVERROR_INVALIDDATA;
355 type = get_bits(&s->gb, 6);
357 if (get_bits1(&s->gb)) {
358 int left = get_bits_left(&s->gb);
361 (left < bps && !show_bits_long(&s->gb, left)) ||
362 !show_bits_long(&s->gb, bps)) {
363 av_log(s->avctx, AV_LOG_ERROR,
364 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
366 return AVERROR_INVALIDDATA;
368 while (!get_bits1(&s->gb))
373 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
374 return AVERROR_PATCHWELCOME;
377 //FIXME use av_log2 for types
379 tmp = get_sbits_long(&s->gb, bps);
380 for (i = 0; i < s->blocksize; i++)
382 } else if (type == 1) {
383 for (i = 0; i < s->blocksize; i++)
384 decoded[i] = get_sbits_long(&s->gb, bps);
385 } else if ((type >= 8) && (type <= 12)) {
386 if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
388 } else if (type >= 32) {
389 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
392 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
393 return AVERROR_INVALIDDATA;
398 for (i = 0; i < s->blocksize; i++)
399 decoded[i] <<= wasted;
405 static int decode_frame(FLACContext *s)
408 GetBitContext *gb = &s->gb;
411 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
412 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
413 return AVERROR_INVALIDDATA;
416 if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
417 s->channels = s->avctx->channels = fi.channels;
418 ff_flac_set_channel_layout(s->avctx);
419 ret = allocate_buffers(s);
423 s->channels = s->avctx->channels = fi.channels;
424 if (!s->avctx->channel_layout)
425 ff_flac_set_channel_layout(s->avctx);
426 s->ch_mode = fi.ch_mode;
428 if (!s->bps && !fi.bps) {
429 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
430 return AVERROR_INVALIDDATA;
434 } else if (s->bps && fi.bps != s->bps) {
435 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
441 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
445 if (!s->max_blocksize)
446 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
447 if (fi.blocksize > s->max_blocksize) {
448 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
450 return AVERROR_INVALIDDATA;
452 s->blocksize = fi.blocksize;
454 if (!s->samplerate && !fi.samplerate) {
455 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
456 " or frame header\n");
457 return AVERROR_INVALIDDATA;
459 if (fi.samplerate == 0)
460 fi.samplerate = s->samplerate;
461 s->samplerate = s->avctx->sample_rate = fi.samplerate;
463 if (!s->got_streaminfo) {
464 ret = allocate_buffers(s);
467 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
468 s->got_streaminfo = 1;
469 dump_headers(s->avctx, (FLACStreaminfo *)s);
472 // dump_headers(s->avctx, (FLACStreaminfo *)s);
475 for (i = 0; i < s->channels; i++) {
476 if ((ret = decode_subframe(s, i)) < 0)
483 skip_bits(gb, 16); /* data crc */
488 static int flac_decode_frame(AVCodecContext *avctx, void *data,
489 int *got_frame_ptr, AVPacket *avpkt)
491 AVFrame *frame = data;
492 const uint8_t *buf = avpkt->data;
493 int buf_size = avpkt->size;
494 FLACContext *s = avctx->priv_data;
500 if (s->max_framesize == 0) {
502 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
503 FLAC_MAX_CHANNELS, 32);
506 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
507 av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
511 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
512 av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
516 /* check that there is at least the smallest decodable amount of data.
517 this amount corresponds to the smallest valid FLAC frame possible.
518 FF F8 69 02 00 00 9A 00 00 34 46 */
519 if (buf_size < FLAC_MIN_FRAME_SIZE)
522 /* check for inline header */
523 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
524 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
525 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
526 return AVERROR_INVALIDDATA;
528 return get_metadata_size(buf, buf_size);
532 init_get_bits(&s->gb, buf, buf_size*8);
533 if ((ret = decode_frame(s)) < 0) {
534 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
537 bytes_read = get_bits_count(&s->gb)/8;
539 if ((s->avctx->err_recognition & AV_EF_CRCCHECK) &&
540 av_crc(av_crc_get_table(AV_CRC_16_ANSI),
541 0, buf, bytes_read)) {
542 av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
543 if (s->avctx->err_recognition & AV_EF_EXPLODE)
544 return AVERROR_INVALIDDATA;
547 /* get output buffer */
548 frame->nb_samples = s->blocksize;
549 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
552 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
553 s->blocksize, s->sample_shift);
555 if (bytes_read > buf_size) {
556 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
557 return AVERROR_INVALIDDATA;
559 if (bytes_read < buf_size) {
560 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
561 buf_size - bytes_read, buf_size);
569 static av_cold int flac_decode_close(AVCodecContext *avctx)
571 FLACContext *s = avctx->priv_data;
573 av_freep(&s->decoded_buffer);
578 AVCodec ff_flac_decoder = {
580 .type = AVMEDIA_TYPE_AUDIO,
581 .id = AV_CODEC_ID_FLAC,
582 .priv_data_size = sizeof(FLACContext),
583 .init = flac_decode_init,
584 .close = flac_decode_close,
585 .decode = flac_decode_frame,
586 .capabilities = CODEC_CAP_DR1,
587 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
588 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
592 AV_SAMPLE_FMT_NONE },