/*****************************************************************************
* x264: top-level x264cli functions
*****************************************************************************
- * Copyright (C) 2003-2011 x264 project
+ * Copyright (C) 2003-2012 x264 project
*
* Authors: Loren Merritt <lorenm@u.washington.edu>
* Laurent Aimar <fenrir@via.ecp.fr>
#endif
#if HAVE_SWSCALE
+#undef DECLARE_ALIGNED
#include <libswscale/swscale.h>
#endif
} cli_opt_t;
/* file i/o operation structs */
-cli_input_t input;
-static cli_output_t output;
+cli_input_t cli_input;
+static cli_output_t cli_output;
/* video filter operation struct */
static cli_vid_filter_t filter;
static const char * const pulldown_names[] = { "none", "22", "32", "64", "double", "triple", "euro", 0 };
static const char * const log_level_names[] = { "none", "error", "warning", "info", "debug", 0 };
-static const char * const output_csp_names[] = { "i420", "i444", "rgb", 0 };
+static const char * const output_csp_names[] =
+{
+#if !X264_CHROMA_FORMAT || X264_CHROMA_FORMAT == X264_CSP_I420
+ "i420",
+#endif
+#if !X264_CHROMA_FORMAT || X264_CHROMA_FORMAT == X264_CSP_I422
+ "i422",
+#endif
+#if !X264_CHROMA_FORMAT || X264_CHROMA_FORMAT == X264_CSP_I444
+ "i444", "rgb",
+#endif
+ 0
+};
+
+static const char * const range_names[] = { "auto", "tv", "pc", 0 };
typedef struct
{
#else
printf( "using an unknown compiler\n" );
#endif
- printf( "configuration: --bit-depth=%d\n", x264_bit_depth );
+ printf( "configuration: --bit-depth=%d --chroma-format=%s\n", x264_bit_depth, X264_CHROMA_FORMAT ? (output_csp_names[0]+1) : "all" );
printf( "x264 license: " );
#if HAVE_GPL
printf( "GPL version 2 or later\n" );
if( filter.free )
filter.free( opt.hin );
else if( opt.hin )
- input.close_file( opt.hin );
+ cli_input.close_file( opt.hin );
if( opt.hout )
- output.close_file( opt.hout, 0, 0 );
+ cli_output.close_file( opt.hout, 0, 0 );
if( opt.tcfile_out )
fclose( opt.tcfile_out );
if( opt.qpfile )
size_t line_len = strlen( INDENT );
for( enum PixelFormat i = PIX_FMT_NONE+1; i < PIX_FMT_NB; i++ )
{
- const char *pfname = av_pix_fmt_descriptors[i].name;
- size_t name_len = strlen( pfname );
- if( line_len + name_len > (80 - strlen( ", " )) )
- {
- printf( "\n" INDENT );
- line_len = strlen( INDENT );
- }
- printf( "%s", pfname );
- line_len += name_len;
- if( i+1 < PIX_FMT_NB )
+ const char *pfname = av_get_pix_fmt_name( i );
+ if( pfname )
{
- printf( ", " );
- line_len += 2;
+ size_t name_len = strlen( pfname );
+ if( line_len + name_len > (80 - strlen( ", " )) )
+ {
+ printf( "\n" INDENT );
+ line_len = strlen( INDENT );
+ }
+ printf( "%s", pfname );
+ line_len += name_len;
+ if( i+1 < PIX_FMT_NB )
+ {
+ printf( ", " );
+ line_len += 2;
+ }
}
}
#endif
H0( "\n" );
H0( " --profile <string> Force the limits of an H.264 profile\n"
" Overrides all settings.\n" );
- H2( " - baseline:\n"
+ H2(
+#if X264_CHROMA_FORMAT <= X264_CSP_I420
+#if BIT_DEPTH==8
+ " - baseline:\n"
" --no-8x8dct --bframes 0 --no-cabac\n"
" --cqm flat --weightp 0\n"
" No interlaced.\n"
" No lossless.\n"
" - high:\n"
" No lossless.\n"
+#endif
" - high10:\n"
" No lossless.\n"
- " Support for bit depth 8-10.\n" );
- else H0( " - baseline,main,high,high10\n" );
+ " Support for bit depth 8-10.\n"
+#endif
+#if X264_CHROMA_FORMAT <= X264_CSP_I422
+ " - high422:\n"
+ " No lossless.\n"
+ " Support for bit depth 8-10.\n"
+ " Support for 4:2:0/4:2:2 chroma subsampling.\n"
+#endif
+ " - high444:\n"
+ " Support for bit depth 8-10.\n"
+ " Support for 4:2:0/4:2:2/4:4:4 chroma subsampling.\n" );
+ else H0(
+ " - "
+#if X264_CHROMA_FORMAT <= X264_CSP_I420
+#if BIT_DEPTH==8
+ "baseline,main,high,"
+#endif
+ "high10,"
+#endif
+#if X264_CHROMA_FORMAT <= X264_CSP_I422
+ "high422,"
+#endif
+ "high444\n"
+ );
H0( " --preset <string> Use a preset to select encoding settings [medium]\n"
" Overridden by user settings.\n" );
H2( " - ultrafast:\n"
" --bframes 16 --b-adapt 2 --direct auto\n"
" --slow-firstpass --no-fast-pskip\n"
" --me tesa --merange 24 --partitions all\n"
- " --rc-lookahead 60 --ref 16 --subme 10\n"
+ " --rc-lookahead 60 --ref 16 --subme 11\n"
" --trellis 2\n" );
else H0( " - ultrafast,superfast,veryfast,faster,fast\n"
" - medium,slow,slower,veryslow,placebo\n" );
" - 7: RD mode decision for all frames\n"
" - 8: RD refinement for I/P-frames\n"
" - 9: RD refinement for all frames\n"
- " - 10: QP-RD - requires trellis=2, aq-mode>0\n" );
- else H1( " decision quality: 1=fast, 10=best.\n" );
+ " - 10: QP-RD - requires trellis=2, aq-mode>0\n"
+ " - 11: Full RD: disable all early terminations\n" );
+ else H1( " decision quality: 1=fast, 11=best\n" );
H1( " --psy-rd <float:float> Strength of psychovisual optimization [\"%.1f:%.1f\"]\n"
" #1: RD (requires subme>=6)\n"
" #2: Trellis (requires trellis, experimental)\n",
H2( " --videoformat <string> Specify video format [\"%s\"]\n"
" - component, pal, ntsc, secam, mac, undef\n",
strtable_lookup( x264_vidformat_names, defaults->vui.i_vidformat ) );
- H2( " --fullrange <string> Specify full range samples setting [\"%s\"]\n"
- " - off, on\n",
- strtable_lookup( x264_fullrange_names, defaults->vui.b_fullrange ) );
+ H2( " --range <string> Specify color range [\"%s\"]\n"
+ " - %s\n", range_names[0], stringify_names( buf, range_names ) );
H2( " --colorprim <string> Specify color primaries [\"%s\"]\n"
" - undef, bt709, bt470m, bt470bg\n"
" smpte170m, smpte240m, film\n",
H1( " --output-csp <string> Specify output colorspace [\"%s\"]\n"
" - %s\n", output_csp_names[0], stringify_names( buf, output_csp_names ) );
H1( " --input-depth <integer> Specify input bit depth for raw input\n" );
+ H1( " --input-range <string> Specify input color range [\"%s\"]\n"
+ " - %s\n", range_names[0], stringify_names( buf, range_names ) );
H1( " --input-res <intxint> Specify input resolution (width x height)\n" );
H1( " --index <string> Filename for input index file\n" );
H0( " --sar width:height Specify Sample Aspect Ratio\n" );
H2( " --thread-input Run Avisynth in its own thread\n" );
H2( " --sync-lookahead <integer> Number of buffer frames for threaded lookahead\n" );
H2( " --non-deterministic Slightly improve quality of SMP, at the cost of repeatability\n" );
+ H2( " --cpu-independent Ensure exact reproducibility across different cpus,\n"
+ " as opposed to letting them select different algorithms\n" );
H2( " --asm <integer> Override CPU detection\n" );
H2( " --no-asm Disable all CPU optimizations\n" );
H2( " --visualize Show MB types overlayed on the encoded video\n" );
H0( "\n" );
}
-enum
+typedef enum
{
OPT_FRAMES = 256,
OPT_SEEK,
OPT_INPUT_CSP,
OPT_INPUT_DEPTH,
OPT_DTS_COMPRESSION,
- OPT_OUTPUT_CSP
+ OPT_OUTPUT_CSP,
+ OPT_INPUT_RANGE,
+ OPT_RANGE
} OptionsOPT;
static char short_options[] = "8A:B:b:f:hI:i:m:o:p:q:r:t:Vvw";
{ "thread-input", no_argument, NULL, OPT_THREAD_INPUT },
{ "sync-lookahead", required_argument, NULL, 0 },
{ "non-deterministic", no_argument, NULL, 0 },
+ { "cpu-independent", no_argument, NULL, 0 },
{ "psnr", no_argument, NULL, 0 },
{ "ssim", no_argument, NULL, 0 },
{ "quiet", no_argument, NULL, OPT_QUIET },
{ "cqm8p", required_argument, NULL, 0 },
{ "overscan", required_argument, NULL, 0 },
{ "videoformat", required_argument, NULL, 0 },
- { "fullrange", required_argument, NULL, 0 },
+ { "range", required_argument, NULL, OPT_RANGE },
{ "colorprim", required_argument, NULL, 0 },
{ "transfer", required_argument, NULL, 0 },
{ "colormatrix", required_argument, NULL, 0 },
{ "input-depth", required_argument, NULL, OPT_INPUT_DEPTH },
{ "dts-compress", no_argument, NULL, OPT_DTS_COMPRESSION },
{ "output-csp", required_argument, NULL, OPT_OUTPUT_CSP },
+ { "input-range", required_argument, NULL, OPT_INPUT_RANGE },
{0, 0, 0, 0}
};
if( !strcasecmp( ext, "mp4" ) )
{
#if HAVE_GPAC
- output = mp4_output;
+ cli_output = mp4_output;
param->b_annexb = 0;
param->b_repeat_headers = 0;
if( param->i_nal_hrd == X264_NAL_HRD_CBR )
}
else if( !strcasecmp( ext, "mkv" ) )
{
- output = mkv_output;
+ cli_output = mkv_output;
param->b_annexb = 0;
param->b_repeat_headers = 0;
}
else if( !strcasecmp( ext, "flv" ) )
{
- output = flv_output;
+ cli_output = flv_output;
param->b_annexb = 0;
param->b_repeat_headers = 0;
}
else
- output = raw_output;
+ cli_output = raw_output;
return 0;
}
if( !strcasecmp( module, "avs" ) || !strcasecmp( ext, "d2v" ) || !strcasecmp( ext, "dga" ) )
{
#if HAVE_AVS
- input = avs_input;
+ cli_input = avs_input;
module = "avs";
#else
x264_cli_log( "x264", X264_LOG_ERROR, "not compiled with AVS input support\n" );
#endif
}
else if( !strcasecmp( module, "y4m" ) )
- input = y4m_input;
+ cli_input = y4m_input;
else if( !strcasecmp( module, "raw" ) || !strcasecmp( ext, "yuv" ) )
- input = raw_input;
+ cli_input = raw_input;
else
{
#if HAVE_FFMS
{
module = "ffms";
b_auto = 0;
- input = ffms_input;
+ cli_input = ffms_input;
}
#endif
#if HAVE_LAVF
{
module = "lavf";
b_auto = 0;
- input = lavf_input;
+ cli_input = lavf_input;
}
#endif
#if HAVE_AVS
{
module = "avs";
b_auto = 0;
- input = avs_input;
+ cli_input = avs_input;
}
#endif
if( b_auto && !raw_input.open_file( filename, p_handle, info, opt ) )
{
module = "raw";
b_auto = 0;
- input = raw_input;
+ cli_input = raw_input;
}
FAIL_IF_ERROR( !(*p_handle), "could not open input file `%s' via any method!\n", filename )
int csp = info->csp & X264_CSP_MASK;
if( output_csp == X264_CSP_I420 && (csp < X264_CSP_I420 || csp > X264_CSP_NV12) )
param->i_csp = X264_CSP_I420;
+ else if( output_csp == X264_CSP_I422 && (csp < X264_CSP_I422 || csp > X264_CSP_NV16) )
+ param->i_csp = X264_CSP_I422;
else if( output_csp == X264_CSP_I444 && (csp < X264_CSP_I444 || csp > X264_CSP_YV24) )
param->i_csp = X264_CSP_I444;
else if( output_csp == X264_CSP_RGB && (csp < X264_CSP_BGR || csp > X264_CSP_RGB) )
param->i_csp = X264_CSP_RGB;
param->i_csp |= info->csp & X264_CSP_HIGH_DEPTH;
+ /* if the output range is not forced, assign it to the input one now */
+ if( param->vui.b_fullrange == RANGE_AUTO )
+ param->vui.b_fullrange = info->fullrange;
if( x264_init_vid_filter( "resize", handle, &filter, info, param, NULL ) )
return -1;
memset( &input_opt, 0, sizeof(cli_input_opt_t) );
memset( &output_opt, 0, sizeof(cli_output_opt_t) );
input_opt.bit_depth = 8;
+ input_opt.input_range = input_opt.output_range = param->vui.b_fullrange = RANGE_AUTO;
int output_csp = defaults.i_csp;
opt->b_progress = 1;
case OPT_OUTPUT_CSP:
FAIL_IF_ERROR( parse_enum_value( optarg, output_csp_names, &output_csp ), "Unknown output csp `%s'\n", optarg )
// correct the parsed value to the libx264 csp value
- output_csp = !output_csp ? X264_CSP_I420 : (output_csp == 1 ? X264_CSP_I444 : X264_CSP_RGB);
+#if X264_CHROMA_FORMAT
+ static const uint8_t output_csp_fix[] = { X264_CHROMA_FORMAT, X264_CSP_RGB };
+#else
+ static const uint8_t output_csp_fix[] = { X264_CSP_I420, X264_CSP_I422, X264_CSP_I444, X264_CSP_RGB };
+#endif
+ param->i_csp = output_csp = output_csp_fix[output_csp];
+ break;
+ case OPT_INPUT_RANGE:
+ FAIL_IF_ERROR( parse_enum_value( optarg, range_names, &input_opt.input_range ), "Unknown input range `%s'\n", optarg )
+ input_opt.input_range += RANGE_AUTO;
+ break;
+ case OPT_RANGE:
+ FAIL_IF_ERROR( parse_enum_value( optarg, range_names, ¶m->vui.b_fullrange ), "Unknown range `%s'\n", optarg );
+ input_opt.output_range = param->vui.b_fullrange += RANGE_AUTO;
break;
default:
generic_option:
if( select_output( muxer, output_filename, param ) )
return -1;
- FAIL_IF_ERROR( output.open_file( output_filename, &opt->hout, &output_opt ), "could not open output file `%s'\n", output_filename )
+ FAIL_IF_ERROR( cli_output.open_file( output_filename, &opt->hout, &output_opt ), "could not open output file `%s'\n", output_filename )
input_filename = argv[optind++];
video_info_t info = {0};
char demuxername[5];
- /* set info flags to param flags to be overwritten by demuxer as necessary. */
+ /* set info flags to be overwritten by demuxer as necessary. */
info.csp = param->i_csp;
info.fps_num = param->i_fps_num;
info.fps_den = param->i_fps_den;
+ info.fullrange = input_opt.input_range == RANGE_PC;
info.interlaced = param->b_interlaced;
info.sar_width = param->vui.i_sar_width;
info.sar_height = param->vui.i_sar_height;
if( select_input( demuxer, demuxername, input_filename, &opt->hin, &info, &input_opt ) )
return -1;
- FAIL_IF_ERROR( !opt->hin && input.open_file( input_filename, &opt->hin, &info, &input_opt ),
+ FAIL_IF_ERROR( !opt->hin && cli_input.open_file( input_filename, &opt->hin, &info, &input_opt ),
"could not open input file `%s'\n", input_filename )
x264_reduce_fraction( &info.sar_width, &info.sar_height );
{
FAIL_IF_ERROR( b_user_fps, "--fps + --tcfile-in is incompatible.\n" )
FAIL_IF_ERROR( timecode_input.open_file( tcfile_name, &opt->hin, &info, &input_opt ), "timecode input failed\n" )
- input = timecode_input;
+ cli_input = timecode_input;
}
else FAIL_IF_ERROR( !info.vfr && input_opt.timebase, "--timebase is incompatible with cfr input\n" )
fprintf( stderr, "x264 [error]: threaded input failed\n" );
return -1;
}
- input = thread_input;
+ cli_input = thread_input;
}
#endif
info.interlaced = param->b_interlaced;
info.tff = param->b_tff;
}
+ if( input_opt.input_range != RANGE_AUTO )
+ info.fullrange = input_opt.input_range;
if( init_vid_filters( vid_filters, &opt->hin, &info, param, output_csp ) )
return -1;
x264_cli_log( "x264", X264_LOG_WARNING, "input appears to be interlaced, but not compiled with interlaced support\n" );
#endif
}
+ /* if the user never specified the output range and the input is now rgb, default it to pc */
+ int csp = param->i_csp & X264_CSP_MASK;
+ if( csp >= X264_CSP_BGR && csp <= X264_CSP_RGB )
+ {
+ if( input_opt.output_range == RANGE_AUTO )
+ param->vui.b_fullrange = RANGE_PC;
+ /* otherwise fail if they specified tv */
+ FAIL_IF_ERROR( !param->vui.b_fullrange, "RGB must be PC range" )
+ }
/* Automatically reduce reference frame count to match the user's target level
* if the user didn't explicitly set a reference frame count. */
if( i_frame_size )
{
- i_frame_size = output.write_frame( hout, nal[0].p_payload, i_frame_size, &pic_out );
+ i_frame_size = cli_output.write_frame( hout, nal[0].p_payload, i_frame_size, &pic_out );
*last_dts = pic_out.i_dts;
}
x264_encoder_parameters( h, param );
- FAIL_IF_ERROR2( output.set_param( opt->hout, param ), "can't set outfile param\n" );
+ FAIL_IF_ERROR2( cli_output.set_param( opt->hout, param ), "can't set outfile param\n" );
i_start = x264_mdate();
int i_nal;
FAIL_IF_ERROR2( x264_encoder_headers( h, &headers, &i_nal ) < 0, "x264_encoder_headers failed\n" )
- FAIL_IF_ERROR2( (i_file = output.write_headers( opt->hout, headers )) < 0, "error writing headers to output file\n" );
+ FAIL_IF_ERROR2( (i_file = cli_output.write_headers( opt->hout, headers )) < 0, "error writing headers to output file\n" );
}
if( opt->tcfile_out )
if( b_ctrl_c )
fprintf( stderr, "aborted at input frame %d, output frame %d\n", opt->i_seek + i_frame, i_frame_output );
- output.close_file( opt->hout, largest_pts, second_largest_pts );
+ cli_output.close_file( opt->hout, largest_pts, second_largest_pts );
opt->hout = NULL;
if( i_frame_output > 0 )
projects / x264 / blobdiff