2012-02-05 10:31:33 +00:00
/*
2006-06-24 10:20:15 +00:00
* FLAC audio encoder
2008-08-16 22:42:59 +00:00
* Copyright ( c ) 2006 Justin Ruggles < justin . ruggles @ gmail . com >
2006-06-24 10:20:15 +00:00
*
2011-03-18 17:35:10 +00:00
* This file is part of Libav .
2006-10-07 15:30:46 +00:00
*
2011-03-18 17:35:10 +00:00
* Libav is free software ; you can redistribute it and / or
2006-06-24 10:20:15 +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 .
2006-06-24 10:20:15 +00:00
*
2011-03-18 17:35:10 +00:00
* Libav is distributed in the hope that it will be useful ,
2006-06-24 10:20:15 +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
2011-03-18 17:35:10 +00:00
* License along with Libav ; if not , write to the Free Software
2006-06-24 10:20:15 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
2008-05-09 11:56:36 +00:00
# include "libavutil/crc.h"
2008-09-14 21:39:54 +00:00
# include "libavutil/md5.h"
2011-04-02 10:28:01 +00:00
# include "libavutil/opt.h"
2006-06-24 10:20:15 +00:00
# include "avcodec.h"
2009-04-13 16:20:26 +00:00
# include "get_bits.h"
2006-06-24 10:20:15 +00:00
# include "golomb.h"
2012-02-03 23:43:39 +00:00
# include "internal.h"
2008-08-16 17:18:20 +00:00
# include "lpc.h"
2009-03-19 03:04:21 +00:00
# include "flac.h"
2009-03-21 01:16:38 +00:00
# include "flacdata.h"
2006-06-24 10:20:15 +00:00
# define FLAC_SUBFRAME_CONSTANT 0
# define FLAC_SUBFRAME_VERBATIM 1
# define FLAC_SUBFRAME_FIXED 8
# define FLAC_SUBFRAME_LPC 32
2006-07-02 10:22:31 +00:00
# define MAX_FIXED_ORDER 4
# define MAX_PARTITION_ORDER 8
# define MAX_PARTITIONS (1 << MAX_PARTITION_ORDER)
# define MAX_LPC_PRECISION 15
# define MAX_LPC_SHIFT 15
# define MAX_RICE_PARAM 14
typedef struct CompressionOptions {
int compression_level ;
int block_time_ms ;
2011-04-02 10:28:01 +00:00
enum FFLPCType lpc_type ;
2010-07-11 16:56:20 +00:00
int lpc_passes ;
2006-07-02 10:22:31 +00:00
int lpc_coeff_precision ;
int min_prediction_order ;
int max_prediction_order ;
int prediction_order_method ;
int min_partition_order ;
int max_partition_order ;
} CompressionOptions ;
2006-06-27 21:01:21 +00:00
typedef struct RiceContext {
int porder ;
2006-07-02 10:22:31 +00:00
int params [ MAX_PARTITIONS ] ;
2006-06-27 21:01:21 +00:00
} RiceContext ;
2006-06-24 10:20:15 +00:00
typedef struct FlacSubframe {
int type ;
int type_code ;
int obits ;
int order ;
2006-07-02 10:22:31 +00:00
int32_t coefs [ MAX_LPC_ORDER ] ;
int shift ;
2006-06-27 21:01:21 +00:00
RiceContext rc ;
2006-06-24 10:20:15 +00:00
int32_t samples [ FLAC_MAX_BLOCKSIZE ] ;
2007-09-25 23:34:48 +00:00
int32_t residual [ FLAC_MAX_BLOCKSIZE + 1 ] ;
2006-06-24 10:20:15 +00:00
} FlacSubframe ;
typedef struct FlacFrame {
2009-03-19 03:04:21 +00:00
FlacSubframe subframes [ FLAC_MAX_CHANNELS ] ;
2006-06-24 10:20:15 +00:00
int blocksize ;
int bs_code [ 2 ] ;
uint8_t crc8 ;
int ch_mode ;
2010-07-31 16:46:32 +00:00
int verbatim_only ;
2006-06-24 10:20:15 +00:00
} FlacFrame ;
typedef struct FlacEncodeContext {
2011-04-02 10:28:01 +00:00
AVClass * class ;
2006-06-24 10:20:15 +00:00
PutBitContext pb ;
2009-03-21 01:20:28 +00:00
int channels ;
int samplerate ;
2006-06-24 10:20:15 +00:00
int sr_code [ 2 ] ;
2009-04-16 02:28:49 +00:00
int max_blocksize ;
2008-09-14 22:25:50 +00:00
int min_framesize ;
2009-03-21 01:20:28 +00:00
int max_framesize ;
2008-09-14 22:25:50 +00:00
int max_encoded_framesize ;
2006-06-24 10:20:15 +00:00
uint32_t frame_count ;
2008-09-14 20:00:36 +00:00
uint64_t sample_count ;
2008-09-14 21:39:54 +00:00
uint8_t md5sum [ 16 ] ;
2006-06-24 10:20:15 +00:00
FlacFrame frame ;
2006-07-02 10:22:31 +00:00
CompressionOptions options ;
2006-06-27 21:01:21 +00:00
AVCodecContext * avctx ;
2011-01-21 00:11:44 +00:00
LPCContext lpc_ctx ;
2008-09-14 21:39:54 +00:00
struct AVMD5 * md5ctx ;
2006-06-24 10:20:15 +00:00
} FlacEncodeContext ;
2010-07-30 18:30:09 +00:00
2006-06-24 10:20:15 +00:00
/**
2010-07-30 18:30:09 +00:00
* Write streaminfo metadata block to byte array .
2006-06-24 10:20:15 +00:00
*/
static void write_streaminfo ( FlacEncodeContext * s , uint8_t * header )
{
PutBitContext pb ;
memset ( header , 0 , FLAC_STREAMINFO_SIZE ) ;
init_put_bits ( & pb , header , FLAC_STREAMINFO_SIZE ) ;
/* streaminfo metadata block */
2009-04-16 02:28:49 +00:00
put_bits ( & pb , 16 , s - > max_blocksize ) ;
put_bits ( & pb , 16 , s - > max_blocksize ) ;
2008-09-14 22:25:50 +00:00
put_bits ( & pb , 24 , s - > min_framesize ) ;
2006-06-24 10:20:15 +00:00
put_bits ( & pb , 24 , s - > max_framesize ) ;
put_bits ( & pb , 20 , s - > samplerate ) ;
put_bits ( & pb , 3 , s - > channels - 1 ) ;
put_bits ( & pb , 5 , 15 ) ; /* bits per sample - 1 */
2008-09-14 20:00:36 +00:00
/* write 36-bit sample count in 2 put_bits() calls */
put_bits ( & pb , 24 , ( s - > sample_count & 0xFFFFFF000LL ) > > 12 ) ;
put_bits ( & pb , 12 , s - > sample_count & 0x000000FFFLL ) ;
2006-06-24 10:20:15 +00:00
flush_put_bits ( & pb ) ;
2008-09-14 21:39:54 +00:00
memcpy ( & header [ 18 ] , s - > md5sum , 16 ) ;
2006-06-24 10:20:15 +00:00
}
2010-07-30 18:30:09 +00:00
2006-06-24 10:20:15 +00:00
/**
2010-07-30 18:30:09 +00:00
* Set blocksize based on samplerate .
* Choose the closest predefined blocksize > = BLOCK_TIME_MS milliseconds .
2006-06-24 10:20:15 +00:00
*/
2006-07-02 10:22:31 +00:00
static int select_blocksize ( int samplerate , int block_time_ms )
2006-06-24 10:20:15 +00:00
{
int i ;
int target ;
int blocksize ;
assert ( samplerate > 0 ) ;
2009-03-21 01:16:38 +00:00
blocksize = ff_flac_blocksize_table [ 1 ] ;
2010-07-30 18:30:09 +00:00
target = ( samplerate * block_time_ms ) / 1000 ;
for ( i = 0 ; i < 16 ; i + + ) {
if ( target > = ff_flac_blocksize_table [ i ] & &
ff_flac_blocksize_table [ i ] > blocksize ) {
2009-03-21 01:16:38 +00:00
blocksize = ff_flac_blocksize_table [ i ] ;
2006-06-24 10:20:15 +00:00
}
}
return blocksize ;
}
2010-07-30 18:30:09 +00:00
2010-07-30 18:59:27 +00:00
static av_cold void dprint_compression_options ( FlacEncodeContext * s )
{
AVCodecContext * avctx = s - > avctx ;
CompressionOptions * opt = & s - > options ;
av_log ( avctx , AV_LOG_DEBUG , " compression: %d \n " , opt - > compression_level ) ;
switch ( opt - > lpc_type ) {
2011-04-02 10:28:01 +00:00
case FF_LPC_TYPE_NONE :
2010-07-30 18:59:27 +00:00
av_log ( avctx , AV_LOG_DEBUG , " lpc type: None \n " ) ;
break ;
2011-04-02 10:28:01 +00:00
case FF_LPC_TYPE_FIXED :
2010-07-30 18:59:27 +00:00
av_log ( avctx , AV_LOG_DEBUG , " lpc type: Fixed pre-defined coefficients \n " ) ;
break ;
2011-04-02 10:28:01 +00:00
case FF_LPC_TYPE_LEVINSON :
2010-07-30 18:59:27 +00:00
av_log ( avctx , AV_LOG_DEBUG , " lpc type: Levinson-Durbin recursion with Welch window \n " ) ;
break ;
2011-04-02 10:28:01 +00:00
case FF_LPC_TYPE_CHOLESKY :
2010-07-30 18:59:27 +00:00
av_log ( avctx , AV_LOG_DEBUG , " lpc type: Cholesky factorization, %d pass%s \n " ,
opt - > lpc_passes , opt - > lpc_passes = = 1 ? " " : " es " ) ;
break ;
}
av_log ( avctx , AV_LOG_DEBUG , " prediction order: %d, %d \n " ,
opt - > min_prediction_order , opt - > max_prediction_order ) ;
switch ( opt - > prediction_order_method ) {
case ORDER_METHOD_EST :
av_log ( avctx , AV_LOG_DEBUG , " order method: %s \n " , " estimate " ) ;
break ;
case ORDER_METHOD_2LEVEL :
av_log ( avctx , AV_LOG_DEBUG , " order method: %s \n " , " 2-level " ) ;
break ;
case ORDER_METHOD_4LEVEL :
av_log ( avctx , AV_LOG_DEBUG , " order method: %s \n " , " 4-level " ) ;
break ;
case ORDER_METHOD_8LEVEL :
av_log ( avctx , AV_LOG_DEBUG , " order method: %s \n " , " 8-level " ) ;
break ;
case ORDER_METHOD_SEARCH :
av_log ( avctx , AV_LOG_DEBUG , " order method: %s \n " , " full search " ) ;
break ;
case ORDER_METHOD_LOG :
av_log ( avctx , AV_LOG_DEBUG , " order method: %s \n " , " log search " ) ;
break ;
}
av_log ( avctx , AV_LOG_DEBUG , " partition order: %d, %d \n " ,
opt - > min_partition_order , opt - > max_partition_order ) ;
av_log ( avctx , AV_LOG_DEBUG , " block size: %d \n " , avctx - > frame_size ) ;
av_log ( avctx , AV_LOG_DEBUG , " lpc precision: %d \n " ,
opt - > lpc_coeff_precision ) ;
}
2008-03-21 03:11:20 +00:00
static av_cold int flac_encode_init ( AVCodecContext * avctx )
2006-06-24 10:20:15 +00:00
{
int freq = avctx - > sample_rate ;
int channels = avctx - > channels ;
FlacEncodeContext * s = avctx - > priv_data ;
2011-01-21 00:12:03 +00:00
int i , level , ret ;
2006-06-24 10:20:15 +00:00
uint8_t * streaminfo ;
2006-06-27 21:01:21 +00:00
s - > avctx = avctx ;
2010-11-12 11:04:40 +00:00
if ( avctx - > sample_fmt ! = AV_SAMPLE_FMT_S16 )
2006-06-24 10:20:15 +00:00
return - 1 ;
2010-07-30 18:30:09 +00:00
if ( channels < 1 | | channels > FLAC_MAX_CHANNELS )
2006-06-24 10:20:15 +00:00
return - 1 ;
s - > channels = channels ;
/* find samplerate in table */
2010-07-30 18:30:09 +00:00
if ( freq < 1 )
2006-06-24 10:20:15 +00:00
return - 1 ;
2010-07-30 18:30:09 +00:00
for ( i = 4 ; i < 12 ; i + + ) {
if ( freq = = ff_flac_sample_rate_table [ i ] ) {
2009-03-21 01:16:38 +00:00
s - > samplerate = ff_flac_sample_rate_table [ i ] ;
2006-06-24 10:20:15 +00:00
s - > sr_code [ 0 ] = i ;
s - > sr_code [ 1 ] = 0 ;
break ;
}
}
/* if not in table, samplerate is non-standard */
2010-07-30 18:30:09 +00:00
if ( i = = 12 ) {
if ( freq % 1000 = = 0 & & freq < 255000 ) {
2006-06-24 10:20:15 +00:00
s - > sr_code [ 0 ] = 12 ;
s - > sr_code [ 1 ] = freq / 1000 ;
2010-07-30 18:30:09 +00:00
} else if ( freq % 10 = = 0 & & freq < 655350 ) {
2006-06-24 10:20:15 +00:00
s - > sr_code [ 0 ] = 14 ;
s - > sr_code [ 1 ] = freq / 10 ;
2010-07-30 18:30:09 +00:00
} else if ( freq < 65535 ) {
2006-06-24 10:20:15 +00:00
s - > sr_code [ 0 ] = 13 ;
s - > sr_code [ 1 ] = freq ;
} else {
return - 1 ;
}
s - > samplerate = freq ;
}
2006-07-02 10:22:31 +00:00
/* set compression option defaults based on avctx->compression_level */
2010-07-30 18:30:09 +00:00
if ( avctx - > compression_level < 0 )
2006-07-02 10:22:31 +00:00
s - > options . compression_level = 5 ;
2010-07-30 18:30:09 +00:00
else
2006-07-02 10:22:31 +00:00
s - > options . compression_level = avctx - > compression_level ;
2010-07-30 18:30:09 +00:00
level = s - > options . compression_level ;
if ( level > 12 ) {
2006-07-02 10:22:31 +00:00
av_log ( avctx , AV_LOG_ERROR , " invalid compression level: %d \n " ,
s - > options . compression_level ) ;
return - 1 ;
}
2010-07-30 18:30:09 +00:00
s - > options . block_time_ms = ( ( int [ ] ) { 27 , 27 , 27 , 105 , 105 , 105 , 105 , 105 , 105 , 105 , 105 , 105 , 105 } ) [ level ] ;
2011-04-02 10:28:01 +00:00
if ( s - > options . lpc_type = = FF_LPC_TYPE_DEFAULT )
s - > options . lpc_type = ( ( int [ ] ) { FF_LPC_TYPE_FIXED , FF_LPC_TYPE_FIXED , FF_LPC_TYPE_FIXED ,
FF_LPC_TYPE_LEVINSON , FF_LPC_TYPE_LEVINSON , FF_LPC_TYPE_LEVINSON ,
FF_LPC_TYPE_LEVINSON , FF_LPC_TYPE_LEVINSON , FF_LPC_TYPE_LEVINSON ,
FF_LPC_TYPE_LEVINSON , FF_LPC_TYPE_LEVINSON , FF_LPC_TYPE_LEVINSON ,
FF_LPC_TYPE_LEVINSON } ) [ level ] ;
2010-07-30 18:30:09 +00:00
s - > options . min_prediction_order = ( ( int [ ] ) { 2 , 0 , 0 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 } ) [ level ] ;
s - > options . max_prediction_order = ( ( int [ ] ) { 3 , 4 , 4 , 6 , 8 , 8 , 8 , 8 , 12 , 12 , 12 , 32 , 32 } ) [ level ] ;
2011-04-02 10:28:01 +00:00
if ( s - > options . prediction_order_method < 0 )
s - > options . prediction_order_method = ( ( int [ ] ) { ORDER_METHOD_EST , ORDER_METHOD_EST , ORDER_METHOD_EST ,
ORDER_METHOD_EST , ORDER_METHOD_EST , ORDER_METHOD_EST ,
ORDER_METHOD_4LEVEL , ORDER_METHOD_LOG , ORDER_METHOD_4LEVEL ,
ORDER_METHOD_LOG , ORDER_METHOD_SEARCH , ORDER_METHOD_LOG ,
ORDER_METHOD_SEARCH } ) [ level ] ;
2010-07-30 18:30:09 +00:00
2011-04-02 10:28:01 +00:00
if ( s - > options . min_partition_order > s - > options . max_partition_order ) {
av_log ( avctx , AV_LOG_ERROR , " invalid partition orders: min=%d max=%d \n " ,
s - > options . min_partition_order , s - > options . max_partition_order ) ;
return AVERROR ( EINVAL ) ;
}
if ( s - > options . min_partition_order < 0 )
s - > options . min_partition_order = ( ( int [ ] ) { 2 , 2 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ) [ level ] ;
if ( s - > options . max_partition_order < 0 )
s - > options . max_partition_order = ( ( int [ ] ) { 2 , 2 , 3 , 3 , 3 , 8 , 8 , 8 , 8 , 8 , 8 , 8 , 8 } ) [ level ] ;
2006-07-02 11:06:27 +00:00
2011-04-02 10:28:01 +00:00
if ( s - > options . lpc_type = = FF_LPC_TYPE_NONE ) {
2010-07-11 16:56:20 +00:00
s - > options . min_prediction_order = 0 ;
} else if ( avctx - > min_prediction_order > = 0 ) {
2011-04-02 10:28:01 +00:00
if ( s - > options . lpc_type = = FF_LPC_TYPE_FIXED ) {
2010-07-30 18:30:09 +00:00
if ( avctx - > min_prediction_order > MAX_FIXED_ORDER ) {
2006-07-02 10:22:31 +00:00
av_log ( avctx , AV_LOG_ERROR , " invalid min prediction order: %d \n " ,
avctx - > min_prediction_order ) ;
return - 1 ;
}
2010-07-30 18:30:09 +00:00
} else if ( avctx - > min_prediction_order < MIN_LPC_ORDER | |
avctx - > min_prediction_order > MAX_LPC_ORDER ) {
2010-07-11 16:56:20 +00:00
av_log ( avctx , AV_LOG_ERROR , " invalid min prediction order: %d \n " ,
avctx - > min_prediction_order ) ;
return - 1 ;
2006-07-02 10:22:31 +00:00
}
s - > options . min_prediction_order = avctx - > min_prediction_order ;
}
2011-04-02 10:28:01 +00:00
if ( s - > options . lpc_type = = FF_LPC_TYPE_NONE ) {
2010-07-11 16:56:20 +00:00
s - > options . max_prediction_order = 0 ;
} else if ( avctx - > max_prediction_order > = 0 ) {
2011-04-02 10:28:01 +00:00
if ( s - > options . lpc_type = = FF_LPC_TYPE_FIXED ) {
2010-07-30 18:30:09 +00:00
if ( avctx - > max_prediction_order > MAX_FIXED_ORDER ) {
2006-07-02 10:22:31 +00:00
av_log ( avctx , AV_LOG_ERROR , " invalid max prediction order: %d \n " ,
avctx - > max_prediction_order ) ;
return - 1 ;
}
2010-07-11 16:56:20 +00:00
} else if ( avctx - > max_prediction_order < MIN_LPC_ORDER | |
avctx - > max_prediction_order > MAX_LPC_ORDER ) {
av_log ( avctx , AV_LOG_ERROR , " invalid max prediction order: %d \n " ,
avctx - > max_prediction_order ) ;
return - 1 ;
2006-07-02 10:22:31 +00:00
}
s - > options . max_prediction_order = avctx - > max_prediction_order ;
}
2010-07-30 18:30:09 +00:00
if ( s - > options . max_prediction_order < s - > options . min_prediction_order ) {
2006-07-02 10:22:31 +00:00
av_log ( avctx , AV_LOG_ERROR , " invalid prediction orders: min=%d max=%d \n " ,
s - > options . min_prediction_order , s - > options . max_prediction_order ) ;
return - 1 ;
}
2010-07-30 18:30:09 +00:00
if ( avctx - > frame_size > 0 ) {
if ( avctx - > frame_size < FLAC_MIN_BLOCKSIZE | |
2006-07-08 16:39:58 +00:00
avctx - > frame_size > FLAC_MAX_BLOCKSIZE ) {
2006-07-02 10:22:31 +00:00
av_log ( avctx , AV_LOG_ERROR , " invalid block size: %d \n " ,
avctx - > frame_size ) ;
return - 1 ;
}
} else {
2008-03-31 00:29:52 +00:00
s - > avctx - > frame_size = select_blocksize ( s - > samplerate , s - > options . block_time_ms ) ;
2006-07-02 10:22:31 +00:00
}
2009-04-16 02:28:49 +00:00
s - > max_blocksize = s - > avctx - > frame_size ;
2006-07-02 10:22:31 +00:00
2006-06-26 06:00:07 +00:00
/* set maximum encoded frame size in verbatim mode */
2009-03-21 01:54:31 +00:00
s - > max_framesize = ff_flac_get_max_frame_size ( s - > avctx - > frame_size ,
s - > channels , 16 ) ;
2006-06-24 10:20:15 +00:00
2008-09-14 21:39:54 +00:00
/* initialize MD5 context */
s - > md5ctx = av_malloc ( av_md5_size ) ;
2010-07-30 18:30:09 +00:00
if ( ! s - > md5ctx )
2010-04-03 14:15:00 +00:00
return AVERROR ( ENOMEM ) ;
2008-09-14 21:39:54 +00:00
av_md5_init ( s - > md5ctx ) ;
2006-06-24 10:20:15 +00:00
streaminfo = av_malloc ( FLAC_STREAMINFO_SIZE ) ;
2010-07-30 18:34:39 +00:00
if ( ! streaminfo )
return AVERROR ( ENOMEM ) ;
2006-06-24 10:20:15 +00:00
write_streaminfo ( s , streaminfo ) ;
avctx - > extradata = streaminfo ;
avctx - > extradata_size = FLAC_STREAMINFO_SIZE ;
2010-07-30 18:30:09 +00:00
s - > frame_count = 0 ;
2009-03-21 00:50:19 +00:00
s - > min_framesize = s - > max_framesize ;
2006-06-24 10:20:15 +00:00
2012-02-03 23:43:39 +00:00
# if FF_API_OLD_ENCODE_AUDIO
2006-06-24 10:20:15 +00:00
avctx - > coded_frame = avcodec_alloc_frame ( ) ;
2010-07-30 18:34:39 +00:00
if ( ! avctx - > coded_frame )
return AVERROR ( ENOMEM ) ;
2012-02-03 23:43:39 +00:00
# endif
2006-06-24 10:20:15 +00:00
2011-01-21 00:12:03 +00:00
ret = ff_lpc_init ( & s - > lpc_ctx , avctx - > frame_size ,
2011-04-02 10:28:01 +00:00
s - > options . max_prediction_order , FF_LPC_TYPE_LEVINSON ) ;
2011-01-21 00:12:03 +00:00
2010-07-30 18:59:27 +00:00
dprint_compression_options ( s ) ;
2011-01-21 00:12:03 +00:00
return ret ;
2006-06-24 10:20:15 +00:00
}
2010-07-30 18:30:09 +00:00
2012-02-03 23:43:39 +00:00
static void init_frame ( FlacEncodeContext * s , int nb_samples )
2006-06-24 10:20:15 +00:00
{
int i , ch ;
FlacFrame * frame ;
frame = & s - > frame ;
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < 16 ; i + + ) {
2012-02-03 23:43:39 +00:00
if ( nb_samples = = ff_flac_blocksize_table [ i ] ) {
2010-07-30 18:30:09 +00:00
frame - > blocksize = ff_flac_blocksize_table [ i ] ;
2006-06-24 10:20:15 +00:00
frame - > bs_code [ 0 ] = i ;
frame - > bs_code [ 1 ] = 0 ;
break ;
}
}
2010-07-30 18:30:09 +00:00
if ( i = = 16 ) {
2012-02-03 23:43:39 +00:00
frame - > blocksize = nb_samples ;
2010-07-30 18:30:09 +00:00
if ( frame - > blocksize < = 256 ) {
2006-06-24 10:20:15 +00:00
frame - > bs_code [ 0 ] = 6 ;
frame - > bs_code [ 1 ] = frame - > blocksize - 1 ;
} else {
frame - > bs_code [ 0 ] = 7 ;
frame - > bs_code [ 1 ] = frame - > blocksize - 1 ;
}
}
2010-07-30 18:30:09 +00:00
for ( ch = 0 ; ch < s - > channels ; ch + + )
2006-06-24 10:20:15 +00:00
frame - > subframes [ ch ] . obits = 16 ;
2010-07-31 16:46:32 +00:00
frame - > verbatim_only = 0 ;
2006-06-24 10:20:15 +00:00
}
2010-07-30 18:30:09 +00:00
2006-06-24 10:20:15 +00:00
/**
2010-07-30 18:30:09 +00:00
* Copy channel - interleaved input samples into separate subframes .
2006-06-24 10:20:15 +00:00
*/
2010-07-24 13:59:49 +00:00
static void copy_samples ( FlacEncodeContext * s , const int16_t * samples )
2006-06-24 10:20:15 +00:00
{
int i , j , ch ;
FlacFrame * frame ;
frame = & s - > frame ;
2010-07-30 18:30:09 +00:00
for ( i = 0 , j = 0 ; i < frame - > blocksize ; i + + )
for ( ch = 0 ; ch < s - > channels ; ch + + , j + + )
2006-06-24 10:20:15 +00:00
frame - > subframes [ ch ] . samples [ i ] = samples [ j ] ;
}
2006-06-27 21:01:21 +00:00
2010-07-31 20:32:12 +00:00
static int rice_count_exact ( int32_t * res , int n , int k )
{
int i ;
int count = 0 ;
for ( i = 0 ; i < n ; i + + ) {
int32_t v = - 2 * res [ i ] - 1 ;
v ^ = v > > 31 ;
count + = ( v > > k ) + 1 + k ;
}
return count ;
}
static int subframe_count_exact ( FlacEncodeContext * s , FlacSubframe * sub ,
int pred_order )
{
int p , porder , psize ;
int i , part_end ;
int count = 0 ;
/* subframe header */
count + = 8 ;
/* subframe */
if ( sub - > type = = FLAC_SUBFRAME_CONSTANT ) {
count + = sub - > obits ;
} else if ( sub - > type = = FLAC_SUBFRAME_VERBATIM ) {
count + = s - > frame . blocksize * sub - > obits ;
} else {
/* warm-up samples */
count + = pred_order * sub - > obits ;
/* LPC coefficients */
if ( sub - > type = = FLAC_SUBFRAME_LPC )
count + = 4 + 5 + pred_order * s - > options . lpc_coeff_precision ;
/* rice-encoded block */
count + = 2 ;
/* partition order */
porder = sub - > rc . porder ;
psize = s - > frame . blocksize > > porder ;
count + = 4 ;
/* residual */
i = pred_order ;
part_end = psize ;
for ( p = 0 ; p < 1 < < porder ; p + + ) {
int k = sub - > rc . params [ p ] ;
count + = 4 ;
count + = rice_count_exact ( & sub - > residual [ i ] , part_end - i , k ) ;
i = part_end ;
part_end = FFMIN ( s - > frame . blocksize , part_end + psize ) ;
}
}
return count ;
}
2006-06-27 21:01:21 +00:00
# define rice_encode_count(sum, n, k) (((n)*((k)+1))+((sum-(n>>1))>>(k)))
2007-09-29 05:41:27 +00:00
/**
2010-07-30 18:30:09 +00:00
* Solve for d / dk ( rice_encode_count ) = n - ( ( sum - ( n > > 1 ) ) > > ( k + 1 ) ) = 0.
2007-09-29 05:41:27 +00:00
*/
2006-06-27 21:01:21 +00:00
static int find_optimal_param ( uint32_t sum , int n )
{
2007-09-29 05:41:27 +00:00
int k ;
uint32_t sum2 ;
2010-07-30 18:30:09 +00:00
if ( sum < = n > > 1 )
2007-09-29 05:41:27 +00:00
return 0 ;
2010-07-30 18:30:09 +00:00
sum2 = sum - ( n > > 1 ) ;
k = av_log2 ( n < 256 ? FASTDIV ( sum2 , n ) : sum2 / n ) ;
2007-09-29 05:41:27 +00:00
return FFMIN ( k , MAX_RICE_PARAM ) ;
2006-06-27 21:01:21 +00:00
}
2010-07-30 18:30:09 +00:00
2006-06-27 21:01:21 +00:00
static uint32_t calc_optimal_rice_params ( RiceContext * rc , int porder ,
uint32_t * sums , int n , int pred_order )
{
int i ;
int k , cnt , part ;
uint32_t all_bits ;
2010-07-30 18:30:09 +00:00
part = ( 1 < < porder ) ;
2007-10-27 13:39:19 +00:00
all_bits = 4 * part ;
2006-06-27 21:01:21 +00:00
cnt = ( n > > porder ) - pred_order ;
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < part ; i + + ) {
2006-06-27 21:01:21 +00:00
k = find_optimal_param ( sums [ i ] , cnt ) ;
rc - > params [ i ] = k ;
all_bits + = rice_encode_count ( sums [ i ] , cnt , k ) ;
2007-10-27 13:39:19 +00:00
cnt = n > > porder ;
2006-06-27 21:01:21 +00:00
}
rc - > porder = porder ;
return all_bits ;
}
2010-07-30 18:30:09 +00:00
2006-07-02 10:22:31 +00:00
static void calc_sums ( int pmin , int pmax , uint32_t * data , int n , int pred_order ,
uint32_t sums [ ] [ MAX_PARTITIONS ] )
2006-06-27 21:01:21 +00:00
{
int i , j ;
2006-07-02 09:30:51 +00:00
int parts ;
uint32_t * res , * res_end ;
2006-06-27 21:01:21 +00:00
/* sums for highest level */
2010-07-30 18:30:09 +00:00
parts = ( 1 < < pmax ) ;
res = & data [ pred_order ] ;
2006-07-02 09:30:51 +00:00
res_end = & data [ n > > pmax ] ;
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < parts ; i + + ) {
2007-09-29 01:54:25 +00:00
uint32_t sum = 0 ;
2010-07-30 18:30:09 +00:00
while ( res < res_end )
2007-09-29 01:54:25 +00:00
sum + = * ( res + + ) ;
sums [ pmax ] [ i ] = sum ;
2010-07-30 18:30:09 +00:00
res_end + = n > > pmax ;
2006-06-27 21:01:21 +00:00
}
/* sums for lower levels */
2010-07-30 18:30:09 +00:00
for ( i = pmax - 1 ; i > = pmin ; i - - ) {
2006-06-27 21:01:21 +00:00
parts = ( 1 < < i ) ;
2010-07-30 18:30:09 +00:00
for ( j = 0 ; j < parts ; j + + )
2006-06-27 21:01:21 +00:00
sums [ i ] [ j ] = sums [ i + 1 ] [ 2 * j ] + sums [ i + 1 ] [ 2 * j + 1 ] ;
}
}
2010-07-30 18:30:09 +00:00
2006-07-02 10:22:31 +00:00
static uint32_t calc_rice_params ( RiceContext * rc , int pmin , int pmax ,
int32_t * data , int n , int pred_order )
2006-06-27 21:01:21 +00:00
{
int i ;
2006-07-02 10:22:31 +00:00
uint32_t bits [ MAX_PARTITION_ORDER + 1 ] ;
2006-06-27 21:01:21 +00:00
int opt_porder ;
2006-07-02 10:22:31 +00:00
RiceContext tmp_rc ;
2006-06-27 21:01:21 +00:00
uint32_t * udata ;
2006-07-02 10:22:31 +00:00
uint32_t sums [ MAX_PARTITION_ORDER + 1 ] [ MAX_PARTITIONS ] ;
2006-06-27 21:01:21 +00:00
2006-07-02 10:22:31 +00:00
assert ( pmin > = 0 & & pmin < = MAX_PARTITION_ORDER ) ;
assert ( pmax > = 0 & & pmax < = MAX_PARTITION_ORDER ) ;
assert ( pmin < = pmax ) ;
2006-06-27 21:01:21 +00:00
udata = av_malloc ( n * sizeof ( uint32_t ) ) ;
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < n ; i + + )
2006-06-27 21:01:21 +00:00
udata [ i ] = ( 2 * data [ i ] ) ^ ( data [ i ] > > 31 ) ;
2006-07-02 10:22:31 +00:00
calc_sums ( pmin , pmax , udata , n , pred_order , sums ) ;
2006-06-27 21:01:21 +00:00
2006-07-02 10:22:31 +00:00
opt_porder = pmin ;
bits [ pmin ] = UINT32_MAX ;
2010-07-30 18:30:09 +00:00
for ( i = pmin ; i < = pmax ; i + + ) {
2006-07-02 10:22:31 +00:00
bits [ i ] = calc_optimal_rice_params ( & tmp_rc , i , sums [ i ] , n , pred_order ) ;
2010-07-30 18:30:09 +00:00
if ( bits [ i ] < = bits [ opt_porder ] ) {
2006-06-27 21:01:21 +00:00
opt_porder = i ;
2010-07-30 18:30:09 +00:00
* rc = tmp_rc ;
2006-06-27 21:01:21 +00:00
}
}
av_freep ( & udata ) ;
2006-07-02 10:22:31 +00:00
return bits [ opt_porder ] ;
2006-06-27 21:01:21 +00:00
}
2010-07-30 18:30:09 +00:00
2006-07-03 09:20:26 +00:00
static int get_max_p_order ( int max_porder , int n , int order )
{
int porder = FFMIN ( max_porder , av_log2 ( n ^ ( n - 1 ) ) ) ;
2010-07-30 18:30:09 +00:00
if ( order > 0 )
2006-07-03 09:20:26 +00:00
porder = FFMIN ( porder , av_log2 ( n / order ) ) ;
return porder ;
}
2010-07-30 18:30:09 +00:00
2010-07-31 20:19:07 +00:00
static uint32_t find_subframe_rice_params ( FlacEncodeContext * s ,
2010-07-31 20:17:59 +00:00
FlacSubframe * sub , int pred_order )
2006-06-27 21:01:21 +00:00
{
2010-07-31 20:17:59 +00:00
int pmin = get_max_p_order ( s - > options . min_partition_order ,
s - > frame . blocksize , pred_order ) ;
int pmax = get_max_p_order ( s - > options . max_partition_order ,
s - > frame . blocksize , pred_order ) ;
uint32_t bits = 8 + pred_order * sub - > obits + 2 + 4 ;
if ( sub - > type = = FLAC_SUBFRAME_LPC )
bits + = 4 + 5 + pred_order * s - > options . lpc_coeff_precision ;
bits + = calc_rice_params ( & sub - > rc , pmin , pmax , sub - > residual ,
s - > frame . blocksize , pred_order ) ;
2006-06-27 21:01:21 +00:00
return bits ;
}
2010-07-30 18:30:09 +00:00
2006-07-02 10:22:31 +00:00
static void encode_residual_fixed ( int32_t * res , const int32_t * smp , int n ,
int order )
2006-06-27 21:01:21 +00:00
{
int i ;
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < order ; i + + )
2006-06-27 21:01:21 +00:00
res [ i ] = smp [ i ] ;
2010-07-30 18:30:09 +00:00
if ( order = = 0 ) {
for ( i = order ; i < n ; i + + )
res [ i ] = smp [ i ] ;
} else if ( order = = 1 ) {
for ( i = order ; i < n ; i + + )
res [ i ] = smp [ i ] - smp [ i - 1 ] ;
} else if ( order = = 2 ) {
2007-09-29 23:21:57 +00:00
int a = smp [ order - 1 ] - smp [ order - 2 ] ;
2010-07-30 18:30:09 +00:00
for ( i = order ; i < n ; i + = 2 ) {
int b = smp [ i ] - smp [ i - 1 ] ;
res [ i ] = b - a ;
a = smp [ i + 1 ] - smp [ i ] ;
res [ i + 1 ] = a - b ;
2007-09-29 23:21:57 +00:00
}
2010-07-30 18:30:09 +00:00
} else if ( order = = 3 ) {
int a = smp [ order - 1 ] - smp [ order - 2 ] ;
2007-09-29 23:21:57 +00:00
int c = smp [ order - 1 ] - 2 * smp [ order - 2 ] + smp [ order - 3 ] ;
2010-07-30 18:30:09 +00:00
for ( i = order ; i < n ; i + = 2 ) {
int b = smp [ i ] - smp [ i - 1 ] ;
int d = b - a ;
res [ i ] = d - c ;
a = smp [ i + 1 ] - smp [ i ] ;
c = a - b ;
res [ i + 1 ] = c - d ;
2007-09-29 23:21:57 +00:00
}
2010-07-30 18:30:09 +00:00
} else {
int a = smp [ order - 1 ] - smp [ order - 2 ] ;
int c = smp [ order - 1 ] - 2 * smp [ order - 2 ] + smp [ order - 3 ] ;
2007-09-29 23:21:57 +00:00
int e = smp [ order - 1 ] - 3 * smp [ order - 2 ] + 3 * smp [ order - 3 ] - smp [ order - 4 ] ;
2010-07-30 18:30:09 +00:00
for ( i = order ; i < n ; i + = 2 ) {
int b = smp [ i ] - smp [ i - 1 ] ;
int d = b - a ;
int f = d - c ;
res [ i ] = f - e ;
a = smp [ i + 1 ] - smp [ i ] ;
c = a - b ;
e = c - d ;
res [ i + 1 ] = e - f ;
2007-09-29 23:21:57 +00:00
}
2006-06-27 21:01:21 +00:00
}
}
2010-07-30 18:30:09 +00:00
2007-09-27 02:42:00 +00:00
# define LPC1(x) {\
2007-09-30 03:36:13 +00:00
int c = coefs [ ( x ) - 1 ] ; \
2010-07-30 18:30:09 +00:00
p0 + = c * s ; \
s = smp [ i - ( x ) + 1 ] ; \
p1 + = c * s ; \
2007-09-27 02:42:00 +00:00
}
2010-07-30 18:30:09 +00:00
static av_always_inline void encode_residual_lpc_unrolled ( int32_t * res ,
const int32_t * smp , int n , int order ,
const int32_t * coefs , int shift , int big )
2007-09-27 02:42:00 +00:00
{
int i ;
2010-07-30 18:30:09 +00:00
for ( i = order ; i < n ; i + = 2 ) {
int s = smp [ i - order ] ;
2007-09-30 03:36:13 +00:00
int p0 = 0 , p1 = 0 ;
2010-07-30 18:30:09 +00:00
if ( big ) {
switch ( order ) {
case 32 : LPC1 ( 32 )
case 31 : LPC1 ( 31 )
case 30 : LPC1 ( 30 )
case 29 : LPC1 ( 29 )
case 28 : LPC1 ( 28 )
case 27 : LPC1 ( 27 )
case 26 : LPC1 ( 26 )
case 25 : LPC1 ( 25 )
case 24 : LPC1 ( 24 )
case 23 : LPC1 ( 23 )
case 22 : LPC1 ( 22 )
case 21 : LPC1 ( 21 )
case 20 : LPC1 ( 20 )
case 19 : LPC1 ( 19 )
case 18 : LPC1 ( 18 )
case 17 : LPC1 ( 17 )
case 16 : LPC1 ( 16 )
case 15 : LPC1 ( 15 )
case 14 : LPC1 ( 14 )
case 13 : LPC1 ( 13 )
case 12 : LPC1 ( 12 )
case 11 : LPC1 ( 11 )
case 10 : LPC1 ( 10 )
case 9 : LPC1 ( 9 )
LPC1 ( 8 )
LPC1 ( 7 )
LPC1 ( 6 )
LPC1 ( 5 )
LPC1 ( 4 )
LPC1 ( 3 )
LPC1 ( 2 )
LPC1 ( 1 )
2007-09-27 02:42:00 +00:00
}
} else {
2010-07-30 18:30:09 +00:00
switch ( order ) {
case 8 : LPC1 ( 8 )
case 7 : LPC1 ( 7 )
case 6 : LPC1 ( 6 )
case 5 : LPC1 ( 5 )
case 4 : LPC1 ( 4 )
case 3 : LPC1 ( 3 )
case 2 : LPC1 ( 2 )
case 1 : LPC1 ( 1 )
2007-09-27 02:42:00 +00:00
}
}
res [ i ] = smp [ i ] - ( p0 > > shift ) ;
res [ i + 1 ] = smp [ i + 1 ] - ( p1 > > shift ) ;
}
}
2010-07-30 18:30:09 +00:00
2006-07-02 10:22:31 +00:00
static void encode_residual_lpc ( int32_t * res , const int32_t * smp , int n ,
int order , const int32_t * coefs , int shift )
{
2007-09-27 02:42:00 +00:00
int i ;
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < order ; i + + )
2006-07-02 10:22:31 +00:00
res [ i ] = smp [ i ] ;
2009-01-13 23:44:16 +00:00
# if CONFIG_SMALL
2010-07-30 18:30:09 +00:00
for ( i = order ; i < n ; i + = 2 ) {
2007-09-27 02:42:00 +00:00
int j ;
2010-07-30 18:30:09 +00:00
int s = smp [ i ] ;
2007-09-30 03:36:13 +00:00
int p0 = 0 , p1 = 0 ;
2010-07-30 18:30:09 +00:00
for ( j = 0 ; j < order ; j + + ) {
2007-09-30 03:36:13 +00:00
int c = coefs [ j ] ;
2010-07-30 18:30:09 +00:00
p1 + = c * s ;
s = smp [ i - j - 1 ] ;
p0 + = c * s ;
2006-07-02 10:22:31 +00:00
}
2007-09-30 03:36:13 +00:00
res [ i ] = smp [ i ] - ( p0 > > shift ) ;
2007-09-25 23:30:29 +00:00
res [ i + 1 ] = smp [ i + 1 ] - ( p1 > > shift ) ;
2006-07-02 10:22:31 +00:00
}
2007-09-27 02:42:00 +00:00
# else
2010-07-30 18:30:09 +00:00
switch ( order ) {
case 1 : encode_residual_lpc_unrolled ( res , smp , n , 1 , coefs , shift , 0 ) ; break ;
case 2 : encode_residual_lpc_unrolled ( res , smp , n , 2 , coefs , shift , 0 ) ; break ;
case 3 : encode_residual_lpc_unrolled ( res , smp , n , 3 , coefs , shift , 0 ) ; break ;
case 4 : encode_residual_lpc_unrolled ( res , smp , n , 4 , coefs , shift , 0 ) ; break ;
case 5 : encode_residual_lpc_unrolled ( res , smp , n , 5 , coefs , shift , 0 ) ; break ;
case 6 : encode_residual_lpc_unrolled ( res , smp , n , 6 , coefs , shift , 0 ) ; break ;
case 7 : encode_residual_lpc_unrolled ( res , smp , n , 7 , coefs , shift , 0 ) ; break ;
case 8 : encode_residual_lpc_unrolled ( res , smp , n , 8 , coefs , shift , 0 ) ; break ;
default : encode_residual_lpc_unrolled ( res , smp , n , order , coefs , shift , 1 ) ; break ;
2007-09-27 02:42:00 +00:00
}
# endif
2006-07-02 10:22:31 +00:00
}
2010-07-30 18:30:09 +00:00
2010-07-31 16:37:23 +00:00
static int encode_residual_ch ( FlacEncodeContext * s , int ch )
2006-06-27 21:01:21 +00:00
{
2006-07-02 10:22:31 +00:00
int i , n ;
2010-07-31 20:17:59 +00:00
int min_order , max_order , opt_order , omethod ;
2006-06-27 21:01:21 +00:00
FlacFrame * frame ;
FlacSubframe * sub ;
2006-07-02 10:22:31 +00:00
int32_t coefs [ MAX_LPC_ORDER ] [ MAX_LPC_ORDER ] ;
int shift [ MAX_LPC_ORDER ] ;
2006-06-27 21:01:21 +00:00
int32_t * res , * smp ;
2010-07-30 19:40:18 +00:00
frame = & s - > frame ;
2010-07-30 18:30:09 +00:00
sub = & frame - > subframes [ ch ] ;
res = sub - > residual ;
smp = sub - > samples ;
n = frame - > blocksize ;
2006-06-27 21:01:21 +00:00
/* CONSTANT */
2010-07-30 18:30:09 +00:00
for ( i = 1 ; i < n ; i + + )
if ( smp [ i ] ! = smp [ 0 ] )
break ;
if ( i = = n ) {
2006-06-27 21:01:21 +00:00
sub - > type = sub - > type_code = FLAC_SUBFRAME_CONSTANT ;
res [ 0 ] = smp [ 0 ] ;
2010-07-31 20:32:12 +00:00
return subframe_count_exact ( s , sub , 0 ) ;
2006-06-27 21:01:21 +00:00
}
/* VERBATIM */
2010-07-31 16:46:32 +00:00
if ( frame - > verbatim_only | | n < 5 ) {
2006-06-27 21:01:21 +00:00
sub - > type = sub - > type_code = FLAC_SUBFRAME_VERBATIM ;
2010-07-31 16:50:27 +00:00
memcpy ( res , smp , n * sizeof ( int32_t ) ) ;
2010-07-31 20:32:12 +00:00
return subframe_count_exact ( s , sub , 0 ) ;
2006-06-27 21:01:21 +00:00
}
2010-07-30 19:40:18 +00:00
min_order = s - > options . min_prediction_order ;
max_order = s - > options . max_prediction_order ;
omethod = s - > options . prediction_order_method ;
2006-06-27 21:01:21 +00:00
/* FIXED */
2010-07-31 20:17:59 +00:00
sub - > type = FLAC_SUBFRAME_FIXED ;
2011-04-02 10:28:01 +00:00
if ( s - > options . lpc_type = = FF_LPC_TYPE_NONE | |
s - > options . lpc_type = = FF_LPC_TYPE_FIXED | | n < = max_order ) {
2006-07-02 10:22:31 +00:00
uint32_t bits [ MAX_FIXED_ORDER + 1 ] ;
2010-07-30 18:30:09 +00:00
if ( max_order > MAX_FIXED_ORDER )
max_order = MAX_FIXED_ORDER ;
2006-07-02 10:22:31 +00:00
opt_order = 0 ;
2010-07-30 18:30:09 +00:00
bits [ 0 ] = UINT32_MAX ;
for ( i = min_order ; i < = max_order ; i + + ) {
2006-07-02 10:22:31 +00:00
encode_residual_fixed ( res , smp , n , i ) ;
2010-07-31 20:19:07 +00:00
bits [ i ] = find_subframe_rice_params ( s , sub , i ) ;
2010-07-30 18:30:09 +00:00
if ( bits [ i ] < bits [ opt_order ] )
2006-07-02 10:22:31 +00:00
opt_order = i ;
2006-06-27 21:01:21 +00:00
}
2010-07-30 18:30:09 +00:00
sub - > order = opt_order ;
2006-07-02 10:22:31 +00:00
sub - > type_code = sub - > type | sub - > order ;
2010-07-30 18:30:09 +00:00
if ( sub - > order ! = max_order ) {
2006-07-02 10:22:31 +00:00
encode_residual_fixed ( res , smp , n , sub - > order ) ;
2010-07-31 20:32:12 +00:00
find_subframe_rice_params ( s , sub , sub - > order ) ;
2006-07-02 10:22:31 +00:00
}
2010-07-31 20:32:12 +00:00
return subframe_count_exact ( s , sub , sub - > order ) ;
2006-06-27 21:01:21 +00:00
}
2006-07-02 10:22:31 +00:00
/* LPC */
2010-07-31 20:17:59 +00:00
sub - > type = FLAC_SUBFRAME_LPC ;
2011-01-21 00:11:44 +00:00
opt_order = ff_lpc_calc_coefs ( & s - > lpc_ctx , smp , n , min_order , max_order ,
2010-07-31 20:17:59 +00:00
s - > options . lpc_coeff_precision , coefs , shift , s - > options . lpc_type ,
2010-07-30 19:40:18 +00:00
s - > options . lpc_passes , omethod ,
2010-07-11 16:56:20 +00:00
MAX_LPC_SHIFT , 0 ) ;
2006-07-16 13:34:47 +00:00
2010-07-30 18:30:09 +00:00
if ( omethod = = ORDER_METHOD_2LEVEL | |
omethod = = ORDER_METHOD_4LEVEL | |
omethod = = ORDER_METHOD_8LEVEL ) {
2006-07-16 13:34:47 +00:00
int levels = 1 < < omethod ;
2010-06-23 21:22:56 +00:00
uint32_t bits [ 1 < < ORDER_METHOD_8LEVEL ] ;
2006-07-16 13:34:47 +00:00
int order ;
2010-07-30 18:30:09 +00:00
int opt_index = levels - 1 ;
opt_order = max_order - 1 ;
2006-07-16 13:34:47 +00:00
bits [ opt_index ] = UINT32_MAX ;
2010-07-30 18:30:09 +00:00
for ( i = levels - 1 ; i > = 0 ; i - - ) {
2006-07-16 13:34:47 +00:00
order = min_order + ( ( ( max_order - min_order + 1 ) * ( i + 1 ) ) / levels ) - 1 ;
2010-07-30 18:30:09 +00:00
if ( order < 0 )
order = 0 ;
2006-07-16 13:34:47 +00:00
encode_residual_lpc ( res , smp , n , order + 1 , coefs [ order ] , shift [ order ] ) ;
2010-07-31 20:19:07 +00:00
bits [ i ] = find_subframe_rice_params ( s , sub , order + 1 ) ;
2010-07-30 18:30:09 +00:00
if ( bits [ i ] < bits [ opt_index ] ) {
2006-07-16 13:34:47 +00:00
opt_index = i ;
opt_order = order ;
}
}
opt_order + + ;
2010-07-30 18:30:09 +00:00
} else if ( omethod = = ORDER_METHOD_SEARCH ) {
2006-07-16 13:34:47 +00:00
// brute-force optimal order search
uint32_t bits [ MAX_LPC_ORDER ] ;
opt_order = 0 ;
2010-07-30 18:30:09 +00:00
bits [ 0 ] = UINT32_MAX ;
for ( i = min_order - 1 ; i < max_order ; i + + ) {
2006-07-16 13:34:47 +00:00
encode_residual_lpc ( res , smp , n , i + 1 , coefs [ i ] , shift [ i ] ) ;
2010-07-31 20:19:07 +00:00
bits [ i ] = find_subframe_rice_params ( s , sub , i + 1 ) ;
2010-07-30 18:30:09 +00:00
if ( bits [ i ] < bits [ opt_order ] )
2006-07-16 13:34:47 +00:00
opt_order = i ;
}
opt_order + + ;
2010-07-30 18:30:09 +00:00
} else if ( omethod = = ORDER_METHOD_LOG ) {
2006-07-16 15:46:45 +00:00
uint32_t bits [ MAX_LPC_ORDER ] ;
int step ;
2010-07-30 18:30:09 +00:00
opt_order = min_order - 1 + ( max_order - min_order ) / 3 ;
2006-07-16 15:46:45 +00:00
memset ( bits , - 1 , sizeof ( bits ) ) ;
2010-07-30 18:30:09 +00:00
for ( step = 16 ; step ; step > > = 1 ) {
int last = opt_order ;
for ( i = last - step ; i < = last + step ; i + = step ) {
if ( i < min_order - 1 | | i > = max_order | | bits [ i ] < UINT32_MAX )
2006-07-16 15:46:45 +00:00
continue ;
encode_residual_lpc ( res , smp , n , i + 1 , coefs [ i ] , shift [ i ] ) ;
2010-07-31 20:19:07 +00:00
bits [ i ] = find_subframe_rice_params ( s , sub , i + 1 ) ;
2010-07-30 18:30:09 +00:00
if ( bits [ i ] < bits [ opt_order ] )
opt_order = i ;
2006-07-16 15:46:45 +00:00
}
}
opt_order + + ;
2006-07-16 13:34:47 +00:00
}
2010-07-30 18:30:09 +00:00
sub - > order = opt_order ;
2006-07-02 10:22:31 +00:00
sub - > type_code = sub - > type | ( sub - > order - 1 ) ;
2010-07-30 18:30:09 +00:00
sub - > shift = shift [ sub - > order - 1 ] ;
for ( i = 0 ; i < sub - > order ; i + + )
2006-07-02 10:22:31 +00:00
sub - > coefs [ i ] = coefs [ sub - > order - 1 ] [ i ] ;
2010-07-30 18:30:09 +00:00
2006-07-02 10:22:31 +00:00
encode_residual_lpc ( res , smp , n , sub - > order , sub - > coefs , sub - > shift ) ;
2010-07-30 18:30:09 +00:00
2010-07-31 20:32:12 +00:00
find_subframe_rice_params ( s , sub , sub - > order ) ;
return subframe_count_exact ( s , sub , sub - > order ) ;
2006-06-27 21:01:21 +00:00
}
2010-07-30 18:30:09 +00:00
2010-07-31 16:37:23 +00:00
static int count_frame_header ( FlacEncodeContext * s )
{
2011-06-03 11:52:29 +00:00
uint8_t av_unused tmp ;
2010-07-31 16:37:23 +00:00
int count ;
/*
< 14 > Sync code
< 1 > Reserved
< 1 > Blocking strategy
< 4 > Block size in inter - channel samples
< 4 > Sample rate
< 4 > Channel assignment
< 3 > Sample size in bits
< 1 > Reserved
*/
count = 32 ;
/* coded frame number */
PUT_UTF8 ( s - > frame_count , tmp , count + = 8 ; )
/* explicit block size */
2010-07-31 18:48:48 +00:00
if ( s - > frame . bs_code [ 0 ] = = 6 )
count + = 8 ;
else if ( s - > frame . bs_code [ 0 ] = = 7 )
count + = 16 ;
2010-07-31 16:37:23 +00:00
/* explicit sample rate */
count + = ( ( s - > sr_code [ 0 ] = = 12 ) + ( s - > sr_code [ 0 ] > 12 ) ) * 8 ;
/* frame header CRC-8 */
count + = 8 ;
return count ;
}
static int encode_frame ( FlacEncodeContext * s )
{
int ch , count ;
count = count_frame_header ( s ) ;
for ( ch = 0 ; ch < s - > channels ; ch + + )
count + = encode_residual_ch ( s , ch ) ;
count + = ( 8 - ( count & 7 ) ) & 7 ; // byte alignment
count + = 16 ; // CRC-16
return count > > 3 ;
}
2006-06-26 06:00:07 +00:00
static int estimate_stereo_mode ( int32_t * left_ch , int32_t * right_ch , int n )
{
int i , best ;
int32_t lt , rt ;
2006-06-27 21:01:21 +00:00
uint64_t sum [ 4 ] ;
2006-06-26 06:00:07 +00:00
uint64_t score [ 4 ] ;
2006-06-27 21:01:21 +00:00
int k ;
2006-06-26 06:00:07 +00:00
2006-07-02 10:22:31 +00:00
/* calculate sum of 2nd order residual for each channel */
2006-06-27 21:01:21 +00:00
sum [ 0 ] = sum [ 1 ] = sum [ 2 ] = sum [ 3 ] = 0 ;
2010-07-30 18:30:09 +00:00
for ( i = 2 ; i < n ; i + + ) {
lt = left_ch [ i ] - 2 * left_ch [ i - 1 ] + left_ch [ i - 2 ] ;
2006-06-26 06:00:07 +00:00
rt = right_ch [ i ] - 2 * right_ch [ i - 1 ] + right_ch [ i - 2 ] ;
2006-10-11 23:17:58 +00:00
sum [ 2 ] + = FFABS ( ( lt + rt ) > > 1 ) ;
sum [ 3 ] + = FFABS ( lt - rt ) ;
sum [ 0 ] + = FFABS ( lt ) ;
sum [ 1 ] + = FFABS ( rt ) ;
2006-06-27 21:01:21 +00:00
}
2006-07-02 10:22:31 +00:00
/* estimate bit counts */
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < 4 ; i + + ) {
k = find_optimal_param ( 2 * sum [ i ] , n ) ;
sum [ i ] = rice_encode_count ( 2 * sum [ i ] , n , k ) ;
2006-06-26 06:00:07 +00:00
}
/* calculate score for each mode */
2006-06-27 21:01:21 +00:00
score [ 0 ] = sum [ 0 ] + sum [ 1 ] ;
score [ 1 ] = sum [ 0 ] + sum [ 3 ] ;
score [ 2 ] = sum [ 1 ] + sum [ 3 ] ;
score [ 3 ] = sum [ 2 ] + sum [ 3 ] ;
2006-06-26 06:00:07 +00:00
/* return mode with lowest score */
best = 0 ;
2010-07-30 18:30:09 +00:00
for ( i = 1 ; i < 4 ; i + + )
if ( score [ i ] < score [ best ] )
2006-06-26 06:00:07 +00:00
best = i ;
2010-07-30 18:30:09 +00:00
if ( best = = 0 ) {
2009-03-21 00:44:42 +00:00
return FLAC_CHMODE_INDEPENDENT ;
2010-07-30 18:30:09 +00:00
} else if ( best = = 1 ) {
2006-06-26 06:00:07 +00:00
return FLAC_CHMODE_LEFT_SIDE ;
2010-07-30 18:30:09 +00:00
} else if ( best = = 2 ) {
2006-06-26 06:00:07 +00:00
return FLAC_CHMODE_RIGHT_SIDE ;
} else {
return FLAC_CHMODE_MID_SIDE ;
}
}
2010-07-30 18:30:09 +00:00
2006-06-26 06:00:07 +00:00
/**
2010-07-30 18:30:09 +00:00
* Perform stereo channel decorrelation .
2006-06-26 06:00:07 +00:00
*/
2010-07-30 19:40:18 +00:00
static void channel_decorrelation ( FlacEncodeContext * s )
2006-06-26 06:00:07 +00:00
{
FlacFrame * frame ;
int32_t * left , * right ;
int i , n ;
2010-07-30 19:40:18 +00:00
frame = & s - > frame ;
2010-07-30 18:30:09 +00:00
n = frame - > blocksize ;
2006-06-26 06:00:07 +00:00
left = frame - > subframes [ 0 ] . samples ;
right = frame - > subframes [ 1 ] . samples ;
2010-07-30 19:40:18 +00:00
if ( s - > channels ! = 2 ) {
2009-03-21 00:44:42 +00:00
frame - > ch_mode = FLAC_CHMODE_INDEPENDENT ;
2006-06-26 06:00:07 +00:00
return ;
}
frame - > ch_mode = estimate_stereo_mode ( left , right , n ) ;
/* perform decorrelation and adjust bits-per-sample */
2010-07-30 18:30:09 +00:00
if ( frame - > ch_mode = = FLAC_CHMODE_INDEPENDENT )
2006-06-26 06:00:07 +00:00
return ;
2010-07-30 18:30:09 +00:00
if ( frame - > ch_mode = = FLAC_CHMODE_MID_SIDE ) {
2006-06-26 06:00:07 +00:00
int32_t tmp ;
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < n ; i + + ) {
tmp = left [ i ] ;
left [ i ] = ( tmp + right [ i ] ) > > 1 ;
right [ i ] = tmp - right [ i ] ;
2006-06-26 06:00:07 +00:00
}
frame - > subframes [ 1 ] . obits + + ;
2010-07-30 18:30:09 +00:00
} else if ( frame - > ch_mode = = FLAC_CHMODE_LEFT_SIDE ) {
for ( i = 0 ; i < n ; i + + )
2006-06-26 06:00:07 +00:00
right [ i ] = left [ i ] - right [ i ] ;
frame - > subframes [ 1 ] . obits + + ;
} else {
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < n ; i + + )
2006-06-26 06:00:07 +00:00
left [ i ] - = right [ i ] ;
frame - > subframes [ 0 ] . obits + + ;
}
}
2010-07-30 18:30:09 +00:00
2006-06-27 21:01:21 +00:00
static void write_utf8 ( PutBitContext * pb , uint32_t val )
2006-06-24 10:20:15 +00:00
{
2006-11-06 10:32:48 +00:00
uint8_t tmp ;
PUT_UTF8 ( val , tmp , put_bits ( pb , 8 , tmp ) ; )
2006-06-24 10:20:15 +00:00
}
2010-07-30 18:30:09 +00:00
2010-07-31 21:14:03 +00:00
static void write_frame_header ( FlacEncodeContext * s )
2006-06-24 10:20:15 +00:00
{
FlacFrame * frame ;
int crc ;
frame = & s - > frame ;
put_bits ( & s - > pb , 16 , 0xFFF8 ) ;
put_bits ( & s - > pb , 4 , frame - > bs_code [ 0 ] ) ;
put_bits ( & s - > pb , 4 , s - > sr_code [ 0 ] ) ;
2010-07-30 18:30:09 +00:00
if ( frame - > ch_mode = = FLAC_CHMODE_INDEPENDENT )
2009-03-21 00:45:44 +00:00
put_bits ( & s - > pb , 4 , s - > channels - 1 ) ;
2010-07-30 18:30:09 +00:00
else
2006-06-24 10:20:15 +00:00
put_bits ( & s - > pb , 4 , frame - > ch_mode ) ;
2010-07-30 18:30:09 +00:00
2006-06-24 10:20:15 +00:00
put_bits ( & s - > pb , 3 , 4 ) ; /* bits-per-sample code */
put_bits ( & s - > pb , 1 , 0 ) ;
write_utf8 ( & s - > pb , s - > frame_count ) ;
2010-07-30 18:30:09 +00:00
if ( frame - > bs_code [ 0 ] = = 6 )
2006-06-26 06:00:07 +00:00
put_bits ( & s - > pb , 8 , frame - > bs_code [ 1 ] ) ;
2010-07-30 18:30:09 +00:00
else if ( frame - > bs_code [ 0 ] = = 7 )
2006-06-26 06:00:07 +00:00
put_bits ( & s - > pb , 16 , frame - > bs_code [ 1 ] ) ;
2010-07-30 18:30:09 +00:00
if ( s - > sr_code [ 0 ] = = 12 )
2006-06-26 06:00:07 +00:00
put_bits ( & s - > pb , 8 , s - > sr_code [ 1 ] ) ;
2010-07-30 18:30:09 +00:00
else if ( s - > sr_code [ 0 ] > 12 )
2006-06-26 06:00:07 +00:00
put_bits ( & s - > pb , 16 , s - > sr_code [ 1 ] ) ;
2010-07-30 18:30:09 +00:00
2006-06-24 10:20:15 +00:00
flush_put_bits ( & s - > pb ) ;
2010-07-30 18:30:09 +00:00
crc = av_crc ( av_crc_get_table ( AV_CRC_8_ATM ) , 0 , s - > pb . buf ,
put_bits_count ( & s - > pb ) > > 3 ) ;
2006-06-24 10:20:15 +00:00
put_bits ( & s - > pb , 8 , crc ) ;
}
2010-07-30 18:30:09 +00:00
2010-07-31 21:14:03 +00:00
static void write_subframes ( FlacEncodeContext * s )
2006-07-02 10:22:31 +00:00
{
2010-07-30 21:32:19 +00:00
int ch ;
for ( ch = 0 ; ch < s - > channels ; ch + + ) {
FlacSubframe * sub = & s - > frame . subframes [ ch ] ;
2010-07-30 21:33:51 +00:00
int i , p , porder , psize ;
int32_t * part_end ;
int32_t * res = sub - > residual ;
int32_t * frame_end = & sub - > residual [ s - > frame . blocksize ] ;
2010-07-30 21:06:38 +00:00
2010-07-30 21:32:19 +00:00
/* subframe header */
put_bits ( & s - > pb , 1 , 0 ) ;
put_bits ( & s - > pb , 6 , sub - > type_code ) ;
put_bits ( & s - > pb , 1 , 0 ) ; /* no wasted bits */
/* subframe */
2010-07-30 21:33:51 +00:00
if ( sub - > type = = FLAC_SUBFRAME_CONSTANT ) {
put_sbits ( & s - > pb , sub - > obits , res [ 0 ] ) ;
} else if ( sub - > type = = FLAC_SUBFRAME_VERBATIM ) {
while ( res < frame_end )
put_sbits ( & s - > pb , sub - > obits , * res + + ) ;
} else {
/* warm-up samples */
2010-07-30 21:07:21 +00:00
for ( i = 0 ; i < sub - > order ; i + + )
2010-07-30 21:33:51 +00:00
put_sbits ( & s - > pb , sub - > obits , * res + + ) ;
/* LPC coefficients */
if ( sub - > type = = FLAC_SUBFRAME_LPC ) {
int cbits = s - > options . lpc_coeff_precision ;
put_bits ( & s - > pb , 4 , cbits - 1 ) ;
put_sbits ( & s - > pb , 5 , sub - > shift ) ;
for ( i = 0 ; i < sub - > order ; i + + )
put_sbits ( & s - > pb , cbits , sub - > coefs [ i ] ) ;
}
2010-07-30 21:07:21 +00:00
2010-07-30 21:33:51 +00:00
/* rice-encoded block */
put_bits ( & s - > pb , 2 , 0 ) ;
/* partition order */
porder = sub - > rc . porder ;
psize = s - > frame . blocksize > > porder ;
put_bits ( & s - > pb , 4 , porder ) ;
/* residual */
part_end = & sub - > residual [ psize ] ;
for ( p = 0 ; p < 1 < < porder ; p + + ) {
int k = sub - > rc . params [ p ] ;
put_bits ( & s - > pb , 4 , k ) ;
while ( res < part_end )
set_sr_golomb_flac ( & s - > pb , * res + + , k , INT32_MAX , 0 ) ;
part_end = FFMIN ( frame_end , part_end + psize ) ;
}
2010-07-30 21:07:21 +00:00
}
2010-07-30 21:06:38 +00:00
}
2006-06-24 10:20:15 +00:00
}
2010-07-30 18:30:09 +00:00
2010-07-31 21:14:03 +00:00
static void write_frame_footer ( FlacEncodeContext * s )
2006-06-24 10:20:15 +00:00
{
int crc ;
flush_put_bits ( & s - > pb ) ;
2010-07-30 18:30:09 +00:00
crc = av_bswap16 ( av_crc ( av_crc_get_table ( AV_CRC_16_ANSI ) , 0 , s - > pb . buf ,
put_bits_count ( & s - > pb ) > > 3 ) ) ;
2006-06-24 10:20:15 +00:00
put_bits ( & s - > pb , 16 , crc ) ;
flush_put_bits ( & s - > pb ) ;
}
2010-07-30 18:30:09 +00:00
2012-02-03 23:43:39 +00:00
static int write_frame ( FlacEncodeContext * s , AVPacket * avpkt )
2010-07-31 17:23:29 +00:00
{
2012-02-03 23:43:39 +00:00
init_put_bits ( & s - > pb , avpkt - > data , avpkt - > size ) ;
2010-07-31 21:14:03 +00:00
write_frame_header ( s ) ;
write_subframes ( s ) ;
write_frame_footer ( s ) ;
2010-07-31 17:23:29 +00:00
return put_bits_count ( & s - > pb ) > > 3 ;
}
2010-07-24 13:59:49 +00:00
static void update_md5_sum ( FlacEncodeContext * s , const int16_t * samples )
2008-09-14 21:39:54 +00:00
{
2009-07-26 12:20:04 +00:00
# if HAVE_BIGENDIAN
2008-09-14 21:39:54 +00:00
int i ;
2010-07-30 18:30:09 +00:00
for ( i = 0 ; i < s - > frame . blocksize * s - > channels ; i + + ) {
2010-07-10 22:12:30 +00:00
int16_t smp = av_le2ne16 ( samples [ i ] ) ;
2008-09-14 21:39:54 +00:00
av_md5_update ( s - > md5ctx , ( uint8_t * ) & smp , 2 ) ;
}
# else
2010-07-24 13:59:49 +00:00
av_md5_update ( s - > md5ctx , ( const uint8_t * ) samples , s - > frame . blocksize * s - > channels * 2 ) ;
2008-09-14 21:39:54 +00:00
# endif
}
2010-07-30 18:30:09 +00:00
2012-02-03 23:43:39 +00:00
static int flac_encode_frame ( AVCodecContext * avctx , AVPacket * avpkt ,
const AVFrame * frame , int * got_packet_ptr )
2006-06-24 10:20:15 +00:00
{
FlacEncodeContext * s ;
2012-02-03 23:43:39 +00:00
const int16_t * samples ;
int frame_bytes , out_bytes , ret ;
2006-06-24 10:20:15 +00:00
s = avctx - > priv_data ;
2008-09-14 20:00:36 +00:00
/* when the last block is reached, update the header in extradata */
2012-02-03 23:43:39 +00:00
if ( ! frame ) {
2008-09-14 22:25:50 +00:00
s - > max_framesize = s - > max_encoded_framesize ;
2008-09-14 21:39:54 +00:00
av_md5_final ( s - > md5ctx , s - > md5sum ) ;
2008-09-14 20:00:36 +00:00
write_streaminfo ( s , avctx - > extradata ) ;
return 0 ;
}
2012-02-03 23:43:39 +00:00
samples = ( const int16_t * ) frame - > data [ 0 ] ;
2008-09-14 20:00:36 +00:00
2010-07-31 20:52:33 +00:00
/* change max_framesize for small final frame */
2012-02-03 23:43:39 +00:00
if ( frame - > nb_samples < s - > frame . blocksize ) {
s - > max_framesize = ff_flac_get_max_frame_size ( frame - > nb_samples ,
2010-07-31 20:52:33 +00:00
s - > channels , 16 ) ;
}
2012-02-03 23:43:39 +00:00
init_frame ( s , frame - > nb_samples ) ;
2006-06-24 10:20:15 +00:00
copy_samples ( s , samples ) ;
2006-06-26 06:00:07 +00:00
channel_decorrelation ( s ) ;
2010-07-31 20:32:12 +00:00
frame_bytes = encode_frame ( s ) ;
2006-06-24 10:20:15 +00:00
2010-07-31 17:23:29 +00:00
/* fallback to verbatim mode if the compressed frame is larger than it
would be if encoded uncompressed . */
2010-07-31 21:08:53 +00:00
if ( frame_bytes > s - > max_framesize ) {
2010-07-31 16:46:32 +00:00
s - > frame . verbatim_only = 1 ;
2010-07-31 20:32:12 +00:00
frame_bytes = encode_frame ( s ) ;
2006-06-24 10:20:15 +00:00
}
2012-02-03 23:43:39 +00:00
if ( ( ret = ff_alloc_packet ( avpkt , frame_bytes ) ) ) {
av_log ( avctx , AV_LOG_ERROR , " Error getting output packet \n " ) ;
return ret ;
2010-07-31 21:08:53 +00:00
}
2012-02-03 23:43:39 +00:00
out_bytes = write_frame ( s , avpkt ) ;
2010-07-31 21:08:53 +00:00
2006-06-24 10:20:15 +00:00
s - > frame_count + + ;
2012-02-03 23:43:39 +00:00
s - > sample_count + = frame - > nb_samples ;
2008-09-14 21:39:54 +00:00
update_md5_sum ( s , samples ) ;
2008-09-14 22:25:50 +00:00
if ( out_bytes > s - > max_encoded_framesize )
s - > max_encoded_framesize = out_bytes ;
2009-03-21 00:50:19 +00:00
if ( out_bytes < s - > min_framesize )
s - > min_framesize = out_bytes ;
2008-09-14 20:00:36 +00:00
2012-02-03 23:43:39 +00:00
avpkt - > pts = frame - > pts ;
avpkt - > duration = ff_samples_to_time_base ( avctx , frame - > nb_samples ) ;
avpkt - > size = out_bytes ;
* got_packet_ptr = 1 ;
return 0 ;
2006-06-24 10:20:15 +00:00
}
2010-07-30 18:30:09 +00:00
2008-03-21 03:11:20 +00:00
static av_cold int flac_encode_close ( AVCodecContext * avctx )
2006-06-24 10:20:15 +00:00
{
2008-09-14 21:39:54 +00:00
if ( avctx - > priv_data ) {
FlacEncodeContext * s = avctx - > priv_data ;
av_freep ( & s - > md5ctx ) ;
2011-01-21 00:12:03 +00:00
ff_lpc_end ( & s - > lpc_ctx ) ;
2008-09-14 21:39:54 +00:00
}
2006-06-26 06:00:07 +00:00
av_freep ( & avctx - > extradata ) ;
avctx - > extradata_size = 0 ;
2012-02-03 23:43:39 +00:00
# if FF_API_OLD_ENCODE_AUDIO
2006-06-24 10:20:15 +00:00
av_freep ( & avctx - > coded_frame ) ;
2012-02-03 23:43:39 +00:00
# endif
2006-06-24 10:20:15 +00:00
return 0 ;
}
2011-04-02 10:28:01 +00:00
# define FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
static const AVOption options [ ] = {
2011-10-04 05:38:01 +00:00
{ " lpc_coeff_precision " , " LPC coefficient precision " , offsetof ( FlacEncodeContext , options . lpc_coeff_precision ) , AV_OPT_TYPE_INT , { . dbl = 15 } , 0 , MAX_LPC_PRECISION , FLAGS } ,
{ " lpc_type " , " LPC algorithm " , offsetof ( FlacEncodeContext , options . lpc_type ) , AV_OPT_TYPE_INT , { . dbl = FF_LPC_TYPE_DEFAULT } , FF_LPC_TYPE_DEFAULT , FF_LPC_TYPE_NB - 1 , FLAGS , " lpc_type " } ,
{ " none " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = FF_LPC_TYPE_NONE } , INT_MIN , INT_MAX , FLAGS , " lpc_type " } ,
{ " fixed " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = FF_LPC_TYPE_FIXED } , INT_MIN , INT_MAX , FLAGS , " lpc_type " } ,
{ " levinson " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = FF_LPC_TYPE_LEVINSON } , INT_MIN , INT_MAX , FLAGS , " lpc_type " } ,
{ " cholesky " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = FF_LPC_TYPE_CHOLESKY } , INT_MIN , INT_MAX , FLAGS , " lpc_type " } ,
{ " lpc_passes " , " Number of passes to use for Cholesky factorization during LPC analysis " , offsetof ( FlacEncodeContext , options . lpc_passes ) , AV_OPT_TYPE_INT , { . dbl = - 1 } , INT_MIN , INT_MAX , FLAGS } ,
{ " min_partition_order " , NULL , offsetof ( FlacEncodeContext , options . min_partition_order ) , AV_OPT_TYPE_INT , { . dbl = - 1 } , - 1 , MAX_PARTITION_ORDER , FLAGS } ,
{ " max_partition_order " , NULL , offsetof ( FlacEncodeContext , options . max_partition_order ) , AV_OPT_TYPE_INT , { . dbl = - 1 } , - 1 , MAX_PARTITION_ORDER , FLAGS } ,
{ " prediction_order_method " , " Search method for selecting prediction order " , offsetof ( FlacEncodeContext , options . prediction_order_method ) , AV_OPT_TYPE_INT , { . dbl = - 1 } , - 1 , ORDER_METHOD_LOG , FLAGS , " predm " } ,
{ " estimation " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = ORDER_METHOD_EST } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " 2level " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = ORDER_METHOD_2LEVEL } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " 4level " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = ORDER_METHOD_4LEVEL } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " 8level " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = ORDER_METHOD_8LEVEL } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " search " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = ORDER_METHOD_SEARCH } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " log " , NULL , 0 , AV_OPT_TYPE_CONST , { . dbl = ORDER_METHOD_LOG } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
2011-04-02 10:28:01 +00:00
{ NULL } ,
} ;
static const AVClass flac_encoder_class = {
" FLAC encoder " ,
av_default_item_name ,
options ,
LIBAVUTIL_VERSION_INT ,
} ;
2010-07-30 18:30:09 +00:00
2011-01-25 21:40:11 +00:00
AVCodec ff_flac_encoder = {
2011-07-17 10:54:31 +00:00
. name = " flac " ,
. type = AVMEDIA_TYPE_AUDIO ,
. id = CODEC_ID_FLAC ,
. priv_data_size = sizeof ( FlacEncodeContext ) ,
. init = flac_encode_init ,
2012-02-03 23:43:39 +00:00
. encode2 = flac_encode_frame ,
2011-07-17 10:54:31 +00:00
. close = flac_encode_close ,
2012-04-06 16:19:39 +00:00
. capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY ,
. sample_fmts = ( const enum AVSampleFormat [ ] ) { AV_SAMPLE_FMT_S16 ,
AV_SAMPLE_FMT_NONE } ,
. long_name = NULL_IF_CONFIG_SMALL ( " FLAC (Free Lossless Audio Codec) " ) ,
. priv_class = & flac_encoder_class ,
2006-06-24 10:20:15 +00:00
} ;