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
*
2006-10-07 15:30:46 +00:00
* This file is part of FFmpeg .
*
* FFmpeg 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
*
2006-10-07 15:30:46 +00:00
* FFmpeg 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
2006-10-07 15:30:46 +00:00
* License along with FFmpeg ; 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
*/
2012-08-02 19:58:17 +00:00
# include "libavutil/avassert.h"
2008-05-09 11:56:36 +00:00
# include "libavutil/crc.h"
2012-10-25 19:07:59 +00:00
# include "libavutil/intmath.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"
2012-10-25 19:00:10 +00:00
# include "dsputil.h"
2013-01-22 20:27:01 +00:00
# include "put_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"
2012-10-27 04:25:04 +00:00
# include "flacdsp.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
2012-10-27 04:46:43 +00:00
enum CodingMode {
CODING_MODE_RICE = 4 ,
CODING_MODE_RICE2 = 5 ,
} ;
2006-07-02 10:22:31 +00:00
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 ;
2012-07-02 13:52:05 +00:00
int ch_mode ;
2006-07-02 10:22:31 +00:00
} CompressionOptions ;
2006-06-27 21:01:21 +00:00
typedef struct RiceContext {
2012-10-27 04:46:43 +00:00
enum CodingMode coding_mode ;
2006-06-27 21:01:21 +00:00
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 ;
2012-10-25 19:07:59 +00:00
int wasted ;
2006-06-24 10:20:15 +00:00
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 ] ;
2012-10-27 04:26:02 +00:00
int bps_code ;
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 ;
2012-10-25 19:00:10 +00:00
uint8_t * md5_buffer ;
unsigned int md5_buffer_size ;
DSPContext dsp ;
2012-10-27 04:25:04 +00:00
FLACDSPContext flac_dsp ;
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 ) ;
2012-10-27 04:26:02 +00:00
put_bits ( & pb , 5 , s - > avctx - > bits_per_raw_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 ;
2012-08-02 19:58:17 +00:00
av_assert0 ( 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 ;
2012-10-27 04:26:02 +00:00
switch ( avctx - > sample_fmt ) {
case AV_SAMPLE_FMT_S16 :
avctx - > bits_per_raw_sample = 16 ;
s - > bps_code = 4 ;
break ;
case AV_SAMPLE_FMT_S32 :
if ( avctx - > bits_per_raw_sample ! = 24 )
av_log ( avctx , AV_LOG_WARNING , " encoding as 24 bits-per-sample \n " ) ;
avctx - > bits_per_raw_sample = 24 ;
s - > bps_code = 6 ;
break ;
}
2006-06-24 10:20:15 +00:00
2012-12-31 11:13:36 +00:00
if ( channels < 1 | | channels > FLAC_MAX_CHANNELS ) {
av_log ( avctx , AV_LOG_ERROR , " %d channels not supported (max %d) \n " ,
channels , FLAC_MAX_CHANNELS ) ;
return AVERROR ( EINVAL ) ;
}
2006-06-24 10:20:15 +00:00
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 {
2012-12-31 11:13:36 +00:00
av_log ( avctx , AV_LOG_ERROR , " %d Hz not supported \n " , freq ) ;
return AVERROR ( EINVAL ) ;
2006-06-24 10:20:15 +00:00
}
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 ) ;
2012-12-31 11:13:36 +00:00
return AVERROR ( EINVAL ) ;
2006-07-02 10:22:31 +00:00
}
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 ) ;
2012-12-31 11:13:36 +00:00
return AVERROR ( EINVAL ) ;
2006-07-02 10:22:31 +00:00
}
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 ) ;
2012-12-31 11:13:36 +00:00
return AVERROR ( EINVAL ) ;
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 ) ;
2012-12-31 11:13:36 +00:00
return AVERROR ( EINVAL ) ;
2006-07-02 10:22:31 +00:00
}
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 ) ;
2012-12-31 11:13:36 +00:00
return AVERROR ( EINVAL ) ;
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 ) ;
2012-12-31 11:13:36 +00:00
return AVERROR ( EINVAL ) ;
2006-07-02 10:22:31 +00:00
}
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 ) ;
2012-12-31 11:13:36 +00:00
return AVERROR ( EINVAL ) ;
2006-07-02 10:22:31 +00:00
}
} 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 ,
2012-10-27 04:26:02 +00:00
s - > channels ,
s - > avctx - > bits_per_raw_sample ) ;
2006-06-24 10:20:15 +00:00
2008-09-14 21:39:54 +00:00
/* initialize MD5 context */
2012-10-11 12:10:45 +00:00
s - > md5ctx = av_md5_alloc ( ) ;
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-04-25 09:23:06 +00:00
if ( channels = = 3 & &
avctx - > channel_layout ! = ( AV_CH_LAYOUT_STEREO | AV_CH_FRONT_CENTER ) | |
channels = = 4 & &
avctx - > channel_layout ! = AV_CH_LAYOUT_2_2 & &
avctx - > channel_layout ! = AV_CH_LAYOUT_QUAD | |
channels = = 5 & &
avctx - > channel_layout ! = AV_CH_LAYOUT_5POINT0 & &
avctx - > channel_layout ! = AV_CH_LAYOUT_5POINT0_BACK | |
channels = = 6 & &
avctx - > channel_layout ! = AV_CH_LAYOUT_5POINT1 & &
avctx - > channel_layout ! = AV_CH_LAYOUT_5POINT1_BACK ) {
if ( avctx - > channel_layout ) {
av_log ( avctx , AV_LOG_ERROR , " Channel layout not supported by Flac, "
" output stream will have incorrect "
" channel layout. \n " ) ;
} else {
av_log ( avctx , AV_LOG_WARNING , " No channel layout specified. The encoder "
" will use Flac channel layout for "
" %d channels. \n " , channels ) ;
}
}
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
2012-10-25 19:00:10 +00:00
ff_dsputil_init ( & s - > dsp , avctx ) ;
2012-10-27 04:26:02 +00:00
ff_flacdsp_init ( & s - > flac_dsp , avctx - > sample_fmt ,
avctx - > bits_per_raw_sample ) ;
2012-10-25 19:00:10 +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 ;
}
}
2012-10-25 19:07:59 +00:00
for ( ch = 0 ; ch < s - > channels ; ch + + ) {
2012-10-27 04:46:43 +00:00
FlacSubframe * sub = & frame - > subframes [ ch ] ;
sub - > wasted = 0 ;
sub - > obits = s - > avctx - > bits_per_raw_sample ;
if ( sub - > obits > 16 )
sub - > rc . coding_mode = CODING_MODE_RICE2 ;
else
sub - > rc . coding_mode = CODING_MODE_RICE ;
2012-10-25 19:07:59 +00:00
}
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
*/
2012-10-27 04:26:02 +00:00
static void copy_samples ( FlacEncodeContext * s , const void * samples )
2006-06-24 10:20:15 +00:00
{
int i , j , ch ;
FlacFrame * frame ;
2012-10-27 04:26:02 +00:00
int shift = av_get_bytes_per_sample ( s - > avctx - > sample_fmt ) * 8 -
s - > avctx - > bits_per_raw_sample ;
# define COPY_SAMPLES(bits) do { \
const int # # bits # # _t * samples0 = samples ; \
frame = & s - > frame ; \
for ( i = 0 , j = 0 ; i < frame - > blocksize ; i + + ) \
for ( ch = 0 ; ch < s - > channels ; ch + + , j + + ) \
frame - > subframes [ ch ] . samples [ i ] = samples0 [ j ] > > shift ; \
} while ( 0 )
if ( s - > avctx - > sample_fmt = = AV_SAMPLE_FMT_S16 )
COPY_SAMPLES ( 16 ) ;
else
COPY_SAMPLES ( 32 ) ;
2006-06-24 10:20:15 +00:00
}
2006-06-27 21:01:21 +00:00
2012-10-27 03:22:38 +00:00
static uint64_t rice_count_exact ( int32_t * res , int n , int k )
2010-07-31 20:32:12 +00:00
{
int i ;
2012-10-27 03:22:38 +00:00
uint64_t count = 0 ;
2010-07-31 20:32:12 +00:00
for ( i = 0 ; i < n ; i + + ) {
int32_t v = - 2 * res [ i ] - 1 ;
v ^ = v > > 31 ;
count + = ( v > > k ) + 1 + k ;
}
return count ;
}
2012-10-27 03:22:38 +00:00
static uint64_t subframe_count_exact ( FlacEncodeContext * s , FlacSubframe * sub ,
int pred_order )
2010-07-31 20:32:12 +00:00
{
int p , porder , psize ;
int i , part_end ;
2012-10-27 03:22:38 +00:00
uint64_t count = 0 ;
2010-07-31 20:32:12 +00:00
/* 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 ] ;
2012-10-27 04:46:43 +00:00
count + = sub - > rc . coding_mode ;
2010-07-31 20:32:12 +00:00
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
*/
2012-10-27 04:46:43 +00:00
static int find_optimal_param ( uint64_t sum , int n , int max_param )
2006-06-27 21:01:21 +00:00
{
2007-09-29 05:41:27 +00:00
int k ;
2012-10-27 03:22:38 +00:00
uint64_t sum2 ;
2007-09-29 05:41:27 +00:00
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 ) ;
2012-10-27 03:22:38 +00:00
k = av_log2 ( av_clipl_int32 ( sum2 / n ) ) ;
2012-10-27 04:46:43 +00:00
return FFMIN ( k , max_param ) ;
2006-06-27 21:01:21 +00:00
}
2010-07-30 18:30:09 +00:00
2012-10-27 03:22:38 +00:00
static uint64_t calc_optimal_rice_params ( RiceContext * rc , int porder ,
uint64_t * sums , int n , int pred_order )
2006-06-27 21:01:21 +00:00
{
int i ;
2012-10-27 04:46:43 +00:00
int k , cnt , part , max_param ;
2012-10-27 03:22:38 +00:00
uint64_t all_bits ;
2006-06-27 21:01:21 +00:00
2012-10-27 04:46:43 +00:00
max_param = ( 1 < < rc - > coding_mode ) - 2 ;
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 + + ) {
2012-10-27 04:46:43 +00:00
k = find_optimal_param ( sums [ i ] , cnt , max_param ) ;
2006-06-27 21:01:21 +00:00
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 ,
2012-10-27 03:22:38 +00:00
uint64_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 + + ) {
2012-10-27 03:22:38 +00:00
uint64_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
2012-10-27 03:22:38 +00:00
static uint64_t calc_rice_params ( RiceContext * rc , int pmin , int pmax ,
2006-07-02 10:22:31 +00:00
int32_t * data , int n , int pred_order )
2006-06-27 21:01:21 +00:00
{
int i ;
2012-10-27 03:22:38 +00:00
uint64_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 ;
2012-10-27 03:22:38 +00:00
uint64_t sums [ MAX_PARTITION_ORDER + 1 ] [ MAX_PARTITIONS ] ;
2006-06-27 21:01:21 +00:00
2012-08-02 19:58:17 +00:00
av_assert1 ( pmin > = 0 & & pmin < = MAX_PARTITION_ORDER ) ;
av_assert1 ( pmax > = 0 & & pmax < = MAX_PARTITION_ORDER ) ;
av_assert1 ( pmin < = pmax ) ;
2006-06-27 21:01:21 +00:00
2012-10-27 04:46:43 +00:00
tmp_rc . coding_mode = rc - > coding_mode ;
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
2012-10-27 03:22:38 +00:00
static uint64_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 ) ;
2012-10-27 04:46:43 +00:00
uint64_t bits = 8 + pred_order * sub - > obits + 2 + sub - > rc . coding_mode ;
2010-07-31 20:17:59 +00:00
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
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 ) {
2012-10-27 03:22:38 +00:00
uint64_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 ;
2012-10-27 03:22:38 +00:00
uint64_t bits [ 1 < < ORDER_METHOD_8LEVEL ] ;
2012-11-07 19:48:28 +00:00
int order = - 1 ;
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 - - ) {
2012-11-07 19:48:28 +00:00
int last_order = order ;
2006-07-16 13:34:47 +00:00
order = min_order + ( ( ( max_order - min_order + 1 ) * ( i + 1 ) ) / levels ) - 1 ;
2012-11-07 19:48:28 +00:00
order = av_clip ( order , min_order - 1 , max_order - 1 ) ;
if ( order = = last_order )
continue ;
2012-10-27 04:25:04 +00:00
s - > flac_dsp . lpc_encode ( 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
2012-10-27 03:22:38 +00:00
uint64_t bits [ MAX_LPC_ORDER ] ;
2006-07-16 13:34:47 +00:00
opt_order = 0 ;
2010-07-30 18:30:09 +00:00
bits [ 0 ] = UINT32_MAX ;
for ( i = min_order - 1 ; i < max_order ; i + + ) {
2012-10-27 04:25:04 +00:00
s - > flac_dsp . lpc_encode ( 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 ) {
2012-10-27 03:22:38 +00:00
uint64_t bits [ MAX_LPC_ORDER ] ;
2006-07-16 15:46:45 +00:00
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 ;
2012-10-27 04:25:04 +00:00
s - > flac_dsp . lpc_encode ( 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
2012-10-27 04:25:04 +00:00
s - > flac_dsp . lpc_encode ( 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 )
{
2012-10-27 03:22:38 +00:00
int ch ;
uint64_t count ;
2010-07-31 16:37:23 +00:00
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
2012-10-27 03:22:38 +00:00
count > > = 3 ;
if ( count > INT_MAX )
return AVERROR_BUG ;
return count ;
2010-07-31 16:37:23 +00:00
}
2012-10-25 19:07:59 +00:00
static void remove_wasted_bits ( FlacEncodeContext * s )
{
int ch , i ;
for ( ch = 0 ; ch < s - > channels ; ch + + ) {
FlacSubframe * sub = & s - > frame . subframes [ ch ] ;
int32_t v = 0 ;
for ( i = 0 ; i < s - > frame . blocksize ; i + + ) {
v | = sub - > samples [ i ] ;
if ( v & 1 )
break ;
}
if ( v & & ! ( v & 1 ) ) {
v = av_ctz ( v ) ;
for ( i = 0 ; i < s - > frame . blocksize ; i + + )
sub - > samples [ i ] > > = v ;
sub - > wasted = v ;
sub - > obits - = v ;
2012-10-27 04:46:43 +00:00
/* for 24-bit, check if removing wasted bits makes the range better
suited for using RICE instead of RICE2 for entropy coding */
if ( sub - > obits < = 17 )
sub - > rc . coding_mode = CODING_MODE_RICE ;
2012-10-25 19:07:59 +00:00
}
}
2010-07-31 16:37:23 +00:00
}
2012-10-27 04:46:43 +00:00
static int estimate_stereo_mode ( int32_t * left_ch , int32_t * right_ch , int n ,
int max_rice_param )
2006-06-26 06:00:07 +00:00
{
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 + + ) {
2012-10-27 04:46:43 +00:00
k = find_optimal_param ( 2 * sum [ i ] , n , max_rice_param ) ;
2010-07-30 18:30:09 +00:00
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 ;
2012-06-17 10:45:10 +00:00
return best ;
2006-06-26 06:00:07 +00:00
}
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 ;
}
2012-10-27 04:46:43 +00:00
if ( s - > options . ch_mode < 0 ) {
int max_rice_param = ( 1 < < frame - > subframes [ 0 ] . rc . coding_mode ) - 2 ;
frame - > ch_mode = estimate_stereo_mode ( left , right , n , max_rice_param ) ;
} else
2012-07-02 13:52:05 +00:00
frame - > ch_mode = s - > options . ch_mode ;
2006-06-26 06:00:07 +00:00
/* 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
2012-06-17 10:45:10 +00:00
put_bits ( & s - > pb , 4 , frame - > ch_mode + FLAC_MAX_CHANNELS - 1 ) ;
2010-07-30 18:30:09 +00:00
2012-10-27 04:26:02 +00:00
put_bits ( & s - > pb , 3 , s - > bps_code ) ;
2006-06-24 10:20:15 +00:00
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 ) ;
2012-10-25 19:07:59 +00:00
put_bits ( & s - > pb , 1 , ! ! sub - > wasted ) ;
if ( sub - > wasted )
put_bits ( & s - > pb , sub - > wasted , 1 ) ;
2010-07-30 21:32:19 +00:00
/* 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 */
2012-10-27 04:46:43 +00:00
put_bits ( & s - > pb , 2 , sub - > rc . coding_mode - 4 ) ;
2010-07-30 21:33:51 +00:00
/* 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 ] ;
2012-10-27 04:46:43 +00:00
put_bits ( & s - > pb , sub - > rc . coding_mode , k ) ;
2010-07-30 21:33:51 +00:00
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 ;
}
2012-10-27 04:26:02 +00:00
static int update_md5_sum ( FlacEncodeContext * s , const void * samples )
2008-09-14 21:39:54 +00:00
{
2012-10-25 19:00:10 +00:00
const uint8_t * buf ;
2012-10-27 04:26:02 +00:00
int buf_size = s - > frame . blocksize * s - > channels *
( ( s - > avctx - > bits_per_raw_sample + 7 ) / 8 ) ;
2012-10-25 19:00:10 +00:00
2012-10-27 04:26:02 +00:00
if ( s - > avctx - > bits_per_raw_sample > 16 | | HAVE_BIGENDIAN ) {
2012-10-25 19:00:10 +00:00
av_fast_malloc ( & s - > md5_buffer , & s - > md5_buffer_size , buf_size ) ;
if ( ! s - > md5_buffer )
return AVERROR ( ENOMEM ) ;
2008-09-14 21:39:54 +00:00
}
2012-10-25 19:00:10 +00:00
2012-10-27 04:26:02 +00:00
if ( s - > avctx - > bits_per_raw_sample < = 16 ) {
buf = ( const uint8_t * ) samples ;
2012-10-25 19:00:10 +00:00
# if HAVE_BIGENDIAN
2012-10-27 04:26:02 +00:00
s - > dsp . bswap16_buf ( ( uint16_t * ) s - > md5_buffer ,
( const uint16_t * ) samples , buf_size / 2 ) ;
buf = s - > md5_buffer ;
2008-09-14 21:39:54 +00:00
# endif
2012-10-27 04:26:02 +00:00
} else {
int i ;
const int32_t * samples0 = samples ;
uint8_t * tmp = s - > md5_buffer ;
for ( i = 0 ; i < s - > frame . blocksize * s - > channels ; i + + ) {
int32_t v = samples0 [ i ] > > 8 ;
* tmp + + = ( v ) & 0xFF ;
* tmp + + = ( v > > 8 ) & 0xFF ;
* tmp + + = ( v > > 16 ) & 0xFF ;
}
buf = s - > md5_buffer ;
}
2012-10-25 19:00:10 +00:00
av_md5_update ( s - > md5ctx , buf , buf_size ) ;
return 0 ;
2008-09-14 21:39:54 +00:00
}
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
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 ;
}
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 ,
2012-10-27 04:26:02 +00:00
s - > channels ,
avctx - > bits_per_raw_sample ) ;
2010-07-31 20:52:33 +00:00
}
2012-02-03 23:43:39 +00:00
init_frame ( s , frame - > nb_samples ) ;
2006-06-24 10:20:15 +00:00
2012-10-27 04:26:02 +00:00
copy_samples ( s , frame - > data [ 0 ] ) ;
2006-06-24 10:20:15 +00:00
2006-06-26 06:00:07 +00:00
channel_decorrelation ( s ) ;
2012-10-25 19:07:59 +00:00
remove_wasted_bits ( 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 . */
2012-10-27 03:22:38 +00:00
if ( frame_bytes < 0 | | 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 ) ;
2012-10-27 03:22:38 +00:00
if ( frame_bytes < 0 ) {
av_log ( avctx , AV_LOG_ERROR , " Bad frame count \n " ) ;
return frame_bytes ;
}
2006-06-24 10:20:15 +00:00
}
2012-03-22 20:22:39 +00:00
if ( ( ret = ff_alloc_packet2 ( avctx , avpkt , frame_bytes ) ) )
2012-02-03 23:43:39 +00:00
return ret ;
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 ;
2012-10-27 04:26:02 +00:00
if ( ( ret = update_md5_sum ( s , frame - > data [ 0 ] ) ) < 0 ) {
2012-10-25 19:00:10 +00:00
av_log ( avctx , AV_LOG_ERROR , " Error updating MD5 checksum \n " ) ;
return ret ;
}
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 ) ;
2012-10-25 19:00:10 +00:00
av_freep ( & s - > md5_buffer ) ;
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 [ ] = {
2012-08-31 10:22:31 +00:00
{ " lpc_coeff_precision " , " LPC coefficient precision " , offsetof ( FlacEncodeContext , options . lpc_coeff_precision ) , AV_OPT_TYPE_INT , { . i64 = 15 } , 0 , MAX_LPC_PRECISION , FLAGS } ,
{ " lpc_type " , " LPC algorithm " , offsetof ( FlacEncodeContext , options . lpc_type ) , AV_OPT_TYPE_INT , { . i64 = FF_LPC_TYPE_DEFAULT } , FF_LPC_TYPE_DEFAULT , FF_LPC_TYPE_NB - 1 , FLAGS , " lpc_type " } ,
2012-08-31 09:45:52 +00:00
{ " none " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_LPC_TYPE_NONE } , INT_MIN , INT_MAX , FLAGS , " lpc_type " } ,
{ " fixed " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_LPC_TYPE_FIXED } , INT_MIN , INT_MAX , FLAGS , " lpc_type " } ,
{ " levinson " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_LPC_TYPE_LEVINSON } , INT_MIN , INT_MAX , FLAGS , " lpc_type " } ,
{ " cholesky " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_LPC_TYPE_CHOLESKY } , INT_MIN , INT_MAX , FLAGS , " lpc_type " } ,
2012-12-07 14:45:25 +00:00
{ " lpc_passes " , " Number of passes to use for Cholesky factorization during LPC analysis " , offsetof ( FlacEncodeContext , options . lpc_passes ) , AV_OPT_TYPE_INT , { . i64 = 2 } , 1 , INT_MAX , FLAGS } ,
2012-08-31 10:22:31 +00:00
{ " min_partition_order " , NULL , offsetof ( FlacEncodeContext , options . min_partition_order ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , MAX_PARTITION_ORDER , FLAGS } ,
{ " max_partition_order " , NULL , offsetof ( FlacEncodeContext , options . max_partition_order ) , AV_OPT_TYPE_INT , { . i64 = - 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 , { . i64 = - 1 } , - 1 , ORDER_METHOD_LOG , FLAGS , " predm " } ,
2012-08-31 09:45:52 +00:00
{ " estimation " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = ORDER_METHOD_EST } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " 2level " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = ORDER_METHOD_2LEVEL } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " 4level " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = ORDER_METHOD_4LEVEL } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " 8level " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = ORDER_METHOD_8LEVEL } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " search " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = ORDER_METHOD_SEARCH } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
{ " log " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = ORDER_METHOD_LOG } , INT_MIN , INT_MAX , FLAGS , " predm " } ,
2012-08-31 10:22:31 +00:00
{ " ch_mode " , " Stereo decorrelation mode " , offsetof ( FlacEncodeContext , options . ch_mode ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , FLAC_CHMODE_MID_SIDE , FLAGS , " ch_mode " } ,
2012-08-31 09:45:52 +00:00
{ " auto " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = - 1 } , INT_MIN , INT_MAX , FLAGS , " ch_mode " } ,
{ " indep " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = FLAC_CHMODE_INDEPENDENT } , INT_MIN , INT_MAX , FLAGS , " ch_mode " } ,
{ " left_side " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = FLAC_CHMODE_LEFT_SIDE } , INT_MIN , INT_MAX , FLAGS , " ch_mode " } ,
{ " right_side " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = FLAC_CHMODE_RIGHT_SIDE } , INT_MIN , INT_MAX , FLAGS , " ch_mode " } ,
{ " mid_side " , NULL , 0 , AV_OPT_TYPE_CONST , { . i64 = FLAC_CHMODE_MID_SIDE } , INT_MIN , INT_MAX , FLAGS , " ch_mode " } ,
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 ,
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 ( 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-07 20:41:37 +00:00
. capabilities = CODEC_CAP_SMALL_LAST_FRAME | CODEC_CAP_DELAY | CODEC_CAP_LOSSLESS ,
2012-04-06 16:19:39 +00:00
. sample_fmts = ( const enum AVSampleFormat [ ] ) { AV_SAMPLE_FMT_S16 ,
2012-10-27 04:26:02 +00:00
AV_SAMPLE_FMT_S32 ,
2012-04-06 16:19:39 +00:00
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
} ;