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"
49 typedef struct FLACContext {
52 AVCodecContext *avctx; ///< parent AVCodecContext
53 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
55 int blocksize; ///< number of samples in the current frame
56 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
57 int ch_mode; ///< channel decorrelation type in the current frame
58 int got_streaminfo; ///< indicates if the STREAMINFO has been read
60 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
61 uint8_t *decoded_buffer;
62 unsigned int decoded_buffer_size;
67 static int allocate_buffers(FLACContext *s);
69 static void flac_set_bps(FLACContext *s)
71 enum AVSampleFormat req = s->avctx->request_sample_fmt;
72 int need32 = s->bps > 16;
73 int want32 = av_get_bytes_per_sample(req) > 2;
74 int planar = av_sample_fmt_is_planar(req);
76 if (need32 || want32) {
78 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32P;
80 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
81 s->sample_shift = 32 - s->bps;
84 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
86 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
87 s->sample_shift = 16 - s->bps;
91 static av_cold int flac_decode_init(AVCodecContext *avctx)
93 enum FLACExtradataFormat format;
96 FLACContext *s = avctx->priv_data;
99 /* for now, the raw FLAC header is allowed to be passed to the decoder as
100 frame data instead of extradata. */
101 if (!avctx->extradata)
104 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
105 return AVERROR_INVALIDDATA;
107 /* initialize based on the demuxer-supplied streamdata header */
108 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
109 ret = allocate_buffers(s);
113 ff_flacdsp_init(&s->dsp, avctx->sample_fmt, s->bps);
114 s->got_streaminfo = 1;
119 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
121 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
122 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
123 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
124 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
125 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
128 static int allocate_buffers(FLACContext *s)
132 av_assert0(s->max_blocksize);
134 buf_size = av_samples_get_buffer_size(NULL, s->channels, s->max_blocksize,
135 AV_SAMPLE_FMT_S32P, 0);
139 av_fast_malloc(&s->decoded_buffer, &s->decoded_buffer_size, buf_size);
140 if (!s->decoded_buffer)
141 return AVERROR(ENOMEM);
143 return av_samples_fill_arrays((uint8_t **)s->decoded, NULL,
144 s->decoded_buffer, s->channels,
145 s->max_blocksize, AV_SAMPLE_FMT_S32P, 0);
149 * Parse the STREAMINFO from an inline header.
150 * @param s the flac decoding context
151 * @param buf input buffer, starting with the "fLaC" marker
152 * @param buf_size buffer size
153 * @return non-zero if metadata is invalid
155 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
157 int metadata_type, metadata_size, ret;
159 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
163 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
164 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
165 metadata_size != FLAC_STREAMINFO_SIZE) {
166 return AVERROR_INVALIDDATA;
168 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
169 ret = allocate_buffers(s);
173 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
174 s->got_streaminfo = 1;
180 * Determine the size of an inline header.
181 * @param buf input buffer, starting with the "fLaC" marker
182 * @param buf_size buffer size
183 * @return number of bytes in the header, or 0 if more data is needed
185 static int get_metadata_size(const uint8_t *buf, int buf_size)
187 int metadata_last, metadata_size;
188 const uint8_t *buf_end = buf + buf_size;
192 if (buf_end - buf < 4)
194 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
196 if (buf_end - buf < metadata_size) {
197 /* need more data in order to read the complete header */
200 buf += metadata_size;
201 } while (!metadata_last);
203 return buf_size - (buf_end - buf);
206 static int decode_residuals(FLACContext *s, int32_t *decoded, int pred_order)
208 int i, tmp, partition, method_type, rice_order;
209 int rice_bits, rice_esc;
212 method_type = get_bits(&s->gb, 2);
213 if (method_type > 1) {
214 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
216 return AVERROR_INVALIDDATA;
219 rice_order = get_bits(&s->gb, 4);
221 samples= s->blocksize >> rice_order;
222 if (pred_order > samples) {
223 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
224 pred_order, samples);
225 return AVERROR_INVALIDDATA;
228 rice_bits = 4 + method_type;
229 rice_esc = (1 << rice_bits) - 1;
231 decoded += pred_order;
233 for (partition = 0; partition < (1 << rice_order); partition++) {
234 tmp = get_bits(&s->gb, rice_bits);
235 if (tmp == rice_esc) {
236 tmp = get_bits(&s->gb, 5);
237 for (; i < samples; i++)
238 *decoded++ = get_sbits_long(&s->gb, tmp);
240 for (; i < samples; i++) {
241 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
250 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
251 int pred_order, int bps)
253 const int blocksize = s->blocksize;
254 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
257 /* warm up samples */
258 for (i = 0; i < pred_order; i++) {
259 decoded[i] = get_sbits_long(&s->gb, bps);
262 if ((ret = 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);
295 return AVERROR_INVALIDDATA;
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");
316 return AVERROR_INVALIDDATA;
318 qlevel = get_sbits(&s->gb, 5);
320 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
322 return AVERROR_INVALIDDATA;
325 for (i = 0; i < pred_order; i++) {
326 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
329 if ((ret = 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");
354 return AVERROR_INVALIDDATA;
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 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 (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
413 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
414 return AVERROR_INVALIDDATA;
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 "
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 && parse_streaminfo(s, buf, buf_size)) {
527 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
528 return AVERROR_INVALIDDATA;
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) &&
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;
577 if (s->max_blocksize)
578 return allocate_buffers(s);
582 static av_cold int flac_decode_close(AVCodecContext *avctx)
584 FLACContext *s = avctx->priv_data;
586 av_freep(&s->decoded_buffer);
591 AVCodec ff_flac_decoder = {
593 .type = AVMEDIA_TYPE_AUDIO,
594 .id = AV_CODEC_ID_FLAC,
595 .priv_data_size = sizeof(FLACContext),
596 .init = flac_decode_init,
597 .close = flac_decode_close,
598 .decode = flac_decode_frame,
599 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
600 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
601 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
602 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
606 AV_SAMPLE_FMT_NONE },