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
)
135 av_assert0(s
->max_blocksize
);
137 buf_size
= av_samples_get_buffer_size(NULL
, s
->channels
, s
->max_blocksize
,
138 AV_SAMPLE_FMT_S32P
, 0);
142 av_fast_malloc(&s
->decoded_buffer
, &s
->decoded_buffer_size
, buf_size
);
143 if (!s
->decoded_buffer
)
144 return AVERROR(ENOMEM
);
146 ret
= av_samples_fill_arrays((uint8_t **)s
->decoded
, NULL
,
147 s
->decoded_buffer
, s
->channels
,
148 s
->max_blocksize
, AV_SAMPLE_FMT_S32P
, 0);
149 return ret
< 0 ? ret
: 0;
153 * Parse the STREAMINFO from an inline header.
154 * @param s the flac decoding context
155 * @param buf input buffer, starting with the "fLaC" marker
156 * @param buf_size buffer size
157 * @return non-zero if metadata is invalid
159 static int parse_streaminfo(FLACContext
*s
, const uint8_t *buf
, int buf_size
)
161 int metadata_type
, metadata_size
, ret
;
163 if (buf_size
< FLAC_STREAMINFO_SIZE
+8) {
167 flac_parse_block_header(&buf
[4], NULL
, &metadata_type
, &metadata_size
);
168 if (metadata_type
!= FLAC_METADATA_TYPE_STREAMINFO
||
169 metadata_size
!= FLAC_STREAMINFO_SIZE
) {
170 return AVERROR_INVALIDDATA
;
172 avpriv_flac_parse_streaminfo(s
->avctx
, (FLACStreaminfo
*)s
, &buf
[8]);
173 ret
= allocate_buffers(s
);
177 ff_flacdsp_init(&s
->dsp
, s
->avctx
->sample_fmt
, s
->bps
);
178 s
->got_streaminfo
= 1;
184 * Determine the size of an inline header.
185 * @param buf input buffer, starting with the "fLaC" marker
186 * @param buf_size buffer size
187 * @return number of bytes in the header, or 0 if more data is needed
189 static int get_metadata_size(const uint8_t *buf
, int buf_size
)
191 int metadata_last
, metadata_size
;
192 const uint8_t *buf_end
= buf
+ buf_size
;
196 if (buf_end
- buf
< 4)
198 flac_parse_block_header(buf
, &metadata_last
, NULL
, &metadata_size
);
200 if (buf_end
- buf
< metadata_size
) {
201 /* need more data in order to read the complete header */
204 buf
+= metadata_size
;
205 } while (!metadata_last
);
207 return buf_size
- (buf_end
- buf
);
210 static int decode_residuals(FLACContext
*s
, int32_t *decoded
, int pred_order
)
212 int i
, tmp
, partition
, method_type
, rice_order
;
213 int rice_bits
, rice_esc
;
216 method_type
= get_bits(&s
->gb
, 2);
217 if (method_type
> 1) {
218 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal residual coding method %d\n",
220 return AVERROR_INVALIDDATA
;
223 rice_order
= get_bits(&s
->gb
, 4);
225 samples
= s
->blocksize
>> rice_order
;
226 if (samples
<< rice_order
!= s
->blocksize
) {
227 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid rice order: %i blocksize %i\n",
228 rice_order
, s
->blocksize
);
229 return AVERROR_INVALIDDATA
;
232 if (pred_order
> samples
) {
233 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid predictor order: %i > %i\n",
234 pred_order
, samples
);
235 return AVERROR_INVALIDDATA
;
238 rice_bits
= 4 + method_type
;
239 rice_esc
= (1 << rice_bits
) - 1;
241 decoded
+= pred_order
;
243 for (partition
= 0; partition
< (1 << rice_order
); partition
++) {
244 tmp
= get_bits(&s
->gb
, rice_bits
);
245 if (tmp
== rice_esc
) {
246 tmp
= get_bits(&s
->gb
, 5);
247 for (; i
< samples
; i
++)
248 *decoded
++ = get_sbits_long(&s
->gb
, tmp
);
250 for (; i
< samples
; i
++) {
251 *decoded
++ = get_sr_golomb_flac(&s
->gb
, tmp
, INT_MAX
, 0);
260 static int decode_subframe_fixed(FLACContext
*s
, int32_t *decoded
,
261 int pred_order
, int bps
)
263 const int blocksize
= s
->blocksize
;
264 int av_uninit(a
), av_uninit(b
), av_uninit(c
), av_uninit(d
), i
;
267 /* warm up samples */
268 for (i
= 0; i
< pred_order
; i
++) {
269 decoded
[i
] = get_sbits_long(&s
->gb
, bps
);
272 if ((ret
= decode_residuals(s
, decoded
, pred_order
)) < 0)
276 a
= decoded
[pred_order
-1];
278 b
= a
- decoded
[pred_order
-2];
280 c
= b
- decoded
[pred_order
-2] + decoded
[pred_order
-3];
282 d
= c
- decoded
[pred_order
-2] + 2*decoded
[pred_order
-3] - decoded
[pred_order
-4];
284 switch (pred_order
) {
288 for (i
= pred_order
; i
< blocksize
; i
++)
289 decoded
[i
] = a
+= decoded
[i
];
292 for (i
= pred_order
; i
< blocksize
; i
++)
293 decoded
[i
] = a
+= b
+= decoded
[i
];
296 for (i
= pred_order
; i
< blocksize
; i
++)
297 decoded
[i
] = a
+= b
+= c
+= decoded
[i
];
300 for (i
= pred_order
; i
< blocksize
; i
++)
301 decoded
[i
] = a
+= b
+= c
+= d
+= decoded
[i
];
304 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal pred order %d\n", pred_order
);
305 return AVERROR_INVALIDDATA
;
311 static int decode_subframe_lpc(FLACContext
*s
, int32_t *decoded
, int pred_order
,
315 int coeff_prec
, qlevel
;
318 /* warm up samples */
319 for (i
= 0; i
< pred_order
; i
++) {
320 decoded
[i
] = get_sbits_long(&s
->gb
, bps
);
323 coeff_prec
= get_bits(&s
->gb
, 4) + 1;
324 if (coeff_prec
== 16) {
325 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coeff precision\n");
326 return AVERROR_INVALIDDATA
;
328 qlevel
= get_sbits(&s
->gb
, 5);
330 av_log(s
->avctx
, AV_LOG_ERROR
, "qlevel %d not supported, maybe buggy stream\n",
332 return AVERROR_INVALIDDATA
;
335 for (i
= 0; i
< pred_order
; i
++) {
336 coeffs
[pred_order
- i
- 1] = get_sbits(&s
->gb
, coeff_prec
);
339 if ((ret
= decode_residuals(s
, decoded
, pred_order
)) < 0)
342 s
->dsp
.lpc(decoded
, coeffs
, pred_order
, qlevel
, s
->blocksize
);
347 static inline int decode_subframe(FLACContext
*s
, int channel
)
349 int32_t *decoded
= s
->decoded
[channel
];
350 int type
, wasted
= 0;
355 if (s
->ch_mode
== FLAC_CHMODE_RIGHT_SIDE
)
358 if (s
->ch_mode
== FLAC_CHMODE_LEFT_SIDE
|| s
->ch_mode
== FLAC_CHMODE_MID_SIDE
)
362 if (get_bits1(&s
->gb
)) {
363 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid subframe padding\n");
364 return AVERROR_INVALIDDATA
;
366 type
= get_bits(&s
->gb
, 6);
368 if (get_bits1(&s
->gb
)) {
369 int left
= get_bits_left(&s
->gb
);
371 (left
< bps
&& !show_bits_long(&s
->gb
, left
)) ||
372 !show_bits_long(&s
->gb
, bps
)) {
373 av_log(s
->avctx
, AV_LOG_ERROR
,
374 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
376 return AVERROR_INVALIDDATA
;
378 wasted
= 1 + get_unary(&s
->gb
, 1, get_bits_left(&s
->gb
));
382 avpriv_report_missing_feature(s
->avctx
, "Decorrelated bit depth > 32");
383 return AVERROR_PATCHWELCOME
;
386 //FIXME use av_log2 for types
388 tmp
= get_sbits_long(&s
->gb
, bps
);
389 for (i
= 0; i
< s
->blocksize
; i
++)
391 } else if (type
== 1) {
392 for (i
= 0; i
< s
->blocksize
; i
++)
393 decoded
[i
] = get_sbits_long(&s
->gb
, bps
);
394 } else if ((type
>= 8) && (type
<= 12)) {
395 if ((ret
= decode_subframe_fixed(s
, decoded
, type
& ~0x8, bps
)) < 0)
397 } else if (type
>= 32) {
398 if ((ret
= decode_subframe_lpc(s
, decoded
, (type
& ~0x20)+1, bps
)) < 0)
401 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coding type\n");
402 return AVERROR_INVALIDDATA
;
407 for (i
= 0; i
< s
->blocksize
; i
++)
408 decoded
[i
] <<= wasted
;
414 static int decode_frame(FLACContext
*s
)
417 GetBitContext
*gb
= &s
->gb
;
420 if ((ret
= ff_flac_decode_frame_header(s
->avctx
, gb
, &fi
, 0)) < 0) {
421 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid frame header\n");
425 if (s
->channels
&& fi
.channels
!= s
->channels
&& s
->got_streaminfo
) {
426 s
->channels
= s
->avctx
->channels
= fi
.channels
;
427 ff_flac_set_channel_layout(s
->avctx
);
428 ret
= allocate_buffers(s
);
432 s
->channels
= s
->avctx
->channels
= fi
.channels
;
433 if (!s
->avctx
->channel_layout
)
434 ff_flac_set_channel_layout(s
->avctx
);
435 s
->ch_mode
= fi
.ch_mode
;
437 if (!s
->bps
&& !fi
.bps
) {
438 av_log(s
->avctx
, AV_LOG_ERROR
, "bps not found in STREAMINFO or frame header\n");
439 return AVERROR_INVALIDDATA
;
443 } else if (s
->bps
&& fi
.bps
!= s
->bps
) {
444 av_log(s
->avctx
, AV_LOG_ERROR
, "switching bps mid-stream is not "
446 return AVERROR_INVALIDDATA
;
450 s
->bps
= s
->avctx
->bits_per_raw_sample
= fi
.bps
;
454 if (!s
->max_blocksize
)
455 s
->max_blocksize
= FLAC_MAX_BLOCKSIZE
;
456 if (fi
.blocksize
> s
->max_blocksize
) {
457 av_log(s
->avctx
, AV_LOG_ERROR
, "blocksize %d > %d\n", fi
.blocksize
,
459 return AVERROR_INVALIDDATA
;
461 s
->blocksize
= fi
.blocksize
;
463 if (!s
->samplerate
&& !fi
.samplerate
) {
464 av_log(s
->avctx
, AV_LOG_ERROR
, "sample rate not found in STREAMINFO"
465 " or frame header\n");
466 return AVERROR_INVALIDDATA
;
468 if (fi
.samplerate
== 0)
469 fi
.samplerate
= s
->samplerate
;
470 s
->samplerate
= s
->avctx
->sample_rate
= fi
.samplerate
;
472 if (!s
->got_streaminfo
) {
473 ret
= allocate_buffers(s
);
476 ff_flacdsp_init(&s
->dsp
, s
->avctx
->sample_fmt
, s
->bps
);
477 s
->got_streaminfo
= 1;
478 dump_headers(s
->avctx
, (FLACStreaminfo
*)s
);
481 // dump_headers(s->avctx, (FLACStreaminfo *)s);
484 for (i
= 0; i
< s
->channels
; i
++) {
485 if ((ret
= decode_subframe(s
, i
)) < 0)
492 skip_bits(gb
, 16); /* data crc */
497 static int flac_decode_frame(AVCodecContext
*avctx
, void *data
,
498 int *got_frame_ptr
, AVPacket
*avpkt
)
500 AVFrame
*frame
= data
;
501 ThreadFrame tframe
= { .f
= data
};
502 const uint8_t *buf
= avpkt
->data
;
503 int buf_size
= avpkt
->size
;
504 FLACContext
*s
= avctx
->priv_data
;
510 if (s
->max_framesize
== 0) {
512 ff_flac_get_max_frame_size(s
->max_blocksize
? s
->max_blocksize
: FLAC_MAX_BLOCKSIZE
,
513 FLAC_MAX_CHANNELS
, 32);
516 if (buf_size
> 5 && !memcmp(buf
, "\177FLAC", 5)) {
517 av_log(s
->avctx
, AV_LOG_DEBUG
, "skipping flac header packet 1\n");
521 if (buf_size
> 0 && (*buf
& 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT
) {
522 av_log(s
->avctx
, AV_LOG_DEBUG
, "skipping vorbis comment\n");
526 /* check that there is at least the smallest decodable amount of data.
527 this amount corresponds to the smallest valid FLAC frame possible.
528 FF F8 69 02 00 00 9A 00 00 34 46 */
529 if (buf_size
< FLAC_MIN_FRAME_SIZE
)
532 /* check for inline header */
533 if (AV_RB32(buf
) == MKBETAG('f','L','a','C')) {
534 if (!s
->got_streaminfo
&& (ret
= parse_streaminfo(s
, buf
, buf_size
))) {
535 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid header\n");
538 return get_metadata_size(buf
, buf_size
);
542 if ((ret
= init_get_bits8(&s
->gb
, buf
, buf_size
)) < 0)
544 if ((ret
= decode_frame(s
)) < 0) {
545 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_frame() failed\n");
548 bytes_read
= get_bits_count(&s
->gb
)/8;
550 if ((s
->avctx
->err_recognition
& (AV_EF_CRCCHECK
|AV_EF_COMPLIANT
)) &&
551 av_crc(av_crc_get_table(AV_CRC_16_ANSI
),
552 0, buf
, bytes_read
)) {
553 av_log(s
->avctx
, AV_LOG_ERROR
, "CRC error at PTS %"PRId64
"\n", avpkt
->pts
);
554 if (s
->avctx
->err_recognition
& AV_EF_EXPLODE
)
555 return AVERROR_INVALIDDATA
;
558 /* get output buffer */
559 frame
->nb_samples
= s
->blocksize
;
560 if ((ret
= ff_thread_get_buffer(avctx
, &tframe
, 0)) < 0)
563 s
->dsp
.decorrelate
[s
->ch_mode
](frame
->data
, s
->decoded
, s
->channels
,
564 s
->blocksize
, s
->sample_shift
);
566 if (bytes_read
> buf_size
) {
567 av_log(s
->avctx
, AV_LOG_ERROR
, "overread: %d\n", bytes_read
- buf_size
);
568 return AVERROR_INVALIDDATA
;
570 if (bytes_read
< buf_size
) {
571 av_log(s
->avctx
, AV_LOG_DEBUG
, "underread: %d orig size: %d\n",
572 buf_size
- bytes_read
, buf_size
);
580 static int init_thread_copy(AVCodecContext
*avctx
)
582 FLACContext
*s
= avctx
->priv_data
;
583 s
->decoded_buffer
= NULL
;
584 s
->decoded_buffer_size
= 0;
586 if (s
->max_blocksize
)
587 return allocate_buffers(s
);
591 static av_cold
int flac_decode_close(AVCodecContext
*avctx
)
593 FLACContext
*s
= avctx
->priv_data
;
595 av_freep(&s
->decoded_buffer
);
600 AVCodec ff_flac_decoder
= {
602 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
603 .type
= AVMEDIA_TYPE_AUDIO
,
604 .id
= AV_CODEC_ID_FLAC
,
605 .priv_data_size
= sizeof(FLACContext
),
606 .init
= flac_decode_init
,
607 .close
= flac_decode_close
,
608 .decode
= flac_decode_frame
,
609 .init_thread_copy
= ONLY_IF_THREADS_ENABLED(init_thread_copy
),
610 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_FRAME_THREADS
,
611 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_S16
,
615 AV_SAMPLE_FMT_NONE
},