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"
51 typedef struct FLACContext {
54 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
63 uint8_t *decoded_buffer;
64 unsigned int decoded_buffer_size;
69 static int allocate_buffers(FLACContext *s);
71 static void flac_set_bps(FLACContext *s)
73 enum AVSampleFormat req = s->avctx->request_sample_fmt;
74 int need32 = s->bps > 16;
75 int want32 = av_get_bytes_per_sample(req) > 2;
76 int planar = av_sample_fmt_is_planar(req);
78 if (need32 || want32) {
80 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
82 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
83 s->sample_shift = 32 - s->bps;
86 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
88 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
89 s->sample_shift = 16 - s->bps;
93 static av_cold int flac_decode_init(AVCodecContext *avctx)
95 enum FLACExtradataFormat format;
98 FLACContext *s = avctx->priv_data;
101 /* for now, the raw FLAC header is allowed to be passed to the decoder as
102 frame data instead of extradata. */
103 if (!avctx->extradata)
106 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
107 return AVERROR_INVALIDDATA;
109 /* initialize based on the demuxer-supplied streamdata header */
110 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
111 ret = allocate_buffers(s);
115 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
116 s->got_streaminfo = 1;
121 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
123 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
124 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
125 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
126 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
127 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
130 static int allocate_buffers(FLACContext *s)
134 av_assert0(s->max_blocksize);
136 buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
137 AV_SAMPLE_FMT_S32P, 0);
141 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
142 if (!s->decoded_buffer)
143 return AVERROR(ENOMEM);
145 return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
146 s->decoded_buffer, s->channels,
147 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
151 * Parse the STREAMINFO from an inline header.
152 * @param s the flac decoding context
153 * @param buf input buffer, starting with the "fLaC" marker
154 * @param buf_size buffer size
155 * @return non-zero if metadata is invalid
157 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
159 int metadata_type, metadata_size, ret;
161 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
165 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
166 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
167 metadata_size != FLAC_STREAMINFO_SIZE) {
168 return AVERROR_INVALIDDATA;
170 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
171 ret = allocate_buffers(s);
175 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
176 s->got_streaminfo = 1;
182 * Determine the size of an inline header.
183 * @param buf input buffer, starting with the "fLaC" marker
184 * @param buf_size buffer size
185 * @return number of bytes in the header, or 0 if more data is needed
187 static int get_metadata_size(const uint8_t *buf, int buf_size)
189 int metadata_last, metadata_size;
190 const uint8_t *buf_end = buf + buf_size;
194 if (buf_end - buf < 4)
196 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
198 if (buf_end - buf < metadata_size) {
199 /* need more data in order to read the complete header */
202 buf += metadata_size;
203 } while (!metadata_last);
205 return buf_size - (buf_end - buf);
208 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
210 int i, tmp, partition, method_type, rice_order;
211 int rice_bits, rice_esc;
214 method_type = get_bits(&s->gb, 2);
215 if (method_type > 1) {
216 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
218 return AVERROR_INVALIDDATA;
221 rice_order = get_bits(&s->gb, 4);
223 samples= s->blocksize >> rice_order;
224 if (pred_order > samples) {
225 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
226 pred_order, samples);
227 return AVERROR_INVALIDDATA;
230 rice_bits = 4 + method_type;
231 rice_esc = (1 << rice_bits) - 1;
233 decoded += pred_order;
235 for (partition = 0; partition < (1 << rice_order); partition++) {
236 tmp = get_bits(&s->gb, rice_bits);
237 if (tmp == rice_esc) {
238 tmp = get_bits(&s->gb, 5);
239 for (; i < samples; i++)
240 *decoded++ = get_sbits_long(&s->gb, tmp);
242 for (; i < samples; i++) {
243 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
252 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
253 int pred_order, int bps)
255 const int blocksize = s->blocksize;
256 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
259 /* warm up samples */
260 for (i = 0; i < pred_order; i++) {
261 decoded[i] = get_sbits_long(&s->gb, bps);
264 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
268 a = decoded[pred_order-1];
270 b = a - decoded[pred_order-2];
272 c = b - decoded[pred_order-2] + decoded[pred_order-3];
274 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
276 switch (pred_order) {
280 for (i = pred_order; i < blocksize; i++)
281 decoded[i] = a += decoded[i];
284 for (i = pred_order; i < blocksize; i++)
285 decoded[i] = a += b += decoded[i];
288 for (i = pred_order; i < blocksize; i++)
289 decoded[i] = a += b += c += decoded[i];
292 for (i = pred_order; i < blocksize; i++)
293 decoded[i] = a += b += c += d += decoded[i];
296 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
297 return AVERROR_INVALIDDATA;
303 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
307 int coeff_prec, qlevel;
310 /* warm up samples */
311 for (i = 0; i < pred_order; i++) {
312 decoded[i] = get_sbits_long(&s->gb, bps);
315 coeff_prec = get_bits(&s->gb, 4) + 1;
316 if (coeff_prec == 16) {
317 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
318 return AVERROR_INVALIDDATA;
320 qlevel = get_sbits(&s->gb, 5);
322 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
324 return AVERROR_INVALIDDATA;
327 for (i = 0; i < pred_order; i++) {
328 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
331 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
334 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
339 static inline int decode_subframe(FLACContext *s, int channel)
341 int32_t *decoded = s->decoded[channel];
342 int type, wasted = 0;
347 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
350 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
354 if (get_bits1(&s->gb)) {
355 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
356 return AVERROR_INVALIDDATA;
358 type = get_bits(&s->gb, 6);
360 if (get_bits1(&s->gb)) {
361 int left = get_bits_left(&s->gb);
363 (left < bps && !show_bits_long(&s->gb, left)) ||
364 !show_bits_long(&s->gb, bps)) {
365 av_log(s->avctx, AV_LOG_ERROR,
366 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
368 return AVERROR_INVALIDDATA;
370 wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
374 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
375 return AVERROR_PATCHWELCOME;
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 ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
389 } else if (type >= 32) {
390 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
393 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
394 return AVERROR_INVALIDDATA;
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 ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
413 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
417 if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
418 s->channels = s->avctx->channels = fi.channels;
419 ff_flac_set_channel_layout(s->avctx);
420 ret = allocate_buffers(s);
424 s->channels = s->avctx->channels = fi.channels;
425 if (!s->avctx->channel_layout)
426 ff_flac_set_channel_layout(s->avctx);
427 s->ch_mode = fi.ch_mode;
429 if (!s->bps && !fi.bps) {
430 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
431 return AVERROR_INVALIDDATA;
435 } else if (s->bps && fi.bps != s->bps) {
436 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
438 return AVERROR_INVALIDDATA;
442 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
446 if (!s->max_blocksize)
447 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
448 if (fi.blocksize > s->max_blocksize) {
449 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
451 return AVERROR_INVALIDDATA;
453 s->blocksize = fi.blocksize;
455 if (!s->samplerate && !fi.samplerate) {
456 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
457 " or frame header\n");
458 return AVERROR_INVALIDDATA;
460 if (fi.samplerate == 0)
461 fi.samplerate = s->samplerate;
462 s->samplerate = s->avctx->sample_rate = fi.samplerate;
464 if (!s->got_streaminfo) {
465 ret = allocate_buffers(s);
468 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
469 s->got_streaminfo = 1;
470 dump_headers(s->avctx, (FLACStreaminfo *)s);
473 // dump_headers(s->avctx, (FLACStreaminfo *)s);
476 for (i = 0; i < s->channels; i++) {
477 if ((ret = decode_subframe(s, i)) < 0)
484 skip_bits(gb, 16); /* data crc */
489 static int flac_decode_frame(AVCodecContext *avctx, void *data,
490 int *got_frame_ptr, AVPacket *avpkt)
492 AVFrame *frame = data;
493 ThreadFrame tframe = { .f = data };
494 const uint8_t *buf = avpkt->data;
495 int buf_size = avpkt->size;
496 FLACContext *s = avctx->priv_data;
502 if (s->max_framesize == 0) {
504 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
505 FLAC_MAX_CHANNELS, 32);
508 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
509 av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
513 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
514 av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
518 /* check that there is at least the smallest decodable amount of data.
519 this amount corresponds to the smallest valid FLAC frame possible.
520 FF F8 69 02 00 00 9A 00 00 34 46 */
521 if (buf_size < FLAC_MIN_FRAME_SIZE)
524 /* check for inline header */
525 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
526 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
527 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
530 return get_metadata_size(buf, buf_size);
534 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
536 if ((ret = decode_frame(s)) < 0) {
537 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
540 bytes_read = get_bits_count(&s->gb)/8;
542 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
543 av_crc(av_crc_get_table(AV_CRC_16_ANSI),
544 0, buf, bytes_read)) {
545 av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
546 if (s->avctx->err_recognition & AV_EF_EXPLODE)
547 return AVERROR_INVALIDDATA;
550 /* get output buffer */
551 frame->nb_samples = s->blocksize;
552 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
555 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
556 s->blocksize, s->sample_shift);
558 if (bytes_read > buf_size) {
559 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
560 return AVERROR_INVALIDDATA;
562 if (bytes_read < buf_size) {
563 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
564 buf_size - bytes_read, buf_size);
572 static int init_thread_copy(AVCodecContext *avctx)
574 FLACContext *s = avctx->priv_data;
575 s->decoded_buffer = NULL;
576 s->decoded_buffer_size = 0;
578 if (s->max_blocksize)
579 return allocate_buffers(s);
583 static av_cold int flac_decode_close(AVCodecContext *avctx)
585 FLACContext *s = avctx->priv_data;
587 av_freep(&s->decoded_buffer);
592 AVCodec ff_flac_decoder = {
594 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
595 .type = AVMEDIA_TYPE_AUDIO,
596 .id = AV_CODEC_ID_FLAC,
597 .priv_data_size = sizeof(FLACContext),
598 .init = flac_decode_init,
599 .close = flac_decode_close,
600 .decode = flac_decode_frame,
601 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
602 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
603 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
607 AV_SAMPLE_FMT_NONE },