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 (samples << rice_order != s->blocksize) {
225 av_log(s->avctx, AV_LOG_ERROR, "invalid rice order: %i blocksize %i\n",
226 rice_order, s->blocksize);
227 return AVERROR_INVALIDDATA;
230 if (pred_order > samples) {
231 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
232 pred_order, samples);
233 return AVERROR_INVALIDDATA;
236 rice_bits = 4 + method_type;
237 rice_esc = (1 << rice_bits) - 1;
239 decoded += pred_order;
241 for (partition = 0; partition < (1 << rice_order); partition++) {
242 tmp = get_bits(&s->gb, rice_bits);
243 if (tmp == rice_esc) {
244 tmp = get_bits(&s->gb, 5);
245 for (; i < samples; i++)
246 *decoded++ = get_sbits_long(&s->gb, tmp);
248 for (; i < samples; i++) {
249 *decoded++ = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
258 static int decode_subframe_fixed(FLACContext *s, int32_t *decoded,
259 int pred_order, int bps)
261 const int blocksize = s->blocksize;
262 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
265 /* warm up samples */
266 for (i = 0; i < pred_order; i++) {
267 decoded[i] = get_sbits_long(&s->gb, bps);
270 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
274 a = decoded[pred_order-1];
276 b = a - decoded[pred_order-2];
278 c = b - decoded[pred_order-2] + decoded[pred_order-3];
280 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
282 switch (pred_order) {
286 for (i = pred_order; i < blocksize; i++)
287 decoded[i] = a += decoded[i];
290 for (i = pred_order; i < blocksize; i++)
291 decoded[i] = a += b += decoded[i];
294 for (i = pred_order; i < blocksize; i++)
295 decoded[i] = a += b += c += decoded[i];
298 for (i = pred_order; i < blocksize; i++)
299 decoded[i] = a += b += c += d += decoded[i];
302 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
303 return AVERROR_INVALIDDATA;
309 static int decode_subframe_lpc(FLACContext *s, int32_t *decoded, int pred_order,
313 int coeff_prec, qlevel;
316 /* warm up samples */
317 for (i = 0; i < pred_order; i++) {
318 decoded[i] = get_sbits_long(&s->gb, bps);
321 coeff_prec = get_bits(&s->gb, 4) + 1;
322 if (coeff_prec == 16) {
323 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
324 return AVERROR_INVALIDDATA;
326 qlevel = get_sbits(&s->gb, 5);
328 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
330 return AVERROR_INVALIDDATA;
333 for (i = 0; i < pred_order; i++) {
334 coeffs[pred_order - i - 1] = get_sbits(&s->gb, coeff_prec);
337 if ((ret = decode_residuals(s, decoded, pred_order)) < 0)
340 s->dsp.lpc(decoded, coeffs, pred_order, qlevel, s->blocksize);
345 static inline int decode_subframe(FLACContext *s, int channel)
347 int32_t *decoded = s->decoded[channel];
348 int type, wasted = 0;
353 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
356 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
360 if (get_bits1(&s->gb)) {
361 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
362 return AVERROR_INVALIDDATA;
364 type = get_bits(&s->gb, 6);
366 if (get_bits1(&s->gb)) {
367 int left = get_bits_left(&s->gb);
369 (left < bps && !show_bits_long(&s->gb, left)) ||
370 !show_bits_long(&s->gb, bps)) {
371 av_log(s->avctx, AV_LOG_ERROR,
372 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
374 return AVERROR_INVALIDDATA;
376 wasted = 1 + get_unary(&s->gb, 1, get_bits_left(&s->gb));
380 avpriv_report_missing_feature(s->avctx, "Decorrelated bit depth > 32");
381 return AVERROR_PATCHWELCOME;
384 //FIXME use av_log2 for types
386 tmp = get_sbits_long(&s->gb, bps);
387 for (i = 0; i < s->blocksize; i++)
389 } else if (type == 1) {
390 for (i = 0; i < s->blocksize; i++)
391 decoded[i] = get_sbits_long(&s->gb, bps);
392 } else if ((type >= 8) && (type <= 12)) {
393 if ((ret = decode_subframe_fixed(s, decoded, type & ~0x8, bps)) < 0)
395 } else if (type >= 32) {
396 if ((ret = decode_subframe_lpc(s, decoded, (type & ~0x20)+1, bps)) < 0)
399 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
400 return AVERROR_INVALIDDATA;
405 for (i = 0; i < s->blocksize; i++)
406 decoded[i] <<= wasted;
412 static int decode_frame(FLACContext *s)
415 GetBitContext *gb = &s->gb;
418 if ((ret = ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) < 0) {
419 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
423 if (s->channels && fi.channels != s->channels && s->got_streaminfo) {
424 s->channels = s->avctx->channels = fi.channels;
425 ff_flac_set_channel_layout(s->avctx);
426 ret = allocate_buffers(s);
430 s->channels = s->avctx->channels = fi.channels;
431 if (!s->avctx->channel_layout)
432 ff_flac_set_channel_layout(s->avctx);
433 s->ch_mode = fi.ch_mode;
435 if (!s->bps && !fi.bps) {
436 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
437 return AVERROR_INVALIDDATA;
441 } else if (s->bps && fi.bps != s->bps) {
442 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
444 return AVERROR_INVALIDDATA;
448 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
452 if (!s->max_blocksize)
453 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
454 if (fi.blocksize > s->max_blocksize) {
455 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
457 return AVERROR_INVALIDDATA;
459 s->blocksize = fi.blocksize;
461 if (!s->samplerate && !fi.samplerate) {
462 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
463 " or frame header\n");
464 return AVERROR_INVALIDDATA;
466 if (fi.samplerate == 0)
467 fi.samplerate = s->samplerate;
468 s->samplerate = s->avctx->sample_rate = fi.samplerate;
470 if (!s->got_streaminfo) {
471 ret = allocate_buffers(s);
474 ff_flacdsp_init(&s->dsp, s->avctx->sample_fmt, s->bps);
475 s->got_streaminfo = 1;
476 dump_headers(s->avctx, (FLACStreaminfo *)s);
479 // dump_headers(s->avctx, (FLACStreaminfo *)s);
482 for (i = 0; i < s->channels; i++) {
483 if ((ret = decode_subframe(s, i)) < 0)
490 skip_bits(gb, 16); /* data crc */
495 static int flac_decode_frame(AVCodecContext *avctx, void *data,
496 int *got_frame_ptr, AVPacket *avpkt)
498 AVFrame *frame = data;
499 ThreadFrame tframe = { .f = data };
500 const uint8_t *buf = avpkt->data;
501 int buf_size = avpkt->size;
502 FLACContext *s = avctx->priv_data;
508 if (s->max_framesize == 0) {
510 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
511 FLAC_MAX_CHANNELS, 32);
514 if (buf_size > 5 && !memcmp(buf, "\177FLAC", 5)) {
515 av_log(s->avctx, AV_LOG_DEBUG, "skiping flac header packet 1\n");
519 if (buf_size > 0 && (*buf & 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT) {
520 av_log(s->avctx, AV_LOG_DEBUG, "skiping vorbis comment\n");
524 /* check that there is at least the smallest decodable amount of data.
525 this amount corresponds to the smallest valid FLAC frame possible.
526 FF F8 69 02 00 00 9A 00 00 34 46 */
527 if (buf_size < FLAC_MIN_FRAME_SIZE)
530 /* check for inline header */
531 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
532 if (!s->got_streaminfo && (ret = parse_streaminfo(s, buf, buf_size))) {
533 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
536 return get_metadata_size(buf, buf_size);
540 if ((ret = init_get_bits8(&s->gb, buf, buf_size)) < 0)
542 if ((ret = decode_frame(s)) < 0) {
543 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
546 bytes_read = get_bits_count(&s->gb)/8;
548 if ((s->avctx->err_recognition & (AV_EF_CRCCHECK|AV_EF_COMPLIANT)) &&
549 av_crc(av_crc_get_table(AV_CRC_16_ANSI),
550 0, buf, bytes_read)) {
551 av_log(s->avctx, AV_LOG_ERROR, "CRC error at PTS %"PRId64"\n", avpkt->pts);
552 if (s->avctx->err_recognition & AV_EF_EXPLODE)
553 return AVERROR_INVALIDDATA;
556 /* get output buffer */
557 frame->nb_samples = s->blocksize;
558 if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0)
561 s->dsp.decorrelate[s->ch_mode](frame->data, s->decoded, s->channels,
562 s->blocksize, s->sample_shift);
564 if (bytes_read > buf_size) {
565 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
566 return AVERROR_INVALIDDATA;
568 if (bytes_read < buf_size) {
569 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
570 buf_size - bytes_read, buf_size);
578 static int init_thread_copy(AVCodecContext *avctx)
580 FLACContext *s = avctx->priv_data;
581 s->decoded_buffer = NULL;
582 s->decoded_buffer_size = 0;
584 if (s->max_blocksize)
585 return allocate_buffers(s);
589 static av_cold int flac_decode_close(AVCodecContext *avctx)
591 FLACContext *s = avctx->priv_data;
593 av_freep(&s->decoded_buffer);
598 AVCodec ff_flac_decoder = {
600 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
601 .type = AVMEDIA_TYPE_AUDIO,
602 .id = AV_CODEC_ID_FLAC,
603 .priv_data_size = sizeof(FLACContext),
604 .init = flac_decode_init,
605 .close = flac_decode_close,
606 .decode = flac_decode_frame,
607 .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
608 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
609 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
613 AV_SAMPLE_FMT_NONE },