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