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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
x264.c
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：38k
源码类别：

Audio

开发平台：

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. #ifndef _MSC_VER
  37. #include "config.h"
  38. #endif
  40. uint8_t *mux_buffer = NULL;
  41. int mux_buffer_size = 0;
  43. /* Ctrl-C handler */
  44. static int     b_ctrl_c = 0;
  45. static int     b_exit_on_ctrl_c = 0;
  46. static void    SigIntHandler( int a )
  47. {
  48.     if( b_exit_on_ctrl_c )
  49.         exit(0);
  50.     b_ctrl_c = 1;
  51. }
  53. typedef struct {
  54.     int b_progress;
  55.     int i_seek;
  56.     hnd_t hin;
  57.     hnd_t hout;
  58.     FILE *qpfile;
  59. } cli_opt_t;
  61. /* input file operation function pointers */
  62. int (*p_open_infile)( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param );
  63. int (*p_get_frame_total)( hnd_t handle );
  64. int (*p_read_frame)( x264_picture_t *p_pic, hnd_t handle, int i_frame );
  65. int (*p_close_infile)( hnd_t handle );
  67. /* output file operation function pointers */
  68. static int (*p_open_outfile)( char *psz_filename, hnd_t *p_handle );
  69. static int (*p_set_outfile_param)( hnd_t handle, x264_param_t *p_param );
  70. static int (*p_write_nalu)( hnd_t handle, uint8_t *p_nal, int i_size );
  71. static int (*p_set_eop)( hnd_t handle, x264_picture_t *p_picture );
  72. static int (*p_close_outfile)( hnd_t handle );
  74. static void Help( x264_param_t *defaults, int b_longhelp );
  75. static int  Parse( int argc, char **argv, x264_param_t *param, cli_opt_t *opt );
  76. static int  Encode( x264_param_t *param, cli_opt_t *opt );
  79. /****************************************************************************
  80.  * main:
  81.  ****************************************************************************/
  82. int main( int argc, char **argv )
  83. {
  84.     x264_param_t param;
  85.     cli_opt_t opt;
  86.     int ret;
  88. #ifdef PTW32_STATIC_LIB
  89.     pthread_win32_process_attach_np();
  90.     pthread_win32_thread_attach_np();
  91. #endif
  93. #ifdef _WIN32
  94.     _setmode(_fileno(stdin), _O_BINARY);
  95.     _setmode(_fileno(stdout), _O_BINARY);
  96. #endif
  98.     x264_param_default( &param );
  100.     /* Parse command line */
  101.     if( Parse( argc, argv, &param, &opt ) < 0 )
  102.         return -1;
  104.     /* Control-C handler */
  105.     signal( SIGINT, SigIntHandler );
  107.     ret = Encode( &param, &opt );
  109. #ifdef PTW32_STATIC_LIB
  110.     pthread_win32_thread_detach_np();
  111.     pthread_win32_process_detach_np();
  112. #endif
  114.     return ret;
  115. }
  117. static char const *strtable_lookup( const char * const table[], int index )
  118. {
  119.     int i = 0; while( table[i] ) i++;
  120.     return ( ( index >= 0 && index < i ) ? table[ index ] : "???" );
  121. }
  123. /*****************************************************************************
  124.  * Help:
  125.  *****************************************************************************/
  126. static void Help( x264_param_t *defaults, int b_longhelp )
  127. {
  128. #define H0 printf
  129. #define H1 if(b_longhelp) printf
  130.     H0( "x264 core:%d%sn"
  131.         "Syntax: x264 [options] -o outfile infile [widthxheight]n"
  132.         "n"
  133.         "Infile can be raw YUV 4:2:0 (in which case resolution is required),n"
  134.         "  or YUV4MPEG 4:2:0 (*.y4m),n"
  135.         "  or AVI or Avisynth if compiled with AVIS support (%s).n"
  136.         "Outfile type is selected by filename:n"
  137.         " .264 -> Raw bytestreamn"
  138.         " .mkv -> Matroskan"
  139.         " .mp4 -> MP4 if compiled with GPAC support (%s)n"
  140.         "n"
  141.         "Options:n"
  142.         "n"
  143.         "  -h, --help                  List the more commonly used optionsn"
  144.         "      --longhelp              List all optionsn"
  145.         "n",
  146.         X264_BUILD, X264_VERSION,
  147. #ifdef AVIS_INPUT
  148.         "yes",
  149. #else
  150.         "no",
  151. #endif
  152. #ifdef MP4_OUTPUT
  153.         "yes"
  154. #else
  155.         "no"
  156. #endif
  157.       );
  158.     H0( "Frame-type options:n" );
  159.     H0( "n" );
  160.     H0( "  -I, --keyint <integer>      Maximum GOP size [%d]n", defaults->i_keyint_max );
  161.     H1( "  -i, --min-keyint <integer>  Minimum GOP size [%d]n", defaults->i_keyint_min );
  162.     H1( "      --scenecut <integer>    How aggressively to insert extra I-frames [%d]n", defaults->i_scenecut_threshold );
  163.     H1( "      --pre-scenecut          Faster, less precise scenecut detection.n"
  164.         "                                  Required and implied by multi-threading.n" );
  165.     H0( "  -b, --bframes <integer>     Number of B-frames between I and P [%d]n", defaults->i_bframe );
  166.     H1( "      --no-b-adapt            Disable adaptive B-frame decisionn" );
  167.     H1( "      --b-bias <integer>      Influences how often B-frames are used [%d]n", defaults->i_bframe_bias );
  168.     H0( "      --b-pyramid             Keep some B-frames as referencesn" );
  169.     H0( "      --no-cabac              Disable CABACn" );
  170.     H0( "  -r, --ref <integer>         Number of reference frames [%d]n", defaults->i_frame_reference );
  171.     H1( "      --no-deblock            Disable loop filtern" );
  172.     H0( "  -f, --deblock <alpha:beta>  Loop filter AlphaC0 and Beta parameters [%d:%d]n",
  173.                                        defaults->i_deblocking_filter_alphac0, defaults->i_deblocking_filter_beta );
  174.     H0( "      --interlaced            Enable pure-interlaced moden" );
  175.     H0( "n" );
  176.     H0( "Ratecontrol:n" );
  177.     H0( "n" );
  178.     H0( "  -q, --qp <integer>          Set QP (0=lossless) [%d]n", defaults->rc.i_qp_constant );
  179.     H0( "  -B, --bitrate <integer>     Set bitrate (kbit/s)n" );
  180.     H0( "      --crf <float>           Quality-based VBR (nominal QP)n" );
  181.     H1( "      --vbv-maxrate <integer> Max local bitrate (kbit/s) [%d]n", defaults->rc.i_vbv_max_bitrate );
  182.     H0( "      --vbv-bufsize <integer> Enable CBR and set size of the VBV buffer (kbit) [%d]n", defaults->rc.i_vbv_buffer_size );
  183.     H1( "      --vbv-init <float>      Initial VBV buffer occupancy [%.1f]n", defaults->rc.f_vbv_buffer_init );
  184.     H1( "      --qpmin <integer>       Set min QP [%d]n", defaults->rc.i_qp_min );
  185.     H1( "      --qpmax <integer>       Set max QP [%d]n", defaults->rc.i_qp_max );
  186.     H1( "      --qpstep <integer>      Set max QP step [%d]n", defaults->rc.i_qp_step );
  187.     H0( "      --ratetol <float>       Allowed variance of average bitrate [%.1f]n", defaults->rc.f_rate_tolerance );
  188.     H0( "      --ipratio <float>       QP factor between I and P [%.2f]n", defaults->rc.f_ip_factor );
  189.     H0( "      --pbratio <float>       QP factor between P and B [%.2f]n", defaults->rc.f_pb_factor );
  190.     H1( "      --chroma-qp-offset <integer>  QP difference between chroma and luma [%d]n", defaults->analyse.i_chroma_qp_offset );
  191.     H0( "      --aq-mode <integer>     How AQ distributes bits [%d]n"
  192.         "                                  - 0: Disabledn"
  193.         "                                  - 1: Avoid moving bits between framesn"
  194.         "                                  - 2: Move bits between framesn", defaults->rc.i_aq_mode );
  195.     H0( "      --aq-strength <float>   Reduces blocking and blurring in flat andn"
  196.         "                              textured areas. [%.1f]n"
  197.         "                                  - 0.5: weak AQn"
  198.         "                                  - 1.5: strong AQn", defaults->rc.f_aq_strength );
  199.     H0( "n" );
  200.     H0( "  -p, --pass <1|2|3>          Enable multipass ratecontroln"
  201.         "                                  - 1: First pass, creates stats filen"
  202.         "                                  - 2: Last pass, does not overwrite stats filen"
  203.         "                                  - 3: Nth pass, overwrites stats filen" );
  204.     H0( "      --stats <string>        Filename for 2 pass stats ["%s"]n", defaults->rc.psz_stat_out );
  205.     H0( "      --qcomp <float>         QP curve compression: 0.0 => CBR, 1.0 => CQP [%.2f]n", defaults->rc.f_qcompress );
  206.     H1( "      --cplxblur <float>      Reduce fluctuations in QP (before curve compression) [%.1f]n", defaults->rc.f_complexity_blur );
  207.     H1( "      --qblur <float>         Reduce fluctuations in QP (after curve compression) [%.1f]n", defaults->rc.f_qblur );
  208.     H0( "      --zones <zone0>/<zone1>/...  Tweak the bitrate of some regions of the videon" );
  209.     H1( "                              Each zone is of the formn"
  210.         "                                  <start frame>,<end frame>,<option>n"
  211.         "                                  where <option> is eithern"
  212.         "                                      q=<integer> (force QP)n"
  213.         "                                  or  b=<float> (bitrate multiplier)n" );
  214.     H1( "      --qpfile <string>       Force frametypes and QPsn" );
  215.     H0( "n" );
  216.     H0( "Analysis:n" );
  217.     H0( "n" );
  218.     H0( "  -A, --partitions <string>   Partitions to consider ["p8x8,b8x8,i8x8,i4x4"]n"
  219.         "                                  - p8x8, p4x4, b8x8, i8x8, i4x4n"
  220.         "                                  - none, alln"
  221.         "                                  (p4x4 requires p8x8. i8x8 requires --8x8dct.)n" );
  222.     H0( "      --direct <string>       Direct MV prediction mode ["%s"]n"
  223.         "                                  - none, spatial, temporal, auton",
  224.                                        strtable_lookup( x264_direct_pred_names, defaults->analyse.i_direct_mv_pred ) );
  225.     H1( "      --direct-8x8 <-1|0|1>   Direct prediction size [%d]n"
  226.         "                                  -  0: 4x4n"
  227.         "                                  -  1: 8x8n"
  228.         "                                  - -1: smallest possible according to leveln",
  229.                                        defaults->analyse.i_direct_8x8_inference );
  230.     H0( "  -w, --weightb               Weighted prediction for B-framesn" );
  231.     H0( "      --me <string>           Integer pixel motion estimation method ["%s"]n",
  232.                                        strtable_lookup( x264_motion_est_names, defaults->analyse.i_me_method ) );
  233.     H1( "                                  - dia: diamond search, radius 1 (fast)n"
  234.         "                                  - hex: hexagonal search, radius 2n"
  235.         "                                  - umh: uneven multi-hexagon searchn"
  236.         "                                  - esa: exhaustive searchn"
  237.         "                                  - tesa: hadamard exhaustive search (slow)n" );
  238.     else H0( "                                  - dia, hex, umhn" );
  239.     H0( "      --merange <integer>     Maximum motion vector search range [%d]n", defaults->analyse.i_me_range );
  240.     H1( "      --mvrange <integer>     Maximum motion vector length [-1 (auto)]n" );
  241.     H1( "      --mvrange-thread <int>  Minimum buffer between threads [-1 (auto)]n" );
  242.     H0( "  -m, --subme <integer>       Subpixel motion estimation and partitionn"
  243.         "                                  decision quality: 1=fast, 7=best. [%d]n", defaults->analyse.i_subpel_refine );
  244.     H0( "      --b-rdo                 RD based mode decision for B-frames. Requires subme 6.n" );
  245.     H0( "      --mixed-refs            Decide references on a per partition basisn" );
  246.     H1( "      --no-chroma-me          Ignore chroma in motion estimationn" );
  247.     H1( "      --bime                  Jointly optimize both MVs in B-framesn" );
  248.     H0( "  -8, --8x8dct                Adaptive spatial transform sizen" );
  249.     H0( "  -t, --trellis <integer>     Trellis RD quantization. Requires CABAC. [%d]n"
  250.         "                                  - 0: disabledn"
  251.         "                                  - 1: enabled only on the final encode of a MBn"
  252.         "                                  - 2: enabled on all mode decisionsn", defaults->analyse.i_trellis );
  253.     H0( "      --no-fast-pskip         Disables early SKIP detection on P-framesn" );
  254.     H0( "      --no-dct-decimate       Disables coefficient thresholding on P-framesn" );
  255.     H0( "      --nr <integer>          Noise reduction [%d]n", defaults->analyse.i_noise_reduction );
  256.     H1( "n" );
  257.     H1( "      --deadzone-inter <int>  Set the size of the inter luma quantization deadzone [%d]n", defaults->analyse.i_luma_deadzone[0] );
  258.     H1( "      --deadzone-intra <int>  Set the size of the intra luma quantization deadzone [%d]n", defaults->analyse.i_luma_deadzone[1] );
  259.     H1( "                                  Deadzones should be in the range 0 - 32.n" );
  260.     H1( "      --cqm <string>          Preset quant matrices ["flat"]n"
  261.         "                                  - jvt, flatn" );
  262.     H0( "      --cqmfile <string>      Read custom quant matrices from a JM-compatible filen" );
  263.     H1( "                                  Overrides any other --cqm* options.n" );
  264.     H1( "      --cqm4 <list>           Set all 4x4 quant matricesn"
  265.         "                                  Takes a comma-separated list of 16 integers.n" );
  266.     H1( "      --cqm8 <list>           Set all 8x8 quant matricesn"
  267.         "                                  Takes a comma-separated list of 64 integers.n" );
  268.     H1( "      --cqm4i, --cqm4p, --cqm8i, --cqm8pn"
  269.         "                              Set both luma and chroma quant matricesn" );
  270.     H1( "      --cqm4iy, --cqm4ic, --cqm4py, --cqm4pcn"
  271.         "                              Set individual quant matricesn" );
  272.     H1( "n" );
  273.     H1( "Video Usability Info (Annex E):n" );
  274.     H1( "The VUI settings are not used by the encoder but are merely suggestions ton" );
  275.     H1( "the playback equipment. See doc/vui.txt for details. Use at your own risk.n" );
  276.     H1( "n" );
  277.     H1( "      --overscan <string>     Specify crop overscan setting ["%s"]n"
  278.         "                                  - undef, show, cropn",
  279.                                        strtable_lookup( x264_overscan_names, defaults->vui.i_overscan ) );
  280.     H1( "      --videoformat <string>  Specify video format ["%s"]n"
  281.         "                                  - component, pal, ntsc, secam, mac, undefn",
  282.                                        strtable_lookup( x264_vidformat_names, defaults->vui.i_vidformat ) );
  283.     H1( "      --fullrange <string>    Specify full range samples setting ["%s"]n"
  284.         "                                  - off, onn",
  285.                                        strtable_lookup( x264_fullrange_names, defaults->vui.b_fullrange ) );
  286.     H1( "      --colorprim <string>    Specify color primaries ["%s"]n"
  287.         "                                  - undef, bt709, bt470m, bt470bgn"
  288.         "                                    smpte170m, smpte240m, filmn",
  289.                                        strtable_lookup( x264_colorprim_names, defaults->vui.i_colorprim ) );
  290.     H1( "      --transfer <string>     Specify transfer characteristics ["%s"]n"
  291.         "                                  - undef, bt709, bt470m, bt470bg, linear,n"
  292.         "                                    log100, log316, smpte170m, smpte240mn",
  293.                                        strtable_lookup( x264_transfer_names, defaults->vui.i_transfer ) );
  294.     H1( "      --colormatrix <string>  Specify color matrix setting ["%s"]n"
  295.         "                                  - undef, bt709, fcc, bt470bgn"
  296.         "                                    smpte170m, smpte240m, GBR, YCgCon",
  297.                                        strtable_lookup( x264_colmatrix_names, defaults->vui.i_colmatrix ) );
  298.     H1( "      --chromaloc <integer>   Specify chroma sample location (0 to 5) [%d]n",
  299.                                        defaults->vui.i_chroma_loc );
  300.     H0( "n" );
  301.     H0( "Input/Output:n" );
  302.     H0( "n" );
  303.     H0( "  -o, --output                Specify output filen" );
  304.     H0( "      --sar width:height      Specify Sample Aspect Ration" );
  305.     H0( "      --fps <float|rational>  Specify frameraten" );
  306.     H0( "      --seek <integer>        First frame to encoden" );
  307.     H0( "      --frames <integer>      Maximum number of frames to encoden" );
  308.     H0( "      --level <string>        Specify level (as defined by Annex A)n" );
  309.     H0( "n" );
  310.     H0( "  -v, --verbose               Print stats for each framen" );
  311.     H0( "      --progress              Show a progress indicator while encodingn" );
  312.     H0( "      --quiet                 Quiet Moden" );
  313.     H0( "      --no-psnr               Disable PSNR computationn" );
  314.     H0( "      --no-ssim               Disable SSIM computationn" );
  315.     H0( "      --threads <integer>     Parallel encodingn" );
  316.     H0( "      --thread-input          Run Avisynth in its own threadn" );
  317.     H1( "      --non-deterministic     Slightly improve quality of SMP, at the cost of repeatabilityn" );
  318.     H1( "      --asm <integer>         Override CPU detectionn" );
  319.     H1( "      --no-asm                Disable all CPU optimizationsn" );
  320.     H1( "      --visualize             Show MB types overlayed on the encoded videon" );
  321.     H1( "      --dump-yuv <string>     Save reconstructed framesn" );
  322.     H1( "      --sps-id <integer>      Set SPS and PPS id numbers [%d]n", defaults->i_sps_id );
  323.     H1( "      --aud                   Use access unit delimitersn" );
  324.     H0( "n" );
  325. }
  327. /*****************************************************************************
  328.  * Parse:
  329.  *****************************************************************************/
  330. static int  Parse( int argc, char **argv,
  331.                    x264_param_t *param, cli_opt_t *opt )
  332. {
  333.     char *psz_filename = NULL;
  334.     x264_param_t defaults = *param;
  335.     char *psz;
  336.     int b_avis = 0;
  337.     int b_y4m = 0;
  338.     int b_thread_input = 0;
  340.     memset( opt, 0, sizeof(cli_opt_t) );
  342.     /* Default input file driver */
  343.     p_open_infile = open_file_yuv;
  344.     p_get_frame_total = get_frame_total_yuv;
  345.     p_read_frame = read_frame_yuv;
  346.     p_close_infile = close_file_yuv;
  348.     /* Default output file driver */
  349.     p_open_outfile = open_file_bsf;
  350.     p_set_outfile_param = set_param_bsf;
  351.     p_write_nalu = write_nalu_bsf;
  352.     p_set_eop = set_eop_bsf;
  353.     p_close_outfile = close_file_bsf;
  355.     /* Parse command line options */
  356.     for( ;; )
  357.     {
  358.         int b_error = 0;
  359.         int long_options_index = -1;
  361. #define OPT_FRAMES 256
  362. #define OPT_SEEK 257
  363. #define OPT_QPFILE 258
  364. #define OPT_THREAD_INPUT 259
  365. #define OPT_QUIET 260
  366. #define OPT_PROGRESS 261
  367. #define OPT_VISUALIZE 262
  368. #define OPT_LONGHELP 263
  370.         static struct option long_options[] =
  371.         {
  372.             { "help",    no_argument,       NULL, 'h' },
  373.             { "longhelp",no_argument,       NULL, OPT_LONGHELP },
  374.             { "version", no_argument,       NULL, 'V' },
  375.             { "bitrate", required_argument, NULL, 'B' },
  376.             { "bframes", required_argument, NULL, 'b' },
  377.             { "no-b-adapt", no_argument,    NULL, 0 },
  378.             { "b-bias",  required_argument, NULL, 0 },
  379.             { "b-pyramid", no_argument,     NULL, 0 },
  380.             { "min-keyint",required_argument,NULL,'i' },
  381.             { "keyint",  required_argument, NULL, 'I' },
  382.             { "scenecut",required_argument, NULL, 0 },
  383.             { "pre-scenecut", no_argument,  NULL, 0 },
  384.             { "nf",      no_argument,       NULL, 0 },
  385.             { "no-deblock", no_argument,    NULL, 0 },
  386.             { "filter",  required_argument, NULL, 0 },
  387.             { "deblock", required_argument, NULL, 'f' },
  388.             { "interlaced", no_argument,    NULL, 0 },
  389.             { "no-cabac",no_argument,       NULL, 0 },
  390.             { "qp",      required_argument, NULL, 'q' },
  391.             { "qpmin",   required_argument, NULL, 0 },
  392.             { "qpmax",   required_argument, NULL, 0 },
  393.             { "qpstep",  required_argument, NULL, 0 },
  394.             { "crf",     required_argument, NULL, 0 },
  395.             { "ref",     required_argument, NULL, 'r' },
  396.             { "asm",     required_argument, NULL, 0 },
  397.             { "no-asm",  no_argument,       NULL, 0 },
  398.             { "sar",     required_argument, NULL, 0 },
  399.             { "fps",     required_argument, NULL, 0 },
  400.             { "frames",  required_argument, NULL, OPT_FRAMES },
  401.             { "seek",    required_argument, NULL, OPT_SEEK },
  402.             { "output",  required_argument, NULL, 'o' },
  403.             { "analyse", required_argument, NULL, 0 },
  404.             { "partitions", required_argument, NULL, 'A' },
  405.             { "direct",  required_argument, NULL, 0 },
  406.             { "direct-8x8", required_argument, NULL, 0 },
  407.             { "weightb", no_argument,       NULL, 'w' },
  408.             { "me",      required_argument, NULL, 0 },
  409.             { "merange", required_argument, NULL, 0 },
  410.             { "mvrange", required_argument, NULL, 0 },
  411.             { "mvrange-thread", required_argument, NULL, 0 },
  412.             { "subme",   required_argument, NULL, 'm' },
  413.             { "b-rdo",   no_argument,       NULL, 0 },
  414.             { "mixed-refs", no_argument,    NULL, 0 },
  415.             { "no-chroma-me", no_argument,  NULL, 0 },
  416.             { "bime",    no_argument,       NULL, 0 },
  417.             { "8x8dct",  no_argument,       NULL, '8' },
  418.             { "trellis", required_argument, NULL, 't' },
  419.             { "no-fast-pskip", no_argument, NULL, 0 },
  420.             { "no-dct-decimate", no_argument, NULL, 0 },
  421.             { "aq-strength", required_argument, NULL, 0 },
  422.             { "aq-mode", required_argument, NULL, 0 },
  423.             { "deadzone-inter", required_argument, NULL, '0' },
  424.             { "deadzone-intra", required_argument, NULL, '0' },
  425.             { "level",   required_argument, NULL, 0 },
  426.             { "ratetol", required_argument, NULL, 0 },
  427.             { "vbv-maxrate", required_argument, NULL, 0 },
  428.             { "vbv-bufsize", required_argument, NULL, 0 },
  429.             { "vbv-init", required_argument,NULL,  0 },
  430.             { "ipratio", required_argument, NULL, 0 },
  431.             { "pbratio", required_argument, NULL, 0 },
  432.             { "chroma-qp-offset", required_argument, NULL, 0 },
  433.             { "pass",    required_argument, NULL, 'p' },
  434.             { "stats",   required_argument, NULL, 0 },
  435.             { "qcomp",   required_argument, NULL, 0 },
  436.             { "qblur",   required_argument, NULL, 0 },
  437.             { "cplxblur",required_argument, NULL, 0 },
  438.             { "zones",   required_argument, NULL, 0 },
  439.             { "qpfile",  required_argument, NULL, OPT_QPFILE },
  440.             { "threads", required_argument, NULL, 0 },
  441.             { "thread-input", no_argument,  NULL, OPT_THREAD_INPUT },
  442.             { "non-deterministic", no_argument, NULL, 0 },
  443.             { "no-psnr", no_argument,       NULL, 0 },
  444.             { "no-ssim", no_argument,       NULL, 0 },
  445.             { "quiet",   no_argument,       NULL, OPT_QUIET },
  446.             { "verbose", no_argument,       NULL, 'v' },
  447.             { "progress",no_argument,       NULL, OPT_PROGRESS },
  448.             { "visualize",no_argument,      NULL, OPT_VISUALIZE },
  449.             { "dump-yuv",required_argument, NULL, 0 },
  450.             { "sps-id",  required_argument, NULL, 0 },
  451.             { "aud",     no_argument,       NULL, 0 },
  452.             { "nr",      required_argument, NULL, 0 },
  453.             { "cqm",     required_argument, NULL, 0 },
  454.             { "cqmfile", required_argument, NULL, 0 },
  455.             { "cqm4",    required_argument, NULL, 0 },
  456.             { "cqm4i",   required_argument, NULL, 0 },
  457.             { "cqm4iy",  required_argument, NULL, 0 },
  458.             { "cqm4ic",  required_argument, NULL, 0 },
  459.             { "cqm4p",   required_argument, NULL, 0 },
  460.             { "cqm4py",  required_argument, NULL, 0 },
  461.             { "cqm4pc",  required_argument, NULL, 0 },
  462.             { "cqm8",    required_argument, NULL, 0 },
  463.             { "cqm8i",   required_argument, NULL, 0 },
  464.             { "cqm8p",   required_argument, NULL, 0 },
  465.             { "overscan", required_argument, NULL, 0 },
  466.             { "videoformat", required_argument, NULL, 0 },
  467.             { "fullrange", required_argument, NULL, 0 },
  468.             { "colorprim", required_argument, NULL, 0 },
  469.             { "transfer", required_argument, NULL, 0 },
  470.             { "colormatrix", required_argument, NULL, 0 },
  471.             { "chromaloc", required_argument, NULL, 0 },
  472.             {0, 0, 0, 0}
  473.         };
  475.         int c = getopt_long( argc, argv, "8A:B:b:f:hI:i:m:o:p:q:r:t:Vvw",
  476.                              long_options, &long_options_index);
  478.         if( c == -1 )
  479.         {
  480.             break;
  481.         }
  483.         switch( c )
  484.         {
  485.             case 'h':
  486.                 Help( &defaults, 0 );
  487.                 exit(0);
  488.             case OPT_LONGHELP:
  489.                 Help( &defaults, 1 );
  490.                 exit(0);
  491.             case 'V':
  492. #ifdef X264_POINTVER
  493.                 printf( "x264 "X264_POINTVER"n" );
  494. #else
  495.                 printf( "x264 0.%d.Xn", X264_BUILD );
  496. #endif
  497.                 exit(0);
  498.             case OPT_FRAMES:
  499.                 param->i_frame_total = atoi( optarg );
  500.                 break;
  501.             case OPT_SEEK:
  502.                 opt->i_seek = atoi( optarg );
  503.                 break;
  504.             case 'o':
  505.                 if( !strncasecmp(optarg + strlen(optarg) - 4, ".mp4", 4) )
  506.                 {
  507. #ifdef MP4_OUTPUT
  508.                     p_open_outfile = open_file_mp4;
  509.                     p_write_nalu = write_nalu_mp4;
  510.                     p_set_outfile_param = set_param_mp4;
  511.                     p_set_eop = set_eop_mp4;
  512.                     p_close_outfile = close_file_mp4;
  513. #else
  514.                     fprintf( stderr, "x264 [error]: not compiled with MP4 output supportn" );
  515.                     return -1;
  516. #endif
  517.                 }
  518.                 else if( !strncasecmp(optarg + strlen(optarg) - 4, ".mkv", 4) )
  519.                 {
  520.                     p_open_outfile = open_file_mkv;
  521.                     p_write_nalu = write_nalu_mkv;
  522.                     p_set_outfile_param = set_param_mkv;
  523.                     p_set_eop = set_eop_mkv;
  524.                     p_close_outfile = close_file_mkv;
  525.                 }
  526.                 if( !strcmp(optarg, "-") )
  527.                     opt->hout = stdout;
  528.                 else if( p_open_outfile( optarg, &opt->hout ) )
  529.                 {
  530.                     fprintf( stderr, "x264 [error]: can't open output file `%s'n", optarg );
  531.                     return -1;
  532.                 }
  533.                 break;
  534.             case OPT_QPFILE:
  535.                 opt->qpfile = fopen( optarg, "r" );
  536.                 if( !opt->qpfile )
  537.                 {
  538.                     fprintf( stderr, "x264 [error]: can't open `%s'n", optarg );
  539.                     return -1;
  540.                 }
  541.                 param->i_scenecut_threshold = -1;
  542.                 param->b_bframe_adaptive = 0;
  543.                 break;
  544.             case OPT_THREAD_INPUT:
  545.                 b_thread_input = 1;
  546.                 break;
  547.             case OPT_QUIET:
  548.                 param->i_log_level = X264_LOG_NONE;
  549.                 break;
  550.             case 'v':
  551.                 param->i_log_level = X264_LOG_DEBUG;
  552.                 break;
  553.             case OPT_PROGRESS:
  554.                 opt->b_progress = 1;
  555.                 break;
  556.             case OPT_VISUALIZE:
  557. #ifdef VISUALIZE
  558.                 param->b_visualize = 1;
  559.                 b_exit_on_ctrl_c = 1;
  560. #else
  561.                 fprintf( stderr, "x264 [warning]: not compiled with visualization supportn" );
  562. #endif
  563.                 break;
  564.             default:
  565.             {
  566.                 int i;
  567.                 if( long_options_index < 0 )
  568.                 {
  569.                     for( i = 0; long_options[i].name; i++ )
  570.                         if( long_options[i].val == c )
  571.                         {
  572.                             long_options_index = i;
  573.                             break;
  574.                         }
  575.                     if( long_options_index < 0 )
  576.                     {
  577.                         /* getopt_long already printed an error message */
  578.                         return -1;
  579.                     }
  580.                 }
  582.                 b_error |= x264_param_parse( param, long_options[long_options_index].name, optarg );
  583.             }
  584.         }
  586.         if( b_error )
  587.         {
  588.             const char *name = long_options_index > 0 ? long_options[long_options_index].name : argv[optind-2];
  589.             fprintf( stderr, "x264 [error]: invalid argument: %s = %sn", name, optarg );
  590.             return -1;
  591.         }
  592.     }
  594.     /* Get the file name */
  595.     if( optind > argc - 1 || !opt->hout )
  596.     {
  597.         fprintf( stderr, "x264 [error]: No %s file. Run x264 --help for a list of options.n",
  598.                  optind > argc - 1 ? "input" : "output" );
  599.         return -1;
  600.     }
  601.     psz_filename = argv[optind++];
  603.     /* check demuxer type */
  604.     psz = psz_filename + strlen(psz_filename) - 1;
  605.     while( psz > psz_filename && *psz != '.' )
  606.         psz--;
  607.     if( !strncasecmp( psz, ".avi", 4 ) || !strncasecmp( psz, ".avs", 4 ) )
  608.         b_avis = 1;
  609.     if( !strncasecmp( psz, ".y4m", 4 ) )
  610.         b_y4m = 1;
  612.     if( !(b_avis || b_y4m) ) // raw yuv
  613.     {
  614.         if( optind > argc - 1 )
  615.         {
  616.             /* try to parse the file name */
  617.             for( psz = psz_filename; *psz; psz++ )
  618.             {
  619.                 if( *psz >= '0' && *psz <= '9'
  620.                     && sscanf( psz, "%ux%u", &param->i_width, &param->i_height ) == 2 )
  621.                 {
  622.                     if( param->i_log_level >= X264_LOG_INFO )
  623.                         fprintf( stderr, "x264 [info]: file name gives %dx%dn", param->i_width, param->i_height );
  624.                     break;
  625.                 }
  626.             }
  627.         }
  628.         else
  629.         {
  630.             sscanf( argv[optind++], "%ux%u", &param->i_width, &param->i_height );
  631.         }
  632.     }
  634.     if( !(b_avis || b_y4m) && ( !param->i_width || !param->i_height ) )
  635.     {
  636.         fprintf( stderr, "x264 [error]: Rawyuv input requires a resolution.n" );
  637.         return -1;
  638.     }
  640.     /* open the input */
  641.     {
  642.         if( b_avis )
  643.         {
  644. #ifdef AVIS_INPUT
  645.             p_open_infile = open_file_avis;
  646.             p_get_frame_total = get_frame_total_avis;
  647.             p_read_frame = read_frame_avis;
  648.             p_close_infile = close_file_avis;
  649. #else
  650.             fprintf( stderr, "x264 [error]: not compiled with AVIS input supportn" );
  651.             return -1;
  652. #endif
  653.         }
  654.         if ( b_y4m )
  655.         {
  656.             p_open_infile = open_file_y4m;
  657.             p_get_frame_total = get_frame_total_y4m;
  658.             p_read_frame = read_frame_y4m;
  659.             p_close_infile = close_file_y4m;
  660.         }
  662.         if( p_open_infile( psz_filename, &opt->hin, param ) )
  663.         {
  664.             fprintf( stderr, "x264 [error]: could not open input file '%s'n", psz_filename );
  665.             return -1;
  666.         }
  667.     }
  669. #ifdef HAVE_PTHREAD
  670.     if( b_thread_input || param->i_threads > 1
  671.         || (param->i_threads == 0 && x264_cpu_num_processors() > 1) )
  672.     {
  673.         if( open_file_thread( NULL, &opt->hin, param ) )
  674.         {
  675.             fprintf( stderr, "x264 [warning]: threaded input failedn" );
  676.         }
  677.         else
  678.         {
  679.             p_open_infile = open_file_thread;
  680.             p_get_frame_total = get_frame_total_thread;
  681.             p_read_frame = read_frame_thread;
  682.             p_close_infile = close_file_thread;
  683.         }
  684.     }
  685. #endif
  687.     return 0;
  688. }
  690. static void parse_qpfile( cli_opt_t *opt, x264_picture_t *pic, int i_frame )
  691. {
  692.     int num = -1, qp, ret;
  693.     char type;
  694.     uint64_t file_pos;
  695.     while( num < i_frame )
  696.     {
  697.         file_pos = ftell( opt->qpfile );
  698.         ret = fscanf( opt->qpfile, "%d %c %dn", &num, &type, &qp );
  699. if( num > i_frame || ret == EOF )
  700. {
  701. pic->i_type = X264_TYPE_AUTO;
  702. pic->i_qpplus1 = 0;
  703. fseek( opt->qpfile , file_pos , SEEK_SET );
  704. break;
  705. }
  706.         if( num < i_frame )
  707.             continue;
  708.         pic->i_qpplus1 = qp+1;
  709.         if     ( type == 'I' ) pic->i_type = X264_TYPE_IDR;
  710.         else if( type == 'i' ) pic->i_type = X264_TYPE_I;
  711.         else if( type == 'P' ) pic->i_type = X264_TYPE_P;
  712.         else if( type == 'B' ) pic->i_type = X264_TYPE_BREF;
  713.         else if( type == 'b' ) pic->i_type = X264_TYPE_B;
  714.         else ret = 0;
  715.         if( ret != 3 || qp < -1 || qp > 51 )
  716.         {
  717.             fprintf( stderr, "x264 [error]: can't parse qpfile for frame %dn", i_frame );
  718.             fclose( opt->qpfile );
  719.             opt->qpfile = NULL;
  720.             pic->i_type = X264_TYPE_AUTO;
  721.             pic->i_qpplus1 = 0;
  722.             break;
  723.         }
  724.     }
  725. }
  727. /*****************************************************************************
  728.  * Encode:
  729.  *****************************************************************************/
  731. static int  Encode_frame( x264_t *h, hnd_t hout, x264_picture_t *pic )
  732. {
  733.     x264_picture_t pic_out;
  734.     x264_nal_t *nal;
  735.     int i_nal, i;
  736.     int i_file = 0;
  738.     if( x264_encoder_encode( h, &nal, &i_nal, pic, &pic_out ) < 0 )
  739.     {
  740.         fprintf( stderr, "x264 [error]: x264_encoder_encode failedn" );
  741.     }
  743.     for( i = 0; i < i_nal; i++ )
  744.     {
  745.         int i_size;
  747.         if( mux_buffer_size < nal[i].i_payload * 3/2 + 4 )
  748.         {
  749.             mux_buffer_size = nal[i].i_payload * 2 + 4;
  750.             x264_free( mux_buffer );
  751.             mux_buffer = x264_malloc( mux_buffer_size );
  752.         }
  754.         i_size = mux_buffer_size;
  755.         x264_nal_encode( mux_buffer, &i_size, 1, &nal[i] );
  756.         i_file += p_write_nalu( hout, mux_buffer, i_size );
  757.     }
  758.     if (i_nal)
  759.         p_set_eop( hout, &pic_out );
  761.     return i_file;
  762. }
  764. static int  Encode( x264_param_t *param, cli_opt_t *opt )
  765. {
  766.     x264_t *h;
  767.     x264_picture_t pic;
  769.     int     i_frame, i_frame_total;
  770.     int64_t i_start, i_end;
  771.     int64_t i_file;
  772.     int     i_frame_size;
  773.     int     i_update_interval;
  775.     opt->b_progress &= param->i_log_level < X264_LOG_DEBUG;
  776.     i_frame_total = p_get_frame_total( opt->hin );
  777.     i_frame_total -= opt->i_seek;
  778.     if( ( i_frame_total == 0 || param->i_frame_total < i_frame_total )
  779.         && param->i_frame_total > 0 )
  780.         i_frame_total = param->i_frame_total;
  781.     param->i_frame_total = i_frame_total;
  782.     i_update_interval = i_frame_total ? x264_clip3( i_frame_total / 1000, 1, 10 ) : 10;
  784.     if( ( h = x264_encoder_open( param ) ) == NULL )
  785.     {
  786.         fprintf( stderr, "x264 [error]: x264_encoder_open failedn" );
  787.         p_close_infile( opt->hin );
  788.         return -1;
  789.     }
  791.     if( p_set_outfile_param( opt->hout, param ) )
  792.     {
  793.         fprintf( stderr, "x264 [error]: can't set outfile paramn" );
  794.         p_close_infile( opt->hin );
  795.         p_close_outfile( opt->hout );
  796.         return -1;
  797.     }
  799.     /* Create a new pic */
  800.     x264_picture_alloc( &pic, X264_CSP_I420, param->i_width, param->i_height );
  802.     i_start = x264_mdate();
  804.     /* Encode frames */
  805.     for( i_frame = 0, i_file = 0; b_ctrl_c == 0 && (i_frame < i_frame_total || i_frame_total == 0); )
  806.     {
  807.         if( p_read_frame( &pic, opt->hin, i_frame + opt->i_seek ) )
  808.             break;
  810.         pic.i_pts = (int64_t)i_frame * param->i_fps_den;
  812.         if( opt->qpfile )
  813.             parse_qpfile( opt, &pic, i_frame + opt->i_seek );
  814.         else
  815.         {
  816.             /* Do not force any parameters */
  817.             pic.i_type = X264_TYPE_AUTO;
  818.             pic.i_qpplus1 = 0;
  819.         }
  821.         i_file += Encode_frame( h, opt->hout, &pic );
  823.         i_frame++;
  825.         /* update status line (up to 1000 times per input file) */
  826.         //if( opt->b_progress && i_frame % i_update_interval == 0 )
  827. if (1)
  828.         {
  829.             int64_t i_elapsed = x264_mdate() - i_start;
  830.             double fps = i_elapsed > 0 ? i_frame * 1000000. / i_elapsed : 0;
  831.             if( i_frame_total )
  832.             {
  833.                 int eta = i_elapsed * (i_frame_total - i_frame) / ((int64_t)i_frame * 1000000);
  834.                 fprintf( stderr, "encoded frames: %d/%d (%.1f%%), %.2f fps, %.2f kb/s, eta %d:%02d:%02d  r",
  835.                          i_frame, i_frame_total, 100. * i_frame / i_frame_total, fps,
  836.                          (double) i_file * 8 * param->i_fps_num / ( (double) param->i_fps_den * i_frame * 1000 ),
  837.                          eta/3600, (eta/60)%60, eta%60 );
  838.             }
  839.             else
  840.                 fprintf( stderr, "encoded frames: %d, %.2f fps   r", i_frame, fps );
  841.             fflush( stderr ); // needed in windows
  842.         }
  843.     }
  844.     /* Flush delayed B-frames */
  845.     do {
  846.         i_file +=
  847.         i_frame_size = Encode_frame( h, opt->hout, NULL );
  848.     } while( i_frame_size );
  850.     i_end = x264_mdate();
  851.     x264_picture_clean( &pic );
  852.     /* Erase progress indicator before printing encoding stats. */
  853.     if( opt->b_progress )
  854.         fprintf( stderr, "                                                                               r" );
  855.     x264_encoder_close( h );
  856.     x264_free( mux_buffer );
  857.     fprintf( stderr, "n" );
  859.     if( b_ctrl_c )
  860.         fprintf( stderr, "aborted at input frame %dn", opt->i_seek + i_frame );
  862.     p_close_infile( opt->hin );
  863.     p_close_outfile( opt->hout );
  865.     if( i_frame > 0 )
  866.     {
  867.         double fps = (double)i_frame * (double)1000000 /
  868.                      (double)( i_end - i_start );
  870.         fprintf( stderr, "encoded %d frames, %.2f fps, %.2f kb/sn", i_frame, fps,
  871.                  (double) i_file * 8 * param->i_fps_num /
  872.                  ( (double) param->i_fps_den * i_frame * 1000 ) );
  873.     }
  875.     return 0;
  876. }