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/audioconvert.h"
37 #include "libavutil/crc.h"
41 #include "bytestream.h"
49 typedef struct FLACContext {
52 AVCodecContext *avctx; ///< parent AVCodecContext
54 GetBitContext gb; ///< GetBitContext initialized to start at the current frame
56 int blocksize; ///< number of samples in the current frame
57 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
58 int is32; ///< flag to indicate if output should be 32-bit instead of 16-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
65 static const int64_t flac_channel_layouts[6] = {
68 AV_CH_LAYOUT_SURROUND,
74 static void allocate_buffers(FLACContext *s);
76 int avpriv_flac_is_extradata_valid(AVCodecContext *avctx,
77 enum FLACExtradataFormat *format,
78 uint8_t **streaminfo_start)
80 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
81 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
84 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
85 /* extradata contains STREAMINFO only */
86 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
87 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
88 FLAC_STREAMINFO_SIZE-avctx->extradata_size);
90 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
91 *streaminfo_start = avctx->extradata;
93 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
94 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
97 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
98 *streaminfo_start = &avctx->extradata[8];
103 static void flac_set_bps(FLACContext *s)
106 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
107 s->sample_shift = 32 - s->bps;
110 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
111 s->sample_shift = 16 - s->bps;
116 static av_cold int flac_decode_init(AVCodecContext *avctx)
118 enum FLACExtradataFormat format;
120 FLACContext *s = avctx->priv_data;
123 /* for now, the raw FLAC header is allowed to be passed to the decoder as
124 frame data instead of extradata. */
125 if (!avctx->extradata)
128 if (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
131 /* initialize based on the demuxer-supplied streamdata header */
132 avpriv_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
135 s->got_streaminfo = 1;
137 avcodec_get_frame_defaults(&s->frame);
138 avctx->coded_frame = &s->frame;
140 if (avctx->channels <= FF_ARRAY_ELEMS(flac_channel_layouts))
141 avctx->channel_layout = flac_channel_layouts[avctx->channels - 1];
146 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
148 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
149 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
150 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
151 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
152 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
155 static void allocate_buffers(FLACContext *s)
159 assert(s->max_blocksize);
161 for (i = 0; i < s->channels; i++) {
162 s->decoded[i] = av_malloc(sizeof(int32_t)*s->max_blocksize);
166 void avpriv_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
167 const uint8_t *buffer)
170 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
172 skip_bits(&gb, 16); /* skip min blocksize */
173 s->max_blocksize = get_bits(&gb, 16);
174 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
175 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
177 s->max_blocksize = 16;
180 skip_bits(&gb, 24); /* skip min frame size */
181 s->max_framesize = get_bits_long(&gb, 24);
183 s->samplerate = get_bits_long(&gb, 20);
184 s->channels = get_bits(&gb, 3) + 1;
185 s->bps = get_bits(&gb, 5) + 1;
187 avctx->channels = s->channels;
188 avctx->sample_rate = s->samplerate;
189 avctx->bits_per_raw_sample = s->bps;
191 s->samples = get_bits_long(&gb, 32) << 4;
192 s->samples |= get_bits(&gb, 4);
194 skip_bits_long(&gb, 64); /* md5 sum */
195 skip_bits_long(&gb, 64); /* md5 sum */
197 dump_headers(avctx, s);
200 void avpriv_flac_parse_block_header(const uint8_t *block_header,
201 int *last, int *type, int *size)
203 int tmp = bytestream_get_byte(&block_header);
209 *size = bytestream_get_be24(&block_header);
213 * Parse the STREAMINFO from an inline header.
214 * @param s the flac decoding context
215 * @param buf input buffer, starting with the "fLaC" marker
216 * @param buf_size buffer size
217 * @return non-zero if metadata is invalid
219 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
221 int metadata_type, metadata_size;
223 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
227 avpriv_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
228 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
229 metadata_size != FLAC_STREAMINFO_SIZE) {
230 return AVERROR_INVALIDDATA;
232 avpriv_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
234 s->got_streaminfo = 1;
240 * Determine the size of an inline header.
241 * @param buf input buffer, starting with the "fLaC" marker
242 * @param buf_size buffer size
243 * @return number of bytes in the header, or 0 if more data is needed
245 static int get_metadata_size(const uint8_t *buf, int buf_size)
247 int metadata_last, metadata_size;
248 const uint8_t *buf_end = buf + buf_size;
252 if (buf_end - buf < 4)
254 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
256 if (buf_end - buf < metadata_size) {
257 /* need more data in order to read the complete header */
260 buf += metadata_size;
261 } while (!metadata_last);
263 return buf_size - (buf_end - buf);
266 static int decode_residuals(FLACContext *s, int channel, int pred_order)
268 int i, tmp, partition, method_type, rice_order;
269 int sample = 0, samples;
271 method_type = get_bits(&s->gb, 2);
272 if (method_type > 1) {
273 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
278 rice_order = get_bits(&s->gb, 4);
280 samples= s->blocksize >> rice_order;
281 if (pred_order > samples) {
282 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
283 pred_order, samples);
289 for (partition = 0; partition < (1 << rice_order); partition++) {
290 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
291 if (tmp == (method_type == 0 ? 15 : 31)) {
292 tmp = get_bits(&s->gb, 5);
293 for (; i < samples; i++, sample++)
294 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
296 for (; i < samples; i++, sample++) {
297 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
306 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order,
309 const int blocksize = s->blocksize;
310 int32_t *decoded = s->decoded[channel];
313 /* warm up samples */
314 for (i = 0; i < pred_order; i++) {
315 decoded[i] = get_sbits_long(&s->gb, bps);
318 if (decode_residuals(s, channel, pred_order) < 0)
322 a = decoded[pred_order-1];
324 b = a - decoded[pred_order-2];
326 c = b - decoded[pred_order-2] + decoded[pred_order-3];
328 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
330 switch (pred_order) {
334 for (i = pred_order; i < blocksize; i++)
335 decoded[i] = a += decoded[i];
338 for (i = pred_order; i < blocksize; i++)
339 decoded[i] = a += b += decoded[i];
342 for (i = pred_order; i < blocksize; i++)
343 decoded[i] = a += b += c += decoded[i];
346 for (i = pred_order; i < blocksize; i++)
347 decoded[i] = a += b += c += d += decoded[i];
350 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
357 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order,
361 int coeff_prec, qlevel;
363 int32_t *decoded = s->decoded[channel];
365 /* warm up samples */
366 for (i = 0; i < pred_order; i++) {
367 decoded[i] = get_sbits_long(&s->gb, bps);
370 coeff_prec = get_bits(&s->gb, 4) + 1;
371 if (coeff_prec == 16) {
372 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
375 qlevel = get_sbits(&s->gb, 5);
377 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
382 for (i = 0; i < pred_order; i++) {
383 coeffs[i] = get_sbits(&s->gb, coeff_prec);
386 if (decode_residuals(s, channel, pred_order) < 0)
391 for (i = pred_order; i < s->blocksize; i++) {
393 for (j = 0; j < pred_order; j++)
394 sum += (int64_t)coeffs[j] * decoded[i-j-1];
395 decoded[i] += sum >> qlevel;
398 for (i = pred_order; i < s->blocksize-1; i += 2) {
400 int d = decoded[i-pred_order];
402 for (j = pred_order-1; j > 0; j--) {
410 d = decoded[i] += s0 >> qlevel;
412 decoded[i+1] += s1 >> qlevel;
414 if (i < s->blocksize) {
416 for (j = 0; j < pred_order; j++)
417 sum += coeffs[j] * decoded[i-j-1];
418 decoded[i] += sum >> qlevel;
425 static inline int decode_subframe(FLACContext *s, int channel)
427 int type, wasted = 0;
432 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
435 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
439 if (get_bits1(&s->gb)) {
440 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
443 type = get_bits(&s->gb, 6);
445 if (get_bits1(&s->gb)) {
446 int left = get_bits_left(&s->gb);
449 (left < bps && !show_bits_long(&s->gb, left)) ||
450 !show_bits_long(&s->gb, bps)) {
451 av_log(s->avctx, AV_LOG_ERROR,
452 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
454 return AVERROR_INVALIDDATA;
456 while (!get_bits1(&s->gb))
461 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
465 //FIXME use av_log2 for types
467 tmp = get_sbits_long(&s->gb, bps);
468 for (i = 0; i < s->blocksize; i++)
469 s->decoded[channel][i] = tmp;
470 } else if (type == 1) {
471 for (i = 0; i < s->blocksize; i++)
472 s->decoded[channel][i] = get_sbits_long(&s->gb, bps);
473 } else if ((type >= 8) && (type <= 12)) {
474 if (decode_subframe_fixed(s, channel, type & ~0x8, bps) < 0)
476 } else if (type >= 32) {
477 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1, bps) < 0)
480 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
486 for (i = 0; i < s->blocksize; i++)
487 s->decoded[channel][i] <<= wasted;
493 static int decode_frame(FLACContext *s)
496 GetBitContext *gb = &s->gb;
499 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
500 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
504 if (s->channels && fi.channels != s->channels) {
505 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
506 "is not supported\n");
509 s->channels = s->avctx->channels = fi.channels;
510 s->ch_mode = fi.ch_mode;
512 if (!s->bps && !fi.bps) {
513 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
518 } else if (s->bps && fi.bps != s->bps) {
519 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
523 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
527 if (!s->max_blocksize)
528 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
529 if (fi.blocksize > s->max_blocksize) {
530 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
534 s->blocksize = fi.blocksize;
536 if (!s->samplerate && !fi.samplerate) {
537 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
538 " or frame header\n");
541 if (fi.samplerate == 0) {
542 fi.samplerate = s->samplerate;
543 } else if (s->samplerate && fi.samplerate != s->samplerate) {
544 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
545 s->samplerate, fi.samplerate);
547 s->samplerate = s->avctx->sample_rate = fi.samplerate;
549 if (!s->got_streaminfo) {
551 s->got_streaminfo = 1;
552 dump_headers(s->avctx, (FLACStreaminfo *)s);
555 // dump_headers(s->avctx, (FLACStreaminfo *)s);
558 for (i = 0; i < s->channels; i++) {
559 if (decode_subframe(s, i) < 0)
566 skip_bits(gb, 16); /* data crc */
571 static int flac_decode_frame(AVCodecContext *avctx, void *data,
572 int *got_frame_ptr, AVPacket *avpkt)
574 const uint8_t *buf = avpkt->data;
575 int buf_size = avpkt->size;
576 FLACContext *s = avctx->priv_data;
577 int i, j = 0, bytes_read = 0;
584 if (s->max_framesize == 0) {
586 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
587 FLAC_MAX_CHANNELS, 32);
590 /* check that there is at least the smallest decodable amount of data.
591 this amount corresponds to the smallest valid FLAC frame possible.
592 FF F8 69 02 00 00 9A 00 00 34 46 */
593 if (buf_size < FLAC_MIN_FRAME_SIZE)
596 /* check for inline header */
597 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
598 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
599 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
602 return get_metadata_size(buf, buf_size);
606 init_get_bits(&s->gb, buf, buf_size*8);
607 if (decode_frame(s) < 0) {
608 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
611 bytes_read = (get_bits_count(&s->gb)+7)/8;
613 /* get output buffer */
614 s->frame.nb_samples = s->blocksize;
615 if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
616 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
619 samples_16 = (int16_t *)s->frame.data[0];
620 samples_32 = (int32_t *)s->frame.data[0];
622 #define DECORRELATE(left, right)\
623 assert(s->channels == 2);\
624 for (i = 0; i < s->blocksize; i++) {\
625 int a= s->decoded[0][i];\
626 int b= s->decoded[1][i];\
628 *samples_32++ = (left) << s->sample_shift;\
629 *samples_32++ = (right) << s->sample_shift;\
631 *samples_16++ = (left) << s->sample_shift;\
632 *samples_16++ = (right) << s->sample_shift;\
637 switch (s->ch_mode) {
638 case FLAC_CHMODE_INDEPENDENT:
639 for (j = 0; j < s->blocksize; j++) {
640 for (i = 0; i < s->channels; i++) {
642 *samples_32++ = s->decoded[i][j] << s->sample_shift;
644 *samples_16++ = s->decoded[i][j] << s->sample_shift;
648 case FLAC_CHMODE_LEFT_SIDE:
650 case FLAC_CHMODE_RIGHT_SIDE:
652 case FLAC_CHMODE_MID_SIDE:
653 DECORRELATE( (a-=b>>1) + b, a)
656 if (bytes_read > buf_size) {
657 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
660 if (bytes_read < buf_size) {
661 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
662 buf_size - bytes_read, buf_size);
666 *(AVFrame *)data = s->frame;
671 static av_cold int flac_decode_close(AVCodecContext *avctx)
673 FLACContext *s = avctx->priv_data;
676 for (i = 0; i < s->channels; i++) {
677 av_freep(&s->decoded[i]);
683 AVCodec ff_flac_decoder = {
685 .type = AVMEDIA_TYPE_AUDIO,
687 .priv_data_size = sizeof(FLACContext),
688 .init = flac_decode_init,
689 .close = flac_decode_close,
690 .decode = flac_decode_frame,
691 .capabilities = CODEC_CAP_DR1,
692 .long_name = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),