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/crc.h"
41 #include "bytestream.h"
50 typedef struct FLACContext
{
53 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 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
62 uint8_t *decoded_buffer
;
63 unsigned int decoded_buffer_size
;
68 static int allocate_buffers(FLACContext
*s
);
70 static void flac_set_bps(FLACContext
*s
)
72 enum AVSampleFormat req
= s
->avctx
->request_sample_fmt
;
73 int need32
= s
->bps
> 16;
74 int want32
= av_get_bytes_per_sample(req
) > 2;
75 int planar
= av_sample_fmt_is_planar(req
);
77 if (need32
|| want32
) {
79 s
->avctx
->sample_fmt
= AV_SAMPLE_FMT_S32P
;
81 s
->avctx
->sample_fmt
= AV_SAMPLE_FMT_S32
;
82 s
->sample_shift
= 32 - s
->bps
;
85 s
->avctx
->sample_fmt
= AV_SAMPLE_FMT_S16P
;
87 s
->avctx
->sample_fmt
= AV_SAMPLE_FMT_S16
;
88 s
->sample_shift
= 16 - s
->bps
;
92 static av_cold
int flac_decode_init(AVCodecContext
*avctx
)
94 enum FLACExtradataFormat format
;
97 FLACContext
*s
= avctx
->priv_data
;
100 /* for now, the raw FLAC header is allowed to be passed to the decoder as
101 frame data instead of extradata. */
102 if (!avctx
->extradata
)
105 if (!ff_flac_is_extradata_valid(avctx
, &format
, &streaminfo
))
106 return AVERROR_INVALIDDATA
;
108 /* initialize based on the demuxer-supplied streamdata header */
109 ff_flac_parse_streaminfo(avctx
, (FLACStreaminfo
*)s
, streaminfo
);
110 ret
= allocate_buffers(s
);
114 ff_flacdsp_init(&s
->dsp
, avctx
->sample_fmt
, s
->channels
, s
->bps
);
115 s
->got_streaminfo
= 1;
120 static void dump_headers(AVCodecContext
*avctx
, FLACStreaminfo
*s
)
122 av_log(avctx
, AV_LOG_DEBUG
, " Max Blocksize: %d\n", s
->max_blocksize
);
123 av_log(avctx
, AV_LOG_DEBUG
, " Max Framesize: %d\n", s
->max_framesize
);
124 av_log(avctx
, AV_LOG_DEBUG
, " Samplerate: %d\n", s
->samplerate
);
125 av_log(avctx
, AV_LOG_DEBUG
, " Channels: %d\n", s
->channels
);
126 av_log(avctx
, AV_LOG_DEBUG
, " Bits: %d\n", s
->bps
);
129 static int allocate_buffers(FLACContext
*s
)
134 av_assert0(s
->max_blocksize
);
136 buf_size
= av_samples_get_buffer_size(NULL
, s
->channels
, s
->max_blocksize
,
137 AV_SAMPLE_FMT_S32P
, 0);
141 av_fast_malloc(&s
->decoded_buffer
, &s
->decoded_buffer_size
, buf_size
);
142 if (!s
->decoded_buffer
)
143 return AVERROR(ENOMEM
);
145 ret
= av_samples_fill_arrays((uint8_t **)s
->decoded
, NULL
,
146 s
->decoded_buffer
, s
->channels
,
147 s
->max_blocksize
, AV_SAMPLE_FMT_S32P
, 0);
148 return ret
< 0 ? ret
: 0;
152 * Parse the STREAMINFO from an inline header.
153 * @param s the flac decoding context
154 * @param buf input buffer, starting with the "fLaC" marker
155 * @param buf_size buffer size
156 * @return non-zero if metadata is invalid
158 static int parse_streaminfo(FLACContext
*s
, const uint8_t *buf
, int buf_size
)
160 int metadata_type
, metadata_size
, ret
;
162 if (buf_size
< FLAC_STREAMINFO_SIZE
+8) {
166 flac_parse_block_header(&buf
[4], NULL
, &metadata_type
, &metadata_size
);
167 if (metadata_type
!= FLAC_METADATA_TYPE_STREAMINFO
||
168 metadata_size
!= FLAC_STREAMINFO_SIZE
) {
169 return AVERROR_INVALIDDATA
;
171 ff_flac_parse_streaminfo(s
->avctx
, (FLACStreaminfo
*)s
, &buf
[8]);
172 ret
= allocate_buffers(s
);
176 ff_flacdsp_init(&s
->dsp
, s
->avctx
->sample_fmt
, s
->channels
, s
->bps
);
177 s
->got_streaminfo
= 1;
183 * Determine the size of an inline header.
184 * @param buf input buffer, starting with the "fLaC" marker
185 * @param buf_size buffer size
186 * @return number of bytes in the header, or 0 if more data is needed
188 static int get_metadata_size(const uint8_t *buf
, int buf_size
)
190 int metadata_last
, metadata_size
;
191 const uint8_t *buf_end
= buf
+ buf_size
;
195 if (buf_end
- buf
< 4)
197 flac_parse_block_header(buf
, &metadata_last
, NULL
, &metadata_size
);
199 if (buf_end
- buf
< metadata_size
) {
200 /* need more data in order to read the complete header */
203 buf
+= metadata_size
;
204 } while (!metadata_last
);
206 return buf_size
- (buf_end
- buf
);
209 static int decode_residuals(FLACContext
*s
, int32_t *decoded
, int pred_order
)
211 int i
, tmp
, partition
, method_type
, rice_order
;
212 int rice_bits
, rice_esc
;
215 method_type
= get_bits(&s
->gb
, 2);
216 if (method_type
> 1) {
217 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal residual coding method %d\n",
219 return AVERROR_INVALIDDATA
;
222 rice_order
= get_bits(&s
->gb
, 4);
224 samples
= s
->blocksize
>> rice_order
;
225 if (samples
<< rice_order
!= s
->blocksize
) {
226 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid rice order: %i blocksize %i\n",
227 rice_order
, s
->blocksize
);
228 return AVERROR_INVALIDDATA
;
231 if (pred_order
> samples
) {
232 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid predictor order: %i > %i\n",
233 pred_order
, samples
);
234 return AVERROR_INVALIDDATA
;
237 rice_bits
= 4 + method_type
;
238 rice_esc
= (1 << rice_bits
) - 1;
240 decoded
+= pred_order
;
242 for (partition
= 0; partition
< (1 << rice_order
); partition
++) {
243 tmp
= get_bits(&s
->gb
, rice_bits
);
244 if (tmp
== rice_esc
) {
245 tmp
= get_bits(&s
->gb
, 5);
246 for (; i
< samples
; i
++)
247 *decoded
++ = get_sbits_long(&s
->gb
, tmp
);
249 for (; i
< samples
; i
++) {
250 *decoded
++ = get_sr_golomb_flac(&s
->gb
, tmp
, INT_MAX
, 0);
259 static int decode_subframe_fixed(FLACContext
*s
, int32_t *decoded
,
260 int pred_order
, int bps
)
262 const int blocksize
= s
->blocksize
;
263 int av_uninit(a
), av_uninit(b
), av_uninit(c
), av_uninit(d
), i
;
266 /* warm up samples */
267 for (i
= 0; i
< pred_order
; i
++) {
268 decoded
[i
] = get_sbits_long(&s
->gb
, bps
);
271 if ((ret
= decode_residuals(s
, decoded
, pred_order
)) < 0)
275 a
= decoded
[pred_order
-1];
277 b
= a
- decoded
[pred_order
-2];
279 c
= b
- decoded
[pred_order
-2] + decoded
[pred_order
-3];
281 d
= c
- decoded
[pred_order
-2] + 2*decoded
[pred_order
-3] - decoded
[pred_order
-4];
283 switch (pred_order
) {
287 for (i
= pred_order
; i
< blocksize
; i
++)
288 decoded
[i
] = a
+= decoded
[i
];
291 for (i
= pred_order
; i
< blocksize
; i
++)
292 decoded
[i
] = a
+= b
+= decoded
[i
];
295 for (i
= pred_order
; i
< blocksize
; i
++)
296 decoded
[i
] = a
+= b
+= c
+= decoded
[i
];
299 for (i
= pred_order
; i
< blocksize
; i
++)
300 decoded
[i
] = a
+= b
+= c
+= d
+= decoded
[i
];
303 av_log(s
->avctx
, AV_LOG_ERROR
, "illegal pred order %d\n", pred_order
);
304 return AVERROR_INVALIDDATA
;
310 static int decode_subframe_lpc(FLACContext
*s
, int32_t *decoded
, int pred_order
,
314 int coeff_prec
, qlevel
;
317 /* warm up samples */
318 for (i
= 0; i
< pred_order
; i
++) {
319 decoded
[i
] = get_sbits_long(&s
->gb
, bps
);
322 coeff_prec
= get_bits(&s
->gb
, 4) + 1;
323 if (coeff_prec
== 16) {
324 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coeff precision\n");
325 return AVERROR_INVALIDDATA
;
327 qlevel
= get_sbits(&s
->gb
, 5);
329 av_log(s
->avctx
, AV_LOG_ERROR
, "qlevel %d not supported, maybe buggy stream\n",
331 return AVERROR_INVALIDDATA
;
334 for (i
= 0; i
< pred_order
; i
++) {
335 coeffs
[pred_order
- i
- 1] = get_sbits(&s
->gb
, coeff_prec
);
338 if ((ret
= decode_residuals(s
, decoded
, pred_order
)) < 0)
341 s
->dsp
.lpc(decoded
, coeffs
, pred_order
, qlevel
, s
->blocksize
);
346 static inline int decode_subframe(FLACContext
*s
, int channel
)
348 int32_t *decoded
= s
->decoded
[channel
];
349 int type
, wasted
= 0;
354 if (s
->ch_mode
== FLAC_CHMODE_RIGHT_SIDE
)
357 if (s
->ch_mode
== FLAC_CHMODE_LEFT_SIDE
|| s
->ch_mode
== FLAC_CHMODE_MID_SIDE
)
361 if (get_bits1(&s
->gb
)) {
362 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid subframe padding\n");
363 return AVERROR_INVALIDDATA
;
365 type
= get_bits(&s
->gb
, 6);
367 if (get_bits1(&s
->gb
)) {
368 int left
= get_bits_left(&s
->gb
);
370 (left
< bps
&& !show_bits_long(&s
->gb
, left
)) ||
371 !show_bits_long(&s
->gb
, bps
)) {
372 av_log(s
->avctx
, AV_LOG_ERROR
,
373 "Invalid number of wasted bits > available bits (%d) - left=%d\n",
375 return AVERROR_INVALIDDATA
;
377 wasted
= 1 + get_unary(&s
->gb
, 1, get_bits_left(&s
->gb
));
381 avpriv_report_missing_feature(s
->avctx
, "Decorrelated bit depth > 32");
382 return AVERROR_PATCHWELCOME
;
385 //FIXME use av_log2 for types
387 tmp
= get_sbits_long(&s
->gb
, bps
);
388 for (i
= 0; i
< s
->blocksize
; i
++)
390 } else if (type
== 1) {
391 for (i
= 0; i
< s
->blocksize
; i
++)
392 decoded
[i
] = get_sbits_long(&s
->gb
, bps
);
393 } else if ((type
>= 8) && (type
<= 12)) {
394 if ((ret
= decode_subframe_fixed(s
, decoded
, type
& ~0x8, bps
)) < 0)
396 } else if (type
>= 32) {
397 if ((ret
= decode_subframe_lpc(s
, decoded
, (type
& ~0x20)+1, bps
)) < 0)
400 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid coding type\n");
401 return AVERROR_INVALIDDATA
;
406 for (i
= 0; i
< s
->blocksize
; i
++)
407 decoded
[i
] <<= wasted
;
413 static int decode_frame(FLACContext
*s
)
416 GetBitContext
*gb
= &s
->gb
;
419 if ((ret
= ff_flac_decode_frame_header(s
->avctx
, gb
, &fi
, 0)) < 0) {
420 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid frame header\n");
424 if (s
->channels
&& fi
.channels
!= s
->channels
&& s
->got_streaminfo
) {
425 s
->channels
= s
->avctx
->channels
= fi
.channels
;
426 ff_flac_set_channel_layout(s
->avctx
);
427 ret
= allocate_buffers(s
);
431 s
->channels
= s
->avctx
->channels
= fi
.channels
;
432 if (!s
->avctx
->channel_layout
)
433 ff_flac_set_channel_layout(s
->avctx
);
434 s
->ch_mode
= fi
.ch_mode
;
436 if (!s
->bps
&& !fi
.bps
) {
437 av_log(s
->avctx
, AV_LOG_ERROR
, "bps not found in STREAMINFO or frame header\n");
438 return AVERROR_INVALIDDATA
;
442 } else if (s
->bps
&& fi
.bps
!= s
->bps
) {
443 av_log(s
->avctx
, AV_LOG_ERROR
, "switching bps mid-stream is not "
445 return AVERROR_INVALIDDATA
;
449 s
->bps
= s
->avctx
->bits_per_raw_sample
= fi
.bps
;
453 if (!s
->max_blocksize
)
454 s
->max_blocksize
= FLAC_MAX_BLOCKSIZE
;
455 if (fi
.blocksize
> s
->max_blocksize
) {
456 av_log(s
->avctx
, AV_LOG_ERROR
, "blocksize %d > %d\n", fi
.blocksize
,
458 return AVERROR_INVALIDDATA
;
460 s
->blocksize
= fi
.blocksize
;
462 if (!s
->samplerate
&& !fi
.samplerate
) {
463 av_log(s
->avctx
, AV_LOG_ERROR
, "sample rate not found in STREAMINFO"
464 " or frame header\n");
465 return AVERROR_INVALIDDATA
;
467 if (fi
.samplerate
== 0)
468 fi
.samplerate
= s
->samplerate
;
469 s
->samplerate
= s
->avctx
->sample_rate
= fi
.samplerate
;
471 if (!s
->got_streaminfo
) {
472 ret
= allocate_buffers(s
);
475 s
->got_streaminfo
= 1;
476 dump_headers(s
->avctx
, (FLACStreaminfo
*)s
);
478 ff_flacdsp_init(&s
->dsp
, s
->avctx
->sample_fmt
, s
->channels
, s
->bps
);
480 // dump_headers(s->avctx, (FLACStreaminfo *)s);
483 for (i
= 0; i
< s
->channels
; i
++) {
484 if ((ret
= decode_subframe(s
, i
)) < 0)
491 skip_bits(gb
, 16); /* data crc */
496 static int flac_decode_frame(AVCodecContext
*avctx
, void *data
,
497 int *got_frame_ptr
, AVPacket
*avpkt
)
499 AVFrame
*frame
= data
;
500 ThreadFrame tframe
= { .f
= data
};
501 const uint8_t *buf
= avpkt
->data
;
502 int buf_size
= avpkt
->size
;
503 FLACContext
*s
= avctx
->priv_data
;
509 if (s
->max_framesize
== 0) {
511 ff_flac_get_max_frame_size(s
->max_blocksize
? s
->max_blocksize
: FLAC_MAX_BLOCKSIZE
,
512 FLAC_MAX_CHANNELS
, 32);
515 if (buf_size
> 5 && !memcmp(buf
, "\177FLAC", 5)) {
516 av_log(s
->avctx
, AV_LOG_DEBUG
, "skipping flac header packet 1\n");
520 if (buf_size
> 0 && (*buf
& 0x7F) == FLAC_METADATA_TYPE_VORBIS_COMMENT
) {
521 av_log(s
->avctx
, AV_LOG_DEBUG
, "skipping vorbis comment\n");
525 /* check that there is at least the smallest decodable amount of data.
526 this amount corresponds to the smallest valid FLAC frame possible.
527 FF F8 69 02 00 00 9A 00 00 34 46 */
528 if (buf_size
< FLAC_MIN_FRAME_SIZE
)
531 /* check for inline header */
532 if (AV_RB32(buf
) == MKBETAG('f','L','a','C')) {
533 if (!s
->got_streaminfo
&& (ret
= parse_streaminfo(s
, buf
, buf_size
))) {
534 av_log(s
->avctx
, AV_LOG_ERROR
, "invalid header\n");
537 return get_metadata_size(buf
, buf_size
);
541 if ((ret
= init_get_bits8(&s
->gb
, buf
, buf_size
)) < 0)
543 if ((ret
= decode_frame(s
)) < 0) {
544 av_log(s
->avctx
, AV_LOG_ERROR
, "decode_frame() failed\n");
547 bytes_read
= get_bits_count(&s
->gb
)/8;
549 if ((s
->avctx
->err_recognition
& (AV_EF_CRCCHECK
|AV_EF_COMPLIANT
)) &&
550 av_crc(av_crc_get_table(AV_CRC_16_ANSI
),
551 0, buf
, bytes_read
)) {
552 av_log(s
->avctx
, AV_LOG_ERROR
, "CRC error at PTS %"PRId64
"\n", avpkt
->pts
);
553 if (s
->avctx
->err_recognition
& AV_EF_EXPLODE
)
554 return AVERROR_INVALIDDATA
;
557 /* get output buffer */
558 frame
->nb_samples
= s
->blocksize
;
559 if ((ret
= ff_thread_get_buffer(avctx
, &tframe
, 0)) < 0)
562 s
->dsp
.decorrelate
[s
->ch_mode
](frame
->data
, s
->decoded
, s
->channels
,
563 s
->blocksize
, s
->sample_shift
);
565 if (bytes_read
> buf_size
) {
566 av_log(s
->avctx
, AV_LOG_ERROR
, "overread: %d\n", bytes_read
- buf_size
);
567 return AVERROR_INVALIDDATA
;
569 if (bytes_read
< buf_size
) {
570 av_log(s
->avctx
, AV_LOG_DEBUG
, "underread: %d orig size: %d\n",
571 buf_size
- bytes_read
, buf_size
);
579 static int init_thread_copy(AVCodecContext
*avctx
)
581 FLACContext
*s
= avctx
->priv_data
;
582 s
->decoded_buffer
= NULL
;
583 s
->decoded_buffer_size
= 0;
585 if (s
->max_blocksize
)
586 return allocate_buffers(s
);
590 static av_cold
int flac_decode_close(AVCodecContext
*avctx
)
592 FLACContext
*s
= avctx
->priv_data
;
594 av_freep(&s
->decoded_buffer
);
599 AVCodec ff_flac_decoder
= {
601 .long_name
= NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
602 .type
= AVMEDIA_TYPE_AUDIO
,
603 .id
= AV_CODEC_ID_FLAC
,
604 .priv_data_size
= sizeof(FLACContext
),
605 .init
= flac_decode_init
,
606 .close
= flac_decode_close
,
607 .decode
= flac_decode_frame
,
608 .init_thread_copy
= ONLY_IF_THREADS_ENABLED(init_thread_copy
),
609 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_FRAME_THREADS
,
610 .sample_fmts
= (const enum AVSampleFormat
[]) { AV_SAMPLE_FMT_S16
,
614 AV_SAMPLE_FMT_NONE
},