git.sesse.net Git - x264/blob - 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  *****************************************************************************/
  23
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include <math.h>
  29
  30 #include <signal.h>
  31 #define _GNU_SOURCE
  32 #include <getopt.h>
  33
  34 #ifdef _MSC_VER
  35 #include <io.h>     /* _setmode() */
  36 #include <fcntl.h>  /* _O_BINARY */
  37 #endif
  38
  39 #include "common/common.h"
  40 #include "x264.h"
  41
  42 #define DATA_MAX 3000000
  43 uint8_t data[DATA_MAX];
  44
  45 /* Ctrl-C handler */
  46 static int     i_ctrl_c = 0;
  47 static void    SigIntHandler( int a )
  48 {
  49     i_ctrl_c = 1;
  50 }
  51
  52 static void Help( x264_param_t *defaults );
  53 static int  Parse( int argc, char **argv, x264_param_t  *param, FILE **p_fin, FILE **p_fout, int *pb_decompress );
  54 static int  Encode( x264_param_t  *param, FILE *fyuv,  FILE *fout );
  55 static int  Decode( x264_param_t  *param, FILE *fh26l, FILE *fout );
  56
  57 /****************************************************************************
  58  * main:
  59  ****************************************************************************/
  60 int main( int argc, char **argv )
  61 {
  62     x264_param_t param;
  63
  64     FILE    *fout;
  65     FILE    *fin;
  66
  67     int     b_decompress;
  68     int     i_ret;
  69
  70 #ifdef _MSC_VER
  71     _setmode(_fileno(stdin), _O_BINARY);    /* thanks to Marcos Morais <morais at dee.ufcg.edu.br> */
  72     _setmode(_fileno(stdout), _O_BINARY);
  73 #endif
  74
  75     x264_param_default( &param );
  76
  77     /* Parse command line */
  78     if( Parse( argc, argv, &param, &fin, &fout, &b_decompress ) < 0 )
  79     {
  80         return -1;
  81     }
  82
  83     /* Control-C handler */
  84     signal( SIGINT, SigIntHandler );
  85
  86     if( b_decompress )
  87         i_ret = Decode( &param, fin, fout );
  88     else
  89         i_ret = Encode( &param, fin, fout );
  90
  91     return i_ret;
  92 }
  93
  94 /*****************************************************************************
  95  * Help:
  96  *****************************************************************************/
  97 static void Help( x264_param_t *defaults )
  98 {
  99     fprintf( stderr,
 100              "x264 build:0x%4.4x\n"
 101              "Syntax: x264 [options] [-o out.h26l] in.yuv widthxheigh\n"
 102              "\n"
 103              "  -h, --help                  Print this help\n"
 104              "\n"
 105              "  -I, --idrframe <integer>    Each 'number' I frames are IDR frames [%d]\n"
 106              "  -i, --iframe <integer>      Max interval between I frames [%d]\n"
 107              "      --scenecut <integer>    How aggresively to insert extra I frames [%d]\n"
 108              "  -b, --bframe <integer>      Number of B-frames between I and P [%d]\n"
 109              "\n"
 110              "  -c, --cabac                 Enable CABAC\n"
 111              "  -r, --ref <integer>         Number of reference frames [%d]\n"
 112              "  -n, --nf                    Disable loop filter\n"
 113              "  -f, --filter <alpha:beta>   Loop filter AplhaCO and Beta parameters [%d]\n"
 114              "\n"
 115              "  -q, --qp <integer>          Set QP [%d]\n"
 116              "  -B, --bitrate <integer>     Set bitrate\n"
 117              "      --qpmin <integer>       Set min QP [%d]\n"
 118              "      --qpmax <integer>       Set max QP [%d]\n"
 119              "      --qpstep <integer>      Set max QP step [%d]\n"
 120              "      --rcsens <integer>      CBR ratecontrol sensitivity [%d]\n"
 121              "      --rcbuf <integer>       Size of VBV buffer [%d]\n"
 122              "      --rcinitbuf <integer>   Initial VBV buffer occupancy [%d]\n"
 123              "      --ipratio <float>       QP factor between I and P [%.2f]\n"
 124              "      --pbratio <float>       QP factor between P and B [%.2f]\n"
 125              "\n"
 126              "  -p, --pass <1|2>            Enable 2 pass ratecontrol\n"
 127              "      --stats <string>        Filename for 2 pass stats [\"%s\"]\n"
 128              "      --rceq <string>         Ratecontrol equation [\"%s\"]\n"
 129              "      --qcomp <float>         0.0 => CBR, 1.0 => CQP [%.2f]\n"
 130              "      --cplxblur <float>      reduce fluctuations in QP (before curve compression) [%.1f]\n"
 131              "      --qblur <float>         reduce fluctuations in QP (after curve compression) [%.1f]\n"
 132              "\n"
 133
 134              "  -A, --analyse <string>      Analyse options: [\"i4x4|psub16x16|bsub16x16\"]\n"
 135              "                                  - i4x4\n"
 136              "                                  - psub16x16, psub8x8, bsub16x16\n"
 137              "                                  - none, all\n"
 138              "      --direct <string>       Direct MV prediction mode [\"temporal\"]\n"
 139              "                                  - none, spatial, temporal\n"
 140              "  -m, --subme <integer>       Subpixel motion estimation quality: 1=fast, 5=best. [%d]\n"
 141              "\n"
 142              "  -s, --sar width:height      Specify Sample Aspect Ratio\n"
 143              "      --fps <float|rational>  Specify framerate\n"
 144              "      --frames <integer>      Maximum number of frames to encode\n"
 145              "  -o, --output                Specify output file\n"
 146              "\n"
 147              "      --no-asm                Disable any CPU optims\n"
 148              "      --no-psnr               Disable PSNR computaion\n"
 149              "      --quiet                 Quiet Mode\n"
 150              "\n",
 151             X264_BUILD,
 152             defaults->i_idrframe,
 153             defaults->i_iframe,
 154             defaults->i_scenecut_threshold,
 155             defaults->i_bframe,
 156             defaults->i_frame_reference,
 157             defaults->i_deblocking_filter_alphac0,
 158             defaults->rc.i_qp_constant,
 159             defaults->rc.i_qp_min,
 160             defaults->rc.i_qp_max,
 161             defaults->rc.i_qp_step,
 162             defaults->rc.i_rc_sens,
 163             defaults->rc.i_rc_buffer_size,
 164             defaults->rc.i_rc_init_buffer,
 165             defaults->rc.f_ip_factor,
 166             defaults->rc.f_pb_factor,
 167             defaults->rc.psz_stat_out,
 168             defaults->rc.psz_rc_eq,
 169             defaults->rc.f_qcompress,
 170             defaults->rc.f_complexity_blur,
 171             defaults->rc.f_qblur,
 172             defaults->analyse.i_subpel_refine
 173            );
 174 }
 175
 176 /*****************************************************************************
 177  * Parse:
 178  *****************************************************************************/
 179 static int  Parse( int argc, char **argv,
 180                    x264_param_t  *param,
 181                    FILE **p_fin, FILE **p_fout, int *pb_decompress )
 182 {
 183     char *psz_filename = NULL;
 184     x264_param_t defaults = *param;
 185
 186     /* Default output */
 187     *p_fout = stdout;
 188     *p_fin  = stdin;
 189     *pb_decompress = 0;
 190
 191     /* Parse command line options */
 192     opterr = 0; // no error message
 193     for( ;; )
 194     {
 195         int long_options_index;
 196 #define OPT_QPMIN 256
 197 #define OPT_QPMAX 257
 198 #define OPT_QPSTEP 258
 199 #define OPT_RCSENS 259
 200 #define OPT_IPRATIO 260
 201 #define OPT_PBRATIO 261
 202 #define OPT_RCBUF 262
 203 #define OPT_RCIBUF 263
 204 #define OPT_RCSTATS 264
 205 #define OPT_RCEQ 265
 206 #define OPT_QCOMP 266
 207 #define OPT_NOPSNR 267
 208 #define OPT_QUIET 268
 209 #define OPT_SCENECUT 270
 210 #define OPT_QBLUR 271
 211 #define OPT_CPLXBLUR 272
 212 #define OPT_FRAMES 273
 213 #define OPT_FPS 274
 214 #define OPT_DIRECT 275
 215
 216         static struct option long_options[] =
 217         {
 218             { "help",    no_argument,       NULL, 'h' },
 219             { "bitrate", required_argument, NULL, 'B' },
 220             { "bframe",  required_argument, NULL, 'b' },
 221             { "iframe",  required_argument, NULL, 'i' },
 222             { "idrframe",required_argument, NULL, 'I' },
 223             { "scenecut",required_argument, NULL, OPT_SCENECUT },
 224             { "nf",      no_argument,       NULL, 'n' },
 225             { "filter",  required_argument, NULL, 'f' },
 226             { "cabac",   no_argument,       NULL, 'c' },
 227             { "qp",      required_argument, NULL, 'q' },
 228             { "qpmin",   required_argument, NULL, OPT_QPMIN },
 229             { "qpmax",   required_argument, NULL, OPT_QPMAX },
 230             { "qpstep",  required_argument, NULL, OPT_QPSTEP },
 231             { "ref",     required_argument, NULL, 'r' },
 232             { "no-asm",  no_argument,       NULL, 'C' },
 233             { "sar",     required_argument, NULL, 's' },
 234             { "fps",     required_argument, NULL, OPT_FPS },
 235             { "frames",  required_argument, NULL, OPT_FRAMES },
 236             { "output",  required_argument, NULL, 'o' },
 237             { "analyse", required_argument, NULL, 'A' },
 238             { "direct",  required_argument, NULL, OPT_DIRECT },
 239             { "subme",   required_argument, NULL, 'm' },
 240             { "rcsens",  required_argument, NULL, OPT_RCSENS },
 241             { "rcbuf",   required_argument, NULL, OPT_RCBUF },
 242             { "rcinitbuf",required_argument,NULL, OPT_RCIBUF },
 243             { "ipratio", required_argument, NULL, OPT_IPRATIO },
 244             { "pbratio", required_argument, NULL, OPT_PBRATIO },
 245             { "pass",    required_argument, NULL, 'p' },
 246             { "stats",   required_argument, NULL, OPT_RCSTATS },
 247             { "rceq",    required_argument, NULL, OPT_RCEQ },
 248             { "qcomp",   required_argument, NULL, OPT_QCOMP },
 249             { "qblur",   required_argument, NULL, OPT_QBLUR },
 250             { "cplxblur",required_argument, NULL, OPT_CPLXBLUR },
 251             { "no-psnr", no_argument,       NULL, OPT_NOPSNR },
 252             { "quiet",   no_argument,       NULL, OPT_QUIET },
 253             {0, 0, 0, 0}
 254         };
 255
 256         int c;
 257
 258         c = getopt_long( argc, argv, "hi:I:b:r:cxB:q:no:s:A:p:",
 259                          long_options, &long_options_index);
 260
 261         if( c == -1 )
 262         {
 263             break;
 264         }
 265
 266         switch( c )
 267         {
 268             case 'h':
 269                 Help( &defaults );
 270                 return -1;
 271
 272             case 0:
 273                 break;
 274             case 'B':
 275                 param->rc.i_bitrate = atol( optarg );
 276                 param->rc.b_cbr = 1;
 277                 break;
 278             case 'b':
 279                 param->i_bframe = atol( optarg );
 280                 break;
 281             case 'i':
 282                 param->i_iframe = atol( optarg );
 283                 break;
 284             case 'I':
 285                 param->i_idrframe = atol( optarg );
 286                 break;
 287             case OPT_SCENECUT:
 288                 param->i_scenecut_threshold = atol( optarg );
 289                 break;
 290             case 'n':
 291                 param->b_deblocking_filter = 0;
 292                 break;
 293             case 'f':
 294             {
 295                 char *p = strchr( optarg, ':' );
 296                 if( p )
 297                 {
 298                     param->i_deblocking_filter_alphac0 = atoi( optarg );
 299                     param->i_deblocking_filter_beta = atoi( p );
 300                 }
 301                 break;
 302             }
 303             case 'q':
 304                 param->rc.i_qp_constant = atoi( optarg );
 305                 break;
 306             case OPT_QPMIN:
 307                 param->rc.i_qp_min = atoi( optarg );
 308                 break;
 309             case OPT_QPMAX:
 310                 param->rc.i_qp_max = atoi( optarg );
 311                 break;
 312             case OPT_QPSTEP:
 313                 param->rc.i_qp_step = atoi( optarg );
 314                 break;
 315             case 'r':
 316                 param->i_frame_reference = atoi( optarg );
 317                 break;
 318             case 'c':
 319                 param->b_cabac = 1;
 320                 break;
 321             case 'x':
 322                 *pb_decompress = 1;
 323                 break;
 324             case 'C':
 325                 param->cpu = 0;
 326                 break;
 327             case OPT_FRAMES:
 328                 param->i_maxframes = atoi( optarg );
 329                 break;
 330             case'o':
 331                 if( ( *p_fout = fopen( optarg, "wb" ) ) == NULL )
 332                 {
 333                     fprintf( stderr, "cannot open output file `%s'\n", optarg );
 334                     return -1;
 335                 }
 336                 break;
 337             case 's':
 338             {
 339                 char *p = strchr( optarg, ':' );
 340                 if( p )
 341                 {
 342                     param->vui.i_sar_width = atoi( optarg );
 343                     param->vui.i_sar_height = atoi( p + 1 );
 344                 }
 345                 break;
 346             }
 347             case OPT_FPS:
 348             {
 349                 float fps;
 350                 if( sscanf( optarg, "%d/%d", &param->i_fps_num, &param->i_fps_den ) == 2 )
 351                     ;
 352                 else if( sscanf( optarg, "%f", &fps ) )
 353                 {
 354                     param->i_fps_num = (int)(fps * 1000 + .5);
 355                     param->i_fps_den = 1000;
 356                 }
 357                 else
 358                 {
 359                     fprintf( stderr, "bad fps `%s'\n", optarg );
 360                     return -1;
 361                 }
 362             }
 363             case 'A':
 364                 param->analyse.inter = 0;
 365                 if( strstr( optarg, "none" ) )  param->analyse.inter = 0x000000;
 366                 if( strstr( optarg, "all" ) )   param->analyse.inter = X264_ANALYSE_I4x4|X264_ANALYSE_PSUB16x16|X264_ANALYSE_PSUB8x8;
 367
 368                 if( strstr( optarg, "i4x4" ) )      param->analyse.inter |= X264_ANALYSE_I4x4;
 369                 if( strstr( optarg, "psub16x16" ) ) param->analyse.inter |= X264_ANALYSE_PSUB16x16;
 370                 if( strstr( optarg, "psub8x8" ) )   param->analyse.inter |= X264_ANALYSE_PSUB8x8;
 371                 if( strstr( optarg, "bsub16x16" ) ) param->analyse.inter |= X264_ANALYSE_BSUB16x16;
 372                 break;
 373             case OPT_DIRECT:
 374                 if( strstr( optarg, "temporal" ) )
 375                     param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_TEMPORAL;
 376                 else if( strstr( optarg, "spatial" ) )
 377                     param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_SPATIAL;
 378                 else if( strstr( optarg, "none" ) )
 379                     param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_NONE;
 380                 else
 381                     param->analyse.i_direct_mv_pred = atoi( optarg );
 382                 break;
 383             case 'm':
 384                 param->analyse.i_subpel_refine = atoi(optarg);
 385                 break;
 386             case OPT_RCBUF:
 387                 param->rc.i_rc_buffer_size = atoi(optarg);
 388                 break;
 389             case OPT_RCIBUF:
 390                 param->rc.i_rc_init_buffer = atoi(optarg);
 391                 break;
 392             case OPT_RCSENS:
 393                 param->rc.i_rc_sens = atoi(optarg);
 394                 break;
 395             case OPT_IPRATIO:
 396                 param->rc.f_ip_factor = atof(optarg);
 397                 break;
 398             case OPT_PBRATIO:
 399                 param->rc.f_pb_factor = atof(optarg);
 400                 break;
 401             case 'p':
 402             {
 403                 int i_pass = atoi(optarg);
 404                 if( i_pass == 1 )
 405                     param->rc.b_stat_write = 1;
 406                 else if( i_pass == 2 )
 407                     param->rc.b_stat_read = 1;
 408                 else if( i_pass > 2 )   /* XXX untested */
 409                     param->rc.b_stat_read =
 410                     param->rc.b_stat_write = 1;
 411                 break;
 412             }
 413             case OPT_RCSTATS:
 414                 param->rc.psz_stat_in = optarg;
 415                 param->rc.psz_stat_out = optarg;
 416                 break;
 417             case OPT_RCEQ:
 418                 param->rc.psz_rc_eq = optarg;
 419                break;
 420             case OPT_QCOMP:
 421                 param->rc.f_qcompress = atof(optarg);
 422                 break;
 423             case OPT_QBLUR:
 424                 param->rc.f_qblur = atof(optarg);
 425                 break;
 426             case OPT_CPLXBLUR:
 427                 param->rc.f_complexity_blur = atof(optarg);
 428                 break;
 429             case OPT_NOPSNR:
 430                 param->analyse.b_psnr = 0;
 431                 break;
 432             case OPT_QUIET:
 433                 param->i_log_level = X264_LOG_NONE;
 434                 break;
 435             default:
 436                 fprintf( stderr, "unknown option (%c)\n", optopt );
 437                 return -1;
 438         }
 439     }
 440
 441     /* Get the file name */
 442     if( optind > argc - 1 )
 443     {
 444         Help( &defaults );
 445         return -1;
 446     }
 447     psz_filename = argv[optind++];
 448
 449     if( !(*pb_decompress) )
 450     {
 451         char *psz_size = NULL;
 452         char *p;
 453
 454
 455         if( optind > argc - 1 )
 456         {
 457             char *psz = psz_filename;
 458             char *x = NULL;
 459             /* try to parse the file name */
 460             while( *psz )
 461             {
 462                 while( *psz && ( *psz < '0' || *psz > '9' ) ) psz++;
 463                 x = strchr( psz, 'x' );
 464                 if( !x )
 465                     break;
 466                 if( ( x[1] >= '0' && x[1] <= '9' ) )
 467                 {
 468                     psz_size = psz;
 469                     break;
 470                 }
 471             }
 472             if( psz_size == NULL )
 473             {
 474                 Help( &defaults );
 475                 return -1;
 476             }
 477             fprintf( stderr, "x264: file name gives %dx%d\n", atoi(psz), atoi(x+1) );
 478         }
 479         else
 480         {
 481             psz_size = argv[optind++];
 482         }
 483
 484         param->i_width           = strtol( psz_size, &p, 0 );
 485         param->i_height          = strtol( p+1, &p, 0 );
 486     }
 487
 488     /* open the input */
 489     if( !strcmp( psz_filename, "-" ) )
 490     {
 491         *p_fin = stdin;
 492         optind++;
 493     }
 494     else if( ( *p_fin = fopen( psz_filename, "rb" ) ) == NULL )
 495     {
 496         fprintf( stderr, "could not open input file '%s'\n", psz_filename );
 497         return -1;
 498     }
 499
 500     return 0;
 501 }
 502
 503 /*****************************************************************************
 504  * Decode:
 505  *****************************************************************************/
 506 static int  Decode( x264_param_t  *param, FILE *fh26l, FILE *fout )
 507 {
 508     fprintf( stderr, "decompressor not working (help is welcome)\n" );
 509     return -1;
 510 #if 0
 511     x264_nal_t nal;
 512     int i_data;
 513     int b_eof;
 514
 515     //param.cpu = 0;
 516     if( ( h = x264_decoder_open( &param ) ) == NULL )
 517     {
 518         fprintf( stderr, "x264_decoder_open failed\n" );
 519         return -1;
 520     }
 521
 522     i_start = x264_mdate();
 523     b_eof = 0;
 524     i_frame = 0;
 525     i_data  = 0;
 526     nal.p_payload = malloc( DATA_MAX );
 527
 528     while( !i_ctrl_c )
 529     {
 530         uint8_t *p, *p_next, *end;
 531         int i_size;
 532         /* fill buffer */
 533         if( i_data < DATA_MAX && !b_eof )
 534         {
 535             int i_read = fread( &data[i_data], 1, DATA_MAX - i_data, fh26l );
 536             if( i_read <= 0 )
 537             {
 538                 b_eof = 1;
 539             }
 540             else
 541             {
 542                 i_data += i_read;
 543             }
 544         }
 545
 546         if( i_data < 3 )
 547         {
 548             break;
 549         }
 550
 551         end = &data[i_data];
 552
 553         /* extract one nal */
 554         p = &data[0];
 555         while( p < end - 3 )
 556         {
 557             if( p[0] == 0x00 && p[1] == 0x00 && p[2] == 0x01 )
 558             {
 559                 break;
 560             }
 561             p++;
 562         }
 563
 564         if( p >= end - 3 )
 565         {
 566             fprintf( stderr, "garbage (i_data = %d)\n", i_data );
 567             i_data = 0;
 568             continue;
 569         }
 570
 571         p_next = p + 3;
 572         while( p_next < end - 3 )
 573         {
 574             if( p_next[0] == 0x00 && p_next[1] == 0x00 && p_next[2] == 0x01 )
 575             {
 576                 break;
 577             }
 578             p_next++;
 579         }
 580
 581         if( p_next == end - 3 && i_data < DATA_MAX )
 582         {
 583             p_next = end;
 584         }
 585
 586         /* decode this nal */
 587         i_size = p_next - p - 3;
 588         if( i_size <= 0 )
 589         {
 590             if( b_eof )
 591             {
 592                 break;
 593             }
 594             fprintf( stderr, "nal too large (FIXME) ?\n" );
 595             i_data = 0;
 596             continue;
 597         }
 598
 599         x264_nal_decode( &nal, p +3, i_size );
 600
 601         /* decode the content of the nal */
 602         x264_decoder_decode( h, &pic, &nal );
 603
 604         if( pic != NULL )
 605         {
 606             int i;
 607
 608             i_frame++;
 609
 610             for( i = 0; i < pic->i_plane;i++ )
 611             {
 612                 int i_line;
 613                 int i_div;
 614
 615                 i_div = i==0 ? 1 : 2;
 616                 for( i_line = 0; i_line < pic->i_height/i_div; i_line++ )
 617                 {
 618                     fwrite( pic->plane[i]+i_line*pic->i_stride[i], 1, pic->i_width/i_div, fout );
 619                 }
 620             }
 621         }
 622
 623         memmove( &data[0], p_next, end - p_next );
 624         i_data -= p_next - &data[0];
 625     }
 626
 627     i_end = x264_mdate();
 628     free( nal.p_payload );
 629     fprintf( stderr, "\n" );
 630
 631     x264_decoder_close( h );
 632
 633     fclose( fh26l );
 634     if( fout != stdout )
 635     {
 636         fclose( fout );
 637     }
 638     if( i_frame > 0 )
 639     {
 640         double fps = (double)i_frame * (double)1000000 /
 641                      (double)( i_end - i_start );
 642         fprintf( stderr, "decoded %d frames %ffps\n", i_frame, fps );
 643     }
 644 #endif
 645 }
 646
 647 /*****************************************************************************
 648  * Encode:
 649  *****************************************************************************/
 650 static int  Encode( x264_param_t  *param, FILE *fyuv, FILE *fout )
 651 {
 652     x264_t *h;
 653     x264_picture_t pic;
 654
 655     int     i_frame, i_frame_total;
 656     int64_t i_start, i_end;
 657     int64_t i_file;
 658
 659     i_frame_total = 0;
 660     if( !fseek( fyuv, 0, SEEK_END ) )
 661     {
 662         int64_t i_size = ftell( fyuv );
 663         fseek( fyuv, 0, SEEK_SET );
 664         i_frame_total = (int)(i_size / ( param->i_width * param->i_height * 3 / 2 ));
 665     }
 666
 667     if( ( h = x264_encoder_open( param ) ) == NULL )
 668     {
 669         fprintf( stderr, "x264_encoder_open failed\n" );
 670         return -1;
 671     }
 672
 673     /* Create a new pic */
 674     x264_picture_alloc( &pic, X264_CSP_I420, param->i_width, param->i_height );
 675
 676     i_start = x264_mdate();
 677     for( i_frame = 0, i_file = 0; i_ctrl_c == 0 ; i_frame++ )
 678     {
 679         int         i_nal;
 680         x264_nal_t  *nal;
 681
 682         int         i;
 683
 684         if (param->i_maxframes!=0 && i_frame>=param->i_maxframes)
 685             break;
 686
 687         /* read a frame */
 688         if( fread( pic.img.plane[0], 1, param->i_width * param->i_height, fyuv ) <= 0 ||
 689             fread( pic.img.plane[1], 1, param->i_width * param->i_height / 4, fyuv ) <= 0 ||
 690             fread( pic.img.plane[2], 1, param->i_width * param->i_height / 4, fyuv ) <= 0 )
 691         {
 692             break;
 693         }
 694
 695         /* Do not force any parameters */
 696         pic.i_type = X264_TYPE_AUTO;
 697         if( x264_encoder_encode( h, &nal, &i_nal, &pic ) < 0 )
 698         {
 699             fprintf( stderr, "x264_encoder_encode failed\n" );
 700         }
 701
 702         for( i = 0; i < i_nal; i++ )
 703         {
 704             int i_size;
 705             int i_data;
 706
 707             i_data = DATA_MAX;
 708             if( ( i_size = x264_nal_encode( data, &i_data, 1, &nal[i] ) ) > 0 )
 709             {
 710                 i_file += fwrite( data, 1, i_size, fout );
 711             }
 712             else if( i_size < 0 )
 713             {
 714                 fprintf( stderr,
 715                          "need to increase buffer size (size=%d)\n", -i_size );
 716             }
 717         }
 718     }
 719     i_end = x264_mdate();
 720     x264_picture_clean( &pic );
 721     x264_encoder_close( h );
 722     fprintf( stderr, "\n" );
 723
 724     fclose( fyuv );
 725     if( fout != stdout )
 726     {
 727         fclose( fout );
 728     }
 729
 730     if( i_frame > 0 )
 731     {
 732         double fps = (double)i_frame * (double)1000000 /
 733                      (double)( i_end - i_start );
 734
 735         fprintf( stderr, "encoded %d frames, %.2f fps, %.2f kb/s\n", i_frame, fps, (double) i_file * 8 * param->i_fps_num / ( param->i_fps_den * i_frame * 1000 ) );
 736     }
 737
 738     return 0;
 739 }
 740
 741