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

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

Audio

开发平台：

Visual C++

x264.c：源码内容
  1. /*****************************************************************************
  2.  * x264: h264 encoder/decoder testing program.
  3.  *****************************************************************************
  4.  * Copyright (C) 2003 Laurent Aimar
  5.  * $Id: x264.c,v 1.1 2004/06/03 19:24:12 fenrir Exp $
  6.  *
  7.  * Authors: 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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22.  *****************************************************************************/
  24. #define _LARGEFILE_SOURCE
  25. #define _FILE_OFFSET_BITS 64
  27. #include <stdlib.h>
  28. #include <stdio.h>
  29. #include <string.h>
  31. #include <math.h>
  33. #include <signal.h>
  34. #define _GNU_SOURCE
  35. #include <getopt.h>
  37. #ifdef _MSC_VER
  38. #include <io.h>     /* _setmode() */
  39. #include <fcntl.h>  /* _O_BINARY */
  40. #endif
  42. #ifndef _MSC_VER
  43. #include "config.h"
  44. #endif
  46. #ifdef AVIS_INPUT
  47. #include <windows.h>
  48. #include <vfw.h>
  49. #endif
  51. #ifdef MP4_OUTPUT
  52. #include <gpac/isomedia.h>
  53. #endif
  56. #include "common/common.h"
  57. #include "x264.h"
  59. #include "matroska.h"
  61. #define DATA_MAX 3000000
  62. uint8_t data[DATA_MAX];
  64. typedef void *hnd_t;
  66. /* Ctrl-C handler */
  67. static int     b_ctrl_c = 0;
  68. static int     b_exit_on_ctrl_c = 0;
  69. static void    SigIntHandler( int a )
  70. {
  71.     if( b_exit_on_ctrl_c )
  72.         exit(0);
  73.     b_ctrl_c = 1;
  74. }
  76. typedef struct {
  77.     int b_decompress;
  78.     int b_progress;
  79.     int i_seek;
  80.     hnd_t hin;
  81.     hnd_t hout;
  82. } cli_opt_t;
  84. /* input file operation function pointers */
  85. static int (*p_open_infile)( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param );
  86. static int (*p_get_frame_total)( hnd_t handle, int i_width, int i_height );
  87. static int (*p_read_frame)( x264_picture_t *p_pic, hnd_t handle, int i_frame, int i_width, int i_height );
  88. static int (*p_close_infile)( hnd_t handle );
  90. static int open_file_yuv( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param );
  91. static int get_frame_total_yuv( hnd_t handle, int i_width, int i_height );
  92. static int read_frame_yuv( x264_picture_t *p_pic, hnd_t handle, int i_frame, int i_width, int i_height );
  93. static int close_file_yuv( hnd_t handle );
  95. #ifdef AVIS_INPUT
  96. static int open_file_avis( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param );
  97. static int get_frame_total_avis( hnd_t handle, int i_width, int i_height );
  98. static int read_frame_avis( x264_picture_t *p_pic, hnd_t handle, int i_frame, int i_width, int i_height );
  99. static int close_file_avis( hnd_t handle );
  100. #endif
  102. /* output file operation function pointers */
  103. static int (*p_open_outfile)( char *psz_filename, hnd_t *p_handle );
  104. static int (*p_set_outfile_param)( hnd_t handle, x264_param_t *p_param );
  105. static int (*p_write_nalu)( hnd_t handle, uint8_t *p_nal, int i_size );
  106. static int (*p_set_eop)( hnd_t handle, x264_picture_t *p_picture );
  107. static int (*p_close_outfile)( hnd_t handle );
  109. static int open_file_bsf( char *psz_filename, hnd_t *p_handle );
  110. static int set_param_bsf( hnd_t handle, x264_param_t *p_param );
  111. static int write_nalu_bsf( hnd_t handle, uint8_t *p_nal, int i_size );
  112. static int set_eop_bsf( hnd_t handle,  x264_picture_t *p_picture );
  113. static int close_file_bsf( hnd_t handle );
  115. #ifdef MP4_OUTPUT
  116. static int open_file_mp4( char *psz_filename, hnd_t *p_handle );
  117. static int set_param_mp4( hnd_t handle, x264_param_t *p_param );
  118. static int write_nalu_mp4( hnd_t handle, uint8_t *p_nal, int i_size );
  119. static int set_eop_mp4( hnd_t handle, x264_picture_t *p_picture );
  120. static int close_file_mp4( hnd_t handle );
  121. #endif
  123. #if 0
  124. static int open_file_mkv( char *psz_filename, hnd_t *p_handle );
  125. static int set_param_mkv( hnd_t handle, x264_param_t *p_param );
  126. static int write_nalu_mkv( hnd_t handle, uint8_t *p_nal, int i_size );
  127. static int set_eop_mkv( hnd_t handle, x264_picture_t *p_picture );
  128. static int close_file_mkv( hnd_t handle );
  129. #endif
  131. static void Help( x264_param_t *defaults );
  132. static int  Parse( int argc, char **argv, x264_param_t *param, cli_opt_t *opt );
  133. static int  Encode( x264_param_t *param, cli_opt_t *opt );
  136. /****************************************************************************
  137.  * main:
  138.  ****************************************************************************/
  139. int main( int argc, char **argv )
  140. {
  141.     x264_param_t param;
  142.     cli_opt_t opt;
  144. #ifdef _MSC_VER
  145.     _setmode(_fileno(stdin), _O_BINARY);    /* thanks to Marcos Morais <morais at dee.ufcg.edu.br> */
  146.     _setmode(_fileno(stdout), _O_BINARY);
  147. #endif
  149.     x264_param_default( &param );
  151.     /* Parse command line */
  152.     if( Parse( argc, argv, &param, &opt ) < 0 )
  153.         return -1;
  155.     /* Control-C handler */
  156.     signal( SIGINT, SigIntHandler );
  158.     return Encode( &param, &opt );
  159. }
  161. static const char * const overscan_str[] = { "undef", "show", "crop", NULL };
  162. static const char * const vidformat_str[] = { "component", "pal", "ntsc", "secam", "mac", "undef", NULL };
  163. static const char * const fullrange_str[] = { "off", "on", NULL };
  164. static const char * const colorprim_str[] = { "", "bt709", "undef", "", "bt470m", "bt470bg", "smpte170m", "smpte240m", "film", NULL };
  165. static const char * const transfer_str[] = { "", "bt709", "undef", "", "bt470m", "bt470bg", "smpte170m", "smpte240m", "linear", "log100", "log316", NULL };
  166. static const char * const colmatrix_str[] = { "GBR", "bt709", "undef", "", "fcc", "bt470bg", "smpte170m", "smpte240m", "YCgCo", NULL };
  168. static char const *strtable_lookup( const char * const table[], int index )
  169. {
  170.     int i = 0; while( table[i] ) i++;
  171.     return ( ( index >= 0 && index < i ) ? table[ index ] : "???" );
  172. }
  174. /*****************************************************************************
  175.  * Help:
  176.  *****************************************************************************/
  177. static void Help( x264_param_t *defaults )
  178. {
  179.     fprintf( stderr,
  180.              "x264 core:%d%sn"
  181.              "Syntax: x264 [options] -o outfile infile [widthxheight]n"
  182.              "n"
  183.              "Infile can be raw YUV 4:2:0 (in which case resolution is required),n"
  184.              "  or AVI or Avisynth if compiled with AVIS support (%s).n"
  185.              "Outfile type is selected by filename:n"
  186.              " .264 -> Raw bytestreamn"
  187.              " .mkv -> Matroskan"
  188.              " .mp4 -> MP4 if compiled with GPAC support (%s)n"
  189.              "n"
  190.              "Options:n"
  191.              "n"
  192.              "  -h, --help                  Print this helpn"
  193.              "n"
  194.              "Frame-type options:n"
  195.              "n"
  196.              "  -I, --keyint <integer>      Maximum GOP size [%d]n"
  197.              "  -i, --min-keyint <integer>  Minimum GOP size [%d]n"
  198.              "      --scenecut <integer>    How aggressively to insert extra I-frames [%d]n"
  199.              "  -b, --bframes <integer>     Number of B-frames between I and P [%d]n"
  200.              "      --no-b-adapt            Disable adaptive B-frame decisionn"
  201.              "      --b-bias <integer>      Influences how often B-frames are used [%d]n"
  202.              "      --b-pyramid             Keep some B-frames as referencesn"
  203.              "n"
  204.              "      --no-cabac              Disable CABACn"
  205.              "  -r, --ref <integer>         Number of reference frames [%d]n"
  206.              "      --nf                    Disable loop filtern"
  207.              "  -f, --filter <alpha:beta>   Loop filter AlphaC0 and Beta parameters [%d:%d]n"
  208.              "n"
  209.              "Ratecontrol:n"
  210.              "n"
  211.              "  -q, --qp <integer>          Set QP (0=lossless) [%d]n"
  212.              "  -B, --bitrate <integer>     Set bitraten"
  213.              "      --crf <integer>         Quality-based VBR (nominal QP)n"
  214.              "      --qpmin <integer>       Set min QP [%d]n"
  215.              "      --qpmax <integer>       Set max QP [%d]n"
  216.              "      --qpstep <integer>      Set max QP step [%d]n"
  217.              "      --ratetol <float>       Allowed variance of average bitrate [%.1f]n"
  218.              "      --vbv-maxrate <integer> Max local bitrate [%d]n"
  219.              "      --vbv-bufsize <integer> Size of VBV buffer [%d]n"
  220.              "      --vbv-init <float>      Initial VBV buffer occupancy [%.1f]n"
  221.              "n"
  222.              "      --ipratio <float>       QP factor between I and P [%.2f]n"
  223.              "      --pbratio <float>       QP factor between P and B [%.2f]n"
  224.              "      --chroma-qp-offset <integer>  QP difference between chroma and luma [%d]n"
  225.              "n"
  226.              "  -p, --pass <1|2|3>          Enable multipass ratecontrol:n"
  227.              "                                  - 1: First pass, creates stats filen"
  228.              "                                  - 2: Last pass, does not overwrite stats filen"
  229.              "                                  - 3: Nth pass, overwrites stats filen"
  230.              "      --stats <string>        Filename for 2 pass stats ["%s"]n"
  231.              "      --rceq <string>         Ratecontrol equation ["%s"]n"
  232.              "      --qcomp <float>         QP curve compression: 0.0 => CBR, 1.0 => CQP [%.2f]n"
  233.              "      --cplxblur <float>      Reduce fluctuations in QP (before curve compression) [%.1f]n"
  234.              "      --qblur <float>         Reduce fluctuations in QP (after curve compression) [%.1f]n"
  235.              "n"
  236.              "      --zones <zone0>/<zone1>/...n"
  237.              "                              Tweak the bitrate of some regions of the videon"
  238.              "                              Each zone is of the formn"
  239.              "                                  <start frame>,<end frame>,<option>n"
  240.              "                                  where <option> is eithern"
  241.              "                                      q=<integer> (force QP)n"
  242.              "                                  or  b=<float> (bitrate multiplier)n"
  243.              "n"
  244.              "Analysis:n"
  245.              "n"
  246.              "  -A, --analyse <string>      Partitions to consider ["p8x8,b8x8,i8x8,i4x4"]n"
  247.              "                                  - p8x8, p4x4, b8x8, i8x8, i4x4n"
  248.              "                                  - none, alln"
  249.              "                                  (p4x4 requires p8x8. i8x8 requires --8x8dct.)n"
  250.              "      --direct <string>       Direct MV prediction mode ["%s"]n"
  251.              "                                  - none, spatial, temporal, auton"
  252.              "  -w, --weightb               Weighted prediction for B-framesn"
  253.              "      --me <string>           Integer pixel motion estimation method ["%s"]n"
  254.              "                                  - dia: diamond search, radius 1 (fast)n"
  255.              "                                  - hex: hexagonal search, radius 2n"
  256.              "                                  - umh: uneven multi-hexagon searchn"
  257.              "                                  - esa: exhaustive search (slow)n"
  258.              "      --merange <integer>     Maximum motion vector search range [%d]n"
  259.              "  -m, --subme <integer>       Subpixel motion estimation and partitionn"
  260.              "                                  decision quality: 1=fast, 6=best. [%d]n"
  261.              "      --b-rdo                 RD based mode decision for B-frames. Requires subme 6.n"
  262.              "      --mixed-refs            Decide references on a per partition basisn"
  263.              "      --no-chroma-me          Ignore chroma in motion estimationn"
  264.              "      --bime                  Jointly optimize both MVs in B-framesn"
  265.              "  -8, --8x8dct                Adaptive spatial transform sizen"
  266.              "  -t, --trellis <integer>     Trellis RD quantization. Requires CABAC. [%d]n"
  267.              "                                  - 0: disabledn"
  268.              "                                  - 1: enabled only on the final encode of a MBn"
  269.              "                                  - 2: enabled on all mode decisionsn"
  270.              "      --no-fast-pskip         Disables early SKIP detection on P-framesn"
  271.              "      --nr <integer>          Noise reduction [%d]n"
  272.              "n"
  273.              "      --cqm <string>          Preset quant matrices ["flat"]n"
  274.              "                                  - jvt, flatn"
  275.              "      --cqmfile <string>      Read quant matrices from a JM-compatible filen"
  276.              "                                  Overrides any other --cqm* options.n"
  277.              "      --cqm4 <list>           Set all 4x4 quant matricesn"
  278.              "                                  Takes a comma-separated list of 16 integers.n"
  279.              "      --cqm8 <list>           Set all 8x8 quant matricesn"
  280.              "                                  Takes a comma-separated list of 64 integers.n"
  281.              "      --cqm4i, --cqm4p, --cqm8i, --cqm8pn"
  282.              "                              Set both luma and chroma quant matricesn"
  283.              "      --cqm4iy, --cqm4ic, --cqm4py, --cqm4pcn"
  284.              "                              Set individual quant matricesn"
  285.              "n"
  286.              "Video Usability Info (Annex E):n"
  287.              "The VUI settings are not used by the encoder but are merely suggestions ton"
  288.              "the playback equipment. See doc/vui.txt for details. Use at your own risk.n"
  289.              "n"
  290.              "      --sar width:height      Specify Sample Aspect Ration"
  291.              "      --overscan <string>     Specify crop overscan setting ["%s"]n"
  292.              "                                  - undef, show, cropn"
  293.              "      --videoformat <string>  Specify video format ["%s"]n"
  294.              "                                  - component, pal, ntsc, secam, mac, undefn"
  295.              "      --fullrange <string>    Specify full range samples setting ["%s"]n"
  296.              "                                  - off, onn"
  297.              "      --colorprim <string>    Specify color primaries ["%s"]n"
  298.              "                                  - undef, bt709, bt470m, bt470bgn"
  299.              "                                    smpte170m, smpte240m, filmn"
  300.              "      --transfer <string>     Specify transfer characteristics ["%s"]n"
  301.              "                                  - undef, bt709, bt470m, bt470bg, linear,n"
  302.              "                                    log100, log316, smpte170m, smpte240mn"
  303.              "      --colormatrix <string>  Specify color matrix setting ["%s"]n"
  304.              "                                  - undef, bt709, fcc, bt470bgn"
  305.              "                                    smpte170m, smpte240m, GBR, YCgCon"
  306.              "      --chromaloc <integer>   Specify chroma sample location (0 to 5) [%d]n"
  307.              "n"
  308.              "Input/Output:n"
  309.              "n"
  310.              "      --level <string>        Specify level (as defined by Annex A)n"
  311.              "      --fps <float|rational>  Specify frameraten"
  312.              "      --seek <integer>        First frame to encoden"
  313.              "      --frames <integer>      Maximum number of frames to encoden"
  314.              "  -o, --output                Specify output filen"
  315.              "n"
  316.              "      --threads <integer>     Parallel encoding (uses slices)n"
  317.              "      --no-asm                Disable all CPU optimizationsn"
  318.              "      --no-psnr               Disable PSNR computationn"
  319.              "      --quiet                 Quiet Moden"
  320.              "  -v, --verbose               Print stats for each framen"
  321.              "      --progress              Show a progress indicator while encodingn"
  322.              "      --visualize             Show MB types overlayed on the encoded videon"
  323.              "      --aud                   Use access unit delimitersn"
  324.              "n",
  325.             X264_BUILD, X264_VERSION,
  326. #ifdef AVIS_INPUT
  327.             "yes",
  328. #else
  329.             "no",
  330. #endif
  331. #ifdef MP4_OUTPUT
  332.             "yes",
  333. #else
  334.             "no",
  335. #endif
  336.             defaults->i_keyint_max,
  337.             defaults->i_keyint_min,
  338.             defaults->i_scenecut_threshold,
  339.             defaults->i_bframe,
  340.             defaults->i_bframe_bias,
  341.             defaults->i_frame_reference,
  342.             defaults->i_deblocking_filter_alphac0,
  343.             defaults->i_deblocking_filter_beta,
  344.             defaults->rc.i_qp_constant,
  345.             defaults->rc.i_qp_min,
  346.             defaults->rc.i_qp_max,
  347.             defaults->rc.i_qp_step,
  348.             defaults->rc.f_rate_tolerance,
  349.             defaults->rc.i_vbv_max_bitrate,
  350.             defaults->rc.i_vbv_buffer_size,
  351.             defaults->rc.f_vbv_buffer_init,
  352.             defaults->rc.f_ip_factor,
  353.             defaults->rc.f_pb_factor,
  354.             defaults->analyse.i_chroma_qp_offset,
  355.             defaults->rc.psz_stat_out,
  356.             defaults->rc.psz_rc_eq,
  357.             defaults->rc.f_qcompress,
  358.             defaults->rc.f_complexity_blur,
  359.             defaults->rc.f_qblur,
  360.             strtable_lookup( x264_direct_pred_names, defaults->analyse.i_direct_mv_pred ),
  361.             strtable_lookup( x264_motion_est_names, defaults->analyse.i_me_method ),
  362.             defaults->analyse.i_me_range,
  363.             defaults->analyse.i_subpel_refine,
  364.             defaults->analyse.i_trellis,
  365.             defaults->analyse.i_noise_reduction,
  366.             strtable_lookup( overscan_str, defaults->vui.i_overscan ),
  367.             strtable_lookup( vidformat_str, defaults->vui.i_vidformat ),
  368.             strtable_lookup( fullrange_str, defaults->vui.b_fullrange ),
  369.             strtable_lookup( colorprim_str, defaults->vui.i_colorprim ),
  370.             strtable_lookup( transfer_str, defaults->vui.i_transfer ),
  371.             strtable_lookup( colmatrix_str, defaults->vui.i_colmatrix ),
  372.             defaults->vui.i_chroma_loc
  373.            );
  374. }
  376. static int parse_enum( const char *arg, const char * const *names, int *dst )
  377. {
  378.     int i;
  379.     for( i = 0; names[i]; i++ )
  380.         if( !strcmp( arg, names[i] ) )
  381.         {
  382.             *dst = i;
  383.             return 0;
  384.         }
  385.     return -1;
  386. }
  388. static int parse_cqm( const char *str, uint8_t *cqm, int length )
  389. {
  390.     int i = 0;
  391.     do {
  392.         int coef;
  393.         if( !sscanf( str, "%d", &coef ) || coef < 1 || coef > 255 )
  394.             return -1;
  395.         cqm[i++] = coef;
  396.     } while( i < length && (str = strchr( str, ',' )) && str++ );
  397.     return (i == length) ? 0 : -1;
  398. }
  400. /*****************************************************************************
  401.  * Parse:
  402.  *****************************************************************************/
  403. static int  Parse( int argc, char **argv,
  404.                    x264_param_t *param, cli_opt_t *opt )
  405. {
  406.     char *psz_filename = NULL;
  407.     x264_param_t defaults = *param;
  408.     char *psz;
  409.     char b_avis = 0;
  411.     memset( opt, 0, sizeof(cli_opt_t) );
  413.     /* Default input file driver */
  414.     p_open_infile = open_file_yuv;
  415.     p_get_frame_total = get_frame_total_yuv;
  416.     p_read_frame = read_frame_yuv;
  417.     p_close_infile = close_file_yuv;
  419.     /* Default output file driver */
  420.     p_open_outfile = open_file_bsf;
  421.     p_set_outfile_param = set_param_bsf;
  422.     p_write_nalu = write_nalu_bsf;
  423.     p_set_eop = set_eop_bsf;
  424.     p_close_outfile = close_file_bsf;
  426.     /* Parse command line options */
  427.     opterr = 0; // no error message
  429.     for( ;; )
  430.     {
  431.         int b_error = 0;
  432.         int long_options_index;
  433. #define OPT_QPMIN 256
  434. #define OPT_QPMAX 257
  435. #define OPT_QPSTEP 258
  436. #define OPT_IPRATIO 260
  437. #define OPT_PBRATIO 261
  438. #define OPT_RATETOL 262
  439. #define OPT_RCSTATS 264
  440. #define OPT_RCEQ 265
  441. #define OPT_QCOMP 266
  442. #define OPT_NOPSNR 267
  443. #define OPT_QUIET 268
  444. #define OPT_SCENECUT 270
  445. #define OPT_QBLUR 271
  446. #define OPT_CPLXBLUR 272
  447. #define OPT_FRAMES 273
  448. #define OPT_FPS 274
  449. #define OPT_DIRECT 275
  450. #define OPT_LEVEL 276
  451. #define OPT_NOBADAPT 277
  452. #define OPT_BBIAS 278
  453. #define OPT_BPYRAMID 279
  454. #define OPT_CHROMA_QP 280
  455. #define OPT_NO_CHROMA_ME 281
  456. #define OPT_NO_CABAC 282
  457. #define OPT_AUD 283
  458. #define OPT_PROGRESS 284
  459. #define OPT_ME 285
  460. #define OPT_MERANGE 286
  461. #define OPT_VBVMAXRATE 287
  462. #define OPT_VBVBUFSIZE 288
  463. #define OPT_VBVINIT 289
  464. #define OPT_VISUALIZE 290
  465. #define OPT_SEEK 291
  466. #define OPT_ZONES 292
  467. #define OPT_THREADS 293
  468. #define OPT_CQM 294
  469. #define OPT_CQM4 295
  470. #define OPT_CQM4I 296
  471. #define OPT_CQM4IY 297
  472. #define OPT_CQM4IC 298
  473. #define OPT_CQM4P 299
  474. #define OPT_CQM4PY 300
  475. #define OPT_CQM4PC 301
  476. #define OPT_CQM8 302
  477. #define OPT_CQM8I 303
  478. #define OPT_CQM8P 304
  479. #define OPT_CQMFILE 305
  480. #define OPT_SAR 306
  481. #define OPT_OVERSCAN 307
  482. #define OPT_VIDFORMAT 308
  483. #define OPT_FULLRANGE 309
  484. #define OPT_COLOURPRIM 310
  485. #define OPT_TRANSFER 311
  486. #define OPT_COLOURMATRIX 312
  487. #define OPT_CHROMALOC 313
  488. #define OPT_MIXED_REFS 314
  489. #define OPT_CRF 315
  490. #define OPT_B_RDO 316
  491. #define OPT_NO_FAST_PSKIP 317
  492. #define OPT_BIME 318
  493. #define OPT_NR 319
  495.         static struct option long_options[] =
  496.         {
  497.             { "help",    no_argument,       NULL, 'h' },
  498.             { "bitrate", required_argument, NULL, 'B' },
  499.             { "bframes", required_argument, NULL, 'b' },
  500.             { "no-b-adapt", no_argument,    NULL, OPT_NOBADAPT },
  501.             { "b-bias",  required_argument, NULL, OPT_BBIAS },
  502.             { "b-pyramid", no_argument,     NULL, OPT_BPYRAMID },
  503.             { "min-keyint",required_argument,NULL,'i' },
  504.             { "keyint",  required_argument, NULL, 'I' },
  505.             { "scenecut",required_argument, NULL, OPT_SCENECUT },
  506.             { "nf",      no_argument,       NULL, 'n' },
  507.             { "filter",  required_argument, NULL, 'f' },
  508.             { "no-cabac",no_argument,       NULL, OPT_NO_CABAC },
  509.             { "qp",      required_argument, NULL, 'q' },
  510.             { "qpmin",   required_argument, NULL, OPT_QPMIN },
  511.             { "qpmax",   required_argument, NULL, OPT_QPMAX },
  512.             { "qpstep",  required_argument, NULL, OPT_QPSTEP },
  513.             { "crf",     required_argument, NULL, OPT_CRF },
  514.             { "ref",     required_argument, NULL, 'r' },
  515.             { "no-asm",  no_argument,       NULL, 'C' },
  516.             { "sar",     required_argument, NULL, OPT_SAR },
  517.             { "fps",     required_argument, NULL, OPT_FPS },
  518.             { "frames",  required_argument, NULL, OPT_FRAMES },
  519.             { "seek",    required_argument, NULL, OPT_SEEK },
  520.             { "output",  required_argument, NULL, 'o' },
  521.             { "analyse", required_argument, NULL, 'A' },
  522.             { "direct",  required_argument, NULL, OPT_DIRECT },
  523.             { "weightb", no_argument,       NULL, 'w' },
  524.             { "me",      required_argument, NULL, OPT_ME },
  525.             { "merange", required_argument, NULL, OPT_MERANGE },
  526.             { "subme",   required_argument, NULL, 'm' },
  527.             { "b-rdo",   no_argument,       NULL, OPT_B_RDO },
  528.             { "mixed-refs", no_argument,    NULL, OPT_MIXED_REFS },
  529.             { "no-chroma-me", no_argument,  NULL, OPT_NO_CHROMA_ME },
  530.             { "bime",    no_argument,       NULL, OPT_BIME },
  531.             { "8x8dct",  no_argument,       NULL, '8' },
  532.             { "trellis", required_argument, NULL, 't' },
  533.             { "no-fast-pskip", no_argument, NULL, OPT_NO_FAST_PSKIP },
  534.             { "level",   required_argument, NULL, OPT_LEVEL },
  535.             { "ratetol", required_argument, NULL, OPT_RATETOL },
  536.             { "vbv-maxrate", required_argument, NULL, OPT_VBVMAXRATE },
  537.             { "vbv-bufsize", required_argument, NULL, OPT_VBVBUFSIZE },
  538.             { "vbv-init", required_argument,NULL,  OPT_VBVINIT },
  539.             { "ipratio", required_argument, NULL, OPT_IPRATIO },
  540.             { "pbratio", required_argument, NULL, OPT_PBRATIO },
  541.             { "chroma-qp-offset", required_argument, NULL, OPT_CHROMA_QP },
  542.             { "pass",    required_argument, NULL, 'p' },
  543.             { "stats",   required_argument, NULL, OPT_RCSTATS },
  544.             { "rceq",    required_argument, NULL, OPT_RCEQ },
  545.             { "qcomp",   required_argument, NULL, OPT_QCOMP },
  546.             { "qblur",   required_argument, NULL, OPT_QBLUR },
  547.             { "cplxblur",required_argument, NULL, OPT_CPLXBLUR },
  548.             { "zones",   required_argument, NULL, OPT_ZONES },
  549.             { "threads", required_argument, NULL, OPT_THREADS },
  550.             { "no-psnr", no_argument,       NULL, OPT_NOPSNR },
  551.             { "quiet",   no_argument,       NULL, OPT_QUIET },
  552.             { "verbose", no_argument,       NULL, 'v' },
  553.             { "progress",no_argument,       NULL, OPT_PROGRESS },
  554.             { "visualize",no_argument,      NULL, OPT_VISUALIZE },
  555.             { "aud",     no_argument,       NULL, OPT_AUD },
  556.             { "nr",      required_argument, NULL, OPT_NR },
  557.             { "cqm",     required_argument, NULL, OPT_CQM },
  558.             { "cqmfile", required_argument, NULL, OPT_CQMFILE },
  559.             { "cqm4",    required_argument, NULL, OPT_CQM4 },
  560.             { "cqm4i",   required_argument, NULL, OPT_CQM4I },
  561.             { "cqm4iy",  required_argument, NULL, OPT_CQM4IY },
  562.             { "cqm4ic",  required_argument, NULL, OPT_CQM4IC },
  563.             { "cqm4p",   required_argument, NULL, OPT_CQM4P },
  564.             { "cqm4py",  required_argument, NULL, OPT_CQM4PY },
  565.             { "cqm4pc",  required_argument, NULL, OPT_CQM4PC },
  566.             { "cqm8",    required_argument, NULL, OPT_CQM8 },
  567.             { "cqm8i",   required_argument, NULL, OPT_CQM8I },
  568.             { "cqm8p",   required_argument, NULL, OPT_CQM8P },
  569.             { "overscan", required_argument, NULL, OPT_OVERSCAN },
  570.             { "videoformat", required_argument, NULL, OPT_VIDFORMAT },
  571.             { "fullrange", required_argument, NULL, OPT_FULLRANGE },
  572.             { "colorprim", required_argument, NULL, OPT_COLOURPRIM },
  573.             { "transfer", required_argument, NULL, OPT_TRANSFER },
  574.             { "colormatrix", required_argument, NULL, OPT_COLOURMATRIX },
  575.             { "chromaloc", required_argument, NULL, OPT_CHROMALOC },
  576.             {0, 0, 0, 0}
  577.         };
  579.         int c;
  581.         c = getopt_long( argc, argv, "hi:I:b:r:cxB:q:f:o:A:m:p:t:vw8",
  582.                          long_options, &long_options_index);
  584.         if( c == -1 )
  585.         {
  586.             break;
  587.         }
  589.         switch( c )
  590.         {
  591.             case 'h':
  592.                 Help( &defaults );
  593.                 return -1;
  595.             case 0:
  596.                 break;
  597.             case 'B':
  598.                 param->rc.i_bitrate = atol( optarg );
  599.                 param->rc.b_cbr = 1;
  600.                 break;
  601.             case OPT_CRF:
  602.                 param->rc.i_rf_constant = atol( optarg );
  603.                 break;
  604.             case 'b':
  605.                 param->i_bframe = atol( optarg );
  606.                 break;
  607.             case OPT_NOBADAPT:
  608.                 param->b_bframe_adaptive = 0;
  609.                 break;
  610.             case OPT_BBIAS:
  611.                 param->i_bframe_bias = atol( optarg );
  612.                 break;
  613.             case OPT_BPYRAMID:
  614.                 param->b_bframe_pyramid = 1;
  615.                 break;
  616.             case 'i':
  617.                 param->i_keyint_min = atol( optarg );
  618.                 if( param->i_keyint_max < param->i_keyint_min )
  619.                     param->i_keyint_max = param->i_keyint_min;
  620.                 break;
  621.             case 'I':
  622.                 param->i_keyint_max = atol( optarg );
  623.                 if( param->i_keyint_min > param->i_keyint_max )
  624.                     param->i_keyint_min = param->i_keyint_max;
  625.                 break;
  626.             case OPT_SCENECUT:
  627.                 param->i_scenecut_threshold = atol( optarg );
  628.                 break;
  629.             case 'n':
  630.                 param->b_deblocking_filter = 0;
  631.                 break;
  632.             case 'f':
  633.             {
  634.                 char *p = strchr( optarg, ':' );
  635.                 if( !p ) p = strchr( optarg, ',' );
  636.                 param->i_deblocking_filter_alphac0 = atoi( optarg );
  637.                 param->i_deblocking_filter_beta = p ? atoi( p+1 ) : param->i_deblocking_filter_alphac0;
  638.                 break;
  639.             }
  640.             case 'q':
  641.                 param->rc.i_qp_constant = atoi( optarg );
  642.                 break;
  643.             case OPT_QPMIN:
  644.                 param->rc.i_qp_min = atoi( optarg );
  645.                 break;
  646.             case OPT_QPMAX:
  647.                 param->rc.i_qp_max = atoi( optarg );
  648.                 break;
  649.             case OPT_QPSTEP:
  650.                 param->rc.i_qp_step = atoi( optarg );
  651.                 break;
  652.             case 'r':
  653.                 param->i_frame_reference = atoi( optarg );
  654.                 break;
  655.             case OPT_NO_CABAC:
  656.                 param->b_cabac = 0;
  657.                 break;
  658.             case 'x':
  659.                 opt->b_decompress = 1;
  660.                 break;
  661.             case 'C':
  662.                 param->cpu = 0;
  663.                 break;
  664.             case OPT_FRAMES:
  665.                 param->i_frame_total = atoi( optarg );
  666.                 break;
  667.             case OPT_SEEK:
  668.                 opt->i_seek = atoi( optarg );
  669.                 break;
  670.             case 'o':
  671.                 if( !strncasecmp(optarg + strlen(optarg) - 4, ".mp4", 4) )
  672.                 {
  673. #ifdef MP4_OUTPUT
  674.                     p_open_outfile = open_file_mp4;
  675.                     p_write_nalu = write_nalu_mp4;
  676.                     p_set_outfile_param = set_param_mp4;
  677.                     p_set_eop = set_eop_mp4;
  678.                     p_close_outfile = close_file_mp4;
  679. #else
  680.                     fprintf( stderr, "not compiled with MP4 output supportn" );
  681.                     return -1;
  682. #endif
  683.                 }
  684. #if 0
  685.                 else if( !strncasecmp(optarg + strlen(optarg) - 4, ".mkv", 4) )
  686.                 {
  687.                     p_open_outfile = open_file_mkv;
  688.                     p_write_nalu = write_nalu_mkv;
  689.                     p_set_outfile_param = set_param_mkv;
  690.                     p_set_eop = set_eop_mkv;
  691.                     p_close_outfile = close_file_mkv;
  692.                 }
  693. #endif
  694.                 if( !strcmp(optarg, "-") )
  695.                     opt->hout = stdout;
  696.                 else if( p_open_outfile( optarg, &opt->hout ) )
  697.                 {
  698.                     fprintf( stderr, "cannot open output file `%s'n", optarg );
  699.                     return -1;
  700.                 }
  701.                 break;
  702.             case OPT_SAR:
  703.             {
  704.                 char *p = strchr( optarg, ':' );
  705.                 if( !p ) p = strchr( optarg, '/' );
  706.                 if( p )
  707.                 {
  708.                     param->vui.i_sar_width = atoi( optarg );
  709.                     param->vui.i_sar_height = atoi( p + 1 );
  710.                 }
  711.                 break;
  712.             }
  713.             case OPT_FPS:
  714.             {
  715.                 float fps;
  716.                 if( sscanf( optarg, "%d/%d", &param->i_fps_num, &param->i_fps_den ) == 2 )
  717.                     ;
  718.                 else if( sscanf( optarg, "%f", &fps ) )
  719.                 {
  720.                     param->i_fps_num = (int)(fps * 1000 + .5);
  721.                     param->i_fps_den = 1000;
  722.                 }
  723.                 else
  724.                 {
  725.                     fprintf( stderr, "bad fps `%s'n", optarg );
  726.                     return -1;
  727.                 }
  728.                 break;
  729.             }
  730.             case 'A':
  731.                 param->analyse.inter = 0;
  732.                 if( strstr( optarg, "none" ) )  param->analyse.inter =  0;
  733.                 if( strstr( optarg, "all" ) )   param->analyse.inter = ~0;
  735.                 if( strstr( optarg, "i4x4" ) )  param->analyse.inter |= X264_ANALYSE_I4x4;
  736.                 if( strstr( optarg, "i8x8" ) )  param->analyse.inter |= X264_ANALYSE_I8x8;
  737.                 if( strstr( optarg, "p8x8" ) )  param->analyse.inter |= X264_ANALYSE_PSUB16x16;
  738.                 if( strstr( optarg, "p4x4" ) )  param->analyse.inter |= X264_ANALYSE_PSUB8x8;
  739.                 if( strstr( optarg, "b8x8" ) )  param->analyse.inter |= X264_ANALYSE_BSUB16x16;
  740.                 break;
  741.             case OPT_DIRECT:
  742.                 b_error |= parse_enum( optarg, x264_direct_pred_names, &param->analyse.i_direct_mv_pred );
  743.                 break;
  744.             case 'w':
  745.                 param->analyse.b_weighted_bipred = 1;
  746.                 break;
  747.             case OPT_ME:
  748.                 b_error |= parse_enum( optarg, x264_motion_est_names, &param->analyse.i_me_method );
  749.                 break;
  750.             case OPT_MERANGE:
  751.                 param->analyse.i_me_range = atoi(optarg);
  752.                 break;
  753.             case 'm':
  754.                 param->analyse.i_subpel_refine = atoi(optarg);
  755.                 break;
  756.             case OPT_B_RDO:
  757.                 param->analyse.b_bframe_rdo = 1;
  758.                 break;
  759.             case OPT_MIXED_REFS:
  760.                 param->analyse.b_mixed_references = 1;
  761.                 break;
  762.             case OPT_NO_CHROMA_ME:
  763.                 param->analyse.b_chroma_me = 0;
  764.                 break;
  765.             case OPT_BIME:
  766.                 param->analyse.b_bidir_me = 1;
  767.                 break;
  768.             case '8':
  769.                 param->analyse.b_transform_8x8 = 1;
  770.                 break;
  771.             case 't':
  772.                 param->analyse.i_trellis = atoi(optarg);
  773.                 break;
  774.             case OPT_NO_FAST_PSKIP:
  775.                 param->analyse.b_fast_pskip = 0;
  776.                 break;
  777.             case OPT_LEVEL:
  778.                 if( atof(optarg) < 6 )
  779.                     param->i_level_idc = (int)(10*atof(optarg)+.5);
  780.                 else
  781.                     param->i_level_idc = atoi(optarg);
  782.                 break;
  783.             case OPT_RATETOL:
  784.                 param->rc.f_rate_tolerance = !strncmp("inf", optarg, 3) ? 1e9 : atof(optarg);
  785.                 break;
  786.             case OPT_VBVMAXRATE:
  787.                 param->rc.i_vbv_max_bitrate = atoi( optarg );
  788.                 break;
  789.             case OPT_VBVBUFSIZE:
  790.                 param->rc.i_vbv_buffer_size = atoi( optarg );
  791.                 break;
  792.             case OPT_VBVINIT:
  793.                 param->rc.f_vbv_buffer_init = atof(optarg);
  794.                 break;
  795.             case OPT_IPRATIO:
  796.                 param->rc.f_ip_factor = atof(optarg);
  797.                 break;
  798.             case OPT_PBRATIO:
  799.                 param->rc.f_pb_factor = atof(optarg);
  800.                 break;
  801.             case OPT_CHROMA_QP:
  802.                 param->analyse.i_chroma_qp_offset = atoi(optarg);
  803.                 break;
  804.             case 'p':
  805.             {
  806.                 int i_pass = atoi(optarg);
  807.                 if( i_pass == 1 )
  808.                     param->rc.b_stat_write = 1;
  809.                 else if( i_pass == 2 )
  810.                     param->rc.b_stat_read = 1;
  811.                 else if( i_pass > 2 )
  812.                     param->rc.b_stat_read =
  813.                     param->rc.b_stat_write = 1;
  814.                 break;
  815.             }
  816.             case OPT_RCSTATS:
  817.                 param->rc.psz_stat_in = optarg;
  818.                 param->rc.psz_stat_out = optarg;
  819.                 break;
  820.             case OPT_RCEQ:
  821.                 param->rc.psz_rc_eq = optarg;
  822.                break;
  823.             case OPT_QCOMP:
  824.                 param->rc.f_qcompress = atof(optarg);
  825.                 break;
  826.             case OPT_QBLUR:
  827.                 param->rc.f_qblur = atof(optarg);
  828.                 break;
  829.             case OPT_CPLXBLUR:
  830.                 param->rc.f_complexity_blur = atof(optarg);
  831.                 break;
  832.             case OPT_ZONES:
  833.                 param->rc.psz_zones = optarg;
  834.                 break;
  835.             case OPT_THREADS:
  836.                 param->i_threads = atoi(optarg);
  837.                 break;
  838.             case OPT_NOPSNR:
  839.                 param->analyse.b_psnr = 0;
  840.                 break;
  841.             case OPT_QUIET:
  842.                 param->i_log_level = X264_LOG_NONE;
  843.                 break;
  844.             case 'v':
  845.                 param->i_log_level = X264_LOG_DEBUG;
  846.                 break;
  847.             case OPT_AUD:
  848.                 param->b_aud = 1;
  849.                 break;
  850.             case OPT_PROGRESS:
  851.                 opt->b_progress = 1;
  852.                 break;
  853.             case OPT_VISUALIZE:
  854. #ifdef VISUALIZE
  855.                 param->b_visualize = 1;
  856.                 b_exit_on_ctrl_c = 1;
  857. #else
  858.                 fprintf( stderr, "not compiled with visualization supportn" );
  859. #endif
  860.                 break;
  861.             case OPT_NR:
  862.                 param->analyse.i_noise_reduction = atoi(optarg);
  863.                 break;
  864.             case OPT_CQM:
  865.                 if( strstr( optarg, "flat" ) )
  866.                     param->i_cqm_preset = X264_CQM_FLAT;
  867.                 else if( strstr( optarg, "jvt" ) )
  868.                     param->i_cqm_preset = X264_CQM_JVT;
  869.                 else
  870.                 {
  871.                     fprintf( stderr, "bad CQM preset `%s'n", optarg );
  872.                     return -1;
  873.                 }
  874.                 break;
  875.             case OPT_CQMFILE:
  876.                 param->psz_cqm_file = optarg;
  877.                 break;
  878.             case OPT_CQM4:
  879.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  880.                 b_error |= parse_cqm( optarg, param->cqm_4iy, 16 );
  881.                 b_error |= parse_cqm( optarg, param->cqm_4ic, 16 );
  882.                 b_error |= parse_cqm( optarg, param->cqm_4py, 16 );
  883.                 b_error |= parse_cqm( optarg, param->cqm_4pc, 16 );
  884.                 break;
  885.             case OPT_CQM8:
  886.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  887.                 b_error |= parse_cqm( optarg, param->cqm_8iy, 64 );
  888.                 b_error |= parse_cqm( optarg, param->cqm_8py, 64 );
  889.                 break;
  890.             case OPT_CQM4I:
  891.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  892.                 b_error |= parse_cqm( optarg, param->cqm_4iy, 16 );
  893.                 b_error |= parse_cqm( optarg, param->cqm_4ic, 16 );
  894.                 break;
  895.             case OPT_CQM4P:
  896.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  897.                 b_error |= parse_cqm( optarg, param->cqm_4py, 16 );
  898.                 b_error |= parse_cqm( optarg, param->cqm_4pc, 16 );
  899.                 break;
  900.             case OPT_CQM4IY:
  901.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  902.                 b_error |= parse_cqm( optarg, param->cqm_4iy, 16 );
  903.                 break;
  904.             case OPT_CQM4IC:
  905.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  906.                 b_error |= parse_cqm( optarg, param->cqm_4ic, 16 );
  907.                 break;
  908.             case OPT_CQM4PY:
  909.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  910.                 b_error |= parse_cqm( optarg, param->cqm_4py, 16 );
  911.                 break;
  912.             case OPT_CQM4PC:
  913.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  914.                 b_error |= parse_cqm( optarg, param->cqm_4pc, 16 );
  915.                 break;
  916.             case OPT_CQM8I:
  917.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  918.                 b_error |= parse_cqm( optarg, param->cqm_8iy, 64 );
  919.                 break;
  920.             case OPT_CQM8P:
  921.                 param->i_cqm_preset = X264_CQM_CUSTOM;
  922.                 b_error |= parse_cqm( optarg, param->cqm_8py, 64 );
  923.                 break;
  924.             case OPT_OVERSCAN:
  925.                 b_error |= parse_enum( optarg, overscan_str, &param->vui.i_overscan );
  926.                 break;
  927.             case OPT_VIDFORMAT:
  928.                 b_error |= parse_enum( optarg, vidformat_str, &param->vui.i_vidformat );
  929.                 break;
  930.             case OPT_FULLRANGE:
  931.                 b_error |= parse_enum( optarg, fullrange_str, &param->vui.b_fullrange );
  932.                 break;
  933.             case OPT_COLOURPRIM:
  934.                 b_error |= parse_enum( optarg, colorprim_str, &param->vui.i_colorprim );
  935.                 break;
  936.             case OPT_TRANSFER:
  937.                 b_error |= parse_enum( optarg, transfer_str, &param->vui.i_transfer );
  938.                 break;
  939.             case OPT_COLOURMATRIX:
  940.                 b_error |= parse_enum( optarg, colmatrix_str, &param->vui.i_colmatrix );
  941.                 break;
  942.             case OPT_CHROMALOC:
  943.                 param->vui.i_chroma_loc = atoi( optarg );
  944.                 b_error = ( param->vui.i_chroma_loc < 0 || param->vui.i_chroma_loc > 5 );
  945.                 break;
  946.             default:
  947.                 fprintf( stderr, "unknown option (%c)n", optopt );
  948.                 return -1;
  949.         }
  951.         if( b_error )
  952.         {
  953.             fprintf( stderr, "bad argument: %s %sn", argv[optind-2], optarg );
  954.             return -1;
  955.         }
  956.     }
  958.     /* Get the file name */
  959.     if( optind > argc - 1 || !opt->hout )
  960.     {
  961.         Help( &defaults );
  962.         return -1;
  963.     }
  964.     psz_filename = argv[optind++];
  966.     if( !opt->b_decompress )
  967.     {
  968.         if( optind > argc - 1 )
  969.         {
  970.             /* try to parse the file name */
  971.             for( psz = psz_filename; *psz; psz++ )
  972.             {
  973.                 if( *psz >= '0' && *psz <= '9'
  974.                     && sscanf( psz, "%ux%u", &param->i_width, &param->i_height ) == 2 )
  975.                 {
  976.                     if( param->i_log_level >= X264_LOG_INFO )
  977.                         fprintf( stderr, "x264 [info]: file name gives %dx%dn", param->i_width, param->i_height );
  978.                     break;
  979.                 }
  980.             }
  981.         }
  982.         else
  983.         {
  984.             sscanf( argv[optind++], "%ux%u", &param->i_width, &param->i_height );
  985.         }
  986.         
  987.         /* check avis input */
  988.         psz = psz_filename + strlen(psz_filename) - 1;
  989.         while( psz > psz_filename && *psz != '.' )
  990.             psz--;
  992.         if( !strncasecmp( psz, ".avi", 4 ) || !strncasecmp( psz, ".avs", 4 ) )
  993.             b_avis = 1;
  995.         if( !b_avis && ( !param->i_width || !param->i_height ) )
  996.         {
  997.             Help( &defaults );
  998.             return -1;
  999.         }
  1000.     }
  1002.     /* open the input */
  1003.     if( !strcmp( psz_filename, "-" ) )
  1004.     {
  1005.         opt->hin = stdin;
  1006.         optind++;
  1007.     }
  1008.     else
  1009.     {
  1010.         if( b_avis )
  1011.         {
  1012. #ifdef AVIS_INPUT
  1013.             p_open_infile = open_file_avis;
  1014.             p_get_frame_total = get_frame_total_avis;
  1015.             p_read_frame = read_frame_avis;
  1016.             p_close_infile = close_file_avis;
  1017. #else
  1018.             fprintf( stderr, "not compiled with AVIS input supportn" );
  1019.             return -1;
  1020. #endif
  1021.         }
  1022.         if( p_open_infile( psz_filename, &opt->hin, param ) )
  1023.         {
  1024.             fprintf( stderr, "could not open input file '%s'n", psz_filename );
  1025.             return -1;
  1026.         }
  1027.     }
  1029.     return 0;
  1032. }
  1034. /*****************************************************************************
  1035.  * Decode:
  1036.  *****************************************************************************/
  1038. static int  Encode_frame( x264_t *h, hnd_t hout, x264_picture_t *pic )
  1039. {
  1040.     x264_picture_t pic_out;
  1041.     x264_nal_t *nal;
  1042.     int i_nal, i;
  1043.     int i_file = 0;
  1045.     /* Do not force any parameters */
  1046.     if( pic )
  1047.     {
  1048.         pic->i_type = X264_TYPE_AUTO;
  1049.         pic->i_qpplus1 = 0;
  1050.     }
  1051.     if( x264_encoder_encode( h, &nal, &i_nal, pic, &pic_out ) < 0 )
  1052.     {
  1053.         fprintf( stderr, "x264_encoder_encode failedn" );
  1054.     }
  1056.     for( i = 0; i < i_nal; i++ )
  1057.     {
  1058.         int i_size;
  1059.         int i_data;
  1061.         i_data = DATA_MAX;
  1062.         if( ( i_size = x264_nal_encode( data, &i_data, 1, &nal[i] ) ) > 0 )
  1063.         {
  1064.             i_file += p_write_nalu( hout, data, i_size );
  1065.         }
  1066.         else if( i_size < 0 )
  1067.         {
  1068.             fprintf( stderr, "need to increase buffer size (size=%d)n", -i_size );
  1069.         }
  1070.     }
  1071.     if (i_nal)
  1072.         p_set_eop( hout, &pic_out );
  1074.     return i_file;
  1075. }
  1077. /*****************************************************************************
  1078.  * Encode:
  1079.  *****************************************************************************/
  1080. static int  Encode( x264_param_t *param, cli_opt_t *opt )
  1081. {
  1082.     x264_t *h;
  1083.     x264_picture_t pic;
  1085.     int     i_frame, i_frame_total;
  1086.     int64_t i_start, i_end;
  1087.     int64_t i_file;
  1088.     int     i_frame_size;
  1089.     int     i_progress;
  1091.     i_frame_total = p_get_frame_total( opt->hin, param->i_width, param->i_height );
  1092.     i_frame_total -= opt->i_seek;
  1093.     if( ( i_frame_total == 0 || param->i_frame_total < i_frame_total )
  1094.         && param->i_frame_total > 0 )
  1095.         i_frame_total = param->i_frame_total;
  1096.     param->i_frame_total = i_frame_total;
  1098.     if( ( h = x264_encoder_open( param ) ) == NULL )
  1099.     {
  1100.         fprintf( stderr, "x264_encoder_open failedn" );
  1101.         p_close_infile( opt->hin );
  1102.         p_close_outfile( opt->hout );
  1103.         return -1;
  1104.     }
  1106.     if( p_set_outfile_param( opt->hout, param ) )
  1107.     {
  1108.         fprintf( stderr, "can't set outfile paramn" );
  1109.         p_close_infile( opt->hin );
  1110.         p_close_outfile( opt->hout );
  1111.         return -1;
  1112.     }
  1114.     /* Create a new pic */
  1115.     x264_picture_alloc( &pic, X264_CSP_I420, param->i_width, param->i_height );
  1117.     i_start = x264_mdate();
  1119.     /* Encode frames */
  1120.     for( i_frame = 0, i_file = 0, i_progress = 0;
  1121.          b_ctrl_c == 0 && (i_frame < i_frame_total || i_frame_total == 0); )
  1122.     {
  1123.         if( p_read_frame( &pic, opt->hin, i_frame + opt->i_seek, param->i_width, param->i_height ) )
  1124.             break;
  1126.         pic.i_pts = (int64_t)i_frame * param->i_fps_den;
  1128.         i_file += Encode_frame( h, opt->hout, &pic );
  1130.         i_frame++;
  1132.         /* update status line (up to 1000 times per input file) */
  1133. #if 0 
  1134. if( opt->b_progress && param->i_log_level < X264_LOG_DEBUG && 
  1135.             ( i_frame_total ? i_frame * 1000 / i_frame_total > i_progress
  1136.                             : i_frame % 10 == 0 ) )
  1137. #else 
  1138.  if (1)
  1139. #endif
  1140.         {
  1141.             int64_t i_elapsed = x264_mdate() - i_start;
  1142.             double fps = i_elapsed > 0 ? i_frame * 1000000. / i_elapsed : 0;
  1143.             if( i_frame_total )
  1144.             {
  1145.                 int eta = i_elapsed * (i_frame_total - i_frame) / ((int64_t)i_frame * 1000000);
  1146.                 i_progress = i_frame * 1000 / i_frame_total;
  1147.                 fprintf( stderr, "encoded frames: %d/%d (%.1f%%), %.2f fps, eta %d:%02d:%02d  r",
  1148.                          i_frame, i_frame_total, (float)i_progress / 10, fps,
  1149.                          eta/3600, (eta/60)%60, eta%60 );
  1150.             }
  1151.             else
  1152.                 fprintf( stderr, "encoded frames: %d, %.2f fps   r", i_frame, fps );
  1153.             fflush( stderr ); // needed in windows
  1154.         }
  1155.     }
  1156.     /* Flush delayed B-frames */
  1157.     do {
  1158.         i_file +=
  1159.         i_frame_size = Encode_frame( h, opt->hout, NULL );
  1160.     } while( i_frame_size );
  1162.     i_end = x264_mdate();
  1163.     x264_picture_clean( &pic );
  1164.     x264_encoder_close( h );
  1165.     fprintf( stderr, "n" );
  1167.     if( b_ctrl_c )
  1168.         fprintf( stderr, "aborted at input frame %dn", opt->i_seek + i_frame );
  1170.     p_close_infile( opt->hin );
  1171.     p_close_outfile( opt->hout );
  1173.     if( i_frame > 0 )
  1174.     {
  1175.         double fps = (double)i_frame * (double)1000000 /
  1176.                      (double)( i_end - i_start );
  1178.         fprintf( stderr, "encoded %d frames, %.2f fps, %.2f kb/sn", i_frame, fps,
  1179.                  (double) i_file * 8 * param->i_fps_num /
  1180.                  ( (double) param->i_fps_den * i_frame * 1000 ) );
  1181.     }
  1183.     return 0;
  1184. }
  1186. /* raw 420 yuv file operation */
  1187. static int open_file_yuv( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param )
  1188. {
  1189.     if ((*p_handle = fopen(psz_filename, "rb")) == NULL)
  1190.         return -1;
  1191.     return 0;
  1192. }
  1194. static int get_frame_total_yuv( hnd_t handle, int i_width, int i_height )
  1195. {
  1196.     FILE *f = (FILE *)handle;
  1197.     int i_frame_total = 0;
  1199.     if( !fseek( f, 0, SEEK_END ) )
  1200.     {
  1201.         uint64_t i_size = ftell( f );
  1202.         fseek( f, 0, SEEK_SET );
  1203.         i_frame_total = (int)(i_size / ( i_width * i_height * 3 / 2 ));
  1204.     }
  1206.     return i_frame_total;
  1207. }
  1209. static int read_frame_yuv( x264_picture_t *p_pic, hnd_t handle, int i_frame, int i_width, int i_height )
  1210. {
  1211.     static int prev_frame = -1;
  1212.     FILE *f = (FILE *)handle;
  1214.     if( i_frame != prev_frame+1 )
  1215.         if( fseek( f, (uint64_t)i_frame * i_width * i_height * 3 / 2, SEEK_SET ) )
  1216.             return -1;
  1218.     if( fread( p_pic->img.plane[0], 1, i_width * i_height, f ) <= 0
  1219.             || fread( p_pic->img.plane[1], 1, i_width * i_height / 4, f ) <= 0
  1220.             || fread( p_pic->img.plane[2], 1, i_width * i_height / 4, f ) <= 0 )
  1221.         return -1;
  1223.     prev_frame = i_frame;
  1225.     return 0;
  1226. }
  1228. static int close_file_yuv(hnd_t handle)
  1229. {
  1230.     if (handle == NULL)
  1231.         return 0;
  1232.     return fclose((FILE *)handle);
  1233. }
  1236. /* avs/avi input file support under cygwin */
  1238. #ifdef AVIS_INPUT
  1240. static int gcd(int a, int b)
  1241. {
  1242.     int c;
  1244.     while (1)
  1245.     {
  1246.         c = a % b;
  1247.         if (!c)
  1248.             return b;
  1249.         a = b;
  1250.         b = c;
  1251.     }
  1252. }
  1254. static int open_file_avis( char *psz_filename, hnd_t *p_handle, x264_param_t *p_param )
  1255. {
  1256.     AVISTREAMINFO info;
  1257.     PAVISTREAM p_avi = NULL;
  1258.     int i;
  1260.     *p_handle = NULL;
  1262.     AVIFileInit();
  1263.     if( AVIStreamOpenFromFile( &p_avi, psz_filename, streamtypeVIDEO, 0, OF_READ, NULL ) )
  1264.     {
  1265.         AVIFileExit();
  1266.         return -1;
  1267.     }
  1269.     if( AVIStreamInfo(p_avi, &info, sizeof(AVISTREAMINFO)) )
  1270.     {
  1271.         AVIStreamRelease(p_avi);
  1272.         AVIFileExit();
  1273.         return -1;
  1274.     }
  1276.     // check input format
  1277.     if (info.fccHandler != MAKEFOURCC('Y', 'V', '1', '2'))
  1278.     {
  1279.         fprintf( stderr, "avis [error]: unsupported input format (%c%c%c%c)n",
  1280.             (char)(info.fccHandler & 0xff), (char)((info.fccHandler >> 8) & 0xff),
  1281.             (char)((info.fccHandler >> 16) & 0xff), (char)((info.fccHandler >> 24)) );
  1283.         AVIStreamRelease(p_avi);
  1284.         AVIFileExit();
  1286.         return -1;
  1287.     }
  1289.     p_param->i_width = info.rcFrame.right - info.rcFrame.left;
  1290.     p_param->i_height = info.rcFrame.bottom - info.rcFrame.top;
  1291.     i = gcd(info.dwRate, info.dwScale);
  1292.     p_param->i_fps_den = info.dwScale / i;
  1293.     p_param->i_fps_num = info.dwRate / i;
  1295.     fprintf( stderr, "avis [info]: %dx%d @ %.2f fps (%d frames)n",  
  1296.         p_param->i_width, p_param->i_height,
  1297.         (double)p_param->i_fps_num / (double)p_param->i_fps_den,
  1298.         (int)info.dwLength );
  1300.     *p_handle = (hnd_t)p_avi;
  1302.     return 0;
  1303. }
  1305. static int get_frame_total_avis( hnd_t handle, int i_width, int i_height )
  1306. {
  1307.     PAVISTREAM p_avi = (PAVISTREAM)handle;
  1308.     AVISTREAMINFO info;
  1310.     if( AVIStreamInfo(p_avi, &info, sizeof(AVISTREAMINFO)) )
  1311.         return -1;
  1313.     return info.dwLength;
  1314. }
  1316. static int read_frame_avis( x264_picture_t *p_pic, hnd_t handle, int i_frame, int i_width, int i_height )
  1317. {
  1318.     PAVISTREAM p_avi = (PAVISTREAM)handle;
  1319.     
  1320.     p_pic->img.i_csp = X264_CSP_YV12;
  1321.     
  1322.     if( AVIStreamRead(p_avi, i_frame, 1, p_pic->img.plane[0], i_width * i_height * 3 / 2, NULL, NULL ) )
  1323.         return -1;
  1325.     return 0;
  1326. }
  1328. static int close_file_avis( hnd_t handle )
  1329. {
  1330.     PAVISTREAM p_avi = (PAVISTREAM)handle;
  1332.     AVIStreamRelease(p_avi);
  1333.     AVIFileExit();
  1335.     return 0;
  1336. }
  1338. #endif
  1341. static int open_file_bsf( char *psz_filename, hnd_t *p_handle )
  1342. {
  1343.     if ((*p_handle = fopen(psz_filename, "w+b")) == NULL)
  1344.         return -1;
  1346.     return 0;
  1347. }
  1349. static int set_param_bsf( hnd_t handle, x264_param_t *p_param )
  1350. {
  1351.     return 0;
  1352. }
  1354. static int write_nalu_bsf( hnd_t handle, uint8_t *p_nalu, int i_size )
  1355. {
  1356.     if (fwrite(p_nalu, i_size, 1, (FILE *)handle) > 0)
  1357.         return i_size;
  1358.     return -1;
  1359. }
  1361. static int set_eop_bsf( hnd_t handle,  x264_picture_t *p_picture )
  1362. {
  1363.     return 0;
  1364. }
  1366. static int close_file_bsf( hnd_t handle )
  1367. {
  1368.     if ((handle == NULL) || (handle == stdout))
  1369.         return 0;
  1371.     return fclose((FILE *)handle);
  1372. }
  1374. /* -- mp4 muxing support ------------------------------------------------- */
  1375. #ifdef MP4_OUTPUT
  1377. typedef struct
  1378. {
  1379.     GF_ISOFile *p_file;
  1380.     GF_AVCConfig *p_config;
  1381.     GF_ISOSample *p_sample;
  1382.     int i_track;
  1383.     int i_descidx;
  1384.     int i_time_inc;
  1385.     int i_time_res;
  1386.     int i_numframe;
  1387.     int i_init_delay;
  1388.     uint8_t b_sps;
  1389.     uint8_t b_pps;
  1390. } mp4_t;
  1393. static void recompute_bitrate_mp4(GF_ISOFile *p_file, int i_track)
  1394. {
  1395.     u32 i, count, di, timescale, time_wnd, rate;
  1396.     u64 offset;
  1397.     Double br;
  1398.     GF_ESD *esd;
  1400.     esd = gf_isom_get_esd(p_file, i_track, 1);
  1401.     if (!esd) return;
  1403.     esd->decoderConfig->avgBitrate = 0;
  1404.     esd->decoderConfig->maxBitrate = 0;
  1405.     rate = time_wnd = 0;
  1407.     timescale = gf_isom_get_media_timescale(p_file, i_track);
  1408.     count = gf_isom_get_sample_count(p_file, i_track);
  1409.     for (i=0; i<count; i++) {
  1410.         GF_ISOSample *samp = gf_isom_get_sample_info(p_file, i_track, i+1, &di, &offset);
  1412.         if (samp->dataLength>esd->decoderConfig->bufferSizeDB) esd->decoderConfig->bufferSizeDB = samp->dataLength;
  1414.         if (esd->decoderConfig->bufferSizeDB < samp->dataLength) esd->decoderConfig->bufferSizeDB = samp->dataLength;
  1415.         esd->decoderConfig->avgBitrate += samp->dataLength;
  1416.         rate += samp->dataLength;
  1417.         if (samp->DTS > time_wnd + timescale) {
  1418.             if (rate > esd->decoderConfig->maxBitrate) esd->decoderConfig->maxBitrate = rate;
  1419.             time_wnd = samp->DTS;
  1420.             rate = 0;
  1421.         }
  1423.         gf_isom_sample_del(&samp);
  1424.     }
  1426.     br = (Double) (s64) gf_isom_get_media_duration(p_file, i_track);
  1427.     br /= timescale;
  1428.     esd->decoderConfig->avgBitrate = (u32) (esd->decoderConfig->avgBitrate / br);
  1429.     /*move to bps*/
  1430.     esd->decoderConfig->avgBitrate *= 8;
  1431.     esd->decoderConfig->maxBitrate *= 8;
  1433.     gf_isom_change_mpeg4_description(p_file, i_track, 1, esd);
  1434.     gf_odf_desc_del((GF_Descriptor *) esd);
  1435. }
  1438. static int close_file_mp4( hnd_t handle )
  1439. {
  1440.     mp4_t *p_mp4 = (mp4_t *)handle;
  1442.     if (p_mp4 == NULL)
  1443.         return 0;
  1445.     if (p_mp4->p_config)
  1446.         gf_odf_avc_cfg_del(p_mp4->p_config);
  1448.     if (p_mp4->p_sample)
  1449.     {
  1450.         if (p_mp4->p_sample->data)
  1451.             free(p_mp4->p_sample->data);
  1453.         gf_isom_sample_del(&p_mp4->p_sample);
  1454.     }
  1456.     if (p_mp4->p_file)
  1457.     {
  1458.         recompute_bitrate_mp4(p_mp4->p_file, p_mp4->i_track);
  1459.         gf_isom_set_pl_indication(p_mp4->p_file, GF_ISOM_PL_VISUAL, 0x15);
  1460.         gf_isom_set_storage_mode(p_mp4->p_file, GF_ISOM_STORE_FLAT);
  1461.         gf_isom_close(p_mp4->p_file);
  1462.     }
  1464.     free(p_mp4);
  1466.     return 0;
  1467. }
  1469. static int open_file_mp4( char *psz_filename, hnd_t *p_handle )
  1470. {
  1471.     mp4_t *p_mp4;
  1473.     *p_handle = NULL;
  1475.     if ((p_mp4 = (mp4_t *)malloc(sizeof(mp4_t))) == NULL)
  1476.         return -1;
  1478.     memset(p_mp4, 0, sizeof(mp4_t));
  1479.     p_mp4->p_file = gf_isom_open(psz_filename, GF_ISOM_OPEN_WRITE, NULL);
  1481.     if ((p_mp4->p_sample = gf_isom_sample_new()) == NULL)
  1482.     {
  1483.         close_file_mp4( p_mp4 );
  1484.         return -1;
  1485.     }
  1487.     gf_isom_set_brand_info(p_mp4->p_file, GF_ISOM_BRAND_AVC1, 0);
  1489.     *p_handle = p_mp4;
  1491.     return 0;
  1492. }
  1495. static int set_param_mp4( hnd_t handle, x264_param_t *p_param )
  1496. {
  1497.     mp4_t *p_mp4 = (mp4_t *)handle;
  1499.     p_mp4->i_track = gf_isom_new_track(p_mp4->p_file, 0, GF_ISOM_MEDIA_VISUAL, 
  1500.         p_param->i_fps_num);
  1502.     p_mp4->p_config = gf_odf_avc_cfg_new();
  1503.     gf_isom_avc_config_new(p_mp4->p_file, p_mp4->i_track, p_mp4->p_config, 
  1504.         NULL, NULL, &p_mp4->i_descidx);
  1506.     gf_isom_set_track_enabled(p_mp4->p_file, p_mp4->i_track, 1);
  1508.     gf_isom_set_visual_info(p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx, 
  1509.         p_param->i_width, p_param->i_height);
  1511.     p_mp4->p_sample->data = (char *)malloc(p_param->i_width * p_param->i_height * 3 / 2);
  1512.     if (p_mp4->p_sample->data == NULL)
  1513.         return -1;
  1515.     p_mp4->i_time_res = p_param->i_fps_num;
  1516.     p_mp4->i_time_inc = p_param->i_fps_den;
  1517.     p_mp4->i_init_delay = p_param->i_bframe ? (p_param->b_bframe_pyramid ? 2 : 1) : 0;
  1518.     p_mp4->i_init_delay *= p_mp4->i_time_inc;
  1519.     fprintf(stderr, "mp4 [info]: initial delay %d (scale %d)n", 
  1520.         p_mp4->i_init_delay, p_mp4->i_time_res);
  1522.     return 0;
  1523. }
  1526. static int write_nalu_mp4( hnd_t handle, uint8_t *p_nalu, int i_size )
  1527. {
  1528.     mp4_t *p_mp4 = (mp4_t *)handle;
  1529.     GF_AVCConfigSlot *p_slot;
  1530.     uint8_t type = p_nalu[4] & 0x1f;
  1531.     int psize;
  1533.     switch(type)
  1534.     {
  1535.     // sps
  1536.     case 0x07:
  1537.         if (!p_mp4->b_sps)
  1538.         {
  1539.             p_mp4->p_config->configurationVersion = 1;
  1540.             p_mp4->p_config->AVCProfileIndication = p_nalu[5];
  1541.             p_mp4->p_config->profile_compatibility = p_nalu[6];
  1542.             p_mp4->p_config->AVCLevelIndication = p_nalu[7];
  1543.             p_slot = (GF_AVCConfigSlot *)malloc(sizeof(GF_AVCConfigSlot));
  1544.             p_slot->size = i_size - 4;
  1545.             p_slot->data = (char *)malloc(p_slot->size);
  1546.             memcpy(p_slot->data, p_nalu + 4, i_size - 4);
  1547.             gf_list_add(p_mp4->p_config->sequenceParameterSets, p_slot);
  1548.             p_slot = NULL;
  1549.             p_mp4->b_sps = 1;
  1550.         }
  1551.         break;
  1553.     // pps      
  1554.     case 0x08:
  1555.         if (!p_mp4->b_pps)
  1556.         {
  1557.             p_slot = (GF_AVCConfigSlot *)malloc(sizeof(GF_AVCConfigSlot));
  1558.             p_slot->size = i_size - 4;
  1559.             p_slot->data = (char *)malloc(p_slot->size);
  1560.             memcpy(p_slot->data, p_nalu + 4, i_size - 4);
  1561.             gf_list_add(p_mp4->p_config->pictureParameterSets, p_slot);
  1562.             p_slot = NULL;
  1563.             p_mp4->b_pps = 1;
  1564.             if (p_mp4->b_sps)
  1565.                 gf_isom_avc_config_update(p_mp4->p_file, p_mp4->i_track, 1, p_mp4->p_config);
  1566.         }
  1567.         break;
  1569.     // slice, sei
  1570.     case 0x1:
  1571.     case 0x5:
  1572.     case 0x6:
  1573.         psize = i_size - 4 ;
  1574.         memcpy(p_mp4->p_sample->data + p_mp4->p_sample->dataLength, p_nalu, i_size);
  1575.         p_mp4->p_sample->data[p_mp4->p_sample->dataLength + 0] = (psize >> 24) & 0xff;
  1576.         p_mp4->p_sample->data[p_mp4->p_sample->dataLength + 1] = (psize >> 16) & 0xff;
  1577.         p_mp4->p_sample->data[p_mp4->p_sample->dataLength + 2] = (psize >> 8) & 0xff;
  1578.         p_mp4->p_sample->data[p_mp4->p_sample->dataLength + 3] = (psize >> 0) & 0xff;
  1579.         p_mp4->p_sample->dataLength += i_size;
  1580.         break;
  1581.     }
  1583.     return i_size;
  1584. }
  1586. static int set_eop_mp4( hnd_t handle, x264_picture_t *p_picture )
  1587. {
  1588.     mp4_t *p_mp4 = (mp4_t *)handle;
  1589.     uint64_t dts = (uint64_t)p_mp4->i_numframe * p_mp4->i_time_inc;
  1590.     uint64_t pts = (uint64_t)p_picture->i_pts;
  1591.     int32_t offset = p_mp4->i_init_delay + pts - dts;
  1593.     p_mp4->p_sample->IsRAP = p_picture->i_type == X264_TYPE_IDR ? 1 : 0;
  1594.     p_mp4->p_sample->DTS = dts;
  1595.     p_mp4->p_sample->CTS_Offset = offset;
  1596.     gf_isom_add_sample(p_mp4->p_file, p_mp4->i_track, p_mp4->i_descidx, p_mp4->p_sample);
  1598.     p_mp4->p_sample->dataLength = 0;
  1599.     p_mp4->i_numframe++;
  1601.     return 0;
  1602. }
  1604. #endif
  1606. #if 0
  1608. /* -- mkv muxing support ------------------------------------------------- */
  1609. typedef struct
  1610. {
  1611.     mk_Writer *w;
  1613.     uint8_t   *sps, *pps;
  1614.     int       sps_len, pps_len;
  1616.     int       width, height, d_width, d_height;
  1618.     int64_t   frame_duration;
  1619.     int       fps_num;
  1621.     int       b_header_written;
  1622.     char      b_writing_frame;
  1623. } mkv_t;
  1625. static int write_header_mkv( mkv_t *p_mkv )
  1626. {
  1627.     int       ret;
  1628.     uint8_t   *avcC;
  1629.     int  avcC_len;
  1631.     if( p_mkv->sps == NULL || p_mkv->pps == NULL ||
  1632.         p_mkv->width == 0 || p_mkv->height == 0 ||
  1633.         p_mkv->d_width == 0 || p_mkv->d_height == 0)
  1634.         return -1;
  1636.     avcC_len = 5 + 1 + 2 + p_mkv->sps_len + 1 + 2 + p_mkv->pps_len;
  1637.     avcC = malloc(avcC_len);
  1638.     if (avcC == NULL)
  1639.         return -1;
  1641.     avcC[0] = 1;
  1642.     avcC[1] = p_mkv->sps[1];
  1643.     avcC[2] = p_mkv->sps[2];
  1644.     avcC[3] = p_mkv->sps[3];
  1645.     avcC[4] = 0xff; // nalu size length is four bytes
  1646.     avcC[5] = 0xe1; // one sps
  1648.     avcC[6] = p_mkv->sps_len >> 8;
  1649.     avcC[7] = p_mkv->sps_len;
  1651.     memcpy(avcC+8, p_mkv->sps, p_mkv->sps_len);
  1653.     avcC[8+p_mkv->sps_len] = 1; // one pps
  1654.     avcC[9+p_mkv->sps_len] = p_mkv->pps_len >> 8;
  1655.     avcC[10+p_mkv->sps_len] = p_mkv->pps_len;
  1657.     memcpy( avcC+11+p_mkv->sps_len, p_mkv->pps, p_mkv->pps_len );
  1659.     ret = mk_writeHeader( p_mkv->w, "x264", "V_MPEG4/ISO/AVC",
  1660.                           avcC, avcC_len, p_mkv->frame_duration, 50000,
  1661.                           p_mkv->width, p_mkv->height,
  1662.                           p_mkv->d_width, p_mkv->d_height );
  1664.     free( avcC );
  1666.     p_mkv->b_header_written = 1;
  1668.     return ret;
  1669. }
  1671. static int open_file_mkv( char *psz_filename, hnd_t *p_handle )
  1672. {
  1673.     mkv_t *p_mkv;
  1675.     *p_handle = NULL;
  1677.     p_mkv  = malloc(sizeof(*p_mkv));
  1678.     if (p_mkv == NULL)
  1679.         return -1;
  1681.     memset(p_mkv, 0, sizeof(*p_mkv));
  1683.     p_mkv->w = mk_createWriter(psz_filename);
  1684.     if (p_mkv->w == NULL)
  1685.     {
  1686.         free(p_mkv);
  1687.         return -1;
  1688.     }
  1690.     *p_handle = p_mkv;
  1692.     return 0;
  1693. }
  1695. static int set_param_mkv( hnd_t handle, x264_param_t *p_param )
  1696. {
  1697.     mkv_t   *p_mkv = handle;
  1698.     int64_t dw, dh;
  1700.     if( p_param->i_fps_num > 0 )
  1701.     {
  1702.         p_mkv->frame_duration = (int64_t)p_param->i_fps_den *
  1703.                                 (int64_t)1000000000 / p_param->i_fps_num;
  1704.         p_mkv->fps_num = p_param->i_fps_num;
  1705.     }
  1706.     else
  1707.     {
  1708.         p_mkv->frame_duration = 0;
  1709.         p_mkv->fps_num = 1;
  1710.     }
  1712.     p_mkv->width = p_param->i_width;
  1713.     p_mkv->height = p_param->i_height;
  1715.     if( p_param->vui.i_sar_width && p_param->vui.i_sar_height )
  1716.     {
  1717.         dw = (int64_t)p_param->i_width  * p_param->vui.i_sar_width;
  1718.         dh = (int64_t)p_param->i_height * p_param->vui.i_sar_height;
  1719.     }
  1720.     else
  1721.     {
  1722.         dw = p_param->i_width;
  1723.         dh = p_param->i_height;
  1724.     }
  1726.     if( dw > 0 && dh > 0 )
  1727.     {
  1728.         int64_t a = dw, b = dh;
  1730.         for (;;)
  1731.         {
  1732.             int64_t c = a % b;
  1733.             if( c == 0 )
  1734.               break;
  1735.             a = b;
  1736.             b = c;
  1737.         }
  1739.         dw /= b;
  1740.         dh /= b;
  1741.     }
  1743.     p_mkv->d_width = (int)dw;
  1744.     p_mkv->d_height = (int)dh;
  1746.     return 0;
  1747. }
  1749. static int write_nalu_mkv( hnd_t handle, uint8_t *p_nalu, int i_size )
  1750. {
  1751.     mkv_t *p_mkv = handle;
  1752.     uint8_t type = p_nalu[4] & 0x1f;
  1753.     uint8_t dsize[4];
  1754.     int psize;
  1756.     switch( type )
  1757.     {
  1758.     // sps
  1759.     case 0x07:
  1760.         if( !p_mkv->sps )
  1761.         {
  1762.             p_mkv->sps = malloc(i_size - 4);
  1763.             if (p_mkv->sps == NULL)
  1764.                 return -1;
  1765.             p_mkv->sps_len = i_size - 4;
  1766.             memcpy(p_mkv->sps, p_nalu + 4, i_size - 4);
  1767.         }
  1768.         break;
  1770.     // pps
  1771.     case 0x08:
  1772.         if( !p_mkv->pps )
  1773.         {
  1774.             p_mkv->pps = malloc(i_size - 4);
  1775.             if (p_mkv->pps == NULL)
  1776.                 return -1;
  1777.             p_mkv->pps_len = i_size - 4;
  1778.             memcpy(p_mkv->pps, p_nalu + 4, i_size - 4);
  1779.         }
  1780.         break;
  1782.     // slice, sei
  1783.     case 0x1:
  1784.     case 0x5:
  1785.     case 0x6:
  1786.         if( !p_mkv->b_writing_frame )
  1787.         {
  1788.             if( mk_startFrame(p_mkv->w) < 0 )
  1789.                 return -1;
  1790.             p_mkv->b_writing_frame = 1;
  1791.         }
  1792.         psize = i_size - 4 ;
  1793.         dsize[0] = psize >> 24;
  1794.         dsize[1] = psize >> 16;
  1795.         dsize[2] = psize >> 8;
  1796.         dsize[3] = psize;
  1797.         if( mk_addFrameData(p_mkv->w, dsize, 4) < 0 ||
  1798.             mk_addFrameData(p_mkv->w, p_nalu + 4, i_size - 4) < 0 )
  1799.             return -1;
  1800.         break;
  1802.     default:
  1803.         break;
  1804.     }
  1806.     if( !p_mkv->b_header_written && p_mkv->pps && p_mkv->sps &&
  1807.         write_header_mkv(p_mkv) < 0 )
  1808.         return -1;
  1810.     return i_size;
  1811. }
  1813. static int set_eop_mkv( hnd_t handle, x264_picture_t *p_picture )
  1814. {
  1815.     mkv_t *p_mkv = handle;
  1816.     int64_t i_stamp = (int64_t)(p_picture->i_pts * 1e9 / p_mkv->fps_num);
  1818.     p_mkv->b_writing_frame = 0;
  1820.     return mk_setFrameFlags( p_mkv->w, i_stamp,
  1821.                              p_picture->i_type == X264_TYPE_IDR );
  1822. }
  1824. static int close_file_mkv( hnd_t handle )
  1825. {
  1826.     mkv_t *p_mkv = handle;
  1827.     int   ret;
  1829.     if( p_mkv->sps )
  1830.         free( p_mkv->sps );
  1831.     if( p_mkv->pps )
  1832.         free( p_mkv->pps );
  1834.     ret = mk_close(p_mkv->w);
  1836.     free( p_mkv );
  1838.     return ret;
  1839. }
  1841. #endif