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 avpriv_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 (!avpriv_flac_is_extradata_valid(avctx, &format, &streaminfo))
110 /* initialize based on the demuxer-supplied streamdata header */
111 avpriv_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 avpriv_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 avpriv_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 avpriv_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 avpriv_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 if (buf_end - buf < 4)
231 avpriv_flac_parse_block_header(buf, &metadata_last, NULL, &metadata_size);
233 if (buf_end - buf < metadata_size) {
234 /* need more data in order to read the complete header */
237 buf += metadata_size;
238 } while (!metadata_last);
240 return buf_size - (buf_end - buf);
243 static int decode_residuals(FLACContext *s, int channel, int pred_order)
245 int i, tmp, partition, method_type, rice_order;
246 int sample = 0, samples;
248 method_type = get_bits(&s->gb, 2);
249 if (method_type > 1) {
250 av_log(s->avctx, AV_LOG_ERROR, "illegal residual coding method %d\n",
255 rice_order = get_bits(&s->gb, 4);
257 samples= s->blocksize >> rice_order;
258 if (pred_order > samples) {
259 av_log(s->avctx, AV_LOG_ERROR, "invalid predictor order: %i > %i\n",
260 pred_order, samples);
266 for (partition = 0; partition < (1 << rice_order); partition++) {
267 tmp = get_bits(&s->gb, method_type == 0 ? 4 : 5);
268 if (tmp == (method_type == 0 ? 15 : 31)) {
269 tmp = get_bits(&s->gb, 5);
270 for (; i < samples; i++, sample++)
271 s->decoded[channel][sample] = get_sbits_long(&s->gb, tmp);
273 for (; i < samples; i++, sample++) {
274 s->decoded[channel][sample] = get_sr_golomb_flac(&s->gb, tmp, INT_MAX, 0);
283 static int decode_subframe_fixed(FLACContext *s, int channel, int pred_order)
285 const int blocksize = s->blocksize;
286 int32_t *decoded = s->decoded[channel];
287 int av_uninit(a), av_uninit(b), av_uninit(c), av_uninit(d), i;
289 /* warm up samples */
290 for (i = 0; i < pred_order; i++) {
291 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
294 if (decode_residuals(s, channel, pred_order) < 0)
298 a = decoded[pred_order-1];
300 b = a - decoded[pred_order-2];
302 c = b - decoded[pred_order-2] + decoded[pred_order-3];
304 d = c - decoded[pred_order-2] + 2*decoded[pred_order-3] - decoded[pred_order-4];
306 switch (pred_order) {
310 for (i = pred_order; i < blocksize; i++)
311 decoded[i] = a += decoded[i];
314 for (i = pred_order; i < blocksize; i++)
315 decoded[i] = a += b += decoded[i];
318 for (i = pred_order; i < blocksize; i++)
319 decoded[i] = a += b += c += decoded[i];
322 for (i = pred_order; i < blocksize; i++)
323 decoded[i] = a += b += c += d += decoded[i];
326 av_log(s->avctx, AV_LOG_ERROR, "illegal pred order %d\n", pred_order);
333 static int decode_subframe_lpc(FLACContext *s, int channel, int pred_order)
336 int coeff_prec, qlevel;
338 int32_t *decoded = s->decoded[channel];
340 /* warm up samples */
341 for (i = 0; i < pred_order; i++) {
342 decoded[i] = get_sbits_long(&s->gb, s->curr_bps);
345 coeff_prec = get_bits(&s->gb, 4) + 1;
346 if (coeff_prec == 16) {
347 av_log(s->avctx, AV_LOG_ERROR, "invalid coeff precision\n");
350 qlevel = get_sbits(&s->gb, 5);
352 av_log(s->avctx, AV_LOG_ERROR, "qlevel %d not supported, maybe buggy stream\n",
357 for (i = 0; i < pred_order; i++) {
358 coeffs[i] = get_sbits(&s->gb, coeff_prec);
361 if (decode_residuals(s, channel, pred_order) < 0)
366 for (i = pred_order; i < s->blocksize; i++) {
368 for (j = 0; j < pred_order; j++)
369 sum += (int64_t)coeffs[j] * decoded[i-j-1];
370 decoded[i] += sum >> qlevel;
373 for (i = pred_order; i < s->blocksize-1; i += 2) {
375 int d = decoded[i-pred_order];
377 for (j = pred_order-1; j > 0; j--) {
385 d = decoded[i] += s0 >> qlevel;
387 decoded[i+1] += s1 >> qlevel;
389 if (i < s->blocksize) {
391 for (j = 0; j < pred_order; j++)
392 sum += coeffs[j] * decoded[i-j-1];
393 decoded[i] += sum >> qlevel;
400 static inline int decode_subframe(FLACContext *s, int channel)
402 int type, wasted = 0;
405 s->curr_bps = s->bps;
407 if (s->ch_mode == FLAC_CHMODE_RIGHT_SIDE)
410 if (s->ch_mode == FLAC_CHMODE_LEFT_SIDE || s->ch_mode == FLAC_CHMODE_MID_SIDE)
414 if (get_bits1(&s->gb)) {
415 av_log(s->avctx, AV_LOG_ERROR, "invalid subframe padding\n");
418 type = get_bits(&s->gb, 6);
420 if (get_bits1(&s->gb)) {
422 while (!get_bits1(&s->gb))
424 s->curr_bps -= wasted;
426 if (s->curr_bps > 32) {
427 av_log_missing_feature(s->avctx, "decorrelated bit depth > 32", 0);
431 //FIXME use av_log2 for types
433 tmp = get_sbits_long(&s->gb, s->curr_bps);
434 for (i = 0; i < s->blocksize; i++)
435 s->decoded[channel][i] = tmp;
436 } else if (type == 1) {
437 for (i = 0; i < s->blocksize; i++)
438 s->decoded[channel][i] = get_sbits_long(&s->gb, s->curr_bps);
439 } else if ((type >= 8) && (type <= 12)) {
440 if (decode_subframe_fixed(s, channel, type & ~0x8) < 0)
442 } else if (type >= 32) {
443 if (decode_subframe_lpc(s, channel, (type & ~0x20)+1) < 0)
446 av_log(s->avctx, AV_LOG_ERROR, "invalid coding type\n");
452 for (i = 0; i < s->blocksize; i++)
453 s->decoded[channel][i] <<= wasted;
459 static int decode_frame(FLACContext *s)
462 GetBitContext *gb = &s->gb;
465 if (ff_flac_decode_frame_header(s->avctx, gb, &fi, 0)) {
466 av_log(s->avctx, AV_LOG_ERROR, "invalid frame header\n");
470 if (s->channels && fi.channels != s->channels) {
471 av_log(s->avctx, AV_LOG_ERROR, "switching channel layout mid-stream "
472 "is not supported\n");
475 s->channels = s->avctx->channels = fi.channels;
476 s->ch_mode = fi.ch_mode;
478 if (!s->bps && !fi.bps) {
479 av_log(s->avctx, AV_LOG_ERROR, "bps not found in STREAMINFO or frame header\n");
484 } else if (s->bps && fi.bps != s->bps) {
485 av_log(s->avctx, AV_LOG_ERROR, "switching bps mid-stream is not "
489 s->bps = s->avctx->bits_per_raw_sample = fi.bps;
492 s->avctx->sample_fmt = AV_SAMPLE_FMT_S32;
493 s->sample_shift = 32 - s->bps;
496 s->avctx->sample_fmt = AV_SAMPLE_FMT_S16;
497 s->sample_shift = 16 - s->bps;
501 if (!s->max_blocksize)
502 s->max_blocksize = FLAC_MAX_BLOCKSIZE;
503 if (fi.blocksize > s->max_blocksize) {
504 av_log(s->avctx, AV_LOG_ERROR, "blocksize %d > %d\n", fi.blocksize,
508 s->blocksize = fi.blocksize;
510 if (!s->samplerate && !fi.samplerate) {
511 av_log(s->avctx, AV_LOG_ERROR, "sample rate not found in STREAMINFO"
512 " or frame header\n");
515 if (fi.samplerate == 0) {
516 fi.samplerate = s->samplerate;
517 } else if (s->samplerate && fi.samplerate != s->samplerate) {
518 av_log(s->avctx, AV_LOG_WARNING, "sample rate changed from %d to %d\n",
519 s->samplerate, fi.samplerate);
521 s->samplerate = s->avctx->sample_rate = fi.samplerate;
523 if (!s->got_streaminfo) {
525 s->got_streaminfo = 1;
526 dump_headers(s->avctx, (FLACStreaminfo *)s);
529 // dump_headers(s->avctx, (FLACStreaminfo *)s);
532 for (i = 0; i < s->channels; i++) {
533 if (decode_subframe(s, i) < 0)
540 skip_bits(gb, 16); /* data crc */
545 static int flac_decode_frame(AVCodecContext *avctx,
546 void *data, int *data_size,
549 const uint8_t *buf = avpkt->data;
550 int buf_size = avpkt->size;
551 FLACContext *s = avctx->priv_data;
552 int i, j = 0, bytes_read = 0;
553 int16_t *samples_16 = data;
554 int32_t *samples_32 = data;
555 int alloc_data_size= *data_size;
560 if (s->max_framesize == 0) {
562 ff_flac_get_max_frame_size(s->max_blocksize ? s->max_blocksize : FLAC_MAX_BLOCKSIZE,
563 FLAC_MAX_CHANNELS, 32);
566 /* check that there is at least the smallest decodable amount of data.
567 this amount corresponds to the smallest valid FLAC frame possible.
568 FF F8 69 02 00 00 9A 00 00 34 46 */
569 if (buf_size < FLAC_MIN_FRAME_SIZE)
572 /* check for inline header */
573 if (AV_RB32(buf) == MKBETAG('f','L','a','C')) {
574 if (!s->got_streaminfo && parse_streaminfo(s, buf, buf_size)) {
575 av_log(s->avctx, AV_LOG_ERROR, "invalid header\n");
578 return get_metadata_size(buf, buf_size);
582 init_get_bits(&s->gb, buf, buf_size*8);
583 if (decode_frame(s) < 0) {
584 av_log(s->avctx, AV_LOG_ERROR, "decode_frame() failed\n");
587 bytes_read = (get_bits_count(&s->gb)+7)/8;
589 /* check if allocated data size is large enough for output */
590 output_size = s->blocksize * s->channels *
591 av_get_bytes_per_sample(avctx->sample_fmt);
592 if (output_size > alloc_data_size) {
593 av_log(s->avctx, AV_LOG_ERROR, "output data size is larger than "
594 "allocated data size\n");
597 *data_size = output_size;
599 #define DECORRELATE(left, right)\
600 assert(s->channels == 2);\
601 for (i = 0; i < s->blocksize; i++) {\
602 int a= s->decoded[0][i];\
603 int b= s->decoded[1][i];\
605 *samples_32++ = (left) << s->sample_shift;\
606 *samples_32++ = (right) << s->sample_shift;\
608 *samples_16++ = (left) << s->sample_shift;\
609 *samples_16++ = (right) << s->sample_shift;\
614 switch (s->ch_mode) {
615 case FLAC_CHMODE_INDEPENDENT:
616 for (j = 0; j < s->blocksize; j++) {
617 for (i = 0; i < s->channels; i++) {
619 *samples_32++ = s->decoded[i][j] << s->sample_shift;
621 *samples_16++ = s->decoded[i][j] << s->sample_shift;
625 case FLAC_CHMODE_LEFT_SIDE:
627 case FLAC_CHMODE_RIGHT_SIDE:
629 case FLAC_CHMODE_MID_SIDE:
630 DECORRELATE( (a-=b>>1) + b, a)
633 if (bytes_read > buf_size) {
634 av_log(s->avctx, AV_LOG_ERROR, "overread: %d\n", bytes_read - buf_size);
637 if (bytes_read < buf_size) {
638 av_log(s->avctx, AV_LOG_DEBUG, "underread: %d orig size: %d\n",
639 buf_size - bytes_read, buf_size);
645 static av_cold int flac_decode_close(AVCodecContext *avctx)
647 FLACContext *s = avctx->priv_data;
650 for (i = 0; i < s->channels; i++) {
651 av_freep(&s->decoded[i]);
657 AVCodec ff_flac_decoder = {
659 .type = AVMEDIA_TYPE_AUDIO,
661 .priv_data_size = sizeof(FLACContext),
662 .init = flac_decode_init,
663 .close = flac_decode_close,
664 .decode = flac_decode_frame,
665 .long_name= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),