2004-02-18 01:22:05 +00:00
/*
* FLAC ( Free Lossless Audio Codec ) decoder
* Copyright ( c ) 2003 Alex Beregszaszi
*
2006-10-07 15:30:46 +00:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2004-02-18 01:22:05 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 15:30:46 +00:00
* version 2.1 of the License , or ( at your option ) any later version .
2004-02-18 01:22:05 +00:00
*
2006-10-07 15:30:46 +00:00
* FFmpeg is distributed in the hope that it will be useful ,
2004-02-18 01:22:05 +00:00
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
2006-10-07 15:30:46 +00:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 22:43:26 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2004-02-18 01:22:05 +00:00
*/
/**
2010-04-20 14:45:34 +00:00
* @ file
2004-02-18 01:22:05 +00:00
* FLAC ( Free Lossless Audio Codec ) decoder
* @ author Alex Beregszaszi
2011-07-14 01:56:07 +00:00
* @ see http : //flac.sourceforge.net/
2004-06-10 04:13:43 +00:00
*
* This decoder can be used in 1 of 2 ways : Either raw FLAC data can be fed
* through , starting from the initial ' fLaC ' signature ; or by passing the
* 34 - byte streaminfo structure through avctx - > extradata [ _size ] followed
* by data starting with the 0xFFF8 marker .
2004-02-18 01:22:05 +00:00
*/
2005-12-17 18:14:38 +00:00
2004-02-18 01:49:30 +00:00
# include <limits.h>
2005-12-17 18:14:38 +00:00
2012-08-02 19:58:03 +00:00
# include "libavutil/avassert.h"
2008-05-09 11:56:36 +00:00
# include "libavutil/crc.h"
2015-05-12 11:00:29 +00:00
# include "libavutil/opt.h"
2004-02-18 01:22:05 +00:00
# include "avcodec.h"
2009-03-03 04:45:45 +00:00
# include "internal.h"
2009-04-13 16:20:26 +00:00
# include "get_bits.h"
2009-03-05 00:56:09 +00:00
# include "bytestream.h"
2004-02-18 01:22:05 +00:00
# include "golomb.h"
2008-05-02 21:33:14 +00:00
# include "flac.h"
2009-03-21 01:16:38 +00:00
# include "flacdata.h"
2012-06-17 14:10:40 +00:00
# include "flacdsp.h"
2013-06-03 15:47:53 +00:00
# include "thread.h"
2013-10-30 13:58:04 +00:00
# include "unary.h"
2004-02-18 01:22:05 +00:00
typedef struct FLACContext {
2015-05-12 11:00:29 +00:00
AVClass * class ;
2015-05-12 10:47:57 +00:00
struct FLACStreaminfo flac_stream_info ;
2008-05-02 21:33:14 +00:00
2009-01-31 02:10:43 +00:00
AVCodecContext * avctx ; ///< parent AVCodecContext
GetBitContext gb ; ///< GetBitContext initialized to start at the current frame
2004-02-18 01:22:05 +00:00
2009-01-31 02:10:43 +00:00
int blocksize ; ///< number of samples in the current frame
2009-01-31 02:11:37 +00:00
int sample_shift ; ///< shift required to make output samples 16-bit or 32-bit
2009-03-21 00:47:04 +00:00
int ch_mode ; ///< channel decorrelation type in the current frame
2009-03-03 23:49:36 +00:00
int got_streaminfo ; ///< indicates if the STREAMINFO has been read
2004-02-18 01:22:05 +00:00
2009-03-19 03:04:21 +00:00
int32_t * decoded [ FLAC_MAX_CHANNELS ] ; ///< decoded samples
2012-10-21 20:15:34 +00:00
uint8_t * decoded_buffer ;
unsigned int decoded_buffer_size ;
2015-05-12 11:00:29 +00:00
int buggy_lpc ; ///< use workaround for old lavc encoded files
2012-06-17 14:10:40 +00:00
FLACDSPContext dsp ;
2004-02-18 01:22:05 +00:00
} FLACContext ;
2012-10-21 20:15:34 +00:00
static int allocate_buffers ( FLACContext * s ) ;
2009-02-26 02:29:24 +00:00
2012-07-02 23:28:32 +00:00
static void flac_set_bps ( FLACContext * s )
{
2012-07-02 23:29:30 +00:00
enum AVSampleFormat req = s - > avctx - > request_sample_fmt ;
2015-05-12 10:47:57 +00:00
int need32 = s - > flac_stream_info . bps > 16 ;
2012-07-02 23:29:30 +00:00
int want32 = av_get_bytes_per_sample ( req ) > 2 ;
int planar = av_sample_fmt_is_planar ( req ) ;
if ( need32 | | want32 ) {
if ( planar )
s - > avctx - > sample_fmt = AV_SAMPLE_FMT_S32P ;
else
s - > avctx - > sample_fmt = AV_SAMPLE_FMT_S32 ;
2015-05-12 10:47:57 +00:00
s - > sample_shift = 32 - s - > flac_stream_info . bps ;
2012-07-02 23:28:32 +00:00
} else {
2012-07-02 23:29:30 +00:00
if ( planar )
s - > avctx - > sample_fmt = AV_SAMPLE_FMT_S16P ;
else
s - > avctx - > sample_fmt = AV_SAMPLE_FMT_S16 ;
2015-05-12 10:47:57 +00:00
s - > sample_shift = 16 - s - > flac_stream_info . bps ;
2012-07-02 23:28:32 +00:00
}
}
2009-01-24 18:51:43 +00:00
static av_cold int flac_decode_init ( AVCodecContext * avctx )
2004-02-18 01:22:05 +00:00
{
2009-02-26 02:29:24 +00:00
enum FLACExtradataFormat format ;
uint8_t * streaminfo ;
2012-10-21 20:15:34 +00:00
int ret ;
2004-06-10 04:13:43 +00:00
FLACContext * s = avctx - > priv_data ;
s - > avctx = avctx ;
2009-02-26 02:29:24 +00:00
/* for now, the raw FLAC header is allowed to be passed to the decoder as
frame data instead of extradata . */
if ( ! avctx - > extradata )
return 0 ;
2014-08-28 18:42:56 +00:00
if ( ! ff_flac_is_extradata_valid ( avctx , & format , & streaminfo ) )
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2009-02-26 02:29:24 +00:00
2009-02-26 02:30:29 +00:00
/* initialize based on the demuxer-supplied streamdata header */
2016-12-03 22:39:11 +00:00
ret = ff_flac_parse_streaminfo ( avctx , & s - > flac_stream_info , streaminfo ) ;
if ( ret < 0 )
return ret ;
2012-10-21 20:15:34 +00:00
ret = allocate_buffers ( s ) ;
if ( ret < 0 )
return ret ;
2012-07-02 23:28:32 +00:00
flac_set_bps ( s ) ;
2015-05-12 10:47:57 +00:00
ff_flacdsp_init ( & s - > dsp , avctx - > sample_fmt ,
s - > flac_stream_info . channels , s - > flac_stream_info . bps ) ;
2009-03-03 23:49:36 +00:00
s - > got_streaminfo = 1 ;
2004-06-10 04:13:43 +00:00
2004-02-18 01:22:05 +00:00
return 0 ;
}
2008-05-02 21:34:34 +00:00
static void dump_headers ( AVCodecContext * avctx , FLACStreaminfo * s )
2004-02-18 01:22:05 +00:00
{
2009-03-03 05:25:23 +00:00
av_log ( avctx , AV_LOG_DEBUG , " Max Blocksize: %d \n " , s - > max_blocksize ) ;
2008-05-02 21:30:32 +00:00
av_log ( avctx , AV_LOG_DEBUG , " Max Framesize: %d \n " , s - > max_framesize ) ;
av_log ( avctx , AV_LOG_DEBUG , " Samplerate: %d \n " , s - > samplerate ) ;
av_log ( avctx , AV_LOG_DEBUG , " Channels: %d \n " , s - > channels ) ;
av_log ( avctx , AV_LOG_DEBUG , " Bits: %d \n " , s - > bps ) ;
2004-02-18 01:22:05 +00:00
}
2012-10-21 20:15:34 +00:00
static int allocate_buffers ( FLACContext * s )
2009-01-24 18:51:43 +00:00
{
2012-10-21 20:15:34 +00:00
int buf_size ;
2014-08-09 22:03:13 +00:00
int ret ;
2004-02-18 01:22:05 +00:00
2015-05-12 10:47:57 +00:00
av_assert0 ( s - > flac_stream_info . max_blocksize ) ;
2004-02-18 01:49:30 +00:00
2015-05-12 10:47:57 +00:00
buf_size = av_samples_get_buffer_size ( NULL , s - > flac_stream_info . channels ,
s - > flac_stream_info . max_blocksize ,
2012-10-21 20:15:34 +00:00
AV_SAMPLE_FMT_S32P , 0 ) ;
if ( buf_size < 0 )
return buf_size ;
av_fast_malloc ( & s - > decoded_buffer , & s - > decoded_buffer_size , buf_size ) ;
if ( ! s - > decoded_buffer )
return AVERROR ( ENOMEM ) ;
2014-08-09 22:03:13 +00:00
ret = av_samples_fill_arrays ( ( uint8_t * * ) s - > decoded , NULL ,
2015-05-12 10:47:57 +00:00
s - > decoded_buffer ,
s - > flac_stream_info . channels ,
s - > flac_stream_info . max_blocksize ,
AV_SAMPLE_FMT_S32P , 0 ) ;
2014-08-09 22:03:13 +00:00
return ret < 0 ? ret : 0 ;
2004-02-18 01:49:30 +00:00
}
2006-11-23 22:22:03 +00:00
/**
2009-03-05 00:56:09 +00:00
* Parse the STREAMINFO from an inline header .
* @ param s the flac decoding context
* @ param buf input buffer , starting with the " fLaC " marker
* @ param buf_size buffer size
2009-03-04 00:52:18 +00:00
* @ return non - zero if metadata is invalid
2006-11-23 22:22:03 +00:00
*/
2009-03-05 00:56:09 +00:00
static int parse_streaminfo ( FLACContext * s , const uint8_t * buf , int buf_size )
2006-11-23 22:22:03 +00:00
{
2012-10-21 20:15:34 +00:00
int metadata_type , metadata_size , ret ;
2006-11-23 22:22:03 +00:00
2009-03-05 00:56:09 +00:00
if ( buf_size < FLAC_STREAMINFO_SIZE + 8 ) {
/* need more data */
return 0 ;
}
2014-05-26 07:43:50 +00:00
flac_parse_block_header ( & buf [ 4 ] , NULL , & metadata_type , & metadata_size ) ;
2009-03-05 00:56:09 +00:00
if ( metadata_type ! = FLAC_METADATA_TYPE_STREAMINFO | |
metadata_size ! = FLAC_STREAMINFO_SIZE ) {
return AVERROR_INVALIDDATA ;
}
2016-12-03 22:39:11 +00:00
ret = ff_flac_parse_streaminfo ( s - > avctx , & s - > flac_stream_info , & buf [ 8 ] ) ;
if ( ret < 0 )
return ret ;
2012-10-21 20:15:34 +00:00
ret = allocate_buffers ( s ) ;
if ( ret < 0 )
return ret ;
2012-06-17 14:10:40 +00:00
flac_set_bps ( s ) ;
2015-05-12 10:47:57 +00:00
ff_flacdsp_init ( & s - > dsp , s - > avctx - > sample_fmt ,
s - > flac_stream_info . channels , s - > flac_stream_info . bps ) ;
2009-03-05 00:56:09 +00:00
s - > got_streaminfo = 1 ;
2006-11-23 22:22:03 +00:00
2009-03-05 00:56:09 +00:00
return 0 ;
}
2006-11-23 22:22:03 +00:00
2009-03-05 00:56:09 +00:00
/**
* Determine the size of an inline header .
* @ param buf input buffer , starting with the " fLaC " marker
* @ param buf_size buffer size
* @ return number of bytes in the header , or 0 if more data is needed
*/
static int get_metadata_size ( const uint8_t * buf , int buf_size )
{
int metadata_last , metadata_size ;
const uint8_t * buf_end = buf + buf_size ;
2008-07-18 12:03:21 +00:00
2009-03-05 00:56:09 +00:00
buf + = 4 ;
do {
2011-09-13 19:13:44 +00:00
if ( buf_end - buf < 4 )
return 0 ;
2014-05-26 07:43:50 +00:00
flac_parse_block_header ( buf , & metadata_last , NULL , & metadata_size ) ;
2009-03-06 01:25:11 +00:00
buf + = 4 ;
2011-09-13 19:13:44 +00:00
if ( buf_end - buf < metadata_size ) {
2009-03-05 00:56:09 +00:00
/* need more data in order to read the complete header */
return 0 ;
2009-03-04 00:53:04 +00:00
}
2009-03-05 00:56:09 +00:00
buf + = metadata_size ;
2009-03-04 00:53:04 +00:00
} while ( ! metadata_last ) ;
2006-11-23 22:22:03 +00:00
2009-03-05 00:56:09 +00:00
return buf_size - ( buf_end - buf ) ;
2004-02-18 01:22:05 +00:00
}
2012-07-02 00:59:04 +00:00
static int decode_residuals ( FLACContext * s , int32_t * decoded , int pred_order )
2004-02-18 01:22:05 +00:00
{
int i , tmp , partition , method_type , rice_order ;
2012-07-02 21:39:34 +00:00
int rice_bits , rice_esc ;
2012-07-02 00:59:04 +00:00
int samples ;
2004-02-18 01:22:05 +00:00
method_type = get_bits ( & s - > gb , 2 ) ;
2009-01-24 18:51:43 +00:00
if ( method_type > 1 ) {
2009-01-24 19:05:52 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " illegal residual coding method %d \n " ,
method_type ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2004-02-18 01:49:30 +00:00
}
2005-12-17 18:14:38 +00:00
2004-02-18 01:22:05 +00:00
rice_order = get_bits ( & s - > gb , 4 ) ;
2004-02-18 01:49:30 +00:00
samples = s - > blocksize > > rice_order ;
2014-01-07 12:57:47 +00:00
if ( samples < < rice_order ! = s - > blocksize ) {
av_log ( s - > avctx , AV_LOG_ERROR , " invalid rice order: %i blocksize %i \n " ,
rice_order , s - > blocksize ) ;
return AVERROR_INVALIDDATA ;
}
2007-01-21 09:55:28 +00:00
if ( pred_order > samples ) {
2009-01-24 19:05:52 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " invalid predictor order: %i > %i \n " ,
pred_order , samples ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2007-01-21 09:55:28 +00:00
}
2004-02-18 01:22:05 +00:00
2012-07-02 21:39:34 +00:00
rice_bits = 4 + method_type ;
rice_esc = ( 1 < < rice_bits ) - 1 ;
2012-07-02 00:59:04 +00:00
decoded + = pred_order ;
2004-02-18 01:49:30 +00:00
i = pred_order ;
2009-01-24 18:51:43 +00:00
for ( partition = 0 ; partition < ( 1 < < rice_order ) ; partition + + ) {
2012-07-02 21:39:34 +00:00
tmp = get_bits ( & s - > gb , rice_bits ) ;
if ( tmp = = rice_esc ) {
2004-02-18 01:22:05 +00:00
tmp = get_bits ( & s - > gb , 5 ) ;
2012-07-02 00:59:04 +00:00
for ( ; i < samples ; i + + )
* decoded + + = get_sbits_long ( & s - > gb , tmp ) ;
2009-01-24 18:51:43 +00:00
} else {
2017-02-20 22:59:26 +00:00
int real_limit = tmp ? ( INT_MAX > > tmp ) + 2 : INT_MAX ;
2012-07-02 00:59:04 +00:00
for ( ; i < samples ; i + + ) {
2017-02-20 22:59:26 +00:00
int v = get_sr_golomb_flac ( & s - > gb , tmp , real_limit , 0 ) ;
2016-12-09 15:29:35 +00:00
if ( v = = 0x80000000 ) {
av_log ( s - > avctx , AV_LOG_ERROR , " invalid residual \n " ) ;
return AVERROR_INVALIDDATA ;
}
* decoded + + = v ;
2004-02-18 01:49:30 +00:00
}
2004-02-18 01:22:05 +00:00
}
2004-02-18 01:49:30 +00:00
i = 0 ;
2004-02-18 01:22:05 +00:00
}
return 0 ;
2005-12-17 18:14:38 +00:00
}
2004-02-18 01:22:05 +00:00
2012-07-02 00:59:04 +00:00
static int decode_subframe_fixed ( FLACContext * s , int32_t * decoded ,
int pred_order , int bps )
2004-02-18 01:22:05 +00:00
{
2007-09-30 02:12:03 +00:00
const int blocksize = s - > blocksize ;
2016-12-03 16:05:43 +00:00
unsigned av_uninit ( a ) , av_uninit ( b ) , av_uninit ( c ) , av_uninit ( d ) ;
int i ;
2013-03-20 07:27:39 +00:00
int ret ;
2005-12-17 18:14:38 +00:00
2004-02-18 01:22:05 +00:00
/* warm up samples */
2009-01-24 18:51:43 +00:00
for ( i = 0 ; i < pred_order ; i + + ) {
2012-07-02 00:43:12 +00:00
decoded [ i ] = get_sbits_long ( & s - > gb , bps ) ;
2004-02-18 01:22:05 +00:00
}
2005-12-17 18:14:38 +00:00
2013-03-20 07:27:39 +00:00
if ( ( ret = decode_residuals ( s , decoded , pred_order ) ) < 0 )
return ret ;
2004-02-18 01:22:05 +00:00
2009-01-24 18:51:43 +00:00
if ( pred_order > 0 )
2008-05-04 01:08:40 +00:00
a = decoded [ pred_order - 1 ] ;
2009-01-24 18:51:43 +00:00
if ( pred_order > 1 )
2008-05-04 01:08:40 +00:00
b = a - decoded [ pred_order - 2 ] ;
2009-01-24 18:51:43 +00:00
if ( pred_order > 2 )
2008-05-04 01:08:40 +00:00
c = b - decoded [ pred_order - 2 ] + decoded [ pred_order - 3 ] ;
2009-01-24 18:51:43 +00:00
if ( pred_order > 3 )
2008-05-04 01:08:40 +00:00
d = c - decoded [ pred_order - 2 ] + 2 * decoded [ pred_order - 3 ] - decoded [ pred_order - 4 ] ;
2007-09-30 02:12:03 +00:00
2009-01-24 18:51:43 +00:00
switch ( pred_order ) {
case 0 :
break ;
case 1 :
for ( i = pred_order ; i < blocksize ; i + + )
decoded [ i ] = a + = decoded [ i ] ;
break ;
case 2 :
for ( i = pred_order ; i < blocksize ; i + + )
decoded [ i ] = a + = b + = decoded [ i ] ;
break ;
case 3 :
for ( i = pred_order ; i < blocksize ; i + + )
decoded [ i ] = a + = b + = c + = decoded [ i ] ;
break ;
case 4 :
for ( i = pred_order ; i < blocksize ; i + + )
decoded [ i ] = a + = b + = c + = d + = decoded [ i ] ;
break ;
default :
av_log ( s - > avctx , AV_LOG_ERROR , " illegal pred order %d \n " , pred_order ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2004-02-18 01:22:05 +00:00
}
2004-02-18 01:49:30 +00:00
2004-02-18 01:22:05 +00:00
return 0 ;
}
2017-02-19 13:34:55 +00:00
static void lpc_analyze_remodulate ( SUINT32 * decoded , const int coeffs [ 32 ] ,
2015-05-17 11:10:33 +00:00
int order , int qlevel , int len , int bps )
{
int i , j ;
int ebps = 1 < < ( bps - 1 ) ;
unsigned sigma = 0 ;
for ( i = order ; i < len ; i + + )
sigma | = decoded [ i ] + ebps ;
if ( sigma < 2 * ebps )
return ;
for ( i = len - 1 ; i > = order ; i - - ) {
int64_t p = 0 ;
for ( j = 0 ; j < order ; j + + )
2017-02-19 13:34:55 +00:00
p + = coeffs [ j ] * ( int64_t ) ( int32_t ) decoded [ i - order + j ] ;
2015-05-17 11:10:33 +00:00
decoded [ i ] - = p > > qlevel ;
}
for ( i = order ; i < len ; i + + , decoded + + ) {
int32_t p = 0 ;
for ( j = 0 ; j < order ; j + + )
p + = coeffs [ j ] * ( uint32_t ) decoded [ j ] ;
decoded [ j ] + = p > > qlevel ;
}
}
2012-07-02 00:59:04 +00:00
static int decode_subframe_lpc ( FLACContext * s , int32_t * decoded , int pred_order ,
2012-07-02 00:43:12 +00:00
int bps )
2004-02-18 01:22:05 +00:00
{
2013-03-20 07:27:39 +00:00
int i , ret ;
2004-02-18 01:22:05 +00:00
int coeff_prec , qlevel ;
2009-08-19 21:59:36 +00:00
int coeffs [ 32 ] ;
2005-12-17 18:14:38 +00:00
2004-02-18 01:22:05 +00:00
/* warm up samples */
2009-01-24 18:51:43 +00:00
for ( i = 0 ; i < pred_order ; i + + ) {
2012-07-02 00:43:12 +00:00
decoded [ i ] = get_sbits_long ( & s - > gb , bps ) ;
2004-02-18 01:22:05 +00:00
}
2005-12-17 18:14:38 +00:00
2004-02-18 01:22:05 +00:00
coeff_prec = get_bits ( & s - > gb , 4 ) + 1 ;
2009-01-24 18:51:43 +00:00
if ( coeff_prec = = 16 ) {
2009-01-24 16:03:17 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " invalid coeff precision \n " ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2004-02-18 01:22:05 +00:00
}
2004-02-18 01:49:30 +00:00
qlevel = get_sbits ( & s - > gb , 5 ) ;
2009-01-24 18:51:43 +00:00
if ( qlevel < 0 ) {
2009-01-24 19:05:52 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " qlevel %d not supported, maybe buggy stream \n " ,
qlevel ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2004-02-18 04:10:52 +00:00
}
2009-01-24 18:51:43 +00:00
for ( i = 0 ; i < pred_order ; i + + ) {
2012-07-05 11:25:40 +00:00
coeffs [ pred_order - i - 1 ] = get_sbits ( & s - > gb , coeff_prec ) ;
2004-02-18 01:22:05 +00:00
}
2005-12-17 18:14:38 +00:00
2013-03-20 07:27:39 +00:00
if ( ( ret = decode_residuals ( s , decoded , pred_order ) ) < 0 )
return ret ;
2004-02-18 01:22:05 +00:00
2015-05-12 11:00:29 +00:00
if ( ( s - > buggy_lpc & & s - > flac_stream_info . bps < = 16 )
| | ( ! s - > buggy_lpc & & bps < = 16
& & bps + coeff_prec + av_log2 ( pred_order ) < = 32 ) ) {
s - > dsp . lpc16 ( decoded , coeffs , pred_order , qlevel , s - > blocksize ) ;
} else {
s - > dsp . lpc32 ( decoded , coeffs , pred_order , qlevel , s - > blocksize ) ;
2015-05-17 11:10:33 +00:00
if ( s - > flac_stream_info . bps < = 16 )
lpc_analyze_remodulate ( decoded , coeffs , pred_order , qlevel , s - > blocksize , bps ) ;
2015-05-12 11:00:29 +00:00
}
2005-12-17 18:14:38 +00:00
2004-02-18 01:22:05 +00:00
return 0 ;
}
static inline int decode_subframe ( FLACContext * s , int channel )
{
2012-07-02 00:59:04 +00:00
int32_t * decoded = s - > decoded [ channel ] ;
2004-02-18 01:22:05 +00:00
int type , wasted = 0 ;
2015-05-12 10:47:57 +00:00
int bps = s - > flac_stream_info . bps ;
2013-03-20 07:27:39 +00:00
int i , tmp , ret ;
2005-12-17 18:14:38 +00:00
2009-01-24 18:51:43 +00:00
if ( channel = = 0 ) {
2009-03-21 00:47:04 +00:00
if ( s - > ch_mode = = FLAC_CHMODE_RIGHT_SIDE )
2012-07-02 00:43:12 +00:00
bps + + ;
2009-01-24 18:51:43 +00:00
} else {
2009-03-21 00:47:04 +00:00
if ( s - > ch_mode = = FLAC_CHMODE_LEFT_SIDE | | s - > ch_mode = = FLAC_CHMODE_MID_SIDE )
2012-07-02 00:43:12 +00:00
bps + + ;
2004-02-18 01:49:30 +00:00
}
2009-01-24 18:51:43 +00:00
if ( get_bits1 ( & s - > gb ) ) {
2005-09-05 09:28:46 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " invalid subframe padding \n " ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2004-02-18 01:22:05 +00:00
}
type = get_bits ( & s - > gb , 6 ) ;
2009-01-24 15:46:19 +00:00
2009-01-24 18:51:43 +00:00
if ( get_bits1 ( & s - > gb ) ) {
2012-02-15 17:52:11 +00:00
int left = get_bits_left ( & s - > gb ) ;
2014-11-26 03:07:34 +00:00
if ( left < = 0 | |
2012-07-02 00:43:12 +00:00
( left < bps & & ! show_bits_long ( & s - > gb , left ) ) | |
! show_bits_long ( & s - > gb , bps ) ) {
2012-02-15 17:52:11 +00:00
av_log ( s - > avctx , AV_LOG_ERROR ,
" Invalid number of wasted bits > available bits (%d) - left=%d \n " ,
2012-07-02 00:43:12 +00:00
bps , left ) ;
2012-02-15 17:52:11 +00:00
return AVERROR_INVALIDDATA ;
}
2013-10-30 13:58:04 +00:00
wasted = 1 + get_unary ( & s - > gb , 1 , get_bits_left ( & s - > gb ) ) ;
2012-07-02 00:43:12 +00:00
bps - = wasted ;
2004-02-18 01:22:05 +00:00
}
2012-07-02 00:43:12 +00:00
if ( bps > 32 ) {
2013-02-25 22:53:52 +00:00
avpriv_report_missing_feature ( s - > avctx , " Decorrelated bit depth > 32 " ) ;
2012-10-08 22:41:34 +00:00
return AVERROR_PATCHWELCOME ;
2009-03-04 23:10:40 +00:00
}
2009-01-24 15:46:19 +00:00
2004-02-18 01:49:30 +00:00
//FIXME use av_log2 for types
2009-01-24 18:51:43 +00:00
if ( type = = 0 ) {
2012-07-02 00:43:12 +00:00
tmp = get_sbits_long ( & s - > gb , bps ) ;
2004-02-18 01:22:05 +00:00
for ( i = 0 ; i < s - > blocksize ; i + + )
2012-07-02 00:59:04 +00:00
decoded [ i ] = tmp ;
2009-01-24 18:51:43 +00:00
} else if ( type = = 1 ) {
2004-02-18 01:22:05 +00:00
for ( i = 0 ; i < s - > blocksize ; i + + )
2012-07-02 00:59:04 +00:00
decoded [ i ] = get_sbits_long ( & s - > gb , bps ) ;
2009-01-24 18:51:43 +00:00
} else if ( ( type > = 8 ) & & ( type < = 12 ) ) {
2013-03-20 07:27:39 +00:00
if ( ( ret = decode_subframe_fixed ( s , decoded , type & ~ 0x8 , bps ) ) < 0 )
return ret ;
2009-01-24 18:51:43 +00:00
} else if ( type > = 32 ) {
2013-03-20 07:27:39 +00:00
if ( ( ret = decode_subframe_lpc ( s , decoded , ( type & ~ 0x20 ) + 1 , bps ) ) < 0 )
return ret ;
2009-01-24 18:51:43 +00:00
} else {
2005-09-05 09:28:46 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " invalid coding type \n " ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2004-02-18 01:22:05 +00:00
}
2005-12-17 18:14:38 +00:00
2009-01-24 18:51:43 +00:00
if ( wasted ) {
2004-02-18 01:22:05 +00:00
int i ;
for ( i = 0 ; i < s - > blocksize ; i + + )
2016-12-03 23:11:17 +00:00
decoded [ i ] = ( unsigned ) decoded [ i ] < < wasted ;
2004-02-18 01:22:05 +00:00
}
return 0 ;
}
2009-03-24 01:17:55 +00:00
static int decode_frame ( FLACContext * s )
{
2012-10-21 21:02:28 +00:00
int i , ret ;
2009-03-24 01:17:55 +00:00
GetBitContext * gb = & s - > gb ;
FLACFrameInfo fi ;
2013-07-10 14:34:14 +00:00
if ( ( ret = ff_flac_decode_frame_header ( s - > avctx , gb , & fi , 0 ) ) < 0 ) {
2009-03-24 01:17:55 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " invalid frame header \n " ) ;
2013-07-10 14:34:14 +00:00
return ret ;
2004-02-18 04:10:52 +00:00
}
2005-12-17 18:14:38 +00:00
2015-05-12 10:47:57 +00:00
if ( s - > flac_stream_info . channels
& & fi . channels ! = s - > flac_stream_info . channels
& & s - > got_streaminfo ) {
s - > flac_stream_info . channels = s - > avctx - > channels = fi . channels ;
2012-10-21 21:02:28 +00:00
ff_flac_set_channel_layout ( s - > avctx ) ;
ret = allocate_buffers ( s ) ;
if ( ret < 0 )
return ret ;
2009-03-22 23:19:49 +00:00
}
2015-05-12 10:47:57 +00:00
s - > flac_stream_info . channels = s - > avctx - > channels = fi . channels ;
2013-02-07 09:36:21 +00:00
if ( ! s - > avctx - > channel_layout )
2012-12-16 16:02:39 +00:00
ff_flac_set_channel_layout ( s - > avctx ) ;
2009-03-24 01:17:55 +00:00
s - > ch_mode = fi . ch_mode ;
2009-03-22 23:19:49 +00:00
2015-05-12 10:47:57 +00:00
if ( ! s - > flac_stream_info . bps & & ! fi . bps ) {
2010-10-02 20:37:43 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " bps not found in STREAMINFO or frame header \n " ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2010-10-02 20:37:43 +00:00
}
if ( ! fi . bps ) {
2015-05-12 10:47:57 +00:00
fi . bps = s - > flac_stream_info . bps ;
} else if ( s - > flac_stream_info . bps & & fi . bps ! = s - > flac_stream_info . bps ) {
2009-03-22 23:19:49 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " switching bps mid-stream is not "
" supported \n " ) ;
2013-07-10 14:34:14 +00:00
return AVERROR_INVALIDDATA ;
2009-03-22 23:19:49 +00:00
}
2010-10-02 20:37:43 +00:00
2015-05-12 10:47:57 +00:00
if ( ! s - > flac_stream_info . bps ) {
s - > flac_stream_info . bps = s - > avctx - > bits_per_raw_sample = fi . bps ;
2012-07-02 23:29:30 +00:00
flac_set_bps ( s ) ;
}
2009-03-22 23:19:49 +00:00
2015-05-12 10:47:57 +00:00
if ( ! s - > flac_stream_info . max_blocksize )
s - > flac_stream_info . max_blocksize = FLAC_MAX_BLOCKSIZE ;
if ( fi . blocksize > s - > flac_stream_info . max_blocksize ) {
2009-03-24 01:17:55 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " blocksize %d > %d \n " , fi . blocksize ,
2015-05-12 10:47:57 +00:00
s - > flac_stream_info . max_blocksize ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2009-03-22 23:19:49 +00:00
}
2009-03-24 01:17:55 +00:00
s - > blocksize = fi . blocksize ;
2009-03-22 23:19:49 +00:00
2015-05-12 10:47:57 +00:00
if ( ! s - > flac_stream_info . samplerate & & ! fi . samplerate ) {
2010-10-02 20:37:43 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " sample rate not found in STREAMINFO "
" or frame header \n " ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2010-10-02 20:37:43 +00:00
}
2012-10-21 21:04:58 +00:00
if ( fi . samplerate = = 0 )
2015-05-12 10:47:57 +00:00
fi . samplerate = s - > flac_stream_info . samplerate ;
s - > flac_stream_info . samplerate = s - > avctx - > sample_rate = fi . samplerate ;
2004-02-18 01:22:05 +00:00
2010-10-02 20:37:43 +00:00
if ( ! s - > got_streaminfo ) {
2012-10-21 21:02:28 +00:00
ret = allocate_buffers ( s ) ;
2012-10-21 20:15:34 +00:00
if ( ret < 0 )
return ret ;
2010-10-02 20:37:43 +00:00
s - > got_streaminfo = 1 ;
2015-05-12 10:47:57 +00:00
dump_headers ( s - > avctx , & s - > flac_stream_info ) ;
2010-10-02 20:37:43 +00:00
}
2015-05-12 10:47:57 +00:00
ff_flacdsp_init ( & s - > dsp , s - > avctx - > sample_fmt ,
s - > flac_stream_info . channels , s - > flac_stream_info . bps ) ;
2010-10-02 20:37:43 +00:00
2015-05-12 10:47:57 +00:00
// dump_headers(s->avctx, &s->flac_stream_info);
2004-02-18 01:22:05 +00:00
/* subframes */
2015-05-12 10:47:57 +00:00
for ( i = 0 ; i < s - > flac_stream_info . channels ; i + + ) {
2013-03-20 07:27:39 +00:00
if ( ( ret = decode_subframe ( s , i ) ) < 0 )
return ret ;
2004-02-18 01:22:05 +00:00
}
2005-12-17 18:14:38 +00:00
2009-03-22 18:52:15 +00:00
align_get_bits ( gb ) ;
2004-02-18 01:22:05 +00:00
/* frame footer */
2009-03-22 18:52:15 +00:00
skip_bits ( gb , 16 ) ; /* data crc */
2004-02-18 01:22:05 +00:00
return 0 ;
}
2011-09-06 16:17:45 +00:00
static int flac_decode_frame ( AVCodecContext * avctx , void * data ,
int * got_frame_ptr , AVPacket * avpkt )
2004-02-18 01:22:05 +00:00
{
2012-12-23 22:49:27 +00:00
AVFrame * frame = data ;
2013-06-03 15:47:53 +00:00
ThreadFrame tframe = { . f = data } ;
2009-04-07 15:59:50 +00:00
const uint8_t * buf = avpkt - > data ;
int buf_size = avpkt - > size ;
2004-02-18 01:22:05 +00:00
FLACContext * s = avctx - > priv_data ;
2012-06-17 14:10:40 +00:00
int bytes_read = 0 ;
2011-09-06 16:17:45 +00:00
int ret ;
2007-01-14 23:50:06 +00:00
2011-09-06 16:17:45 +00:00
* got_frame_ptr = 0 ;
2004-02-18 01:22:05 +00:00
2015-05-12 10:47:57 +00:00
if ( s - > flac_stream_info . max_framesize = = 0 ) {
s - > flac_stream_info . max_framesize =
ff_flac_get_max_frame_size ( s - > flac_stream_info . max_blocksize ? s - > flac_stream_info . max_blocksize : FLAC_MAX_BLOCKSIZE ,
2010-10-02 20:37:43 +00:00
FLAC_MAX_CHANNELS , 32 ) ;
2004-02-18 01:49:30 +00:00
}
2004-02-18 01:22:05 +00:00
2013-02-02 18:17:25 +00:00
if ( buf_size > 5 & & ! memcmp ( buf , " \177 FLAC " , 5 ) ) {
2014-04-27 12:50:14 +00:00
av_log ( s - > avctx , AV_LOG_DEBUG , " skipping flac header packet 1 \n " ) ;
2013-02-02 18:17:25 +00:00
return buf_size ;
}
if ( buf_size > 0 & & ( * buf & 0x7F ) = = FLAC_METADATA_TYPE_VORBIS_COMMENT ) {
2014-04-27 12:50:14 +00:00
av_log ( s - > avctx , AV_LOG_DEBUG , " skipping vorbis comment \n " ) ;
2013-02-02 18:17:25 +00:00
return buf_size ;
}
2009-03-04 23:55:10 +00:00
/* check that there is at least the smallest decodable amount of data.
2009-03-05 04:40:42 +00:00
this amount corresponds to the smallest valid FLAC frame possible .
FF F8 69 02 00 00 9 A 00 00 34 46 */
2010-12-07 14:58:34 +00:00
if ( buf_size < FLAC_MIN_FRAME_SIZE )
2010-12-07 14:57:02 +00:00
return buf_size ;
2009-03-04 23:55:10 +00:00
2009-03-04 00:52:18 +00:00
/* check for inline header */
2009-03-05 00:56:09 +00:00
if ( AV_RB32 ( buf ) = = MKBETAG ( ' f ' , ' L ' , ' a ' , ' C ' ) ) {
2013-07-10 14:34:14 +00:00
if ( ! s - > got_streaminfo & & ( ret = parse_streaminfo ( s , buf , buf_size ) ) ) {
2009-03-04 00:52:18 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " invalid header \n " ) ;
2013-07-10 14:34:14 +00:00
return ret ;
2009-03-04 00:52:18 +00:00
}
2010-12-07 14:57:02 +00:00
return get_metadata_size ( buf , buf_size ) ;
2009-01-24 16:13:21 +00:00
}
2009-03-05 01:15:38 +00:00
/* decode frame */
2013-06-03 19:21:17 +00:00
if ( ( ret = init_get_bits8 ( & s - > gb , buf , buf_size ) ) < 0 )
return ret ;
2013-03-20 07:27:39 +00:00
if ( ( ret = decode_frame ( s ) ) < 0 ) {
2009-01-24 16:13:21 +00:00
av_log ( s - > avctx , AV_LOG_ERROR , " decode_frame() failed \n " ) ;
2013-03-20 07:27:39 +00:00
return ret ;
2009-01-24 16:13:21 +00:00
}
2013-02-16 09:07:49 +00:00
bytes_read = get_bits_count ( & s - > gb ) / 8 ;
2013-10-27 08:28:30 +00:00
if ( ( s - > avctx - > err_recognition & ( AV_EF_CRCCHECK | AV_EF_COMPLIANT ) ) & &
2013-02-16 09:07:49 +00:00
av_crc ( av_crc_get_table ( AV_CRC_16_ANSI ) ,
0 , buf , bytes_read ) ) {
av_log ( s - > avctx , AV_LOG_ERROR , " CRC error at PTS % " PRId64 " \n " , avpkt - > pts ) ;
if ( s - > avctx - > err_recognition & AV_EF_EXPLODE )
return AVERROR_INVALIDDATA ;
}
2004-02-18 01:49:30 +00:00
2011-09-06 16:17:45 +00:00
/* get output buffer */
2012-12-23 22:49:27 +00:00
frame - > nb_samples = s - > blocksize ;
2013-06-03 15:47:53 +00:00
if ( ( ret = ff_thread_get_buffer ( avctx , & tframe , 0 ) ) < 0 )
2011-09-06 16:17:45 +00:00
return ret ;
2012-06-17 14:10:40 +00:00
2015-05-12 10:47:57 +00:00
s - > dsp . decorrelate [ s - > ch_mode ] ( frame - > data , s - > decoded ,
s - > flac_stream_info . channels ,
2012-06-17 14:10:40 +00:00
s - > blocksize , s - > sample_shift ) ;
2004-02-18 01:22:05 +00:00
2009-03-04 23:24:44 +00:00
if ( bytes_read > buf_size ) {
av_log ( s - > avctx , AV_LOG_ERROR , " overread: %d \n " , bytes_read - buf_size ) ;
2013-03-20 07:27:39 +00:00
return AVERROR_INVALIDDATA ;
2004-02-18 01:49:30 +00:00
}
2010-12-07 14:57:02 +00:00
if ( bytes_read < buf_size ) {
av_log ( s - > avctx , AV_LOG_DEBUG , " underread: %d orig size: %d \n " ,
buf_size - bytes_read , buf_size ) ;
}
2004-02-18 01:22:05 +00:00
2012-12-23 22:49:27 +00:00
* got_frame_ptr = 1 ;
2011-09-06 16:17:45 +00:00
2010-12-07 14:57:02 +00:00
return bytes_read ;
2004-02-18 01:22:05 +00:00
}
2015-09-17 02:22:27 +00:00
# if HAVE_THREADS
2013-06-03 15:47:53 +00:00
static int init_thread_copy ( AVCodecContext * avctx )
{
FLACContext * s = avctx - > priv_data ;
s - > decoded_buffer = NULL ;
s - > decoded_buffer_size = 0 ;
2013-06-13 21:49:18 +00:00
s - > avctx = avctx ;
2015-05-12 10:47:57 +00:00
if ( s - > flac_stream_info . max_blocksize )
2013-06-06 01:00:56 +00:00
return allocate_buffers ( s ) ;
return 0 ;
2013-06-03 15:47:53 +00:00
}
2015-09-17 02:22:27 +00:00
# endif
2013-06-03 15:47:53 +00:00
2008-03-21 03:11:20 +00:00
static av_cold int flac_decode_close ( AVCodecContext * avctx )
2004-02-18 01:22:05 +00:00
{
FLACContext * s = avctx - > priv_data ;
2005-12-17 18:14:38 +00:00
2012-10-21 20:15:34 +00:00
av_freep ( & s - > decoded_buffer ) ;
2005-12-17 18:14:38 +00:00
2004-02-18 01:22:05 +00:00
return 0 ;
}
2015-05-12 11:00:29 +00:00
static const AVOption options [ ] = {
2015-11-21 21:04:39 +00:00
{ " use_buggy_lpc " , " emulate old buggy lavc behavior " , offsetof ( FLACContext , buggy_lpc ) , AV_OPT_TYPE_BOOL , { . i64 = 0 } , 0 , 1 , AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM } ,
2015-05-12 11:00:29 +00:00
{ NULL } ,
} ;
static const AVClass flac_decoder_class = {
" FLAC decoder " ,
av_default_item_name ,
options ,
LIBAVUTIL_VERSION_INT ,
} ;
2011-01-25 21:40:11 +00:00
AVCodec ff_flac_decoder = {
2011-07-17 10:54:31 +00:00
. name = " flac " ,
2013-10-03 20:57:53 +00:00
. long_name = NULL_IF_CONFIG_SMALL ( " FLAC (Free Lossless Audio Codec) " ) ,
2011-07-17 10:54:31 +00:00
. type = AVMEDIA_TYPE_AUDIO ,
2012-08-05 09:11:04 +00:00
. id = AV_CODEC_ID_FLAC ,
2011-07-17 10:54:31 +00:00
. priv_data_size = sizeof ( FLACContext ) ,
. init = flac_decode_init ,
. close = flac_decode_close ,
. decode = flac_decode_frame ,
2013-06-06 20:17:36 +00:00
. init_thread_copy = ONLY_IF_THREADS_ENABLED ( init_thread_copy ) ,
2015-07-27 20:21:19 +00:00
. capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS ,
2012-07-02 23:29:30 +00:00
. sample_fmts = ( const enum AVSampleFormat [ ] ) { AV_SAMPLE_FMT_S16 ,
AV_SAMPLE_FMT_S16P ,
AV_SAMPLE_FMT_S32 ,
AV_SAMPLE_FMT_S32P ,
2012-10-15 13:26:47 +00:00
AV_SAMPLE_FMT_NONE } ,
2015-05-12 11:00:29 +00:00
. priv_class = & flac_decoder_class ,
2004-02-18 01:22:05 +00:00
} ;