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/crc.h"
40 #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 curr_bps; ///< bps for current subframe, adjusted for channel correlation and wasted bits
56 int sample_shift; ///< shift required to make output samples 16-bit or 32-bit
57 int is32; ///< flag to indicate if output should be 32-bit instead of 16-bit
58 int ch_mode; ///< channel decorrelation type in the current frame
59 int got_streaminfo; ///< indicates if the STREAMINFO has been read
61 int32_t *decoded[FLAC_MAX_CHANNELS]; ///< decoded samples
64 static void allocate_buffers(FLACContext *s);
66 int ff_flac_is_extradata_valid(AVCodecContext *avctx,
67 enum FLACExtradataFormat *format,
68 uint8_t **streaminfo_start)
70 if (!avctx->extradata || avctx->extradata_size < FLAC_STREAMINFO_SIZE) {
71 av_log(avctx, AV_LOG_ERROR, "extradata NULL or too small.\n");
74 if (AV_RL32(avctx->extradata) != MKTAG('f','L','a','C')) {
75 /* extradata contains STREAMINFO only */
76 if (avctx->extradata_size != FLAC_STREAMINFO_SIZE) {
77 av_log(avctx, AV_LOG_WARNING, "extradata contains %d bytes too many.\n",
78 FLAC_STREAMINFO_SIZE-avctx->extradata_size);
80 *format = FLAC_EXTRADATA_FORMAT_STREAMINFO;
81 *streaminfo_start = avctx->extradata;
83 if (avctx->extradata_size < 8+FLAC_STREAMINFO_SIZE) {
84 av_log(avctx, AV_LOG_ERROR, "extradata too small.\n");
87 *format = FLAC_EXTRADATA_FORMAT_FULL_HEADER;
88 *streaminfo_start = &avctx->extradata[8];
93 static av_cold int flac_decode_init(AVCodecContext *avctx)
95 enum FLACExtradataFormat format;
97 FLACContext *s = avctx->priv_data;
100 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
102 /* for now, the raw FLAC header is allowed to be passed to the decoder as
103 frame data instead of extradata. */
104 if (!avctx->extradata)
107 if (!ff_flac_is_extradata_valid(avctx, &format, &streaminfo))
110 /* initialize based on the demuxer-supplied streamdata header */
111 ff_flac_parse_streaminfo(avctx, (FLACStreaminfo *)s, streaminfo);
113 avctx->sample_fmt = AV_SAMPLE_FMT_S32;
115 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
117 s->got_streaminfo = 1;
122 static void dump_headers(AVCodecContext *avctx, FLACStreaminfo *s)
124 av_log(avctx, AV_LOG_DEBUG, " Max Blocksize: %d\n", s->max_blocksize);
125 av_log(avctx, AV_LOG_DEBUG, " Max Framesize: %d\n", s->max_framesize);
126 av_log(avctx, AV_LOG_DEBUG, " Samplerate: %d\n", s->samplerate);
127 av_log(avctx, AV_LOG_DEBUG, " Channels: %d\n", s->channels);
128 av_log(avctx, AV_LOG_DEBUG, " Bits: %d\n", s->bps);
131 static void allocate_buffers(FLACContext *s)
135 assert(s->max_blocksize);
137 for (i = 0; i < s->channels; i++) {
138 s->decoded[i] = av_realloc(s->decoded[i],
139 sizeof(int32_t)*s->max_blocksize);
143 void ff_flac_parse_streaminfo(AVCodecContext *avctx, struct FLACStreaminfo *s,
144 const uint8_t *buffer)
147 init_get_bits(&gb, buffer, FLAC_STREAMINFO_SIZE*8);
149 skip_bits(&gb, 16); /* skip min blocksize */
150 s->max_blocksize = get_bits(&gb, 16);
151 if (s->max_blocksize < FLAC_MIN_BLOCKSIZE) {
152 av_log(avctx, AV_LOG_WARNING, "invalid max blocksize: %d\n",
154 s->max_blocksize = 16;
157 skip_bits(&gb, 24); /* skip min frame size */
158 s->max_framesize = get_bits_long(&gb, 24);
160 s->samplerate = get_bits_long(&gb, 20);
161 s->channels = get_bits(&gb, 3) + 1;
162 s->bps = get_bits(&gb, 5) + 1;
164 avctx->channels = s->channels;
165 avctx->sample_rate = s->samplerate;
166 avctx->bits_per_raw_sample = s->bps;
168 s->samples = get_bits_long(&gb, 32) << 4;
169 s->samples |= get_bits(&gb, 4);
171 skip_bits_long(&gb, 64); /* md5 sum */
172 skip_bits_long(&gb, 64); /* md5 sum */
174 dump_headers(avctx, s);
177 void ff_flac_parse_block_header(const uint8_t *block_header,
178 int *last, int *type, int *size)
180 int tmp = bytestream_get_byte(&block_header);
186 *size = bytestream_get_be24(&block_header);
190 * Parse the STREAMINFO from an inline header.
191 * @param s the flac decoding context
192 * @param buf input buffer, starting with the "fLaC" marker
193 * @param buf_size buffer size
194 * @return non-zero if metadata is invalid
196 static int parse_streaminfo(FLACContext *s, const uint8_t *buf, int buf_size)
198 int metadata_type, metadata_size;
200 if (buf_size < FLAC_STREAMINFO_SIZE+8) {
204 ff_flac_parse_block_header(&buf[4], NULL, &metadata_type, &metadata_size);
205 if (metadata_type != FLAC_METADATA_TYPE_STREAMINFO ||
206 metadata_size != FLAC_STREAMINFO_SIZE) {
207 return AVERROR_INVALIDDATA;
209 ff_flac_parse_streaminfo(s->avctx, (FLACStreaminfo *)s, &buf[8]);
211 s->got_streaminfo = 1;
217 * Determine the size of an inline header.
218 * @param buf input buffer, starting with the "fLaC" marker
219 * @param buf_size buffer size
220 * @return number of bytes in the header, or 0 if more data is needed
222 static int get_metadata_size(const uint8_t *buf, int buf_size)
224 int metadata_last, metadata_size;
225 const uint8_t *buf_end = buf + buf_size;
229 ff_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
231 if (buf + metadata_size > buf_end) {
232 /* need more data in order to read the complete header */
235 buf += metadata_size;
236 } while (!metadata_last);
238 return buf_size - (buf_end - buf);
241 static int decode_residuals(FLACContext *s, int channel, int pred_order)
243 int i, tmp, partition, method_type, rice_order;
244 int sample = 0, samples;
246 method_type = get_bits(&s->gb, 2);
247 if (method_type > 1) {
248 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
253 rice_order = get_bits(&s->gb, 4);
255 samples= s->blocksize >> rice_order;
256 if (pred_order > samples) {
257 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
258 pred_order, samples);
264 for (partition = 0; partition < (1 << rice_order); partition++) {
265 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
266 if (tmp == (method_type == 0 ? 15 : 31)) {
267 tmp = get_bits(&s->gb, 5);
268 for (; i < samples; i++, sample++)
269 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
271 for (; i < samples; i++, sample++) {
272 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
281 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
283 const int blocksize = s->blocksize;
284 int32_t *decoded = s->decoded[channel];
285 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
287 /* warm up samples */
288 for (i = 0; i < pred_order; i++) {
289 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
292 if (decode_residuals(s, channel, pred_order) < 0)
296 a = decoded[pred_order-1];
298 b = a - decoded[pred_order-2];
300 c = b - decoded[pred_order-2] + decoded[pred_order-3];
302 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
304 switch (pred_order) {
308 for (i = pred_order; i < blocksize; i++)
309 decoded[i] = a += decoded[i];
312 for (i = pred_order; i < blocksize; i++)
313 decoded[i] = a += b += decoded[i];
316 for (i = pred_order; i < blocksize; i++)
317 decoded[i] = a += b += c += decoded[i];
320 for (i = pred_order; i < blocksize; i++)
321 decoded[i] = a += b += c += d += decoded[i];
324 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
331 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
334 int coeff_prec, qlevel;
336 int32_t *decoded = s->decoded[channel];
338 /* warm up samples */
339 for (i = 0; i < pred_order; i++) {
340 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
343 coeff_prec = get_bits(&s->gb, 4) + 1;
344 if (coeff_prec == 16) {
345 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
348 qlevel = get_sbits(&s->gb, 5);
350 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
355 for (i = 0; i < pred_order; i++) {
356 coeffs[i] = get_sbits(&s->gb, coeff_prec);
359 if (decode_residuals(s, channel, pred_order) < 0)
364 for (i = pred_order; i < s->blocksize; i++) {
366 for (j = 0; j < pred_order; j++)
367 sum += (int64_t)coeffs[j] * decoded[i-j-1];
368 decoded[i] += sum >> qlevel;
371 for (i = pred_order; i < s->blocksize-1; i += 2) {
373 int d = decoded[i-pred_order];
375 for (j = pred_order-1; j > 0; j--) {
383 d = decoded[i] += s0 >> qlevel;
385 decoded[i+1] += s1 >> qlevel;
387 if (i < s->blocksize) {
389 for (j = 0; j < pred_order; j++)
390 sum += coeffs[j] * decoded[i-j-1];
391 decoded[i] += sum >> qlevel;
398 static inline int decode_subframe(FLACContext *s, int channel)
400 int type, wasted = 0;
403 s->curr_bps = s->bps;
405 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
408 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
412 if (get_bits1(&s->gb)) {
413 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
416 type = get_bits(&s->gb, 6);
418 if (get_bits1(&s->gb)) {
420 while (!get_bits1(&s->gb))
422 s->curr_bps -= wasted;
424 if (s->curr_bps > 32) {
425 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
429 //FIXME use av_log2 for types
431 tmp = get_sbits_long(&s->gb, s->curr_bps);
432 for (i = 0; i < s->blocksize; i++)
433 s->decoded[channel][i] = tmp;
434 } else if (type == 1) {
435 for (i = 0; i < s->blocksize; i++)
436 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
437 } else if ((type >= 8) && (type <= 12)) {
438 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
440 } else if (type >= 32) {
441 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
444 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
450 for (i = 0; i < s->blocksize; i++)
451 s->decoded[channel][i] <<= wasted;
457 static int decode_frame(FLACContext *s)
460 GetBitContext *gb = &s->gb;
463 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
464 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
468 if (s->channels && fi.channels != s->channels) {
469 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
470 "is not supported\n");
473 s->channels = s->avctx->channels = fi.channels;
474 s->ch_mode = fi.ch_mode;
476 if (!s->bps && !fi.bps) {
477 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
482 } else if (s->bps && fi.bps != s->bps) {
483 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
487 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
490 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
491 s->sample_shift = 32 - s->bps;
494 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
495 s->sample_shift = 16 - s->bps;
499 if (!s->max_blocksize)
500 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
501 if (fi.blocksize > s->max_blocksize) {
502 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
506 s->blocksize = fi.blocksize;
508 if (!s->samplerate && !fi.samplerate) {
509 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
510 " or frame header\n");
513 if (fi.samplerate == 0) {
514 fi.samplerate = s->samplerate;
515 } else if (s->samplerate && fi.samplerate != s->samplerate) {
516 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
517 s->samplerate, fi.samplerate);
519 s->samplerate = s->avctx->sample_rate = fi.samplerate;
521 if (!s->got_streaminfo) {
523 s->got_streaminfo = 1;
524 dump_headers(s->avctx, (FLACStreaminfo *)s);
527 // dump_headers(s->avctx, (FLACStreaminfo *)s);
530 for (i = 0; i < s->channels; i++) {
531 if (decode_subframe(s, i) < 0)
538 skip_bits(gb, 16); /* data crc */
543 static int flac_decode_frame(AVCodecContext *avctx,
544 void *data, int *data_size,
547 const uint8_t *buf = avpkt->data;
548 int buf_size = avpkt->size;
549 FLACContext *s = avctx->priv_data;
550 int i, j = 0, bytes_read = 0;
551 int16_t *samples_16 = data;
552 int32_t *samples_32 = data;
553 int alloc_data_size= *data_size;
558 if (s->max_framesize == 0) {
560 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
561 FLAC_MAX_CHANNELS, 32);
564 /* check that there is at least the smallest decodable amount of data.
565 this amount corresponds to the smallest valid FLAC frame possible.
566 FF F8 69 02 00 00 9A 00 00 34 46 */
567 if (buf_size < FLAC_MIN_FRAME_SIZE)
570 /* check for inline header */
571 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
572 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
573 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
576 return get_metadata_size(buf, buf_size);
580 init_get_bits(&s->gb, buf, buf_size*8);
581 if (decode_frame(s) < 0) {
582 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
585 bytes_read = (get_bits_count(&s->gb)+7)/8;
587 /* check if allocated data size is large enough for output */
588 output_size = s->blocksize * s->channels * (s->is32 ? 4 : 2);
589 if (output_size > alloc_data_size) {
590 av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
591 "allocated data size\n");
594 *data_size = output_size;
596 #define DECORRELATE(left, right)\
597 assert(s->channels == 2);\
598 for (i = 0; i < s->blocksize; i++) {\
599 int a= s->decoded[0][i];\
600 int b= s->decoded[1][i];\
602 *samples_32++ = (left) << s->sample_shift;\
603 *samples_32++ = (right) << s->sample_shift;\
605 *samples_16++ = (left) << s->sample_shift;\
606 *samples_16++ = (right) << s->sample_shift;\
611 switch (s->ch_mode) {
612 case FLAC_CHMODE_INDEPENDENT:
613 for (j = 0; j < s->blocksize; j++) {
614 for (i = 0; i < s->channels; i++) {
616 *samples_32++ = s->decoded[i][j] << s->sample_shift;
618 *samples_16++ = s->decoded[i][j] << s->sample_shift;
622 case FLAC_CHMODE_LEFT_SIDE:
624 case FLAC_CHMODE_RIGHT_SIDE:
626 case FLAC_CHMODE_MID_SIDE:
627 DECORRELATE( (a-=b>>1) + b, a)
630 if (bytes_read > buf_size) {
631 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
634 if (bytes_read < buf_size) {
635 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
636 buf_size - bytes_read, buf_size);
642 static av_cold int flac_decode_close(AVCodecContext *avctx)
644 FLACContext *s = avctx->priv_data;
647 for (i = 0; i < s->channels; i++) {
648 av_freep(&s->decoded[i]);
654 AVCodec ff_flac_decoder = {
656 .type = AVMEDIA_TYPE_AUDIO,
658 .priv_data_size = sizeof(FLACContext),
659 .init = flac_decode_init,
660 .close = flac_decode_close,
661 .decode = flac_decode_frame,
662 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),