2010-06-03 20:47:59 +00:00
/*
* Copyright ( c ) 2010 , Google , Inc .
*
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
* FFmpeg is distributed in the hope that it will be useful ,
* 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
* License along with FFmpeg ; if not , write to the Free Software
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
/**
* @ file
* VP8 encoder support via libvpx
*/
# define VPX_DISABLE_CTRL_TYPECHECKS 1
# define VPX_CODEC_DISABLE_COMPAT 1
# include <vpx/vpx_encoder.h>
# include <vpx/vp8cx.h>
# include "avcodec.h"
2011-09-26 08:22:38 +00:00
# include "internal.h"
2012-07-25 19:35:48 +00:00
# include "libavutil/avassert.h"
2010-06-03 20:47:59 +00:00
# include "libavutil/base64.h"
2012-08-06 13:49:32 +00:00
# include "libavutil/common.h"
2011-07-04 06:44:49 +00:00
# include "libavutil/mathematics.h"
2011-09-26 08:22:38 +00:00
# include "libavutil/opt.h"
2010-06-03 20:47:59 +00:00
/**
* Portion of struct vpx_codec_cx_pkt from vpx_encoder . h .
* One encoded frame returned from the library .
*/
struct FrameListData {
2010-08-02 07:25:25 +00:00
void * buf ; /**< compressed data buffer */
size_t sz ; /**< length of compressed data */
int64_t pts ; /**< time stamp to show frame
2010-06-03 20:47:59 +00:00
( in timebase units ) */
2010-08-02 07:25:25 +00:00
unsigned long duration ; /**< duration to show frame
2010-06-03 20:47:59 +00:00
( in timebase units ) */
2010-08-02 07:25:25 +00:00
uint32_t flags ; /**< flags for this frame */
2010-06-03 20:47:59 +00:00
struct FrameListData * next ;
} ;
typedef struct VP8EncoderContext {
2011-10-02 18:38:38 +00:00
AVClass * class ;
2010-06-03 20:47:59 +00:00
struct vpx_codec_ctx encoder ;
struct vpx_image rawimg ;
struct vpx_fixed_buf twopass_stats ;
2011-05-26 18:20:36 +00:00
int deadline ; //i.e., RT/GOOD/BEST
2010-06-03 20:47:59 +00:00
struct FrameListData * coded_frame_list ;
2011-05-26 18:20:36 +00:00
2011-10-02 18:38:38 +00:00
int cpu_used ;
2012-01-05 22:24:26 +00:00
/**
* VP8 specific flags , see VP8F_ * below .
*/
int flags ;
# define VP8F_ERROR_RESILIENT 0x00000001 ///< Enable measures appropriate for streaming over lossy links
# define VP8F_AUTO_ALT_REF 0x00000002 ///< Enable automatic alternate reference frame generation
2011-10-04 01:01:06 +00:00
int auto_alt_ref ;
2011-05-26 18:20:36 +00:00
int arnr_max_frames ;
int arnr_strength ;
int arnr_type ;
2011-09-08 02:14:33 +00:00
2011-10-02 18:38:38 +00:00
int lag_in_frames ;
2011-10-04 01:01:06 +00:00
int error_resilient ;
2011-09-08 02:14:37 +00:00
int crf ;
2012-06-09 21:40:51 +00:00
int max_intra_rate ;
2010-06-03 20:47:59 +00:00
} VP8Context ;
/** String mappings for enum vp8e_enc_control_id */
2012-02-20 08:42:33 +00:00
static const char * const ctlidstr [ ] = {
2010-06-03 20:47:59 +00:00
[ VP8E_UPD_ENTROPY ] = " VP8E_UPD_ENTROPY " ,
[ VP8E_UPD_REFERENCE ] = " VP8E_UPD_REFERENCE " ,
[ VP8E_USE_REFERENCE ] = " VP8E_USE_REFERENCE " ,
[ VP8E_SET_ROI_MAP ] = " VP8E_SET_ROI_MAP " ,
[ VP8E_SET_ACTIVEMAP ] = " VP8E_SET_ACTIVEMAP " ,
[ VP8E_SET_SCALEMODE ] = " VP8E_SET_SCALEMODE " ,
[ VP8E_SET_CPUUSED ] = " VP8E_SET_CPUUSED " ,
[ VP8E_SET_ENABLEAUTOALTREF ] = " VP8E_SET_ENABLEAUTOALTREF " ,
[ VP8E_SET_NOISE_SENSITIVITY ] = " VP8E_SET_NOISE_SENSITIVITY " ,
[ VP8E_SET_SHARPNESS ] = " VP8E_SET_SHARPNESS " ,
[ VP8E_SET_STATIC_THRESHOLD ] = " VP8E_SET_STATIC_THRESHOLD " ,
[ VP8E_SET_TOKEN_PARTITIONS ] = " VP8E_SET_TOKEN_PARTITIONS " ,
[ VP8E_GET_LAST_QUANTIZER ] = " VP8E_GET_LAST_QUANTIZER " ,
[ VP8E_SET_ARNR_MAXFRAMES ] = " VP8E_SET_ARNR_MAXFRAMES " ,
[ VP8E_SET_ARNR_STRENGTH ] = " VP8E_SET_ARNR_STRENGTH " ,
[ VP8E_SET_ARNR_TYPE ] = " VP8E_SET_ARNR_TYPE " ,
2011-04-12 00:00:35 +00:00
[ VP8E_SET_CQ_LEVEL ] = " VP8E_SET_CQ_LEVEL " ,
2012-06-09 21:40:51 +00:00
[ VP8E_SET_MAX_INTRA_BITRATE_PCT ] = " VP8E_SET_MAX_INTRA_BITRATE_PCT " ,
2010-06-03 20:47:59 +00:00
} ;
static av_cold void log_encoder_error ( AVCodecContext * avctx , const char * desc )
{
VP8Context * ctx = avctx - > priv_data ;
const char * error = vpx_codec_error ( & ctx - > encoder ) ;
const char * detail = vpx_codec_error_detail ( & ctx - > encoder ) ;
av_log ( avctx , AV_LOG_ERROR , " %s: %s \n " , desc , error ) ;
if ( detail )
av_log ( avctx , AV_LOG_ERROR , " Additional information: %s \n " , detail ) ;
}
static av_cold void dump_enc_cfg ( AVCodecContext * avctx ,
const struct vpx_codec_enc_cfg * cfg )
{
int width = - 30 ;
int level = AV_LOG_DEBUG ;
av_log ( avctx , level , " vpx_codec_enc_cfg \n " ) ;
av_log ( avctx , level , " generic settings \n "
" %*s%u \n %*s%u \n %*s%u \n %*s%u \n %*s%u \n "
" %*s{%u/%u} \n %*s%u \n %*s%d \n %*s%u \n " ,
width , " g_usage: " , cfg - > g_usage ,
width , " g_threads: " , cfg - > g_threads ,
width , " g_profile: " , cfg - > g_profile ,
width , " g_w: " , cfg - > g_w ,
width , " g_h: " , cfg - > g_h ,
width , " g_timebase: " , cfg - > g_timebase . num , cfg - > g_timebase . den ,
width , " g_error_resilient: " , cfg - > g_error_resilient ,
width , " g_pass: " , cfg - > g_pass ,
width , " g_lag_in_frames: " , cfg - > g_lag_in_frames ) ;
av_log ( avctx , level , " rate control settings \n "
" %*s%u \n %*s%u \n %*s%u \n %*s%u \n "
" %*s%d \n %*s%p(%zu) \n %*s%u \n " ,
width , " rc_dropframe_thresh: " , cfg - > rc_dropframe_thresh ,
width , " rc_resize_allowed: " , cfg - > rc_resize_allowed ,
width , " rc_resize_up_thresh: " , cfg - > rc_resize_up_thresh ,
width , " rc_resize_down_thresh: " , cfg - > rc_resize_down_thresh ,
width , " rc_end_usage: " , cfg - > rc_end_usage ,
width , " rc_twopass_stats_in: " , cfg - > rc_twopass_stats_in . buf , cfg - > rc_twopass_stats_in . sz ,
width , " rc_target_bitrate: " , cfg - > rc_target_bitrate ) ;
av_log ( avctx , level , " quantizer settings \n "
" %*s%u \n %*s%u \n " ,
width , " rc_min_quantizer: " , cfg - > rc_min_quantizer ,
width , " rc_max_quantizer: " , cfg - > rc_max_quantizer ) ;
av_log ( avctx , level , " bitrate tolerance \n "
" %*s%u \n %*s%u \n " ,
width , " rc_undershoot_pct: " , cfg - > rc_undershoot_pct ,
width , " rc_overshoot_pct: " , cfg - > rc_overshoot_pct ) ;
av_log ( avctx , level , " decoder buffer model \n "
" %*s%u \n %*s%u \n %*s%u \n " ,
width , " rc_buf_sz: " , cfg - > rc_buf_sz ,
width , " rc_buf_initial_sz: " , cfg - > rc_buf_initial_sz ,
width , " rc_buf_optimal_sz: " , cfg - > rc_buf_optimal_sz ) ;
av_log ( avctx , level , " 2 pass rate control settings \n "
" %*s%u \n %*s%u \n %*s%u \n " ,
width , " rc_2pass_vbr_bias_pct: " , cfg - > rc_2pass_vbr_bias_pct ,
width , " rc_2pass_vbr_minsection_pct: " , cfg - > rc_2pass_vbr_minsection_pct ,
width , " rc_2pass_vbr_maxsection_pct: " , cfg - > rc_2pass_vbr_maxsection_pct ) ;
av_log ( avctx , level , " keyframing settings \n "
" %*s%d \n %*s%u \n %*s%u \n " ,
width , " kf_mode: " , cfg - > kf_mode ,
width , " kf_min_dist: " , cfg - > kf_min_dist ,
width , " kf_max_dist: " , cfg - > kf_max_dist ) ;
av_log ( avctx , level , " \n " ) ;
}
static void coded_frame_add ( void * list , struct FrameListData * cx_frame )
{
struct FrameListData * * p = list ;
while ( * p ! = NULL )
p = & ( * p ) - > next ;
* p = cx_frame ;
cx_frame - > next = NULL ;
}
static av_cold void free_coded_frame ( struct FrameListData * cx_frame )
{
av_freep ( & cx_frame - > buf ) ;
av_freep ( & cx_frame ) ;
}
static av_cold void free_frame_list ( struct FrameListData * list )
{
struct FrameListData * p = list ;
while ( p ) {
list = list - > next ;
free_coded_frame ( p ) ;
p = list ;
}
}
static av_cold int codecctl_int ( AVCodecContext * avctx ,
enum vp8e_enc_control_id id , int val )
{
VP8Context * ctx = avctx - > priv_data ;
char buf [ 80 ] ;
int width = - 30 ;
int res ;
snprintf ( buf , sizeof ( buf ) , " %s: " , ctlidstr [ id ] ) ;
av_log ( avctx , AV_LOG_DEBUG , " %*s%d \n " , width , buf , val ) ;
res = vpx_codec_control ( & ctx - > encoder , id , val ) ;
if ( res ! = VPX_CODEC_OK ) {
snprintf ( buf , sizeof ( buf ) , " Failed to set %s codec control " ,
ctlidstr [ id ] ) ;
log_encoder_error ( avctx , buf ) ;
}
return res = = VPX_CODEC_OK ? 0 : AVERROR ( EINVAL ) ;
}
static av_cold int vp8_free ( AVCodecContext * avctx )
{
VP8Context * ctx = avctx - > priv_data ;
vpx_codec_destroy ( & ctx - > encoder ) ;
av_freep ( & ctx - > twopass_stats . buf ) ;
av_freep ( & avctx - > coded_frame ) ;
av_freep ( & avctx - > stats_out ) ;
free_frame_list ( ctx - > coded_frame_list ) ;
return 0 ;
}
static av_cold int vp8_init ( AVCodecContext * avctx )
{
VP8Context * ctx = avctx - > priv_data ;
const struct vpx_codec_iface * iface = & vpx_codec_vp8_cx_algo ;
struct vpx_codec_enc_cfg enccfg ;
int res ;
av_log ( avctx , AV_LOG_INFO , " %s \n " , vpx_codec_version_str ( ) ) ;
av_log ( avctx , AV_LOG_VERBOSE , " %s \n " , vpx_codec_build_config ( ) ) ;
if ( ( res = vpx_codec_enc_config_default ( iface , & enccfg , 0 ) ) ! = VPX_CODEC_OK ) {
av_log ( avctx , AV_LOG_ERROR , " Failed to get config: %s \n " ,
vpx_codec_err_to_string ( res ) ) ;
return AVERROR ( EINVAL ) ;
}
2012-08-16 14:59:42 +00:00
if ( ! avctx - > bit_rate )
if ( avctx - > rc_max_rate | | avctx - > rc_buffer_size | | avctx - > rc_initial_buffer_occupancy ) {
av_log ( avctx , AV_LOG_ERROR , " Rate control parameters set without a bitrate \n " ) ;
return AVERROR ( EINVAL ) ;
}
2010-06-03 20:47:59 +00:00
dump_enc_cfg ( avctx , & enccfg ) ;
enccfg . g_w = avctx - > width ;
enccfg . g_h = avctx - > height ;
enccfg . g_timebase . num = avctx - > time_base . num ;
enccfg . g_timebase . den = avctx - > time_base . den ;
enccfg . g_threads = avctx - > thread_count ;
2011-10-02 18:38:38 +00:00
enccfg . g_lag_in_frames = ctx - > lag_in_frames ;
2010-06-03 20:47:59 +00:00
if ( avctx - > flags & CODEC_FLAG_PASS1 )
enccfg . g_pass = VPX_RC_FIRST_PASS ;
else if ( avctx - > flags & CODEC_FLAG_PASS2 )
enccfg . g_pass = VPX_RC_LAST_PASS ;
else
enccfg . g_pass = VPX_RC_ONE_PASS ;
if ( avctx - > rc_min_rate = = avctx - > rc_max_rate & &
2012-08-17 15:11:24 +00:00
avctx - > rc_min_rate = = avctx - > bit_rate & & avctx - > bit_rate )
2010-06-03 20:47:59 +00:00
enccfg . rc_end_usage = VPX_CBR ;
2011-09-08 02:14:37 +00:00
else if ( ctx - > crf )
2011-04-12 00:00:35 +00:00
enccfg . rc_end_usage = VPX_CQ ;
2010-06-03 20:47:59 +00:00
enccfg . rc_target_bitrate = av_rescale_rnd ( avctx - > bit_rate , 1 , 1000 ,
AV_ROUND_NEAR_INF ) ;
2011-09-30 10:15:59 +00:00
if ( avctx - > qmin > 0 )
enccfg . rc_min_quantizer = avctx - > qmin ;
if ( avctx - > qmax > 0 )
enccfg . rc_max_quantizer = avctx - > qmax ;
2010-06-08 09:01:14 +00:00
enccfg . rc_dropframe_thresh = avctx - > frame_skip_threshold ;
2010-06-03 20:47:59 +00:00
2010-07-22 12:35:32 +00:00
//0-100 (0 => CBR, 100 => VBR)
enccfg . rc_2pass_vbr_bias_pct = round ( avctx - > qcompress * 100 ) ;
2012-08-16 14:58:59 +00:00
if ( avctx - > bit_rate )
enccfg . rc_2pass_vbr_minsection_pct =
avctx - > rc_min_rate * 100LL / avctx - > bit_rate ;
2010-07-22 12:35:32 +00:00
if ( avctx - > rc_max_rate )
enccfg . rc_2pass_vbr_maxsection_pct =
2010-12-12 16:27:32 +00:00
avctx - > rc_max_rate * 100LL / avctx - > bit_rate ;
2010-07-22 12:35:32 +00:00
2010-07-28 08:02:35 +00:00
if ( avctx - > rc_buffer_size )
enccfg . rc_buf_sz =
2010-12-12 16:27:32 +00:00
avctx - > rc_buffer_size * 1000LL / avctx - > bit_rate ;
2010-07-28 08:02:35 +00:00
if ( avctx - > rc_initial_buffer_occupancy )
enccfg . rc_buf_initial_sz =
2010-12-12 16:27:32 +00:00
avctx - > rc_initial_buffer_occupancy * 1000LL / avctx - > bit_rate ;
2010-07-28 08:02:35 +00:00
enccfg . rc_buf_optimal_sz = enccfg . rc_buf_sz * 5 / 6 ;
2011-05-26 18:20:36 +00:00
enccfg . rc_undershoot_pct = round ( avctx - > rc_buffer_aggressivity * 100 ) ;
2010-07-28 08:02:35 +00:00
2010-06-08 08:47:50 +00:00
//_enc_init() will balk if kf_min_dist differs from max w/VPX_KF_AUTO
2011-09-30 10:15:59 +00:00
if ( avctx - > keyint_min > = 0 & & avctx - > keyint_min = = avctx - > gop_size )
2010-06-03 20:47:59 +00:00
enccfg . kf_min_dist = avctx - > keyint_min ;
2011-09-30 10:15:59 +00:00
if ( avctx - > gop_size > = 0 )
enccfg . kf_max_dist = avctx - > gop_size ;
2010-06-03 20:47:59 +00:00
if ( enccfg . g_pass = = VPX_RC_FIRST_PASS )
enccfg . g_lag_in_frames = 0 ;
else if ( enccfg . g_pass = = VPX_RC_LAST_PASS ) {
int decode_size ;
if ( ! avctx - > stats_in ) {
av_log ( avctx , AV_LOG_ERROR , " No stats file for second pass \n " ) ;
return AVERROR_INVALIDDATA ;
}
ctx - > twopass_stats . sz = strlen ( avctx - > stats_in ) * 3 / 4 ;
ctx - > twopass_stats . buf = av_malloc ( ctx - > twopass_stats . sz ) ;
if ( ! ctx - > twopass_stats . buf ) {
av_log ( avctx , AV_LOG_ERROR ,
" Stat buffer alloc (%zu bytes) failed \n " ,
ctx - > twopass_stats . sz ) ;
return AVERROR ( ENOMEM ) ;
}
decode_size = av_base64_decode ( ctx - > twopass_stats . buf , avctx - > stats_in ,
ctx - > twopass_stats . sz ) ;
if ( decode_size < 0 ) {
av_log ( avctx , AV_LOG_ERROR , " Stat buffer decode failed \n " ) ;
return AVERROR_INVALIDDATA ;
}
ctx - > twopass_stats . sz = decode_size ;
enccfg . rc_twopass_stats_in = ctx - > twopass_stats ;
}
2010-07-11 17:46:44 +00:00
/* 0-3: For non-zero values the encoder increasingly optimizes for reduced
complexity playback on low powered devices at the expense of encode
quality . */
if ( avctx - > profile ! = FF_PROFILE_UNKNOWN )
enccfg . g_profile = avctx - > profile ;
2010-06-03 20:47:59 +00:00
2012-01-05 22:24:26 +00:00
enccfg . g_error_resilient = ctx - > error_resilient | | ctx - > flags & VP8F_ERROR_RESILIENT ;
2011-05-26 18:20:36 +00:00
2010-06-03 20:47:59 +00:00
dump_enc_cfg ( avctx , & enccfg ) ;
/* Construct Encoder Context */
res = vpx_codec_enc_init ( & ctx - > encoder , iface , & enccfg , 0 ) ;
if ( res ! = VPX_CODEC_OK ) {
log_encoder_error ( avctx , " Failed to initialize encoder " ) ;
return AVERROR ( EINVAL ) ;
}
//codec control failures are currently treated only as warnings
av_log ( avctx , AV_LOG_DEBUG , " vpx_codec_control \n " ) ;
2011-10-04 01:01:06 +00:00
if ( ctx - > cpu_used ! = INT_MIN )
codecctl_int ( avctx , VP8E_SET_CPUUSED , ctx - > cpu_used ) ;
2012-01-05 22:24:26 +00:00
if ( ctx - > flags & VP8F_AUTO_ALT_REF )
ctx - > auto_alt_ref = 1 ;
2011-10-04 01:01:06 +00:00
if ( ctx - > auto_alt_ref > = 0 )
codecctl_int ( avctx , VP8E_SET_ENABLEAUTOALTREF , ctx - > auto_alt_ref ) ;
if ( ctx - > arnr_max_frames > = 0 )
codecctl_int ( avctx , VP8E_SET_ARNR_MAXFRAMES , ctx - > arnr_max_frames ) ;
if ( ctx - > arnr_strength > = 0 )
codecctl_int ( avctx , VP8E_SET_ARNR_STRENGTH , ctx - > arnr_strength ) ;
if ( ctx - > arnr_type > = 0 )
codecctl_int ( avctx , VP8E_SET_ARNR_TYPE , ctx - > arnr_type ) ;
2010-06-03 20:47:59 +00:00
codecctl_int ( avctx , VP8E_SET_NOISE_SENSITIVITY , avctx - > noise_reduction ) ;
2010-10-22 18:09:14 +00:00
codecctl_int ( avctx , VP8E_SET_TOKEN_PARTITIONS , av_log2 ( avctx - > slices ) ) ;
2011-04-12 00:00:29 +00:00
codecctl_int ( avctx , VP8E_SET_STATIC_THRESHOLD , avctx - > mb_threshold ) ;
2011-09-08 02:14:37 +00:00
codecctl_int ( avctx , VP8E_SET_CQ_LEVEL , ctx - > crf ) ;
2012-06-09 21:40:51 +00:00
if ( ctx - > max_intra_rate > = 0 )
codecctl_int ( avctx , VP8E_SET_MAX_INTRA_BITRATE_PCT , ctx - > max_intra_rate ) ;
2011-05-26 18:20:36 +00:00
av_log ( avctx , AV_LOG_DEBUG , " Using deadline: %d \n " , ctx - > deadline ) ;
2010-06-03 20:47:59 +00:00
//provide dummy value to initialize wrapper, values will be updated each _encode()
vpx_img_wrap ( & ctx - > rawimg , VPX_IMG_FMT_I420 , avctx - > width , avctx - > height , 1 ,
( unsigned char * ) 1 ) ;
avctx - > coded_frame = avcodec_alloc_frame ( ) ;
if ( ! avctx - > coded_frame ) {
av_log ( avctx , AV_LOG_ERROR , " Error allocating coded frame \n " ) ;
vp8_free ( avctx ) ;
return AVERROR ( ENOMEM ) ;
}
return 0 ;
}
static inline void cx_pktcpy ( struct FrameListData * dst ,
const struct vpx_codec_cx_pkt * src )
{
dst - > pts = src - > data . frame . pts ;
dst - > duration = src - > data . frame . duration ;
dst - > flags = src - > data . frame . flags ;
dst - > sz = src - > data . frame . sz ;
dst - > buf = src - > data . frame . buf ;
}
/**
2012-02-22 06:38:13 +00:00
* Store coded frame information in format suitable for return from encode2 ( ) .
2010-06-03 20:47:59 +00:00
*
2012-02-22 06:38:13 +00:00
* Write information from @ a cx_frame to @ a pkt
* @ return packet data size on success
* @ return a negative AVERROR on error
2010-06-03 20:47:59 +00:00
*/
static int storeframe ( AVCodecContext * avctx , struct FrameListData * cx_frame ,
2012-02-22 06:38:13 +00:00
AVPacket * pkt , AVFrame * coded_frame )
2010-06-03 20:47:59 +00:00
{
2012-03-22 14:00:48 +00:00
int ret = ff_alloc_packet2 ( avctx , pkt , cx_frame - > sz ) ;
2012-02-22 06:38:13 +00:00
if ( ret > = 0 ) {
memcpy ( pkt - > data , cx_frame - > buf , pkt - > size ) ;
pkt - > pts = pkt - > dts = cx_frame - > pts ;
2010-06-03 20:47:59 +00:00
coded_frame - > pts = cx_frame - > pts ;
coded_frame - > key_frame = ! ! ( cx_frame - > flags & VPX_FRAME_IS_KEY ) ;
2012-02-22 06:38:13 +00:00
if ( coded_frame - > key_frame ) {
2011-04-27 23:40:44 +00:00
coded_frame - > pict_type = AV_PICTURE_TYPE_I ;
2012-02-22 06:38:13 +00:00
pkt - > flags | = AV_PKT_FLAG_KEY ;
} else
2011-04-27 23:40:44 +00:00
coded_frame - > pict_type = AV_PICTURE_TYPE_P ;
2010-06-03 20:47:59 +00:00
} else {
2012-02-22 06:38:13 +00:00
return ret ;
2010-06-03 20:47:59 +00:00
}
2012-02-22 06:38:13 +00:00
return pkt - > size ;
2010-06-03 20:47:59 +00:00
}
/**
* Queue multiple output frames from the encoder , returning the front - most .
* In cases where vpx_codec_get_cx_data ( ) returns more than 1 frame append
* the frame queue . Return the head frame if available .
* @ return Stored frame size
* @ return AVERROR ( EINVAL ) on output size error
* @ return AVERROR ( ENOMEM ) on coded frame queue data allocation error
*/
2012-02-22 06:38:13 +00:00
static int queue_frames ( AVCodecContext * avctx , AVPacket * pkt_out ,
2010-06-03 20:47:59 +00:00
AVFrame * coded_frame )
{
VP8Context * ctx = avctx - > priv_data ;
const struct vpx_codec_cx_pkt * pkt ;
const void * iter = NULL ;
int size = 0 ;
if ( ctx - > coded_frame_list ) {
struct FrameListData * cx_frame = ctx - > coded_frame_list ;
/* return the leading frame if we've already begun queueing */
2012-02-22 06:38:13 +00:00
size = storeframe ( avctx , cx_frame , pkt_out , coded_frame ) ;
2010-06-03 20:47:59 +00:00
if ( size < 0 )
2012-02-22 06:38:13 +00:00
return size ;
2010-06-03 20:47:59 +00:00
ctx - > coded_frame_list = cx_frame - > next ;
free_coded_frame ( cx_frame ) ;
}
/* consume all available output from the encoder before returning. buffers
are only good through the next vpx_codec call */
while ( ( pkt = vpx_codec_get_cx_data ( & ctx - > encoder , & iter ) ) ) {
switch ( pkt - > kind ) {
case VPX_CODEC_CX_FRAME_PKT :
if ( ! size ) {
struct FrameListData cx_frame ;
/* avoid storing the frame when the list is empty and we haven't yet
provided a frame for output */
2012-07-25 19:35:48 +00:00
av_assert0 ( ! ctx - > coded_frame_list ) ;
2010-06-03 20:47:59 +00:00
cx_pktcpy ( & cx_frame , pkt ) ;
2012-02-22 06:38:13 +00:00
size = storeframe ( avctx , & cx_frame , pkt_out , coded_frame ) ;
2010-06-03 20:47:59 +00:00
if ( size < 0 )
2012-02-22 06:38:13 +00:00
return size ;
2010-06-03 20:47:59 +00:00
} else {
struct FrameListData * cx_frame =
av_malloc ( sizeof ( struct FrameListData ) ) ;
if ( ! cx_frame ) {
av_log ( avctx , AV_LOG_ERROR ,
" Frame queue element alloc failed \n " ) ;
return AVERROR ( ENOMEM ) ;
}
cx_pktcpy ( cx_frame , pkt ) ;
cx_frame - > buf = av_malloc ( cx_frame - > sz ) ;
if ( ! cx_frame - > buf ) {
av_log ( avctx , AV_LOG_ERROR ,
" Data buffer alloc (%zu bytes) failed \n " ,
cx_frame - > sz ) ;
return AVERROR ( ENOMEM ) ;
}
memcpy ( cx_frame - > buf , pkt - > data . frame . buf , pkt - > data . frame . sz ) ;
coded_frame_add ( & ctx - > coded_frame_list , cx_frame ) ;
}
break ;
case VPX_CODEC_STATS_PKT : {
struct vpx_fixed_buf * stats = & ctx - > twopass_stats ;
2011-09-28 15:16:11 +00:00
stats - > buf = av_realloc_f ( stats - > buf , 1 ,
stats - > sz + pkt - > data . twopass_stats . sz ) ;
2010-06-03 20:47:59 +00:00
if ( ! stats - > buf ) {
av_log ( avctx , AV_LOG_ERROR , " Stat buffer realloc failed \n " ) ;
return AVERROR ( ENOMEM ) ;
}
memcpy ( ( uint8_t * ) stats - > buf + stats - > sz ,
pkt - > data . twopass_stats . buf , pkt - > data . twopass_stats . sz ) ;
stats - > sz + = pkt - > data . twopass_stats . sz ;
break ;
}
case VPX_CODEC_PSNR_PKT : //FIXME add support for CODEC_FLAG_PSNR
case VPX_CODEC_CUSTOM_PKT :
//ignore unsupported/unrecognized packet types
break ;
}
}
return size ;
}
2012-02-22 06:38:13 +00:00
static int vp8_encode ( AVCodecContext * avctx , AVPacket * pkt ,
const AVFrame * frame , int * got_packet )
2010-06-03 20:47:59 +00:00
{
VP8Context * ctx = avctx - > priv_data ;
struct vpx_image * rawimg = NULL ;
int64_t timestamp = 0 ;
2012-06-10 21:15:20 +00:00
long flags = 0 ;
2010-06-03 20:47:59 +00:00
int res , coded_size ;
if ( frame ) {
rawimg = & ctx - > rawimg ;
rawimg - > planes [ VPX_PLANE_Y ] = frame - > data [ 0 ] ;
rawimg - > planes [ VPX_PLANE_U ] = frame - > data [ 1 ] ;
rawimg - > planes [ VPX_PLANE_V ] = frame - > data [ 2 ] ;
rawimg - > stride [ VPX_PLANE_Y ] = frame - > linesize [ 0 ] ;
rawimg - > stride [ VPX_PLANE_U ] = frame - > linesize [ 1 ] ;
rawimg - > stride [ VPX_PLANE_V ] = frame - > linesize [ 2 ] ;
timestamp = frame - > pts ;
2012-06-10 21:15:20 +00:00
flags = frame - > pict_type = = AV_PICTURE_TYPE_I ? VPX_EFLAG_FORCE_KF : 0 ;
2010-06-03 20:47:59 +00:00
}
res = vpx_codec_encode ( & ctx - > encoder , rawimg , timestamp ,
2012-06-10 21:15:20 +00:00
avctx - > ticks_per_frame , flags , ctx - > deadline ) ;
2010-06-03 20:47:59 +00:00
if ( res ! = VPX_CODEC_OK ) {
log_encoder_error ( avctx , " Error encoding frame " ) ;
return AVERROR_INVALIDDATA ;
}
2012-02-22 06:38:13 +00:00
coded_size = queue_frames ( avctx , pkt , avctx - > coded_frame ) ;
2010-06-03 20:47:59 +00:00
if ( ! frame & & avctx - > flags & CODEC_FLAG_PASS1 ) {
2010-06-07 21:34:56 +00:00
unsigned int b64_size = AV_BASE64_SIZE ( ctx - > twopass_stats . sz ) ;
2010-06-03 20:47:59 +00:00
avctx - > stats_out = av_malloc ( b64_size ) ;
if ( ! avctx - > stats_out ) {
av_log ( avctx , AV_LOG_ERROR , " Stat buffer alloc (%d bytes) failed \n " ,
b64_size ) ;
return AVERROR ( ENOMEM ) ;
}
av_base64_encode ( avctx - > stats_out , b64_size , ctx - > twopass_stats . buf ,
ctx - > twopass_stats . sz ) ;
}
2012-02-22 06:38:13 +00:00
* got_packet = ! ! coded_size ;
return 0 ;
2010-06-03 20:47:59 +00:00
}
2011-10-04 01:01:06 +00:00
# define OFFSET(x) offsetof(VP8Context, x)
2011-10-02 18:38:38 +00:00
# define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
2011-09-26 08:22:38 +00:00
static const AVOption options [ ] = {
2011-10-04 05:38:01 +00:00
{ " cpu-used " , " Quality/Speed ratio modifier " , OFFSET ( cpu_used ) , AV_OPT_TYPE_INT , { INT_MIN } , INT_MIN , INT_MAX , VE } ,
2011-10-04 01:01:06 +00:00
{ " auto-alt-ref " , " Enable use of alternate reference "
2011-10-04 05:38:01 +00:00
" frames (2-pass only) " , OFFSET ( auto_alt_ref ) , AV_OPT_TYPE_INT , { - 1 } , - 1 , 1 , VE } ,
2011-10-04 01:01:06 +00:00
{ " lag-in-frames " , " Number of frames to look ahead for "
2011-10-04 05:38:01 +00:00
" alternate reference frame selection " , OFFSET ( lag_in_frames ) , AV_OPT_TYPE_INT , { - 1 } , - 1 , INT_MAX , VE } ,
{ " arnr-maxframes " , " altref noise reduction max frame count " , OFFSET ( arnr_max_frames ) , AV_OPT_TYPE_INT , { - 1 } , - 1 , INT_MAX , VE } ,
{ " arnr-strength " , " altref noise reduction filter strength " , OFFSET ( arnr_strength ) , AV_OPT_TYPE_INT , { - 1 } , - 1 , INT_MAX , VE } ,
{ " arnr-type " , " altref noise reduction filter type " , OFFSET ( arnr_type ) , AV_OPT_TYPE_INT , { - 1 } , - 1 , INT_MAX , VE , " arnr_type " } ,
{ " backward " , NULL , 0 , AV_OPT_TYPE_CONST , { 1 } , 0 , 0 , VE , " arnr_type " } ,
{ " forward " , NULL , 0 , AV_OPT_TYPE_CONST , { 2 } , 0 , 0 , VE , " arnr_type " } ,
{ " centered " , NULL , 0 , AV_OPT_TYPE_CONST , { 3 } , 0 , 0 , VE , " arnr_type " } ,
{ " deadline " , " Time to spend encoding, in microseconds. " , OFFSET ( deadline ) , AV_OPT_TYPE_INT , { VPX_DL_GOOD_QUALITY } , INT_MIN , INT_MAX , VE , " quality " } ,
{ " best " , NULL , 0 , AV_OPT_TYPE_CONST , { VPX_DL_BEST_QUALITY } , 0 , 0 , VE , " quality " } ,
{ " good " , NULL , 0 , AV_OPT_TYPE_CONST , { VPX_DL_GOOD_QUALITY } , 0 , 0 , VE , " quality " } ,
{ " realtime " , NULL , 0 , AV_OPT_TYPE_CONST , { VPX_DL_REALTIME } , 0 , 0 , VE , " quality " } ,
{ " error-resilient " , " Error resilience configuration " , OFFSET ( error_resilient ) , AV_OPT_TYPE_FLAGS , { 0 } , INT_MIN , INT_MAX , VE , " er " } ,
2012-06-09 21:40:51 +00:00
{ " max-intra-rate " , " Maximum I-frame bitrate (pct) 0=unlimited " , OFFSET ( max_intra_rate ) , AV_OPT_TYPE_INT , { - 1 } , - 1 , INT_MAX , VE } ,
2011-10-04 01:01:06 +00:00
# ifdef VPX_ERROR_RESILIENT_DEFAULT
2011-10-04 05:38:01 +00:00
{ " default " , " Improve resiliency against losses of whole frames " , 0 , AV_OPT_TYPE_CONST , { VPX_ERROR_RESILIENT_DEFAULT } , 0 , 0 , VE , " er " } ,
2011-10-04 01:01:06 +00:00
{ " partitions " , " The frame partitions are independently decodable "
" by the bool decoder, meaning that partitions can be decoded even "
" though earlier partitions have been lost. Note that intra predicition "
2011-10-04 05:38:01 +00:00
" is still done over the partition boundary. " , 0 , AV_OPT_TYPE_CONST , { VPX_ERROR_RESILIENT_PARTITIONS } , 0 , 0 , VE , " er " } ,
2011-10-04 01:01:06 +00:00
# endif
2011-10-17 05:33:10 +00:00
{ " speed " , " " , offsetof ( VP8Context , cpu_used ) , AV_OPT_TYPE_INT , { . dbl = 3 } , - 16 , 16 , VE } ,
{ " quality " , " " , offsetof ( VP8Context , deadline ) , AV_OPT_TYPE_INT , { . dbl = VPX_DL_GOOD_QUALITY } , INT_MIN , INT_MAX , VE , " quality " } ,
2012-01-05 22:24:26 +00:00
{ " vp8flags " , " " , offsetof ( VP8Context , flags ) , FF_OPT_TYPE_FLAGS , { . dbl = 0 } , 0 , UINT_MAX , VE , " flags " } ,
{ " error_resilient " , " enable error resilience " , 0 , FF_OPT_TYPE_CONST , { . dbl = VP8F_ERROR_RESILIENT } , INT_MIN , INT_MAX , VE , " flags " } ,
{ " altref " , " enable use of alternate reference frames (VP8/2-pass only) " , 0 , FF_OPT_TYPE_CONST , { . dbl = VP8F_AUTO_ALT_REF } , INT_MIN , INT_MAX , VE , " flags " } ,
2011-10-17 05:33:10 +00:00
{ " arnr_max_frames " , " altref noise reduction max frame count " , offsetof ( VP8Context , arnr_max_frames ) , AV_OPT_TYPE_INT , { . dbl = 0 } , 0 , 15 , VE } ,
{ " arnr_strength " , " altref noise reduction filter strength " , offsetof ( VP8Context , arnr_strength ) , AV_OPT_TYPE_INT , { . dbl = 3 } , 0 , 6 , VE } ,
{ " arnr_type " , " altref noise reduction filter type " , offsetof ( VP8Context , arnr_type ) , AV_OPT_TYPE_INT , { . dbl = 3 } , 1 , 3 , VE } ,
{ " rc_lookahead " , " Number of frames to look ahead for alternate reference frame selection " , offsetof ( VP8Context , lag_in_frames ) , AV_OPT_TYPE_INT , { . dbl = 25 } , 0 , 25 , VE } ,
{ " crf " , " Select the quality for constant quality mode " , offsetof ( VP8Context , crf ) , AV_OPT_TYPE_INT , { . dbl = 0 } , 0 , 63 , VE } ,
2011-10-02 02:41:22 +00:00
{ NULL }
2011-09-26 08:22:38 +00:00
} ;
static const AVClass class = {
. class_name = " libvpx encoder " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2011-09-30 10:15:59 +00:00
static const AVCodecDefault defaults [ ] = {
{ " qmin " , " -1 " } ,
{ " qmax " , " -1 " } ,
{ " g " , " -1 " } ,
{ " keyint_min " , " -1 " } ,
{ NULL } ,
} ;
2011-01-25 21:40:11 +00:00
AVCodec ff_libvpx_encoder = {
2011-07-17 10:54:31 +00:00
. name = " libvpx " ,
. type = AVMEDIA_TYPE_VIDEO ,
2012-08-05 09:11:04 +00:00
. id = AV_CODEC_ID_VP8 ,
2011-07-17 10:54:31 +00:00
. priv_data_size = sizeof ( VP8Context ) ,
. init = vp8_init ,
2012-02-22 06:38:13 +00:00
. encode2 = vp8_encode ,
2011-07-17 10:54:31 +00:00
. close = vp8_free ,
2012-01-10 16:21:52 +00:00
. capabilities = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS ,
2012-04-06 16:19:39 +00:00
. pix_fmts = ( const enum PixelFormat [ ] ) { PIX_FMT_YUV420P , PIX_FMT_NONE } ,
. long_name = NULL_IF_CONFIG_SMALL ( " libvpx VP8 " ) ,
. priv_class = & class ,
2011-09-30 10:15:59 +00:00
. defaults = defaults ,
2010-06-03 20:47:59 +00:00
} ;