VfW: Enable weighted B prediction when max B-frames > 1. Enforce max reference frames...
[x262.git] / 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, --keyint <integer  >    Maximum GOP size [%d]\n"
106              "  -i, --min-keyint <integer>  Minimum GOP size [%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              "  -w, --weightb               Weighted prediction for B-frames\n"
141              "  -m, --subme <integer>       Subpixel motion estimation quality: 1=fast, 5=best. [%d]\n"
142              "\n"
143              "      --level <integer>       Specify IDC level\n"
144              "  -s, --sar width:height      Specify Sample Aspect Ratio\n"
145              "      --fps <float|rational>  Specify framerate\n"
146              "      --frames <integer>      Maximum number of frames to encode\n"
147              "  -o, --output                Specify output file\n"
148              "\n"
149              "      --no-asm                Disable any CPU optims\n"
150              "      --no-psnr               Disable PSNR computaion\n"
151              "      --quiet                 Quiet Mode\n"
152              "  -v, --verbose               Print stats for each frame\n"
153              "\n",
154             X264_BUILD,
155             defaults->i_keyint_max,
156             defaults->i_keyint_min,
157             defaults->i_scenecut_threshold,
158             defaults->i_bframe,
159             defaults->i_frame_reference,
160             defaults->i_deblocking_filter_alphac0,
161             defaults->rc.i_qp_constant,
162             defaults->rc.i_qp_min,
163             defaults->rc.i_qp_max,
164             defaults->rc.i_qp_step,
165             defaults->rc.i_rc_sens,
166             defaults->rc.i_rc_buffer_size,
167             defaults->rc.i_rc_init_buffer,
168             defaults->rc.f_ip_factor,
169             defaults->rc.f_pb_factor,
170             defaults->rc.psz_stat_out,
171             defaults->rc.psz_rc_eq,
172             defaults->rc.f_qcompress,
173             defaults->rc.f_complexity_blur,
174             defaults->rc.f_qblur,
175             defaults->analyse.i_subpel_refine
176            );
177 }
178
179 /*****************************************************************************
180  * Parse:
181  *****************************************************************************/
182 static int  Parse( int argc, char **argv,
183                    x264_param_t  *param,
184                    FILE **p_fin, FILE **p_fout, int *pb_decompress )
185 {
186     char *psz_filename = NULL;
187     x264_param_t defaults = *param;
188
189     /* Default output */
190     *p_fout = stdout;
191     *p_fin  = stdin;
192     *pb_decompress = 0;
193
194     /* Parse command line options */
195     opterr = 0; // no error message
196     for( ;; )
197     {
198         int long_options_index;
199 #define OPT_QPMIN 256
200 #define OPT_QPMAX 257
201 #define OPT_QPSTEP 258
202 #define OPT_RCSENS 259
203 #define OPT_IPRATIO 260
204 #define OPT_PBRATIO 261
205 #define OPT_RCBUF 262
206 #define OPT_RCIBUF 263
207 #define OPT_RCSTATS 264
208 #define OPT_RCEQ 265
209 #define OPT_QCOMP 266
210 #define OPT_NOPSNR 267
211 #define OPT_QUIET 268
212 #define OPT_SCENECUT 270
213 #define OPT_QBLUR 271
214 #define OPT_CPLXBLUR 272
215 #define OPT_FRAMES 273
216 #define OPT_FPS 274
217 #define OPT_DIRECT 275
218 #define OPT_LEVEL 276
219
220         static struct option long_options[] =
221         {
222             { "help",    no_argument,       NULL, 'h' },
223             { "bitrate", required_argument, NULL, 'B' },
224             { "bframe",  required_argument, NULL, 'b' },
225             { "min-keyint",required_argument,NULL,'i' },
226             { "keyint",  required_argument, NULL, 'I' },
227             { "scenecut",required_argument, NULL, OPT_SCENECUT },
228             { "nf",      no_argument,       NULL, 'n' },
229             { "filter",  required_argument, NULL, 'f' },
230             { "cabac",   no_argument,       NULL, 'c' },
231             { "qp",      required_argument, NULL, 'q' },
232             { "qpmin",   required_argument, NULL, OPT_QPMIN },
233             { "qpmax",   required_argument, NULL, OPT_QPMAX },
234             { "qpstep",  required_argument, NULL, OPT_QPSTEP },
235             { "ref",     required_argument, NULL, 'r' },
236             { "no-asm",  no_argument,       NULL, 'C' },
237             { "sar",     required_argument, NULL, 's' },
238             { "fps",     required_argument, NULL, OPT_FPS },
239             { "frames",  required_argument, NULL, OPT_FRAMES },
240             { "output",  required_argument, NULL, 'o' },
241             { "analyse", required_argument, NULL, 'A' },
242             { "direct",  required_argument, NULL, OPT_DIRECT },
243             { "weightb", no_argument,       NULL, 'w' },
244             { "subme",   required_argument, NULL, 'm' },
245             { "level",   required_argument, NULL, OPT_LEVEL },
246             { "rcsens",  required_argument, NULL, OPT_RCSENS },
247             { "rcbuf",   required_argument, NULL, OPT_RCBUF },
248             { "rcinitbuf",required_argument,NULL, OPT_RCIBUF },
249             { "ipratio", required_argument, NULL, OPT_IPRATIO },
250             { "pbratio", required_argument, NULL, OPT_PBRATIO },
251             { "pass",    required_argument, NULL, 'p' },
252             { "stats",   required_argument, NULL, OPT_RCSTATS },
253             { "rceq",    required_argument, NULL, OPT_RCEQ },
254             { "qcomp",   required_argument, NULL, OPT_QCOMP },
255             { "qblur",   required_argument, NULL, OPT_QBLUR },
256             { "cplxblur",required_argument, NULL, OPT_CPLXBLUR },
257             { "no-psnr", no_argument,       NULL, OPT_NOPSNR },
258             { "quiet",   no_argument,       NULL, OPT_QUIET },
259             { "verbose", no_argument,       NULL, 'v' },
260             {0, 0, 0, 0}
261         };
262
263         int c;
264
265         c = getopt_long( argc, argv, "hi:I:b:r:cxB:q:nf:o:s:A:m:p:vw",
266                          long_options, &long_options_index);
267
268         if( c == -1 )
269         {
270             break;
271         }
272
273         switch( c )
274         {
275             case 'h':
276                 Help( &defaults );
277                 return -1;
278
279             case 0:
280                 break;
281             case 'B':
282                 param->rc.i_bitrate = atol( optarg );
283                 param->rc.b_cbr = 1;
284                 break;
285             case 'b':
286                 param->i_bframe = atol( optarg );
287                 break;
288             case 'i':
289                 param->i_keyint_min = atol( optarg );
290                 break;
291             case 'I':
292                 param->i_keyint_max = atol( optarg );
293                 break;
294             case OPT_SCENECUT:
295                 param->i_scenecut_threshold = atol( optarg );
296                 break;
297             case 'n':
298                 param->b_deblocking_filter = 0;
299                 break;
300             case 'f':
301             {
302                 char *p = strchr( optarg, ':' );
303                 if( p )
304                 {
305                     param->i_deblocking_filter_alphac0 = atoi( optarg );
306                     param->i_deblocking_filter_beta = atoi( p );
307                 }
308                 break;
309             }
310             case 'q':
311                 param->rc.i_qp_constant = atoi( optarg );
312                 break;
313             case OPT_QPMIN:
314                 param->rc.i_qp_min = atoi( optarg );
315                 break;
316             case OPT_QPMAX:
317                 param->rc.i_qp_max = atoi( optarg );
318                 break;
319             case OPT_QPSTEP:
320                 param->rc.i_qp_step = atoi( optarg );
321                 break;
322             case 'r':
323                 param->i_frame_reference = atoi( optarg );
324                 break;
325             case 'c':
326                 param->b_cabac = 1;
327                 break;
328             case 'x':
329                 *pb_decompress = 1;
330                 break;
331             case 'C':
332                 param->cpu = 0;
333                 break;
334             case OPT_FRAMES:
335                 param->i_maxframes = atoi( optarg );
336                 break;
337             case'o':
338                 if( ( *p_fout = fopen( optarg, "wb" ) ) == NULL )
339                 {
340                     fprintf( stderr, "cannot open output file `%s'\n", optarg );
341                     return -1;
342                 }
343                 break;
344             case 's':
345             {
346                 char *p = strchr( optarg, ':' );
347                 if( p )
348                 {
349                     param->vui.i_sar_width = atoi( optarg );
350                     param->vui.i_sar_height = atoi( p + 1 );
351                 }
352                 break;
353             }
354             case OPT_FPS:
355             {
356                 float fps;
357                 if( sscanf( optarg, "%d/%d", &param->i_fps_num, &param->i_fps_den ) == 2 )
358                     ;
359                 else if( sscanf( optarg, "%f", &fps ) )
360                 {
361                     param->i_fps_num = (int)(fps * 1000 + .5);
362                     param->i_fps_den = 1000;
363                 }
364                 else
365                 {
366                     fprintf( stderr, "bad fps `%s'\n", optarg );
367                     return -1;
368                 }
369             }
370             case 'A':
371                 param->analyse.inter = 0;
372                 if( strstr( optarg, "none" ) )  param->analyse.inter = 0x000000;
373                 if( strstr( optarg, "all" ) )   param->analyse.inter = X264_ANALYSE_I4x4|X264_ANALYSE_PSUB16x16|X264_ANALYSE_PSUB8x8|X264_ANALYSE_BSUB16x16;
374
375                 if( strstr( optarg, "i4x4" ) )      param->analyse.inter |= X264_ANALYSE_I4x4;
376                 if( strstr( optarg, "psub16x16" ) ) param->analyse.inter |= X264_ANALYSE_PSUB16x16;
377                 if( strstr( optarg, "psub8x8" ) )   param->analyse.inter |= X264_ANALYSE_PSUB8x8;
378                 if( strstr( optarg, "bsub16x16" ) ) param->analyse.inter |= X264_ANALYSE_BSUB16x16;
379                 break;
380             case OPT_DIRECT:
381                 if( strstr( optarg, "temporal" ) )
382                     param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_TEMPORAL;
383                 else if( strstr( optarg, "spatial" ) )
384                     param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_SPATIAL;
385                 else if( strstr( optarg, "none" ) )
386                     param->analyse.i_direct_mv_pred = X264_DIRECT_PRED_NONE;
387                 else
388                     param->analyse.i_direct_mv_pred = atoi( optarg );
389                 break;
390             case 'w':
391                 param->analyse.b_weighted_bipred = 1;
392                 break;
393             case 'm':
394                 param->analyse.i_subpel_refine = atoi(optarg);
395                 break;
396             case OPT_LEVEL:
397                 param->i_level_idc = atoi(optarg);
398                 break;
399             case OPT_RCBUF:
400                 param->rc.i_rc_buffer_size = atoi(optarg);
401                 break;
402             case OPT_RCIBUF:
403                 param->rc.i_rc_init_buffer = atoi(optarg);
404                 break;
405             case OPT_RCSENS:
406                 param->rc.i_rc_sens = atoi(optarg);
407                 break;
408             case OPT_IPRATIO:
409                 param->rc.f_ip_factor = atof(optarg);
410                 break;
411             case OPT_PBRATIO:
412                 param->rc.f_pb_factor = atof(optarg);
413                 break;
414             case 'p':
415             {
416                 int i_pass = atoi(optarg);
417                 if( i_pass == 1 )
418                     param->rc.b_stat_write = 1;
419                 else if( i_pass == 2 )
420                     param->rc.b_stat_read = 1;
421                 else if( i_pass > 2 )
422                     param->rc.b_stat_read =
423                     param->rc.b_stat_write = 1;
424                 break;
425             }
426             case OPT_RCSTATS:
427                 param->rc.psz_stat_in = optarg;
428                 param->rc.psz_stat_out = optarg;
429                 break;
430             case OPT_RCEQ:
431                 param->rc.psz_rc_eq = optarg;
432                break;
433             case OPT_QCOMP:
434                 param->rc.f_qcompress = atof(optarg);
435                 break;
436             case OPT_QBLUR:
437                 param->rc.f_qblur = atof(optarg);
438                 break;
439             case OPT_CPLXBLUR:
440                 param->rc.f_complexity_blur = atof(optarg);
441                 break;
442             case OPT_NOPSNR:
443                 param->analyse.b_psnr = 0;
444                 break;
445             case OPT_QUIET:
446                 param->i_log_level = X264_LOG_NONE;
447                 break;
448             case 'v':
449                 param->i_log_level = X264_LOG_DEBUG;
450                 break;
451             default:
452                 fprintf( stderr, "unknown option (%c)\n", optopt );
453                 return -1;
454         }
455     }
456
457     /* Get the file name */
458     if( optind > argc - 1 )
459     {
460         Help( &defaults );
461         return -1;
462     }
463     psz_filename = argv[optind++];
464
465     if( !(*pb_decompress) )
466     {
467         char *psz_size = NULL;
468         char *p;
469
470
471         if( optind > argc - 1 )
472         {
473             char *psz = psz_filename;
474             char *x = NULL;
475             /* try to parse the file name */
476             while( *psz )
477             {
478                 while( *psz && ( *psz < '0' || *psz > '9' ) ) psz++;
479                 x = strchr( psz, 'x' );
480                 if( !x )
481                     break;
482                 if( ( x[1] >= '0' && x[1] <= '9' ) )
483                 {
484                     psz_size = psz;
485                     break;
486                 }
487             }
488             if( psz_size == NULL )
489             {
490                 Help( &defaults );
491                 return -1;
492             }
493             fprintf( stderr, "x264: file name gives %dx%d\n", atoi(psz), atoi(x+1) );
494         }
495         else
496         {
497             psz_size = argv[optind++];
498         }
499
500         param->i_width           = strtol( psz_size, &p, 0 );
501         param->i_height          = strtol( p+1, &p, 0 );
502     }
503
504     /* open the input */
505     if( !strcmp( psz_filename, "-" ) )
506     {
507         *p_fin = stdin;
508         optind++;
509     }
510     else if( ( *p_fin = fopen( psz_filename, "rb" ) ) == NULL )
511     {
512         fprintf( stderr, "could not open input file '%s'\n", psz_filename );
513         return -1;
514     }
515
516     return 0;
517 }
518
519 /*****************************************************************************
520  * Decode:
521  *****************************************************************************/
522 static int  Decode( x264_param_t  *param, FILE *fh26l, FILE *fout )
523 {
524     fprintf( stderr, "decompressor not working (help is welcome)\n" );
525     return -1;
526 #if 0
527     x264_nal_t nal;
528     int i_data;
529     int b_eof;
530
531     //param.cpu = 0;
532     if( ( h = x264_decoder_open( &param ) ) == NULL )
533     {
534         fprintf( stderr, "x264_decoder_open failed\n" );
535         return -1;
536     }
537
538     i_start = x264_mdate();
539     b_eof = 0;
540     i_frame = 0;
541     i_data  = 0;
542     nal.p_payload = malloc( DATA_MAX );
543
544     while( !i_ctrl_c )
545     {
546         uint8_t *p, *p_next, *end;
547         int i_size;
548         /* fill buffer */
549         if( i_data < DATA_MAX && !b_eof )
550         {
551             int i_read = fread( &data[i_data], 1, DATA_MAX - i_data, fh26l );
552             if( i_read <= 0 )
553             {
554                 b_eof = 1;
555             }
556             else
557             {
558                 i_data += i_read;
559             }
560         }
561
562         if( i_data < 3 )
563         {
564             break;
565         }
566
567         end = &data[i_data];
568
569         /* extract one nal */
570         p = &data[0];
571         while( p < end - 3 )
572         {
573             if( p[0] == 0x00 && p[1] == 0x00 && p[2] == 0x01 )
574             {
575                 break;
576             }
577             p++;
578         }
579
580         if( p >= end - 3 )
581         {
582             fprintf( stderr, "garbage (i_data = %d)\n", i_data );
583             i_data = 0;
584             continue;
585         }
586
587         p_next = p + 3;
588         while( p_next < end - 3 )
589         {
590             if( p_next[0] == 0x00 && p_next[1] == 0x00 && p_next[2] == 0x01 )
591             {
592                 break;
593             }
594             p_next++;
595         }
596
597         if( p_next == end - 3 && i_data < DATA_MAX )
598         {
599             p_next = end;
600         }
601
602         /* decode this nal */
603         i_size = p_next - p - 3;
604         if( i_size <= 0 )
605         {
606             if( b_eof )
607             {
608                 break;
609             }
610             fprintf( stderr, "nal too large (FIXME) ?\n" );
611             i_data = 0;
612             continue;
613         }
614
615         x264_nal_decode( &nal, p +3, i_size );
616
617         /* decode the content of the nal */
618         x264_decoder_decode( h, &pic, &nal );
619
620         if( pic != NULL )
621         {
622             int i;
623
624             i_frame++;
625
626             for( i = 0; i < pic->i_plane;i++ )
627             {
628                 int i_line;
629                 int i_div;
630
631                 i_div = i==0 ? 1 : 2;
632                 for( i_line = 0; i_line < pic->i_height/i_div; i_line++ )
633                 {
634                     fwrite( pic->plane[i]+i_line*pic->i_stride[i], 1, pic->i_width/i_div, fout );
635                 }
636             }
637         }
638
639         memmove( &data[0], p_next, end - p_next );
640         i_data -= p_next - &data[0];
641     }
642
643     i_end = x264_mdate();
644     free( nal.p_payload );
645     fprintf( stderr, "\n" );
646
647     x264_decoder_close( h );
648
649     fclose( fh26l );
650     if( fout != stdout )
651     {
652         fclose( fout );
653     }
654     if( i_frame > 0 )
655     {
656         double fps = (double)i_frame * (double)1000000 /
657                      (double)( i_end - i_start );
658         fprintf( stderr, "decoded %d frames %ffps\n", i_frame, fps );
659     }
660 #endif
661 }
662
663 /*****************************************************************************
664  * Encode:
665  *****************************************************************************/
666 static int  Encode( x264_param_t  *param, FILE *fyuv, FILE *fout )
667 {
668     x264_t *h;
669     x264_picture_t pic;
670
671     int     i_frame, i_frame_total;
672     int64_t i_start, i_end;
673     int64_t i_file;
674
675     i_frame_total = 0;
676     if( !fseek( fyuv, 0, SEEK_END ) )
677     {
678         int64_t i_size = ftell( fyuv );
679         fseek( fyuv, 0, SEEK_SET );
680         i_frame_total = (int)(i_size / ( param->i_width * param->i_height * 3 / 2 ));
681     }
682
683     if( ( h = x264_encoder_open( param ) ) == NULL )
684     {
685         fprintf( stderr, "x264_encoder_open failed\n" );
686         return -1;
687     }
688
689     /* Create a new pic */
690     x264_picture_alloc( &pic, X264_CSP_I420, param->i_width, param->i_height );
691
692     i_start = x264_mdate();
693     for( i_frame = 0, i_file = 0; i_ctrl_c == 0 ; i_frame++ )
694     {
695         int         i_nal;
696         x264_nal_t  *nal;
697
698         int         i;
699
700         if (param->i_maxframes!=0 && i_frame>=param->i_maxframes)
701             break;
702
703         /* read a frame */
704         if( fread( pic.img.plane[0], 1, param->i_width * param->i_height, fyuv ) <= 0 ||
705             fread( pic.img.plane[1], 1, param->i_width * param->i_height / 4, fyuv ) <= 0 ||
706             fread( pic.img.plane[2], 1, param->i_width * param->i_height / 4, fyuv ) <= 0 )
707         {
708             break;
709         }
710
711         /* Do not force any parameters */
712         pic.i_type = X264_TYPE_AUTO;
713         if( x264_encoder_encode( h, &nal, &i_nal, &pic ) < 0 )
714         {
715             fprintf( stderr, "x264_encoder_encode failed\n" );
716         }
717
718         for( i = 0; i < i_nal; i++ )
719         {
720             int i_size;
721             int i_data;
722
723             i_data = DATA_MAX;
724             if( ( i_size = x264_nal_encode( data, &i_data, 1, &nal[i] ) ) > 0 )
725             {
726                 i_file += fwrite( data, 1, i_size, fout );
727             }
728             else if( i_size < 0 )
729             {
730                 fprintf( stderr,
731                          "need to increase buffer size (size=%d)\n", -i_size );
732             }
733         }
734     }
735     i_end = x264_mdate();
736     x264_picture_clean( &pic );
737     x264_encoder_close( h );
738     fprintf( stderr, "\n" );
739
740     fclose( fyuv );
741     if( fout != stdout )
742     {
743         fclose( fout );
744     }
745
746     if( i_frame > 0 )
747     {
748         double fps = (double)i_frame * (double)1000000 /
749                      (double)( i_end - i_start );
750
751         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 ) );
752     }
753
754     return 0;
755 }
756
757