static int handle_opts( const char **optlist, char **opts, video_info_t *info, resizer_hnd_t *h )
{
uint32_t out_sar_w, out_sar_h;
char *str_width = x264_get_option( optlist[0], opts );
char *str_height = x264_get_option( optlist[1], opts );
char *str_sar = x264_get_option( optlist[2], opts );
char *fittobox = x264_get_option( optlist[3], opts );
char *str_csp = x264_get_option( optlist[4], opts );
int width = x264_otoi( str_width, -1 );
int height = x264_otoi( str_height, -1 );
int csp_only = 0;
uint32_t in_sar_w = info->sar_width;
uint32_t in_sar_h = info->sar_height;
if( str_csp )
{
/* output csp was specified, first check if optional depth was provided */
char *str_depth = strchr( str_csp, ':' );
int depth = x264_cli_csp_depth_factor( info->csp ) * 8;
if( str_depth )
{
/* csp bit depth was specified */
*str_depth++ = '\0';
depth = x264_otoi( str_depth, -1 );
FAIL_IF_ERROR( depth != 8 && depth != 16, "unsupported bit depth %d\n", depth );
}
/* now lookup against the list of valid csps */
int csp;
if( strlen( str_csp ) == 0 )
csp = info->csp & X264_CSP_MASK;
else
for( csp = X264_CSP_CLI_MAX-1; csp > X264_CSP_NONE; csp-- )
{
if( x264_cli_csps[csp].name && !strcasecmp( x264_cli_csps[csp].name, str_csp ) )
break;
}
FAIL_IF_ERROR( csp == X264_CSP_NONE, "unsupported colorspace `%s'\n", str_csp );
h->dst_csp = csp;
if( depth == 16 )
h->dst_csp |= X264_CSP_HIGH_DEPTH;
}
/* if the input sar is currently invalid, set it to 1:1 so it can be used in math */
if( !in_sar_w || !in_sar_h )
in_sar_w = in_sar_h = 1;
if( str_sar )
{
FAIL_IF_ERROR( 2 != sscanf( str_sar, "%u:%u", &out_sar_w, &out_sar_h ) &&
2 != sscanf( str_sar, "%u/%u", &out_sar_w, &out_sar_h ),
"invalid sar `%s'\n", str_sar )
}
else
static int init( hnd_t *handle, cli_vid_filter_t *filter, video_info_t *info,
x264_param_t *param, char *opt_string )
{
int ret = 0;
int change_fmt = (info->csp ^ param->i_csp) & X264_CSP_HIGH_DEPTH;
int csp = ~(~info->csp ^ change_fmt);
int bit_depth = 8*x264_cli_csp_depth_factor( csp );
if( opt_string )
{
static const char * const optlist[] = { "bit_depth", NULL };
char **opts = x264_split_options( opt_string, optlist );
if( opts )
{
char *str_bit_depth = x264_get_option( "bit_depth", opts );
bit_depth = x264_otoi( str_bit_depth, -1 );
ret = bit_depth < 8 || bit_depth > 16;
csp = bit_depth > 8 ? csp | X264_CSP_HIGH_DEPTH : csp & ~X264_CSP_HIGH_DEPTH;
change_fmt = (info->csp ^ csp) & X264_CSP_HIGH_DEPTH;
free( opts );
}
else
ret = 1;
}
FAIL_IF_ERROR( bit_depth != BIT_DEPTH, "this filter supports only bit depth %d\n", BIT_DEPTH );
FAIL_IF_ERROR( ret, "unsupported bit depth conversion.\n" );
/* only add the filter to the chain if it's needed */
if( change_fmt || bit_depth != 8 * x264_cli_csp_depth_factor( csp ) )
{
FAIL_IF_ERROR( !depth_filter_csp_is_supported(csp), "unsupported colorspace.\n" );
depth_hnd_t *h = x264_malloc( sizeof(depth_hnd_t) + (info->width+1)*sizeof(int16_t) );
if( !h )
return -1;
h->error_buf = (int16_t*)(h + 1);
h->dst_csp = csp;
h->bit_depth = bit_depth;
h->prev_hnd = *handle;
h->prev_filter = *filter;
if( x264_cli_pic_alloc( &h->buffer, h->dst_csp, info->width, info->height ) )
{
x264_free( h );
return -1;
}
*handle = h;
*filter = depth_filter;
info->csp = h->dst_csp;
}
return 0;
}
static int handle_opts( crop_hnd_t *h, video_info_t *info, char **opts, const char * const *optlist )
{
for( int i = 0; i < 4; i++ )
{
char *opt = x264_get_option( optlist[i], opts );
FAIL_IF_ERROR( !opt, "%s crop value not specified\n", optlist[i] );
h->dims[i] = x264_otoi( opt, -1 );
FAIL_IF_ERROR( h->dims[i] < 0, "%s crop value `%s' is less than 0\n", optlist[i], opt );
int dim_mod = i&1 ? (h->csp->mod_height << info->interlaced) : h->csp->mod_width;
FAIL_IF_ERROR( h->dims[i] % dim_mod, "%s crop value `%s' is not a multiple of %d\n", optlist[i], opt, dim_mod );
}
return 0;
}
static int handle_opts( const char **optlist, char **opts, video_info_t *info, resizer_hnd_t *h )
{
uint32_t out_sar_w, out_sar_h;
char *str_width = x264_get_option( optlist[0], opts );
char *str_height = x264_get_option( optlist[1], opts );
char *str_sar = x264_get_option( optlist[2], opts );
char *fittobox = x264_get_option( optlist[3], opts );
char *str_csp = x264_get_option( optlist[4], opts );
int width = x264_otoi( str_width, -1 );
int height = x264_otoi( str_height, -1 );
int csp_only = 0;
uint32_t in_sar_w = info->sar_width;
uint32_t in_sar_h = info->sar_height;
if( str_csp )
{
/* output csp was specified, lookup against valid values */
int csp;
for( csp = X264_CSP_CLI_MAX-1; x264_cli_csps[csp].name && strcasecmp( x264_cli_csps[csp].name, str_csp ); )
csp--;
FAIL_IF_ERROR( csp == X264_CSP_NONE, "unsupported colorspace `%s'\n", str_csp );
h->dst_csp = csp;
}
/* if the input sar is currently invalid, set it to 1:1 so it can be used in math */
if( !in_sar_w || !in_sar_h )
in_sar_w = in_sar_h = 1;
if( str_sar )
{
FAIL_IF_ERROR( 2 != sscanf( str_sar, "%u:%u", &out_sar_w, &out_sar_h ) &&
2 != sscanf( str_sar, "%u/%u", &out_sar_w, &out_sar_h ),
"invalid sar `%s'\n", str_sar )
}
else
static int init( hnd_t *handle, cli_vid_filter_t *filter, video_info_t *info, x264_param_t *param, char *opt_string )
{
selvry_hnd_t *h = malloc( sizeof(selvry_hnd_t) );
if( !h )
return -1;
h->pattern_len = 0;
h->step_size = 0;
int offsets[MAX_PATTERN_SIZE];
for( char *tok, *p = opt_string; (tok = strtok( p, "," )); p = NULL )
{
int val = x264_otoi( tok, -1 );
if( p )
{
FAIL_IF_ERROR( val <= 0, "invalid step `%s'\n", tok )
h->step_size = val;
continue;
}
FAIL_IF_ERROR( val < 0 || val >= h->step_size, "invalid offset `%s'\n", tok )
FAIL_IF_ERROR( h->pattern_len >= MAX_PATTERN_SIZE, "max pattern size %d reached\n", MAX_PATTERN_SIZE )
offsets[h->pattern_len++] = val;
}
FAIL_IF_ERROR( !h->step_size, "no step size provided\n" )
FAIL_IF_ERROR( !h->pattern_len, "no offsets supplied\n" )
h->pattern = malloc( h->pattern_len * sizeof(int) );
if( !h->pattern )
return -1;
memcpy( h->pattern, offsets, h->pattern_len * sizeof(int) );
/* determine required cache size to maintain pattern. */
intptr_t max_rewind = 0;
int min = h->step_size;
for( int i = h->pattern_len-1; i >= 0; i-- )
{
min = X264_MIN( min, offsets[i] );
if( i )
max_rewind = X264_MAX( max_rewind, offsets[i-1] - min + 1 );
/* reached maximum rewind size */
if( max_rewind == h->step_size )
break;
}
if( x264_init_vid_filter( "cache", handle, filter, info, param, (void*)max_rewind ) )
return -1;
/* done initing, overwrite properties */
if( h->step_size != h->pattern_len )
{
info->num_frames = (uint64_t)info->num_frames * h->pattern_len / h->step_size;
info->fps_den *= h->step_size;
info->fps_num *= h->pattern_len;
x264_reduce_fraction( &info->fps_num, &info->fps_den );
if( info->vfr )
{
info->timebase_den *= h->pattern_len;
info->timebase_num *= h->step_size;
x264_reduce_fraction( &info->timebase_num, &info->timebase_den );
}
}
h->pts = 0;
h->vfr = info->vfr;
h->prev_filter = *filter;
h->prev_hnd = *handle;
*filter = select_every_filter;
*handle = h;
return 0;
}
