开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
x264.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：53k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

x264.c：源码内容
  1. /*****************************************************************************
  2.  * x264: h264 encoder testing program.
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2008 x264 project
  5.  *
  6.  * Authors: Loren Merritt <lorenm@u.washington.edu>
  7.  *          Laurent Aimar <fenrir@via.ecp.fr>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  24. #include <stdlib.h>
  25. #include <math.h>
  27. #include <signal.h>
  28. #define _GNU_SOURCE
  29. #include <getopt.h>
  31. #include "common/common.h"
  32. #include "common/cpu.h"
  33. #include "x264.h"
  34. #include "muxers.h"
  36. //配置MS VC环境 --@lia
  37. #ifndef _MSC_VER
  38. #include "config.h"
  39. #endif
  41. #ifdef _WIN32
  42. #include <windows.h>
  43. #else
  44. #define SetConsoleTitle(t)
  45. #endif
  47. uint8_t *mux_buffer = NULL;
  48. int mux_buffer_size = 0;
  50. /* Ctrl-C handler */
  51. static int     b_ctrl_c = 0;
  52. static int     b_exit_on_ctrl_c = 0;
  53. static void    SigIntHandler( int a )
  54. {
  55.     if( b_exit_on_ctrl_c )
  56.         exit(0);
  57.     b_ctrl_c = 1;
  58. }
  60. typedef struct {
  61.     int b_progress;
  62.     int i_seek;
  63.     hnd_t hin;
  64.     hnd_t hout;
  65.     FILE *qpfile;
  66. } cli_opt_t;
  68. /* input file operation function pointers */
  69. int (*p_open_infile)( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param );
  70. int (*p_get_frame_total)( hnd_t handle );
  71. int (*p_read_frame)( x264_picture_t *p_pic, hnd_t handle, int i_frame );
  72. int (*p_close_infile)( hnd_t handle );
  74. /* output file operation function pointers */
  75. static int (*p_open_outfile)( char *psz_filename, hnd_t *p_handle );
  76. static int (*p_set_outfile_param)( hnd_t handle, x264_param_t *p_param );
  77. static int (*p_write_nalu)( hnd_t handle, uint8_t *p_nal, int i_size );
  78. static int (*p_set_eop)( hnd_t handle, x264_picture_t *p_picture );
  79. static int (*p_close_outfile)( hnd_t handle );
  81. static void Help( x264_param_t *defaults, int longhelp );
  82. static int  Parse( int argc, char **argv, x264_param_t *param, cli_opt_t *opt );
  83. static int  Encode( x264_param_t *param, cli_opt_t *opt );
  86. /****************************************************************************
  87.  * main:
  88.  ****************************************************************************/
  89. int main( int argc, char **argv )
  90. {
  91.     x264_param_t param;
  92.     cli_opt_t opt;
  93.     int ret;
  95. #ifdef PTW32_STATIC_LIB
  96.     pthread_win32_process_attach_np();
  97.     pthread_win32_thread_attach_np();
  98. #endif
  100. #ifdef _WIN32
  101.     _setmode(_fileno(stdin), _O_BINARY);
  102.     _setmode(_fileno(stdout), _O_BINARY);
  103. #endif
  105.     x264_param_default( &param );
  107.     /* Parse command line */
  108.     if( Parse( argc, argv, &param, &opt ) < 0 )
  109.         return -1;
  111.     /* Control-C handler */
  112.     signal( SIGINT, SigIntHandler );
  114.     ret = Encode( &param, &opt );
  116. #ifdef PTW32_STATIC_LIB
  117.     pthread_win32_thread_detach_np();
  118.     pthread_win32_process_detach_np();
  119. #endif
  121.     return ret;
  122. }
  124. static char const *strtable_lookup( const char * const table[], int index )
  125. {
  126.     int i = 0; while( table[i] ) i++;
  127.     return ( ( index >= 0 && index < i ) ? table[ index ] : "???" );
  128. }
  130. /*****************************************************************************
  131.  * Help:
  132.  *****************************************************************************/
  133. static void Help( x264_param_t *defaults, int longhelp )
  134. {
  135. #define H0 printf
  136. #define H1 if(longhelp>=1) printf
  137. #define H2 if(longhelp==2) printf
  138.     H0( "x264 core:%d%sn"
  139.         "Syntax: x264 [options] -o outfile infile [widthxheight]n"
  140.         "n"
  141.         "Infile can be raw YUV 4:2:0 (in which case resolution is required),n"
  142.         "  or YUV4MPEG 4:2:0 (*.y4m),n"
  143.         "  or AVI or Avisynth if compiled with AVIS support (%s).n"
  144.         "Outfile type is selected by filename:n"
  145.         " .264 -> Raw bytestreamn"
  146.         " .mkv -> Matroskan"
  147.         " .mp4 -> MP4 if compiled with GPAC support (%s)n"
  148.         "n"
  149.         "Options:n"
  150.         "n"
  151.         "  -h, --help                  List basic optionsn"
  152.         "      --longhelp              List more optionsn"
  153.         "      --fullhelp              List all optionsn"
  154.         "n",
  155.         X264_BUILD, X264_VERSION,
  156. #ifdef AVIS_INPUT
  157.         "yes",
  158. #else
  159.         "no",
  160. #endif
  161. #ifdef MP4_OUTPUT
  162.         "yes"
  163. #else
  164.         "no"
  165. #endif
  166.       );
  167.     H0( "Example usage:n" );
  168.     H0( "n" );
  169.     H0( "      Constant quality mode:n" );
  170.     H0( "            x264 --crf 24 -o output inputn" );
  171.     H0( "n" );
  172.     H0( "      Two-pass with a bitrate of 1000kbps:n" );
  173.     H0( "            x264 --pass 1 --bitrate 1000 -o output inputn" );
  174.     H0( "            x264 --pass 2 --bitrate 1000 -o output inputn" );
  175.     H0( "n" );
  176.     H0( "      Lossless:n" );
  177.     H0( "            x264 --crf 0 -o output inputn" );
  178.     H0( "n" );
  179.     H0( "      Maximum PSNR at the cost of speed and visual quality:n" );
  180.     H0( "            x264 --preset placebo --tune psnr -o output inputn" );
  181.     H0( "n" );
  182.     H0( "      Constant bitrate at 1000kbps with a 2 second-buffer:n");
  183.     H0( "            x264 --vbv-bufsize 2000 --bitrate 1000 -o output inputn" );
  184.     H0( "n" );
  185.     H0( "Presets:n" );
  186.     H0( "n" );
  187.     H0( "      --profile               Force H.264 profile [high]n" );
  188.     H0( "                                  Overrides all settingsn");
  189.     H0( "                                  - baseline,main,highn" );
  190.     H0( "      --preset                Use a preset to select encoding settings [medium]n" );
  191.     H0( "                                  Overridden by user settingsn");
  192.     H0( "                                  - ultrafast,veryfast,faster,fast,mediumn"
  193.         "                                  - slow,slower,veryslow,placebon" );
  194.     H0( "      --tune                  Tune the settings for a particular type of sourcen" );
  195.     H0( "                                  Overridden by user settingsn");
  196.     H2( "                                  - film,animation,grain,psnr,ssimn"
  197.         "                                  - fastdecode,touhoun");
  198.     else H0( "                                  - film,animation,grain,psnr,ssim,fastdecoden");
  199.     H1( "      --slow-firstpass        Don't use faster settings with --pass 1n" );
  200.     H0( "n" );
  201.     H0( "Frame-type options:n" );
  202.     H0( "n" );
  203.     H0( "  -I, --keyint <integer>      Maximum GOP size [%d]n", defaults->i_keyint_max );
  204.     H2( "  -i, --min-keyint <integer>  Minimum GOP size [%d]n", defaults->i_keyint_min );
  205.     H2( "      --no-scenecut           Disable adaptive I-frame decisionn" );
  206.     H2( "      --scenecut <integer>    How aggressively to insert extra I-frames [%d]n", defaults->i_scenecut_threshold );
  207.     H1( "  -b, --bframes <integer>     Number of B-frames between I and P [%d]n", defaults->i_bframe );
  208.     H1( "      --b-adapt               Adaptive B-frame decision method [%d]n"
  209.         "                                  Higher values may lower threading efficiency.n"
  210.         "                                  - 0: Disabledn"
  211.         "                                  - 1: Fastn"
  212.         "                                  - 2: Optimal (slow with high --bframes)n", defaults->i_bframe_adaptive );
  213.     H2( "      --b-bias <integer>      Influences how often B-frames are used [%d]n", defaults->i_bframe_bias );
  214.     H1( "      --b-pyramid             Keep some B-frames as referencesn" );
  215.     H1( "      --no-cabac              Disable CABACn" );
  216.     H1( "  -r, --ref <integer>         Number of reference frames [%d]n", defaults->i_frame_reference );
  217.     H1( "      --no-deblock            Disable loop filtern" );
  218.     H1( "  -f, --deblock <alpha:beta>  Loop filter parameters [%d:%d]n",
  219.                                        defaults->i_deblocking_filter_alphac0, defaults->i_deblocking_filter_beta );
  220.     H2( "      --slices <integer>      Number of slices per frame; forces rectangularn"
  221.         "                              slices and is overridden by other slicing optionsn" );
  222.     else H1( "      --slices <integer>      Number of slices per framen" );
  223.     H2( "      --slice-max-size <integer> Limit the size of each slice in bytesn");
  224.     H2( "      --slice-max-mbs <integer> Limit the size of each slice in macroblocksn");
  225.     H0( "      --interlaced            Enable pure-interlaced moden" );
  226.     H2( "      --constrained-intra     Enable constrained intra prediction.n" );
  227.     H0( "n" );
  228.     H0( "Ratecontrol:n" );
  229.     H0( "n" );
  230.     H1( "  -q, --qp <integer>          Force constant QP (0-51, 0=lossless)n" );
  231.     H0( "  -B, --bitrate <integer>     Set bitrate (kbit/s)n" );
  232.     H0( "      --crf <float>           Quality-based VBR (0-51, 0=lossless) [%.1f]n", defaults->rc.f_rf_constant );
  233.     H1( "      --rc-lookahead <integer> Number of frames for frametype lookahead [%d]n", defaults->rc.i_lookahead );
  234.     H0( "      --vbv-maxrate <integer> Max local bitrate (kbit/s) [%d]n", defaults->rc.i_vbv_max_bitrate );
  235.     H0( "      --vbv-bufsize <integer> Set size of the VBV buffer (kbit) [%d]n", defaults->rc.i_vbv_buffer_size );
  236.     H2( "      --vbv-init <float>      Initial VBV buffer occupancy [%.1f]n", defaults->rc.f_vbv_buffer_init );
  237.     H2( "      --qpmin <integer>       Set min QP [%d]n", defaults->rc.i_qp_min );
  238.     H2( "      --qpmax <integer>       Set max QP [%d]n", defaults->rc.i_qp_max );
  239.     H2( "      --qpstep <integer>      Set max QP step [%d]n", defaults->rc.i_qp_step );
  240.     H2( "      --ratetol <float>       Allowed variance of average bitrate [%.1f]n", defaults->rc.f_rate_tolerance );
  241.     H2( "      --ipratio <float>       QP factor between I and P [%.2f]n", defaults->rc.f_ip_factor );
  242.     H2( "      --pbratio <float>       QP factor between P and B [%.2f]n", defaults->rc.f_pb_factor );
  243.     H2( "      --chroma-qp-offset <integer>  QP difference between chroma and luma [%d]n", defaults->analyse.i_chroma_qp_offset );
  244.     H2( "      --aq-mode <integer>     AQ method [%d]n"
  245.         "                                  - 0: Disabledn"
  246.         "                                  - 1: Variance AQ (complexity mask)n"
  247.         "                                  - 2: Auto-variance AQ (experimental)n", defaults->rc.i_aq_mode );
  248.     H1( "      --aq-strength <float>   Reduces blocking and blurring in flat andn"
  249.         "                              textured areas. [%.1f]n", defaults->rc.f_aq_strength );
  250.     H1( "n" );
  251.     H2( "  -p, --pass <1|2|3>          Enable multipass ratecontroln" );
  252.     else H0( "  -p, --pass <1|2>            Enable multipass ratecontroln" );
  253.     H0( "                                  - 1: First pass, creates stats filen"
  254.         "                                  - 2: Last pass, does not overwrite stats filen" );
  255.     H2( "                                  - 3: Nth pass, overwrites stats filen" );
  256.     H1( "      --stats <string>        Filename for 2 pass stats ["%s"]n", defaults->rc.psz_stat_out );
  257.     H2( "      --no-mbtree             Disable mb-tree ratecontrol.n");
  258.     H2( "      --qcomp <float>         QP curve compression [%.2f]n", defaults->rc.f_qcompress );
  259.     H2( "      --cplxblur <float>      Reduce fluctuations in QP (before curve compression) [%.1f]n", defaults->rc.f_complexity_blur );
  260.     H2( "      --qblur <float>         Reduce fluctuations in QP (after curve compression) [%.1f]n", defaults->rc.f_qblur );
  261.     H2( "      --zones <zone0>/<zone1>/...  Tweak the bitrate of regions of the videon" );
  262.     H2( "                              Each zone is of the formn"
  263.         "                                  <start frame>,<end frame>,<option>n"
  264.         "                                  where <option> is eithern"
  265.         "                                      q=<integer> (force QP)n"
  266.         "                                  or  b=<float> (bitrate multiplier)n" );
  267.     H2( "      --qpfile <string>       Force frametypes and QPs for some or all framesn"
  268.         "                              Format of each line: framenumber frametype QPn"
  269.         "                              QP of -1 lets x264 choose. Frametypes: I,i,P,B,b.n"
  270.         "                              QPs are restricted by qpmin/qpmax.n" );
  271.     H1( "n" );
  272.     H1( "Analysis:n" );
  273.     H1( "n" );
  274.     H1( "  -A, --partitions <string>   Partitions to consider ["p8x8,b8x8,i8x8,i4x4"]n"
  275.         "                                  - p8x8, p4x4, b8x8, i8x8, i4x4n"
  276.         "                                  - none, alln"
  277.         "                                  (p4x4 requires p8x8. i8x8 requires --8x8dct.)n" );
  278.     H1( "      --direct <string>       Direct MV prediction mode ["%s"]n"
  279.         "                                  - none, spatial, temporal, auton",
  280.                                        strtable_lookup( x264_direct_pred_names, defaults->analyse.i_direct_mv_pred ) );
  281.     H2( "      --no-weightb            Disable weighted prediction for B-framesn" );
  282.     H1( "      --me <string>           Integer pixel motion estimation method ["%s"]n",
  283.                                        strtable_lookup( x264_motion_est_names, defaults->analyse.i_me_method ) );
  284.     H2( "                                  - dia: diamond search, radius 1 (fast)n"
  285.         "                                  - hex: hexagonal search, radius 2n"
  286.         "                                  - umh: uneven multi-hexagon searchn"
  287.         "                                  - esa: exhaustive searchn"
  288.         "                                  - tesa: hadamard exhaustive search (slow)n" );
  289.     else H1( "                                  - dia, hex, umhn" );
  290.     H2( "      --merange <integer>     Maximum motion vector search range [%d]n", defaults->analyse.i_me_range );
  291.     H2( "      --mvrange <integer>     Maximum motion vector length [-1 (auto)]n" );
  292.     H2( "      --mvrange-thread <int>  Minimum buffer between threads [-1 (auto)]n" );
  293.     H1( "  -m, --subme <integer>       Subpixel motion estimation and mode decision [%d]n", defaults->analyse.i_subpel_refine );
  294.     H2( "                                  - 0: fullpel only (not recommended)n"
  295.         "                                  - 1: SAD mode decision, one qpel iterationn"
  296.         "                                  - 2: SATD mode decisionn"
  297.         "                                  - 3-5: Progressively more qpeln"
  298.         "                                  - 6: RD mode decision for I/P-framesn"
  299.         "                                  - 7: RD mode decision for all framesn"
  300.         "                                  - 8: RD refinement for I/P-framesn"
  301.         "                                  - 9: RD refinement for all framesn"
  302.         "                                  - 10: QP-RD - requires trellis=2, aq-mode>0n" );
  303.     else H1( "                                  decision quality: 1=fast, 10=best.n"  );
  304.     H1( "      --psy-rd                Strength of psychovisual optimization ["%.1f:%.1f"]n"
  305.         "                                  #1: RD (requires subme>=6)n"
  306.         "                                  #2: Trellis (requires trellis, experimental)n",
  307.                                        defaults->analyse.f_psy_rd, defaults->analyse.f_psy_trellis );
  308.     H2( "      --no-psy                Disable all visual optimizations that worsenn"
  309.         "                              both PSNR and SSIM.n" );
  310.     H2( "      --no-mixed-refs         Don't decide references on a per partition basisn" );
  311.     H2( "      --no-chroma-me          Ignore chroma in motion estimationn" );
  312.     H1( "      --no-8x8dct             Disable adaptive spatial transform sizen" );
  313.     H1( "  -t, --trellis <integer>     Trellis RD quantization. Requires CABAC. [%d]n"
  314.         "                                  - 0: disabledn"
  315.         "                                  - 1: enabled only on the final encode of a MBn"
  316.         "                                  - 2: enabled on all mode decisionsn", defaults->analyse.i_trellis );
  317.     H2( "      --no-fast-pskip         Disables early SKIP detection on P-framesn" );
  318.     H2( "      --no-dct-decimate       Disables coefficient thresholding on P-framesn" );
  319.     H1( "      --nr <integer>          Noise reduction [%d]n", defaults->analyse.i_noise_reduction );
  320.     H2( "n" );
  321.     H2( "      --deadzone-inter <int>  Set the size of the inter luma quantization deadzone [%d]n", defaults->analyse.i_luma_deadzone[0] );
  322.     H2( "      --deadzone-intra <int>  Set the size of the intra luma quantization deadzone [%d]n", defaults->analyse.i_luma_deadzone[1] );
  323.     H2( "                                  Deadzones should be in the range 0 - 32.n" );
  324.     H2( "      --cqm <string>          Preset quant matrices ["flat"]n"
  325.         "                                  - jvt, flatn" );
  326.     H1( "      --cqmfile <string>      Read custom quant matrices from a JM-compatible filen" );
  327.     H2( "                                  Overrides any other --cqm* options.n" );
  328.     H2( "      --cqm4 <list>           Set all 4x4 quant matricesn"
  329.         "                                  Takes a comma-separated list of 16 integers.n" );
  330.     H2( "      --cqm8 <list>           Set all 8x8 quant matricesn"
  331.         "                                  Takes a comma-separated list of 64 integers.n" );
  332.     H2( "      --cqm4i, --cqm4p, --cqm8i, --cqm8pn"
  333.         "                              Set both luma and chroma quant matricesn" );
  334.     H2( "      --cqm4iy, --cqm4ic, --cqm4py, --cqm4pcn"
  335.         "                              Set individual quant matricesn" );
  336.     H2( "n" );
  337.     H2( "Video Usability Info (Annex E):n" );
  338.     H2( "The VUI settings are not used by the encoder but are merely suggestions ton" );
  339.     H2( "the playback equipment. See doc/vui.txt for details. Use at your own risk.n" );
  340.     H2( "n" );
  341.     H2( "      --overscan <string>     Specify crop overscan setting ["%s"]n"
  342.         "                                  - undef, show, cropn",
  343.                                        strtable_lookup( x264_overscan_names, defaults->vui.i_overscan ) );
  344.     H2( "      --videoformat <string>  Specify video format ["%s"]n"
  345.         "                                  - component, pal, ntsc, secam, mac, undefn",
  346.                                        strtable_lookup( x264_vidformat_names, defaults->vui.i_vidformat ) );
  347.     H2( "      --fullrange <string>    Specify full range samples setting ["%s"]n"
  348.         "                                  - off, onn",
  349.                                        strtable_lookup( x264_fullrange_names, defaults->vui.b_fullrange ) );
  350.     H2( "      --colorprim <string>    Specify color primaries ["%s"]n"
  351.         "                                  - undef, bt709, bt470m, bt470bgn"
  352.         "                                    smpte170m, smpte240m, filmn",
  353.                                        strtable_lookup( x264_colorprim_names, defaults->vui.i_colorprim ) );
  354.     H2( "      --transfer <string>     Specify transfer characteristics ["%s"]n"
  355.         "                                  - undef, bt709, bt470m, bt470bg, linear,n"
  356.         "                                    log100, log316, smpte170m, smpte240mn",
  357.                                        strtable_lookup( x264_transfer_names, defaults->vui.i_transfer ) );
  358.     H2( "      --colormatrix <string>  Specify color matrix setting ["%s"]n"
  359.         "                                  - undef, bt709, fcc, bt470bgn"
  360.         "                                    smpte170m, smpte240m, GBR, YCgCon",
  361.                                        strtable_lookup( x264_colmatrix_names, defaults->vui.i_colmatrix ) );
  362.     H2( "      --chromaloc <integer>   Specify chroma sample location (0 to 5) [%d]n",
  363.                                        defaults->vui.i_chroma_loc );
  364.     H0( "n" );
  365.     H0( "Input/Output:n" );
  366.     H0( "n" );
  367.     H0( "  -o, --output                Specify output filen" );
  368.     H0( "      --sar width:height      Specify Sample Aspect Ration" );
  369.     H0( "      --fps <float|rational>  Specify frameraten" );
  370.     H0( "      --seek <integer>        First frame to encoden" );
  371.     H0( "      --frames <integer>      Maximum number of frames to encoden" );
  372.     H0( "      --level <string>        Specify level (as defined by Annex A)n" );
  373.     H1( "n" );
  374.     H1( "  -v, --verbose               Print stats for each framen" );
  375.     H1( "      --no-progress           Don't show the progress indicator while encodingn" );
  376.     H0( "      --quiet                 Quiet Moden" );
  377.     H1( "      --psnr                  Enable PSNR computationn" );
  378.     H1( "      --ssim                  Enable SSIM computationn" );
  379.     H1( "      --threads <integer>     Force a specific number of threadsn" );
  380.     H2( "      --thread-input          Run Avisynth in its own threadn" );
  381.     H2( "      --sync-lookahead <integer> Number of buffer frames for threaded lookaheadn" );
  382.     H2( "      --non-deterministic     Slightly improve quality of SMP, at the cost of repeatabilityn" );
  383.     H2( "      --asm <integer>         Override CPU detectionn" );
  384.     H2( "      --no-asm                Disable all CPU optimizationsn" );
  385.     H2( "      --visualize             Show MB types overlayed on the encoded videon" );
  386.     H2( "      --dump-yuv <string>     Save reconstructed framesn" );
  387.     H2( "      --sps-id <integer>      Set SPS and PPS id numbers [%d]n", defaults->i_sps_id );
  388.     H2( "      --aud                   Use access unit delimitersn" );
  389.     H0( "n" );
  390. }
  392. #define OPT_FRAMES 256
  393. #define OPT_SEEK 257
  394. #define OPT_QPFILE 258
  395. #define OPT_THREAD_INPUT 259
  396. #define OPT_QUIET 260
  397. #define OPT_NOPROGRESS 261
  398. #define OPT_VISUALIZE 262
  399. #define OPT_LONGHELP 263
  400. #define OPT_PROFILE 264
  401. #define OPT_PRESET 265
  402. #define OPT_TUNE 266
  403. #define OPT_SLOWFIRSTPASS 267
  404. #define OPT_FULLHELP 268
  405. #define OPT_FPS 269
  407. static char short_options[] = "8A:B:b:f:hI:i:m:o:p:q:r:t:Vvw";
  408. static struct option long_options[] =
  409. {
  410.     { "help",              no_argument, NULL, 'h' },
  411.     { "longhelp",          no_argument, NULL, OPT_LONGHELP },
  412.     { "fullhelp",          no_argument, NULL, OPT_FULLHELP },
  413.     { "version",           no_argument, NULL, 'V' },
  414.     { "profile",     required_argument, NULL, OPT_PROFILE },
  415.     { "preset",      required_argument, NULL, OPT_PRESET },
  416.     { "tune",        required_argument, NULL, OPT_TUNE },
  417.     { "slow-firstpass",    no_argument, NULL, OPT_SLOWFIRSTPASS },
  418.     { "bitrate",     required_argument, NULL, 'B' },
  419.     { "bframes",     required_argument, NULL, 'b' },
  420.     { "b-adapt",     required_argument, NULL, 0 },
  421.     { "no-b-adapt",        no_argument, NULL, 0 },
  422.     { "b-bias",      required_argument, NULL, 0 },
  423.     { "b-pyramid",         no_argument, NULL, 0 },
  424.     { "min-keyint",  required_argument, NULL, 'i' },
  425.     { "keyint",      required_argument, NULL, 'I' },
  426.     { "scenecut",    required_argument, NULL, 0 },
  427.     { "no-scenecut",       no_argument, NULL, 0 },
  428.     { "nf",                no_argument, NULL, 0 },
  429.     { "no-deblock",        no_argument, NULL, 0 },
  430.     { "filter",      required_argument, NULL, 0 },
  431.     { "deblock",     required_argument, NULL, 'f' },
  432.     { "interlaced",        no_argument, NULL, 0 },
  433.     { "constrained-intra", no_argument, NULL, 0 },
  434.     { "cabac",             no_argument, NULL, 0 },
  435.     { "no-cabac",          no_argument, NULL, 0 },
  436.     { "qp",          required_argument, NULL, 'q' },
  437.     { "qpmin",       required_argument, NULL, 0 },
  438.     { "qpmax",       required_argument, NULL, 0 },
  439.     { "qpstep",      required_argument, NULL, 0 },
  440.     { "crf",         required_argument, NULL, 0 },
  441.     { "rc-lookahead",required_argument, NULL, 0 },
  442.     { "ref",         required_argument, NULL, 'r' },
  443.     { "asm",         required_argument, NULL, 0 },
  444.     { "no-asm",            no_argument, NULL, 0 },
  445.     { "sar",         required_argument, NULL, 0 },
  446.     { "fps",         required_argument, NULL, OPT_FPS },
  447.     { "frames",      required_argument, NULL, OPT_FRAMES },
  448.     { "seek",        required_argument, NULL, OPT_SEEK },
  449.     { "output",      required_argument, NULL, 'o' },
  450.     { "analyse",     required_argument, NULL, 0 },
  451.     { "partitions",  required_argument, NULL, 'A' },
  452.     { "direct",      required_argument, NULL, 0 },
  453.     { "weightb",           no_argument, NULL, 'w' },
  454.     { "no-weightb",        no_argument, NULL, 0 },
  455.     { "me",          required_argument, NULL, 0 },
  456.     { "merange",     required_argument, NULL, 0 },
  457.     { "mvrange",     required_argument, NULL, 0 },
  458.     { "mvrange-thread", required_argument, NULL, 0 },
  459.     { "subme",       required_argument, NULL, 'm' },
  460.     { "psy-rd",      required_argument, NULL, 0 },
  461.     { "no-psy",            no_argument, NULL, 0 },
  462.     { "psy",               no_argument, NULL, 0 },
  463.     { "mixed-refs",        no_argument, NULL, 0 },
  464.     { "no-mixed-refs",     no_argument, NULL, 0 },
  465.     { "no-chroma-me",      no_argument, NULL, 0 },
  466.     { "8x8dct",            no_argument, NULL, 0 },
  467.     { "no-8x8dct",         no_argument, NULL, 0 },
  468.     { "trellis",     required_argument, NULL, 't' },
  469.     { "fast-pskip",        no_argument, NULL, 0 },
  470.     { "no-fast-pskip",     no_argument, NULL, 0 },
  471.     { "no-dct-decimate",   no_argument, NULL, 0 },
  472.     { "aq-strength", required_argument, NULL, 0 },
  473.     { "aq-mode",     required_argument, NULL, 0 },
  474.     { "deadzone-inter", required_argument, NULL, '0' },
  475.     { "deadzone-intra", required_argument, NULL, '0' },
  476.     { "level",       required_argument, NULL, 0 },
  477.     { "ratetol",     required_argument, NULL, 0 },
  478.     { "vbv-maxrate", required_argument, NULL, 0 },
  479.     { "vbv-bufsize", required_argument, NULL, 0 },
  480.     { "vbv-init",    required_argument, NULL,  0 },
  481.     { "ipratio",     required_argument, NULL, 0 },
  482.     { "pbratio",     required_argument, NULL, 0 },
  483.     { "chroma-qp-offset", required_argument, NULL, 0 },
  484.     { "pass",        required_argument, NULL, 'p' },
  485.     { "stats",       required_argument, NULL, 0 },
  486.     { "qcomp",       required_argument, NULL, 0 },
  487.     { "mbtree",            no_argument, NULL, 0 },
  488.     { "no-mbtree",         no_argument, NULL, 0 },
  489.     { "qblur",       required_argument, NULL, 0 },
  490.     { "cplxblur",    required_argument, NULL, 0 },
  491.     { "zones",       required_argument, NULL, 0 },
  492.     { "qpfile",      required_argument, NULL, OPT_QPFILE },
  493.     { "threads",     required_argument, NULL, 0 },
  494.     { "slice-max-size",    required_argument, NULL, 0 },
  495.     { "slice-max-mbs",     required_argument, NULL, 0 },
  496.     { "slices",            required_argument, NULL, 0 },
  497.     { "thread-input",      no_argument, NULL, OPT_THREAD_INPUT },
  498.     { "sync-lookahead",    required_argument, NULL, 0 },
  499.     { "non-deterministic", no_argument, NULL, 0 },
  500.     { "psnr",              no_argument, NULL, 0 },
  501.     { "ssim",              no_argument, NULL, 0 },
  502.     { "quiet",             no_argument, NULL, OPT_QUIET },
  503.     { "verbose",           no_argument, NULL, 'v' },
  504.     { "no-progress",       no_argument, NULL, OPT_NOPROGRESS },
  505.     { "visualize",         no_argument, NULL, OPT_VISUALIZE },
  506.     { "dump-yuv",    required_argument, NULL, 0 },
  507.     { "sps-id",      required_argument, NULL, 0 },
  508.     { "aud",               no_argument, NULL, 0 },
  509.     { "nr",          required_argument, NULL, 0 },
  510.     { "cqm",         required_argument, NULL, 0 },
  511.     { "cqmfile",     required_argument, NULL, 0 },
  512.     { "cqm4",        required_argument, NULL, 0 },
  513.     { "cqm4i",       required_argument, NULL, 0 },
  514.     { "cqm4iy",      required_argument, NULL, 0 },
  515.     { "cqm4ic",      required_argument, NULL, 0 },
  516.     { "cqm4p",       required_argument, NULL, 0 },
  517.     { "cqm4py",      required_argument, NULL, 0 },
  518.     { "cqm4pc",      required_argument, NULL, 0 },
  519.     { "cqm8",        required_argument, NULL, 0 },
  520.     { "cqm8i",       required_argument, NULL, 0 },
  521.     { "cqm8p",       required_argument, NULL, 0 },
  522.     { "overscan",    required_argument, NULL, 0 },
  523.     { "videoformat", required_argument, NULL, 0 },
  524.     { "fullrange",   required_argument, NULL, 0 },
  525.     { "colorprim",   required_argument, NULL, 0 },
  526.     { "transfer",    required_argument, NULL, 0 },
  527.     { "colormatrix", required_argument, NULL, 0 },
  528.     { "chromaloc",   required_argument, NULL, 0 },
  529.     {0, 0, 0, 0}
  530. };
  532. /*****************************************************************************
  533.  * Parse:
  534.  *****************************************************************************/
  535. static int  Parse( int argc, char **argv,
  536.                    x264_param_t *param, cli_opt_t *opt )
  537. {
  538.     char *psz_filename = NULL;
  539.     x264_param_t defaults = *param;
  540.     char *psz;
  541.     char *profile = NULL;
  542.     int b_avis = 0;
  543.     int b_y4m = 0;
  544.     int b_thread_input = 0;
  545.     int b_turbo = 1;
  546.     int b_pass1 = 0;
  547.     int b_user_ref = 0;
  548.     int b_user_fps = 0;
  550.     memset( opt, 0, sizeof(cli_opt_t) );
  551.     opt->b_progress = 1;
  553.     /* Default input file driver */
  554.     p_open_infile = open_file_yuv;
  555.     p_get_frame_total = get_frame_total_yuv;
  556.     p_read_frame = read_frame_yuv;
  557.     p_close_infile = close_file_yuv;
  559.     /* Default output file driver */
  560.     p_open_outfile = open_file_bsf;
  561.     p_set_outfile_param = set_param_bsf;
  562.     p_write_nalu = write_nalu_bsf;
  563.     p_set_eop = set_eop_bsf;
  564.     p_close_outfile = close_file_bsf;
  566.     /* Presets are applied before all other options. */
  567.     for( optind = 0;; )
  568.     {
  569.         int c = getopt_long( argc, argv, short_options, long_options, NULL );
  570.         if( c == -1 )
  571.             break;
  573.         if( c == OPT_PRESET )
  574.         {
  575.             if( !strcasecmp( optarg, "ultrafast" ) )
  576.             {
  577.                 param->i_frame_reference = 1;
  578.                 param->i_scenecut_threshold = 0;
  579.                 param->b_deblocking_filter = 0;
  580.                 param->b_cabac = 0;
  581.                 param->i_bframe = 0;
  582.                 param->analyse.intra = 0;
  583.                 param->analyse.inter = 0;
  584.                 param->analyse.b_transform_8x8 = 0;
  585.                 param->analyse.i_me_method = X264_ME_DIA;
  586.                 param->analyse.i_subpel_refine = 0;
  587.                 param->rc.i_aq_mode = 0;
  588.                 param->analyse.b_mixed_references = 0;
  589.                 param->analyse.i_trellis = 0;
  590.                 param->i_bframe_adaptive = X264_B_ADAPT_NONE;
  591.                 param->rc.b_mb_tree = 0;
  592.             }
  593.             else if( !strcasecmp( optarg, "veryfast" ) )
  594.             {
  595.                 param->analyse.inter = X264_ANALYSE_I8x8|X264_ANALYSE_I4x4;
  596.                 param->analyse.i_me_method = X264_ME_DIA;
  597.                 param->analyse.i_subpel_refine = 1;
  598.                 param->i_frame_reference = 1;
  599.                 param->analyse.b_mixed_references = 0;
  600.                 param->analyse.i_trellis = 0;
  601.                 param->rc.b_mb_tree = 0;
  602.             }
  603.             else if( !strcasecmp( optarg, "faster" ) )
  604.             {
  605.                 param->analyse.b_mixed_references = 0;
  606.                 param->i_frame_reference = 2;
  607.                 param->analyse.i_subpel_refine = 4;
  608.                 param->rc.b_mb_tree = 0;
  609.             }
  610.             else if( !strcasecmp( optarg, "fast" ) )
  611.             {
  612.                 param->i_frame_reference = 2;
  613.                 param->analyse.i_subpel_refine = 6;
  614.                 param->rc.i_lookahead = 30;
  615.             }
  616.             else if( !strcasecmp( optarg, "medium" ) )
  617.             {
  618.                 /* Default is medium */
  619.             }
  620.             else if( !strcasecmp( optarg, "slow" ) )
  621.             {
  622.                 param->analyse.i_me_method = X264_ME_UMH;
  623.                 param->analyse.i_subpel_refine = 8;
  624.                 param->i_frame_reference = 5;
  625.                 param->i_bframe_adaptive = X264_B_ADAPT_TRELLIS;
  626.                 param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_AUTO;
  627.                 param->rc.i_lookahead = 50;
  628.             }
  629.             else if( !strcasecmp( optarg, "slower" ) )
  630.             {
  631.                 param->analyse.i_me_method = X264_ME_UMH;
  632.                 param->analyse.i_subpel_refine = 9;
  633.                 param->i_frame_reference = 8;
  634.                 param->i_bframe_adaptive = X264_B_ADAPT_TRELLIS;
  635.                 param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_AUTO;
  636.                 param->analyse.inter |= X264_ANALYSE_PSUB8x8;
  637.                 param->analyse.i_trellis = 2;
  638.                 param->rc.i_lookahead = 60;
  639.             }
  640.             else if( !strcasecmp( optarg, "veryslow" ) )
  641.             {
  642.                 param->analyse.i_me_method = X264_ME_UMH;
  643.                 param->analyse.i_subpel_refine = 10;
  644.                 param->analyse.i_me_range = 24;
  645.                 param->i_frame_reference = 16;
  646.                 param->i_bframe_adaptive = X264_B_ADAPT_TRELLIS;
  647.                 param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_AUTO;
  648.                 param->analyse.inter |= X264_ANALYSE_PSUB8x8;
  649.                 param->analyse.i_trellis = 2;
  650.                 param->i_bframe = 8;
  651.                 param->rc.i_lookahead = 60;
  652.             }
  653.             else if( !strcasecmp( optarg, "placebo" ) )
  654.             {
  655.                 param->analyse.i_me_method = X264_ME_TESA;
  656.                 param->analyse.i_subpel_refine = 10;
  657.                 param->analyse.i_me_range = 24;
  658.                 param->i_frame_reference = 16;
  659.                 param->i_bframe_adaptive = X264_B_ADAPT_TRELLIS;
  660.                 param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_AUTO;
  661.                 param->analyse.inter |= X264_ANALYSE_PSUB8x8;
  662.                 param->analyse.b_fast_pskip = 0;
  663.                 param->analyse.i_trellis = 2;
  664.                 param->i_bframe = 16;
  665.                 param->rc.i_lookahead = 60;
  666.                 b_turbo = 0;
  667.             }
  668.             else
  669.             {
  670.                 fprintf( stderr, "x264 [error]: invalid preset: %sn", optarg );
  671.                 return -1;
  672.             }
  673.         }
  674.         else if( c == '?' )
  675.             return -1;
  676.     }
  678.     /* Tunings are applied next. */
  679.     for( optind = 0;; )
  680.     {
  681.         int c = getopt_long( argc, argv, short_options, long_options, NULL );
  682.         if( c == -1 )
  683.             break;
  685.         if( c == OPT_TUNE )
  686.         {
  687.             if( !strcasecmp( optarg, "film" ) )
  688.             {
  689.                 param->i_deblocking_filter_alphac0 = -1;
  690.                 param->i_deblocking_filter_beta = -1;
  691.                 param->analyse.f_psy_trellis = 0.15;
  692.             }
  693.             else if( !strcasecmp( optarg, "animation" ) )
  694.             {
  695.                 param->i_frame_reference = param->i_frame_reference > 1 ? param->i_frame_reference*2 : 1;
  696.                 param->i_deblocking_filter_alphac0 = 1;
  697.                 param->i_deblocking_filter_beta = 1;
  698.                 param->analyse.f_psy_rd = 0.4;
  699.                 param->rc.f_aq_strength = 0.6;
  700.                 param->i_bframe += 2;
  701.             }
  702.             else if( !strcasecmp( optarg, "grain" ) )
  703.             {
  704.                 param->i_deblocking_filter_alphac0 = -2;
  705.                 param->i_deblocking_filter_beta = -2;
  706.                 param->analyse.f_psy_trellis = 0.25;
  707.                 param->analyse.b_dct_decimate = 0;
  708.                 param->rc.f_pb_factor = 1.1;
  709.                 param->rc.f_ip_factor = 1.1;
  710.                 param->rc.f_aq_strength = 0.5;
  711.                 param->analyse.i_luma_deadzone[0] = 6;
  712.                 param->analyse.i_luma_deadzone[1] = 6;
  713.                 param->rc.f_qcompress = 0.8;
  714.             }
  715.             else if( !strcasecmp( optarg, "psnr" ) )
  716.             {
  717.                 param->rc.i_aq_mode = X264_AQ_NONE;
  718.                 param->analyse.b_psy = 0;
  719.             }
  720.             else if( !strcasecmp( optarg, "ssim" ) )
  721.             {
  722.                 param->rc.i_aq_mode = X264_AQ_AUTOVARIANCE;
  723.                 param->analyse.b_psy = 0;
  724.             }
  725.             else if( !strcasecmp( optarg, "fastdecode" ) )
  726.             {
  727.                 param->b_deblocking_filter = 0;
  728.                 param->b_cabac = 0;
  729.                 param->analyse.b_weighted_bipred = 0;
  730.             }
  731.             else if( !strcasecmp( optarg, "touhou" ) )
  732.             {
  733.                 param->i_frame_reference = param->i_frame_reference > 1 ? param->i_frame_reference*2 : 1;
  734.                 param->i_deblocking_filter_alphac0 = -1;
  735.                 param->i_deblocking_filter_beta = -1;
  736.                 param->analyse.f_psy_trellis = 0.2;
  737.                 param->rc.f_aq_strength = 1.3;
  738.                 if( param->analyse.inter & X264_ANALYSE_PSUB16x16 )
  739.                     param->analyse.inter |= X264_ANALYSE_PSUB8x8;
  740.             }
  741.             else
  742.             {
  743.                 fprintf( stderr, "x264 [error]: invalid tune: %sn", optarg );
  744.                 return -1;
  745.             }
  746.         }
  747.         else if( c == '?' )
  748.             return -1;
  749.     }
  751.     /* Parse command line options */
  752.     for( optind = 0;; )
  753.     {
  754.         int b_error = 0;
  755.         int long_options_index = -1;
  757.         int c = getopt_long( argc, argv, short_options, long_options, &long_options_index );
  759.         if( c == -1 )
  760.         {
  761.             break;
  762.         }
  764.         switch( c )
  765.         {
  766.             case 'h':
  767.                 Help( &defaults, 0 );
  768.                 exit(0);
  769.             case OPT_LONGHELP:
  770.                 Help( &defaults, 1 );
  771.                 exit(0);
  772.             case OPT_FULLHELP:
  773.                 Help( &defaults, 2 );
  774.                 exit(0);
  775.             case 'V':
  776. #ifdef X264_POINTVER
  777.                 printf( "x264 "X264_POINTVER"n" );
  778. #else
  779.                 printf( "x264 0.%d.Xn", X264_BUILD );
  780. #endif
  781.                 printf( "built on " __DATE__ ", " );
  782. #ifdef __GNUC__
  783.                 printf( "gcc: " __VERSION__ "n" );
  784. #else
  785.                 printf( "using a non-gcc compilern" );
  786. #endif
  787.                 exit(0);
  788.             case OPT_FRAMES:
  789.                 param->i_frame_total = atoi( optarg );
  790.                 break;
  791.             case OPT_SEEK:
  792.                 opt->i_seek = atoi( optarg );
  793.                 break;
  794.             case 'o':
  795.                 if( !strncasecmp(optarg + strlen(optarg) - 4, ".mp4", 4) )
  796.                 {
  797. #ifdef MP4_OUTPUT
  798.                     p_open_outfile = open_file_mp4;
  799.                     p_write_nalu = write_nalu_mp4;
  800.                     p_set_outfile_param = set_param_mp4;
  801.                     p_set_eop = set_eop_mp4;
  802.                     p_close_outfile = close_file_mp4;
  803. #else
  804.                     fprintf( stderr, "x264 [error]: not compiled with MP4 output supportn" );
  805.                     return -1;
  806. #endif
  807.                 }
  808.                 else if( !strncasecmp(optarg + strlen(optarg) - 4, ".mkv", 4) )
  809.                 {
  810.                     p_open_outfile = open_file_mkv;
  811.                     p_write_nalu = write_nalu_mkv;
  812.                     p_set_outfile_param = set_param_mkv;
  813.                     p_set_eop = set_eop_mkv;
  814.                     p_close_outfile = close_file_mkv;
  815.                 }
  816.                 if( !strcmp(optarg, "-") )
  817.                     opt->hout = stdout;
  818.                 else if( p_open_outfile( optarg, &opt->hout ) )
  819.                 {
  820.                     fprintf( stderr, "x264 [error]: can't open output file `%s'n", optarg );
  821.                     return -1;
  822.                 }
  823.                 break;
  824.             case OPT_QPFILE:
  825.                 opt->qpfile = fopen( optarg, "rb" );
  826.                 if( !opt->qpfile )
  827.                 {
  828.                     fprintf( stderr, "x264 [error]: can't open `%s'n", optarg );
  829.                     return -1;
  830.                 }
  831.                 break;
  832.             case OPT_THREAD_INPUT:
  833.                 b_thread_input = 1;
  834.                 break;
  835.             case OPT_QUIET:
  836.                 param->i_log_level = X264_LOG_NONE;
  837.                 break;
  838.             case 'v':
  839.                 param->i_log_level = X264_LOG_DEBUG;
  840.                 break;
  841.             case OPT_NOPROGRESS:
  842.                 opt->b_progress = 0;
  843.                 break;
  844.             case OPT_VISUALIZE:
  845. #ifdef VISUALIZE
  846.                 param->b_visualize = 1;
  847.                 b_exit_on_ctrl_c = 1;
  848. #else
  849.                 fprintf( stderr, "x264 [warning]: not compiled with visualization supportn" );
  850. #endif
  851.                 break;
  852.             case OPT_TUNE:
  853.             case OPT_PRESET:
  854.                 break;
  855.             case OPT_PROFILE:
  856.                 profile = optarg;
  857.                 break;
  858.             case OPT_SLOWFIRSTPASS:
  859.                 b_turbo = 0;
  860.                 break;
  861.             case 'r':
  862.                 b_user_ref = 1;
  863.                 goto generic_option;
  864.             case 'p':
  865.                 b_pass1 = atoi( optarg ) == 1;
  866.                 goto generic_option;
  867.             case OPT_FPS:
  868.                 b_user_fps = 1;
  869.                 goto generic_option;
  870.             default:
  871. generic_option:
  872.             {
  873.                 int i;
  874.                 if( long_options_index < 0 )
  875.                 {
  876.                     for( i = 0; long_options[i].name; i++ )
  877.                         if( long_options[i].val == c )
  878.                         {
  879.                             long_options_index = i;
  880.                             break;
  881.                         }
  882.                     if( long_options_index < 0 )
  883.                     {
  884.                         /* getopt_long already printed an error message */
  885.                         return -1;
  886.                     }
  887.                 }
  889.                 b_error |= x264_param_parse( param, long_options[long_options_index].name, optarg );
  890.             }
  891.         }
  893.         if( b_error )
  894.         {
  895.             const char *name = long_options_index > 0 ? long_options[long_options_index].name : argv[optind-2];
  896.             fprintf( stderr, "x264 [error]: invalid argument: %s = %sn", name, optarg );
  897.             return -1;
  898.         }
  899.     }
  901.     /* Set faster options in case of turbo firstpass. */
  902.     if( b_turbo && b_pass1 )
  903.     {
  904.         param->i_frame_reference = 1;
  905.         param->analyse.b_transform_8x8 = 0;
  906.         param->analyse.inter = 0;
  907.         param->analyse.i_me_method = X264_ME_DIA;
  908.         param->analyse.i_subpel_refine = X264_MIN( 2, param->analyse.i_subpel_refine );
  909.         param->analyse.i_trellis = 0;
  910.     }
  912.     /* Apply profile restrictions. */
  913.     if( profile )
  914.     {
  915.         if( !strcasecmp( profile, "baseline" ) )
  916.         {
  917.             param->analyse.b_transform_8x8 = 0;
  918.             param->b_cabac = 0;
  919.             param->i_cqm_preset = X264_CQM_FLAT;
  920.             param->i_bframe = 0;
  921.             if( param->b_interlaced )
  922.             {
  923.                 fprintf( stderr, "x264 [error]: baseline profile doesn't support interlacingn" );
  924.                 return -1;
  925.             }
  926.         }
  927.         else if( !strcasecmp( profile, "main" ) )
  928.         {
  929.             param->analyse.b_transform_8x8 = 0;
  930.             param->i_cqm_preset = X264_CQM_FLAT;
  931.         }
  932.         else if( !strcasecmp( profile, "high" ) )
  933.         {
  934.             /* Default */
  935.         }
  936.         else
  937.         {
  938.             fprintf( stderr, "x264 [error]: invalid profile: %sn", profile );
  939.             return -1;
  940.         }
  941.         if( (param->rc.i_rc_method == X264_RC_CQP && param->rc.i_qp_constant == 0) ||
  942.             (param->rc.i_rc_method == X264_RC_CRF && param->rc.f_rf_constant == 0) )
  943.         {
  944.             fprintf( stderr, "x264 [error]: %s profile doesn't support losslessn", profile );
  945.             return -1;
  946.         }
  947.     }
  949.     /* Get the file name */
  950.     if( optind > argc - 1 || !opt->hout )
  951.     {
  952.         fprintf( stderr, "x264 [error]: No %s file. Run x264 --help for a list of options.n",
  953.                  optind > argc - 1 ? "input" : "output" );
  954.         return -1;
  955.     }
  956.     psz_filename = argv[optind++];
  958.     /* check demuxer type */
  959.     psz = psz_filename + strlen(psz_filename) - 1;
  960.     while( psz > psz_filename && *psz != '.' )
  961.         psz--;
  962.     if( !strncasecmp( psz, ".avi", 4 ) || !strncasecmp( psz, ".avs", 4 ) )
  963.         b_avis = 1;
  964.     if( !strncasecmp( psz, ".y4m", 4 ) )
  965.         b_y4m = 1;
  967.     if( !(b_avis || b_y4m) ) // raw yuv
  968.     {
  969.         if( optind > argc - 1 )
  970.         {
  971.             /* try to parse the file name */
  972.             for( psz = psz_filename; *psz; psz++ )
  973.             {
  974.                 if( *psz >= '0' && *psz <= '9'
  975.                     && sscanf( psz, "%ux%u", &param->i_width, &param->i_height ) == 2 )
  976.                 {
  977.                     if( param->i_log_level >= X264_LOG_INFO )
  978.                         fprintf( stderr, "x264 [info]: %dx%d (given by file name) @ %.2f fpsn", param->i_width, param->i_height, (double)param->i_fps_num / (double)param->i_fps_den);
  979.                     break;
  980.                 }
  981.             }
  982.         }
  983.         else
  984.         {
  985.             sscanf( argv[optind++], "%ux%u", &param->i_width, &param->i_height );
  986.             if( param->i_log_level >= X264_LOG_INFO )
  987.                 fprintf( stderr, "x264 [info]: %dx%d @ %.2f fpsn", param->i_width, param->i_height, (double)param->i_fps_num / (double)param->i_fps_den);
  988.         }
  989.     }
  991.     if( !(b_avis || b_y4m) && ( !param->i_width || !param->i_height ) )
  992.     {
  993.         fprintf( stderr, "x264 [error]: Rawyuv input requires a resolution.n" );
  994.         return -1;
  995.     }
  997.     /* open the input */
  998.     {
  999.         int i_fps_num = param->i_fps_num;
  1000.         int i_fps_den = param->i_fps_den;
  1001.         if( b_avis )
  1002.         {
  1003. #ifdef AVIS_INPUT
  1004.             p_open_infile = open_file_avis;
  1005.             p_get_frame_total = get_frame_total_avis;
  1006.             p_read_frame = read_frame_avis;
  1007.             p_close_infile = close_file_avis;
  1008. #else
  1009.             fprintf( stderr, "x264 [error]: not compiled with AVIS input supportn" );
  1010.             return -1;
  1011. #endif
  1012.         }
  1013.         if( b_y4m )
  1014.         {
  1015.             p_open_infile = open_file_y4m;
  1016.             p_get_frame_total = get_frame_total_y4m;
  1017.             p_read_frame = read_frame_y4m;
  1018.             p_close_infile = close_file_y4m;
  1019.         }
  1021.         if( p_open_infile( psz_filename, &opt->hin, param ) )
  1022.         {
  1023.             fprintf( stderr, "x264 [error]: could not open input file '%s'n", psz_filename );
  1024.             return -1;
  1025.         }
  1026.         /* Restore the user's frame rate if fps has been explicitly set on the commandline. */
  1027.         if( b_user_fps )
  1028.         {
  1029.             param->i_fps_num = i_fps_num;
  1030.             param->i_fps_den = i_fps_den;
  1031.         }
  1032.     }
  1034. #ifdef HAVE_PTHREAD
  1035.     if( b_thread_input || param->i_threads > 1
  1036.         || (param->i_threads == X264_THREADS_AUTO && x264_cpu_num_processors() > 1) )
  1037.     {
  1038.         if( open_file_thread( NULL, &opt->hin, param ) )
  1039.         {
  1040.             fprintf( stderr, "x264 [error]: threaded input failedn" );
  1041.             return -1;
  1042.         }
  1043.         else
  1044.         {
  1045.             p_open_infile = open_file_thread;
  1046.             p_get_frame_total = get_frame_total_thread;
  1047.             p_read_frame = read_frame_thread;
  1048.             p_close_infile = close_file_thread;
  1049.         }
  1050.     }
  1051. #endif
  1054.     /* Automatically reduce reference frame count to match the user's target level
  1055.      * if the user didn't explicitly set a reference frame count. */
  1056.     if( !b_user_ref )
  1057.     {
  1058.         int mbs = (((param->i_width)+15)>>4) * (((param->i_height)+15)>>4);
  1059.         int i;
  1060.         for( i = 0; x264_levels[i].level_idc != 0; i++ )
  1061.             if( param->i_level_idc == x264_levels[i].level_idc )
  1062.             {
  1063.                 while( mbs * 384 * param->i_frame_reference > x264_levels[i].dpb
  1064.                        && param->i_frame_reference > 1 )
  1065.                 {
  1066.                     param->i_frame_reference--;
  1067.                 }
  1068.                 break;
  1069.             }
  1070.     }
  1073.     return 0;
  1074. }
  1076. static void parse_qpfile( cli_opt_t *opt, x264_picture_t *pic, int i_frame )
  1077. {
  1078.     int num = -1, qp, ret;
  1079.     char type;
  1080.     uint64_t file_pos;
  1081.     while( num < i_frame )
  1082.     {
  1083.         file_pos = ftell( opt->qpfile );
  1084.         ret = fscanf( opt->qpfile, "%d %c %dn", &num, &type, &qp );
  1085.         if( num > i_frame || ret == EOF )
  1086.         {
  1087.             pic->i_type = X264_TYPE_AUTO;
  1088.             pic->i_qpplus1 = 0;
  1089.             fseek( opt->qpfile , file_pos , SEEK_SET );
  1090.             break;
  1091.         }
  1092.         if( num < i_frame && ret == 3 )
  1093.             continue;
  1094.         pic->i_qpplus1 = qp+1;
  1095.         if     ( type == 'I' ) pic->i_type = X264_TYPE_IDR;
  1096.         else if( type == 'i' ) pic->i_type = X264_TYPE_I;
  1097.         else if( type == 'P' ) pic->i_type = X264_TYPE_P;
  1098.         else if( type == 'B' ) pic->i_type = X264_TYPE_BREF;
  1099.         else if( type == 'b' ) pic->i_type = X264_TYPE_B;
  1100.         else ret = 0;
  1101.         if( ret != 3 || qp < -1 || qp > 51 )
  1102.         {
  1103.             fprintf( stderr, "x264 [error]: can't parse qpfile for frame %dn", i_frame );
  1104.             fclose( opt->qpfile );
  1105.             opt->qpfile = NULL;
  1106.             pic->i_type = X264_TYPE_AUTO;
  1107.             pic->i_qpplus1 = 0;
  1108.             break;
  1109.         }
  1110.     }
  1111. }
  1113. /*****************************************************************************
  1114.  * Encode:
  1115.  *****************************************************************************/
  1117. static int  Encode_frame( x264_t *h, hnd_t hout, x264_picture_t *pic )
  1118. {
  1119.     x264_picture_t pic_out;
  1120.     x264_nal_t *nal;
  1121.     int i_nal, i, i_nalu_size;
  1122.     int i_file = 0;
  1124.     if( x264_encoder_encode( h, &nal, &i_nal, pic, &pic_out ) < 0 )
  1125.     {
  1126.         fprintf( stderr, "x264 [error]: x264_encoder_encode failedn" );
  1127.         return -1;
  1128.     }
  1130.     for( i = 0; i < i_nal; i++ )
  1131.     {
  1132.         i_nalu_size = p_write_nalu( hout, nal[i].p_payload, nal[i].i_payload );
  1133.         if( i_nalu_size < 0 )
  1134.             return -1;
  1135.         i_file += i_nalu_size;
  1136.     }
  1137.     if (i_nal)
  1138.         p_set_eop( hout, &pic_out );
  1140.     return i_file;
  1141. }
  1143. static void Print_status( int64_t i_start, int i_frame, int i_frame_total, int64_t i_file, x264_param_t *param )
  1144. {
  1145.     char    buf[200];
  1146.     int64_t i_elapsed = x264_mdate() - i_start;
  1147.     double fps = i_elapsed > 0 ? i_frame * 1000000. / i_elapsed : 0;
  1148.     double bitrate = (double) i_file * 8 * param->i_fps_num / ( (double) param->i_fps_den * i_frame * 1000 );
  1149.     if( i_frame_total )
  1150.     {
  1151.         int eta = i_elapsed * (i_frame_total - i_frame) / ((int64_t)i_frame * 1000000);
  1152.         sprintf( buf, "x264 [%.1f%%] %d/%d frames, %.2f fps, %.2f kb/s, eta %d:%02d:%02d",
  1153.                  100. * i_frame / i_frame_total, i_frame, i_frame_total, fps, bitrate,
  1154.                  eta/3600, (eta/60)%60, eta%60 );
  1155.     }
  1156.     else
  1157.     {
  1158.         sprintf( buf, "x264 %d frames: %.2f fps, %.2f kb/s", i_frame, fps, bitrate );
  1159.     }
  1160.     fprintf( stderr, "%s  r", buf+5 );
  1161.     SetConsoleTitle( buf );
  1162.     fflush( stderr ); // needed in windows
  1163. }
  1165. static int  Encode( x264_param_t *param, cli_opt_t *opt )
  1166. {
  1167.     x264_t *h;
  1168.     x264_picture_t pic;
  1170.     int     i_frame, i_frame_total, i_frame_output;
  1171.     int64_t i_start, i_end;
  1172.     int64_t i_file;
  1173.     int     i_frame_size;
  1174.     int     i_update_interval;
  1176.     opt->b_progress &= param->i_log_level < X264_LOG_DEBUG;
  1177.     i_frame_total = p_get_frame_total( opt->hin );
  1178.     i_frame_total -= opt->i_seek;
  1179.     if( ( i_frame_total == 0 || param->i_frame_total < i_frame_total )
  1180.         && param->i_frame_total > 0 )
  1181.         i_frame_total = param->i_frame_total;
  1182.     param->i_frame_total = i_frame_total;
  1183.     i_update_interval = i_frame_total ? x264_clip3( i_frame_total / 1000, 1, 10 ) : 10;
  1185.     if( ( h = x264_encoder_open( param ) ) == NULL )
  1186.     {
  1187.         fprintf( stderr, "x264 [error]: x264_encoder_open failedn" );
  1188.         p_close_infile( opt->hin );
  1189.         return -1;
  1190.     }
  1192.     if( p_set_outfile_param( opt->hout, param ) )
  1193.     {
  1194.         fprintf( stderr, "x264 [error]: can't set outfile paramn" );
  1195.         p_close_infile( opt->hin );
  1196.         p_close_outfile( opt->hout );
  1197.         return -1;
  1198.     }
  1200.     /* Create a new pic */
  1201.     if( x264_picture_alloc( &pic, X264_CSP_I420, param->i_width, param->i_height ) < 0 )
  1202.     {
  1203.         fprintf( stderr, "x264 [error]: malloc failedn" );
  1204.         return -1;
  1205.     }
  1207.     i_start = x264_mdate();
  1209.     /* Encode frames */
  1210.     for( i_frame = 0, i_file = 0, i_frame_output = 0; b_ctrl_c == 0 && (i_frame < i_frame_total || i_frame_total == 0); )
  1211.     {
  1212.         if( p_read_frame( &pic, opt->hin, i_frame + opt->i_seek ) )
  1213.             break;
  1215.         pic.i_pts = (int64_t)i_frame * param->i_fps_den;
  1217.         if( opt->qpfile )
  1218.             parse_qpfile( opt, &pic, i_frame + opt->i_seek );
  1219.         else
  1220.         {
  1221.             /* Do not force any parameters */
  1222.             pic.i_type = X264_TYPE_AUTO;
  1223.             pic.i_qpplus1 = 0;
  1224.         }
  1226.         i_frame_size = Encode_frame( h, opt->hout, &pic );
  1227.         if( i_frame_size < 0 )
  1228.             return -1;
  1229.         i_file += i_frame_size;
  1230.         if( i_frame_size )
  1231.             i_frame_output++;
  1233.         i_frame++;
  1235.         /* update status line (up to 1000 times per input file) */
  1236.         if( opt->b_progress && i_frame_output % i_update_interval == 0 && i_frame_output )
  1237.             Print_status( i_start, i_frame_output, i_frame_total, i_file, param );
  1238.     }
  1239.     /* Flush delayed frames */
  1240.     while( !b_ctrl_c && x264_encoder_delayed_frames( h ) )
  1241.     {
  1242.         i_frame_size = Encode_frame( h, opt->hout, NULL );
  1243.         if( i_frame_size < 0 )
  1244.             return -1;
  1245.         i_file += i_frame_size;
  1246.         if( i_frame_size )
  1247.             i_frame_output++;
  1248.         if( opt->b_progress && i_frame_output % i_update_interval == 0 && i_frame_output )
  1249.             Print_status( i_start, i_frame_output, i_frame_total, i_file, param );
  1250.     }
  1252.     i_end = x264_mdate();
  1253.     x264_picture_clean( &pic );
  1254.     /* Erase progress indicator before printing encoding stats. */
  1255.     if( opt->b_progress )
  1256.         fprintf( stderr, "                                                                               r" );
  1257.     x264_encoder_close( h );
  1258.     x264_free( mux_buffer );
  1259.     fprintf( stderr, "n" );
  1261.     if( b_ctrl_c )
  1262.         fprintf( stderr, "aborted at input frame %d, output frame %dn", opt->i_seek + i_frame, i_frame_output );
  1264.     p_close_infile( opt->hin );
  1265.     p_close_outfile( opt->hout );
  1267.     if( i_frame_output > 0 )
  1268.     {
  1269.         double fps = (double)i_frame_output * (double)1000000 /
  1270.                      (double)( i_end - i_start );
  1272.         fprintf( stderr, "encoded %d frames, %.2f fps, %.2f kb/sn", i_frame_output, fps,
  1273.                  (double) i_file * 8 * param->i_fps_num /
  1274.                  ( (double) param->i_fps_den * i_frame_output * 1000 ) );
  1275.     }
  1277.     return 0;
  1278. }