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"
50 typedef struct FLACContext
{
53 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
67 static const int64_t flac_channel_layouts
[6] = {
70 AV_CH_LAYOUT_SURROUND
,
76 static void allocate_buffers(FLACContext
*s
);
78 int avpriv_flac_is_extradata_valid(AVCodecContext
*avctx
,
79 enum FLACExtradataFormat
*format
,
80 uint8_t **streaminfo_start
)
82 if (!avctx
->extradata
|| avctx
->extradata_size
< FLAC_STREAMINFO_SIZE
) {
83 av_log(avctx
, AV_LOG_ERROR
, "extradata NULL or too small.\n");
86 if (AV_RL32(avctx
->extradata
) != MKTAG('f','L','a','C')) {
87 /* extradata contains STREAMINFO only */
88 if (avctx
->extradata_size
!= FLAC_STREAMINFO_SIZE
) {
89 av_log(avctx
, AV_LOG_WARNING
, "extradata contains %d bytes too many.\n",
90 FLAC_STREAMINFO_SIZE
-avctx
->extradata_size
);
92 *format
= FLAC_EXTRADATA_FORMAT_STREAMINFO
;
93 *streaminfo_start
= avctx
->extradata
;
95 if (avctx
->extradata_size
< 8+FLAC_STREAMINFO_SIZE
) {
96 av_log(avctx
, AV_LOG_ERROR
, "extradata too small.\n");
99 *format
= FLAC_EXTRADATA_FORMAT_FULL_HEADER
;
100 *streaminfo_start
= &avctx
->extradata
[8];
105 static void flac_set_bps(FLACContext
*s
)
108 s
->avctx
->sample_fmt
= AV_SAMPLE_FMT_S32
;
109 s
->sample_shift
= 32 - s
->bps
;
111 s
->avctx
->sample_fmt
= AV_SAMPLE_FMT_S16
;
112 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 ff_flacdsp_init(&s
->dsp
, avctx
->sample_fmt
);
136 s
->got_streaminfo
= 1;
138 avcodec_get_frame_defaults(&s
->frame
);
139 avctx
->coded_frame
= &s
->frame
;
141 if (avctx
->channels
<= FF_ARRAY_ELEMS(flac_channel_layouts
))
142 avctx
->channel_layout
= flac_channel_layouts
[avctx
->channels
- 1];
147 static void dump_headers(AVCodecContext
*avctx
, FLACStreaminfo
*s
)
149 av_log(avctx
, AV_LOG_DEBUG
, " Max Blocksize: %d\n", s
->max_blocksize
);
150 av_log(avctx
, AV_LOG_DEBUG
, " Max Framesize: %d\n", s
->max_framesize
);
151 av_log(avctx
, AV_LOG_DEBUG
, " Samplerate: %d\n", s
->samplerate
);
152 av_log(avctx
, AV_LOG_DEBUG
, " Channels: %d\n", s
->channels
);
153 av_log(avctx
, AV_LOG_DEBUG
, " Bits: %d\n", s
->bps
);
156 static void allocate_buffers(FLACContext
*s
)
160 assert(s
->max_blocksize
);
162 for (i
= 0; i
< s
->channels
; i
++) {
163 s
->decoded
[i
] = av_malloc(sizeof(int32_t)*s
->max_blocksize
);
167 void avpriv_flac_parse_streaminfo(AVCodecContext
*avctx
, struct FLACStreaminfo
*s
,
168 const uint8_t *buffer
)
171 init_get_bits(&gb
, buffer
, FLAC_STREAMINFO_SIZE
*8);
173 skip_bits(&gb
, 16); /* skip min blocksize */
174 s
->max_blocksize
= get_bits(&gb
, 16);
175 if (s
->max_blocksize
< FLAC_MIN_BLOCKSIZE
) {
176 av_log(avctx
, AV_LOG_WARNING
, "invalid max blocksize: %d\n",
178 s
->max_blocksize
= 16;
181 skip_bits(&gb
, 24); /* skip min frame size */
182 s
->max_framesize
= get_bits_long(&gb
, 24);
184 s
->samplerate
= get_bits_long(&gb
, 20);
185 s
->channels
= get_bits(&gb
, 3) + 1;
186 s
->bps
= get_bits(&gb
, 5) + 1;
188 avctx
->channels
= s
->channels
;
189 avctx
->sample_rate
= s
->samplerate
;
190 avctx
->bits_per_raw_sample
= s
->bps
;
192 s
->samples
= get_bits_long(&gb
, 32) << 4;
193 s
->samples
|= get_bits(&gb
, 4);
195 skip_bits_long(&gb
, 64); /* md5 sum */
196 skip_bits_long(&gb
, 64); /* md5 sum */
198 dump_headers(avctx
, s
);
201 void avpriv_flac_parse_block_header(const uint8_t *block_header
,
202 int *last
, int *type
, int *size
)
204 int tmp
= bytestream_get_byte(&block_header
);
210 *size
= bytestream_get_be24(&block_header
);
214 * Parse the STREAMINFO from an inline header.
215 * @param s the flac decoding context
216 * @param buf input buffer, starting with the "fLaC" marker
217 * @param buf_size buffer size
218 * @return non-zero if metadata is invalid
220 static int parse_streaminfo(FLACContext
*s
, const uint8_t *buf
, int buf_size
)
222 int metadata_type
, metadata_size
;
224 if (buf_size
< FLAC_STREAMINFO_SIZE
+8) {
228 avpriv_flac_parse_block_header(&buf
[4], NULL
, &metadata_type
, &metadata_size
);
229 if (metadata_type
!= FLAC_METADATA_TYPE_STREAMINFO
||
230 metadata_size
!= FLAC_STREAMINFO_SIZE
) {
231 return AVERROR_INVALIDDATA
;
233 avpriv_flac_parse_streaminfo(s
->avctx
, (FLACStreaminfo
*)s
, &buf
[8]);
236 ff_flacdsp_init(&s
->dsp
, s
->avctx
->sample_fmt
);
237 s
->got_streaminfo
= 1;
243 * Determine the size of an inline header.
244 * @param buf input buffer, starting with the "fLaC" marker
245 * @param buf_size buffer size
246 * @return number of bytes in the header, or 0 if more data is needed
248 static int get_metadata_size(const uint8_t *buf
, int buf_size
)
250 int metadata_last
, metadata_size
;
251 const uint8_t *buf_end
= buf
+ buf_size
;
255 if (buf_end
- buf
< 4)
257 avpriv_flac_parse_block_header(buf
, &metadata_last
, NULL
, &metadata_size
);
259 if (buf_end
- buf
< metadata_size
) {
260 /* need more data in order to read the complete header */
263 buf
+= metadata_size
;
264 } while (!metadata_last
);
266 return buf_size
- (buf_end
- buf
);
269 static int decode_residuals(FLACContext
*s
, int channel
, int pred_order
)
271 int i
, tmp
, partition
, method_type
, rice_order
;
272 int sample
= 0, samples
;
274 method_type
= get_bits(&s
->gb
, 2);
275 if (method_type
> 1) {
276 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal residual coding method %d\n",
281 rice_order
= get_bits(&s
->gb
, 4);
283 samples
= s
->blocksize
>> rice_order
;
284 if (pred_order
> samples
) {
285 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid predictor order: %i > %i\n",
286 pred_order
, samples
);
292 for (partition
= 0; partition
< (1 << rice_order
); partition
++) {
293 tmp
= get_bits(&s
->gb
, method_type
== 0 ?
4 : 5);
294 if (tmp
== (method_type
== 0 ?
15 : 31)) {
295 tmp
= get_bits(&s
->gb
, 5);
296 for (; i
< samples
; i
++, sample
++)
297 s
->decoded
[channel
][sample
] = get_sbits_long(&s
->gb
, tmp
);
299 for (; i
< samples
; i
++, sample
++) {
300 s
->decoded
[channel
][sample
] = get_sr_golomb_flac(&s
->gb
, tmp
, INT_MAX
, 0);
309 static int decode_subframe_fixed(FLACContext
*s
, int channel
, int pred_order
,
312 const int blocksize
= s
->blocksize
;
313 int32_t *decoded
= s
->decoded
[channel
];
316 /* warm up samples */
317 for (i
= 0; i
< pred_order
; i
++) {
318 decoded
[i
] = get_sbits_long(&s
->gb
, bps
);
321 if (decode_residuals(s
, channel
, pred_order
) < 0)
325 a
= decoded
[pred_order
-1];
327 b
= a
- decoded
[pred_order
-2];
329 c
= b
- decoded
[pred_order
-2] + decoded
[pred_order
-3];
331 d
= c
- decoded
[pred_order
-2] + 2*decoded
[pred_order
-3] - decoded
[pred_order
-4];
333 switch (pred_order
) {
337 for (i
= pred_order
; i
< blocksize
; i
++)
338 decoded
[i
] = a
+= decoded
[i
];
341 for (i
= pred_order
; i
< blocksize
; i
++)
342 decoded
[i
] = a
+= b
+= decoded
[i
];
345 for (i
= pred_order
; i
< blocksize
; i
++)
346 decoded
[i
] = a
+= b
+= c
+= decoded
[i
];
349 for (i
= pred_order
; i
< blocksize
; i
++)
350 decoded
[i
] = a
+= b
+= c
+= d
+= decoded
[i
];
353 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal pred order %d\n", pred_order
);
360 static int decode_subframe_lpc(FLACContext
*s
, int channel
, int pred_order
,
364 int coeff_prec
, qlevel
;
366 int32_t *decoded
= s
->decoded
[channel
];
368 /* warm up samples */
369 for (i
= 0; i
< pred_order
; i
++) {
370 decoded
[i
] = get_sbits_long(&s
->gb
, bps
);
373 coeff_prec
= get_bits(&s
->gb
, 4) + 1;
374 if (coeff_prec
== 16) {
375 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coeff precision\n");
378 qlevel
= get_sbits(&s
->gb
, 5);
380 av_log(s
->avctx
, AV_LOG_ERROR
, "qlevel %d not supported, maybe buggy stream\n",
385 for (i
= 0; i
< pred_order
; i
++) {
386 coeffs
[i
] = get_sbits(&s
->gb
, coeff_prec
);
389 if (decode_residuals(s
, channel
, pred_order
) < 0)
394 for (i
= pred_order
; i
< s
->blocksize
; i
++) {
396 for (j
= 0; j
< pred_order
; j
++)
397 sum
+= (int64_t)coeffs
[j
] * decoded
[i
-j
-1];
398 decoded
[i
] += sum
>> qlevel
;
401 for (i
= pred_order
; i
< s
->blocksize
-1; i
+= 2) {
403 int d
= decoded
[i
-pred_order
];
405 for (j
= pred_order
-1; j
> 0; j
--) {
413 d
= decoded
[i
] += s0
>> qlevel
;
415 decoded
[i
+1] += s1
>> qlevel
;
417 if (i
< s
->blocksize
) {
419 for (j
= 0; j
< pred_order
; j
++)
420 sum
+= coeffs
[j
] * decoded
[i
-j
-1];
421 decoded
[i
] += sum
>> qlevel
;
428 static inline int decode_subframe(FLACContext
*s
, int channel
)
430 int type
, wasted
= 0;
435 if (s
->ch_mode
== FLAC_CHMODE_RIGHT_SIDE
)
438 if (s
->ch_mode
== FLAC_CHMODE_LEFT_SIDE
|| s
->ch_mode
== FLAC_CHMODE_MID_SIDE
)
442 if (get_bits1(&s
->gb
)) {
443 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid subframe padding\n");
446 type
= get_bits(&s
->gb
, 6);
448 if (get_bits1(&s
->gb
)) {
449 int left
= get_bits_left(&s
->gb
);
452 (left
< bps
&& !show_bits_long(&s
->gb
, left
)) ||
453 !show_bits_long(&s
->gb
, bps
)) {
454 av_log(s
->avctx
, AV_LOG_ERROR
,
455 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
457 return AVERROR_INVALIDDATA
;
459 while (!get_bits1(&s
->gb
))
464 av_log_missing_feature(s
->avctx
, "decorrelated bit depth > 32", 0);
468 //FIXME use av_log2 for types
470 tmp
= get_sbits_long(&s
->gb
, bps
);
471 for (i
= 0; i
< s
->blocksize
; i
++)
472 s
->decoded
[channel
][i
] = tmp
;
473 } else if (type
== 1) {
474 for (i
= 0; i
< s
->blocksize
; i
++)
475 s
->decoded
[channel
][i
] = get_sbits_long(&s
->gb
, bps
);
476 } else if ((type
>= 8) && (type
<= 12)) {
477 if (decode_subframe_fixed(s
, channel
, type
& ~0x8, bps
) < 0)
479 } else if (type
>= 32) {
480 if (decode_subframe_lpc(s
, channel
, (type
& ~0x20)+1, bps
) < 0)
483 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coding type\n");
489 for (i
= 0; i
< s
->blocksize
; i
++)
490 s
->decoded
[channel
][i
] <<= wasted
;
496 static int decode_frame(FLACContext
*s
)
499 GetBitContext
*gb
= &s
->gb
;
502 if (ff_flac_decode_frame_header(s
->avctx
, gb
, &fi
, 0)) {
503 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid frame header\n");
507 if (s
->channels
&& fi
.channels
!= s
->channels
) {
508 av_log(s
->avctx
, AV_LOG_ERROR
, "switching channel layout mid-stream "
509 "is not supported\n");
512 s
->channels
= s
->avctx
->channels
= fi
.channels
;
513 s
->ch_mode
= fi
.ch_mode
;
515 if (!s
->bps
&& !fi
.bps
) {
516 av_log(s
->avctx
, AV_LOG_ERROR
, "bps not found in STREAMINFO or frame header\n");
521 } else if (s
->bps
&& fi
.bps
!= s
->bps
) {
522 av_log(s
->avctx
, AV_LOG_ERROR
, "switching bps mid-stream is not "
526 s
->bps
= s
->avctx
->bits_per_raw_sample
= fi
.bps
;
530 if (!s
->max_blocksize
)
531 s
->max_blocksize
= FLAC_MAX_BLOCKSIZE
;
532 if (fi
.blocksize
> s
->max_blocksize
) {
533 av_log(s
->avctx
, AV_LOG_ERROR
, "blocksize %d > %d\n", fi
.blocksize
,
537 s
->blocksize
= fi
.blocksize
;
539 if (!s
->samplerate
&& !fi
.samplerate
) {
540 av_log(s
->avctx
, AV_LOG_ERROR
, "sample rate not found in STREAMINFO"
541 " or frame header\n");
544 if (fi
.samplerate
== 0) {
545 fi
.samplerate
= s
->samplerate
;
546 } else if (s
->samplerate
&& fi
.samplerate
!= s
->samplerate
) {
547 av_log(s
->avctx
, AV_LOG_WARNING
, "sample rate changed from %d to %d\n",
548 s
->samplerate
, fi
.samplerate
);
550 s
->samplerate
= s
->avctx
->sample_rate
= fi
.samplerate
;
552 if (!s
->got_streaminfo
) {
554 ff_flacdsp_init(&s
->dsp
, s
->avctx
->sample_fmt
);
555 s
->got_streaminfo
= 1;
556 dump_headers(s
->avctx
, (FLACStreaminfo
*)s
);
559 // dump_headers(s->avctx, (FLACStreaminfo *)s);
562 for (i
= 0; i
< s
->channels
; i
++) {
563 if (decode_subframe(s
, i
) < 0)
570 skip_bits(gb
, 16); /* data crc */
575 static int flac_decode_frame(AVCodecContext
*avctx
, void *data
,
576 int *got_frame_ptr
, AVPacket
*avpkt
)
578 const uint8_t *buf
= avpkt
->data
;
579 int buf_size
= avpkt
->size
;
580 FLACContext
*s
= avctx
->priv_data
;
586 if (s
->max_framesize
== 0) {
588 ff_flac_get_max_frame_size(s
->max_blocksize ? s
->max_blocksize
: FLAC_MAX_BLOCKSIZE
,
589 FLAC_MAX_CHANNELS
, 32);
592 /* check that there is at least the smallest decodable amount of data.
593 this amount corresponds to the smallest valid FLAC frame possible.
594 FF F8 69 02 00 00 9A 00 00 34 46 */
595 if (buf_size
< FLAC_MIN_FRAME_SIZE
)
598 /* check for inline header */
599 if (AV_RB32(buf
) == MKBETAG('f','L','a','C')) {
600 if (!s
->got_streaminfo
&& parse_streaminfo(s
, buf
, buf_size
)) {
601 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid header\n");
604 return get_metadata_size(buf
, buf_size
);
608 init_get_bits(&s
->gb
, buf
, buf_size
*8);
609 if (decode_frame(s
) < 0) {
610 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_frame() failed\n");
613 bytes_read
= (get_bits_count(&s
->gb
)+7)/8;
615 /* get output buffer */
616 s
->frame
.nb_samples
= s
->blocksize
;
617 if ((ret
= avctx
->get_buffer(avctx
, &s
->frame
)) < 0) {
618 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
622 s
->dsp
.decorrelate
[s
->ch_mode
](s
->frame
.data
, s
->decoded
, s
->channels
,
623 s
->blocksize
, s
->sample_shift
);
625 if (bytes_read
> buf_size
) {
626 av_log(s
->avctx
, AV_LOG_ERROR
, "overread: %d\n", bytes_read
- buf_size
);
629 if (bytes_read
< buf_size
) {
630 av_log(s
->avctx
, AV_LOG_DEBUG
, "underread: %d orig size: %d\n",
631 buf_size
- bytes_read
, buf_size
);
635 *(AVFrame
*)data
= s
->frame
;
640 static av_cold
int flac_decode_close(AVCodecContext
*avctx
)
642 FLACContext
*s
= avctx
->priv_data
;
645 for (i
= 0; i
< s
->channels
; i
++) {
646 av_freep(&s
->decoded
[i
]);
652 AVCodec ff_flac_decoder
= {
654 .type
= AVMEDIA_TYPE_AUDIO
,
656 .priv_data_size
= sizeof(FLACContext
),
657 .init
= flac_decode_init
,
658 .close
= flac_decode_close
,
659 .decode
= flac_decode_frame
,
660 .capabilities
= CODEC_CAP_DR1
,
661 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),