1 /*****************************************************************************
2 * common.c: h264 library
3 *****************************************************************************
4 * Copyright (C) 2003-2008 x264 project
6 * Authors: Loren Merritt <lorenm@u.washington.edu>
7 * Laurent Aimar <fenrir@via.ecp.fr>
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.
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.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111, USA.
22 *****************************************************************************/
34 static void x264_log_default( void *, int, const char *, va_list );
36 /****************************************************************************
38 ****************************************************************************/
39 void x264_param_default( x264_param_t
*param
)
42 memset( param
, 0, sizeof( x264_param_t
) );
45 param
->cpu
= x264_cpu_detect();
47 param
->b_deterministic
= 1;
49 /* Video properties */
50 param
->i_csp
= X264_CSP_I420
;
53 param
->vui
.i_sar_width
= 0;
54 param
->vui
.i_sar_height
= 0;
55 param
->vui
.i_overscan
= 0; /* undef */
56 param
->vui
.i_vidformat
= 5; /* undef */
57 param
->vui
.b_fullrange
= 0; /* off */
58 param
->vui
.i_colorprim
= 2; /* undef */
59 param
->vui
.i_transfer
= 2; /* undef */
60 param
->vui
.i_colmatrix
= 2; /* undef */
61 param
->vui
.i_chroma_loc
= 0; /* left center */
62 param
->i_fps_num
= 25;
64 param
->i_level_idc
= -1;
66 /* Encoder parameters */
67 param
->i_frame_reference
= 1;
68 param
->i_keyint_max
= 250;
69 param
->i_keyint_min
= 25;
71 param
->i_scenecut_threshold
= 40;
72 param
->i_bframe_adaptive
= X264_B_ADAPT_FAST
;
73 param
->i_bframe_bias
= 0;
74 param
->b_bframe_pyramid
= 0;
76 param
->b_deblocking_filter
= 1;
77 param
->i_deblocking_filter_alphac0
= 0;
78 param
->i_deblocking_filter_beta
= 0;
81 param
->i_cabac_init_idc
= 0;
83 param
->rc
.i_rc_method
= X264_RC_NONE
;
84 param
->rc
.i_bitrate
= 0;
85 param
->rc
.f_rate_tolerance
= 1.0;
86 param
->rc
.i_vbv_max_bitrate
= 0;
87 param
->rc
.i_vbv_buffer_size
= 0;
88 param
->rc
.f_vbv_buffer_init
= 0.9;
89 param
->rc
.i_qp_constant
= 26;
90 param
->rc
.f_rf_constant
= 0;
91 param
->rc
.i_qp_min
= 10;
92 param
->rc
.i_qp_max
= 51;
93 param
->rc
.i_qp_step
= 4;
94 param
->rc
.f_ip_factor
= 1.4;
95 param
->rc
.f_pb_factor
= 1.3;
96 param
->rc
.i_aq_mode
= X264_AQ_VARIANCE
;
97 param
->rc
.f_aq_strength
= 1.0;
99 param
->rc
.b_stat_write
= 0;
100 param
->rc
.psz_stat_out
= "x264_2pass.log";
101 param
->rc
.b_stat_read
= 0;
102 param
->rc
.psz_stat_in
= "x264_2pass.log";
103 param
->rc
.f_qcompress
= 0.6;
104 param
->rc
.f_qblur
= 0.5;
105 param
->rc
.f_complexity_blur
= 20;
106 param
->rc
.i_zones
= 0;
109 param
->pf_log
= x264_log_default
;
110 param
->p_log_private
= NULL
;
111 param
->i_log_level
= X264_LOG_INFO
;
114 param
->analyse
.intra
= X264_ANALYSE_I4x4
| X264_ANALYSE_I8x8
;
115 param
->analyse
.inter
= X264_ANALYSE_I4x4
| X264_ANALYSE_I8x8
116 | X264_ANALYSE_PSUB16x16
| X264_ANALYSE_BSUB16x16
;
117 param
->analyse
.i_direct_mv_pred
= X264_DIRECT_PRED_SPATIAL
;
118 param
->analyse
.i_me_method
= X264_ME_HEX
;
119 param
->analyse
.f_psy_rd
= 1.0;
120 param
->analyse
.f_psy_trellis
= 0;
121 param
->analyse
.i_me_range
= 16;
122 param
->analyse
.i_subpel_refine
= 6;
123 param
->analyse
.b_chroma_me
= 1;
124 param
->analyse
.i_mv_range_thread
= -1;
125 param
->analyse
.i_mv_range
= -1; // set from level_idc
126 param
->analyse
.i_direct_8x8_inference
= 1;
127 param
->analyse
.i_chroma_qp_offset
= 0;
128 param
->analyse
.b_fast_pskip
= 1;
129 param
->analyse
.b_dct_decimate
= 1;
130 param
->analyse
.i_luma_deadzone
[0] = 21;
131 param
->analyse
.i_luma_deadzone
[1] = 11;
132 param
->analyse
.b_psnr
= 1;
133 param
->analyse
.b_ssim
= 1;
135 param
->i_cqm_preset
= X264_CQM_FLAT
;
136 memset( param
->cqm_4iy
, 16, 16 );
137 memset( param
->cqm_4ic
, 16, 16 );
138 memset( param
->cqm_4py
, 16, 16 );
139 memset( param
->cqm_4pc
, 16, 16 );
140 memset( param
->cqm_8iy
, 16, 64 );
141 memset( param
->cqm_8py
, 16, 64 );
143 param
->b_repeat_headers
= 1;
147 static int parse_enum( const char *arg
, const char * const *names
, int *dst
)
150 for( i
= 0; names
[i
]; i
++ )
151 if( !strcmp( arg
, names
[i
] ) )
159 static int parse_cqm( const char *str
, uint8_t *cqm
, int length
)
164 if( !sscanf( str
, "%d", &coef
) || coef
< 1 || coef
> 255 )
167 } while( i
< length
&& (str
= strchr( str
, ',' )) && str
++ );
168 return (i
== length
) ? 0 : -1;
171 static int x264_atobool( const char *str
, int *b_error
)
173 if( !strcmp(str
, "1") ||
174 !strcmp(str
, "true") ||
175 !strcmp(str
, "yes") )
177 if( !strcmp(str
, "0") ||
178 !strcmp(str
, "false") ||
185 static int x264_atoi( const char *str
, int *b_error
)
188 int v
= strtol( str
, &end
, 0 );
189 if( end
== str
|| *end
!= '\0' )
194 static double x264_atof( const char *str
, int *b_error
)
197 double v
= strtod( str
, &end
);
198 if( end
== str
|| *end
!= '\0' )
203 #define atobool(str) ( name_was_bool = 1, x264_atobool( str, &b_error ) )
204 #define atoi(str) x264_atoi( str, &b_error )
205 #define atof(str) x264_atof( str, &b_error )
207 int x264_param_parse( x264_param_t
*p
, const char *name
, const char *value
)
209 char *name_buf
= NULL
;
212 int value_was_null
= !value
;
216 return X264_PARAM_BAD_NAME
;
220 if( value
[0] == '=' )
223 if( strchr( name
, '_' ) ) // s/_/-/g
226 name_buf
= strdup(name
);
227 while( (p
= strchr( name_buf
, '_' )) )
232 if( (!strncmp( name
, "no-", 3 ) && (i
= 3)) ||
233 (!strncmp( name
, "no", 2 ) && (i
= 2)) )
236 value
= atobool(value
) ? "false" : "true";
240 #define OPT(STR) else if( !strcmp( name, STR ) )
241 #define OPT2(STR0, STR1) else if( !strcmp( name, STR0 ) || !strcmp( name, STR1 ) )
245 p
->cpu
= isdigit(value
[0]) ? atoi(value
) :
246 !strcmp(value
, "auto") || atobool(value
) ? x264_cpu_detect() : 0;
249 char *buf
= strdup(value
);
250 char *tok
, *saveptr
, *init
;
253 for( init
=buf
; (tok
=strtok_r(init
, ",", &saveptr
)); init
=NULL
)
255 for( i
=0; x264_cpu_names
[i
].flags
&& strcasecmp(tok
, x264_cpu_names
[i
].name
); i
++ );
256 p
->cpu
|= x264_cpu_names
[i
].flags
;
257 if( !x264_cpu_names
[i
].flags
)
265 if( !strcmp(value
, "auto") )
268 p
->i_threads
= atoi(value
);
270 OPT2("deterministic", "n-deterministic")
271 p
->b_deterministic
= atobool(value
);
272 OPT2("level", "level-idc")
274 if( atof(value
) < 6 )
275 p
->i_level_idc
= (int)(10*atof(value
)+.5);
277 p
->i_level_idc
= atoi(value
);
281 b_error
= ( 2 != sscanf( value
, "%d:%d", &p
->vui
.i_sar_width
, &p
->vui
.i_sar_height
) &&
282 2 != sscanf( value
, "%d/%d", &p
->vui
.i_sar_width
, &p
->vui
.i_sar_height
) );
285 b_error
|= parse_enum( value
, x264_overscan_names
, &p
->vui
.i_overscan
);
287 b_error
|= parse_enum( value
, x264_vidformat_names
, &p
->vui
.i_vidformat
);
289 b_error
|= parse_enum( value
, x264_fullrange_names
, &p
->vui
.b_fullrange
);
291 b_error
|= parse_enum( value
, x264_colorprim_names
, &p
->vui
.i_colorprim
);
293 b_error
|= parse_enum( value
, x264_transfer_names
, &p
->vui
.i_transfer
);
295 b_error
|= parse_enum( value
, x264_colmatrix_names
, &p
->vui
.i_colmatrix
);
298 p
->vui
.i_chroma_loc
= atoi(value
);
299 b_error
= ( p
->vui
.i_chroma_loc
< 0 || p
->vui
.i_chroma_loc
> 5 );
303 if( sscanf( value
, "%d/%d", &p
->i_fps_num
, &p
->i_fps_den
) == 2 )
307 float fps
= atof(value
);
308 p
->i_fps_num
= (int)(fps
* 1000 + .5);
312 OPT2("ref", "frameref")
313 p
->i_frame_reference
= atoi(value
);
316 p
->i_keyint_max
= atoi(value
);
317 if( p
->i_keyint_min
> p
->i_keyint_max
)
318 p
->i_keyint_min
= p
->i_keyint_max
;
320 OPT2("min-keyint", "keyint-min")
322 p
->i_keyint_min
= atoi(value
);
323 if( p
->i_keyint_max
< p
->i_keyint_min
)
324 p
->i_keyint_max
= p
->i_keyint_min
;
327 p
->i_scenecut_threshold
= atoi(value
);
329 p
->b_pre_scenecut
= atobool(value
);
331 p
->i_bframe
= atoi(value
);
334 p
->i_bframe_adaptive
= atobool(value
);
338 p
->i_bframe_adaptive
= atoi(value
);
342 p
->i_bframe_bias
= atoi(value
);
344 p
->b_bframe_pyramid
= atobool(value
);
346 p
->b_deblocking_filter
= !atobool(value
);
347 OPT2("filter", "deblock")
349 if( 2 == sscanf( value
, "%d:%d", &p
->i_deblocking_filter_alphac0
, &p
->i_deblocking_filter_beta
) ||
350 2 == sscanf( value
, "%d,%d", &p
->i_deblocking_filter_alphac0
, &p
->i_deblocking_filter_beta
) )
352 p
->b_deblocking_filter
= 1;
354 else if( sscanf( value
, "%d", &p
->i_deblocking_filter_alphac0
) )
356 p
->b_deblocking_filter
= 1;
357 p
->i_deblocking_filter_beta
= p
->i_deblocking_filter_alphac0
;
360 p
->b_deblocking_filter
= atobool(value
);
363 p
->b_cabac
= atobool(value
);
365 p
->i_cabac_init_idc
= atoi(value
);
367 p
->b_interlaced
= atobool(value
);
370 if( strstr( value
, "flat" ) )
371 p
->i_cqm_preset
= X264_CQM_FLAT
;
372 else if( strstr( value
, "jvt" ) )
373 p
->i_cqm_preset
= X264_CQM_JVT
;
375 p
->psz_cqm_file
= strdup(value
);
378 p
->psz_cqm_file
= strdup(value
);
381 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
382 b_error
|= parse_cqm( value
, p
->cqm_4iy
, 16 );
383 b_error
|= parse_cqm( value
, p
->cqm_4ic
, 16 );
384 b_error
|= parse_cqm( value
, p
->cqm_4py
, 16 );
385 b_error
|= parse_cqm( value
, p
->cqm_4pc
, 16 );
389 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
390 b_error
|= parse_cqm( value
, p
->cqm_8iy
, 64 );
391 b_error
|= parse_cqm( value
, p
->cqm_8py
, 64 );
395 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
396 b_error
|= parse_cqm( value
, p
->cqm_4iy
, 16 );
397 b_error
|= parse_cqm( value
, p
->cqm_4ic
, 16 );
401 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
402 b_error
|= parse_cqm( value
, p
->cqm_4py
, 16 );
403 b_error
|= parse_cqm( value
, p
->cqm_4pc
, 16 );
407 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
408 b_error
|= parse_cqm( value
, p
->cqm_4iy
, 16 );
412 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
413 b_error
|= parse_cqm( value
, p
->cqm_4ic
, 16 );
417 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
418 b_error
|= parse_cqm( value
, p
->cqm_4py
, 16 );
422 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
423 b_error
|= parse_cqm( value
, p
->cqm_4pc
, 16 );
427 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
428 b_error
|= parse_cqm( value
, p
->cqm_8iy
, 64 );
432 p
->i_cqm_preset
= X264_CQM_CUSTOM
;
433 b_error
|= parse_cqm( value
, p
->cqm_8py
, 64 );
436 p
->i_log_level
= atoi(value
);
439 p
->b_visualize
= atobool(value
);
442 p
->psz_dump_yuv
= strdup(value
);
443 OPT2("analyse", "partitions")
445 p
->analyse
.inter
= 0;
446 if( strstr( value
, "none" ) ) p
->analyse
.inter
= 0;
447 if( strstr( value
, "all" ) ) p
->analyse
.inter
= ~0;
449 if( strstr( value
, "i4x4" ) ) p
->analyse
.inter
|= X264_ANALYSE_I4x4
;
450 if( strstr( value
, "i8x8" ) ) p
->analyse
.inter
|= X264_ANALYSE_I8x8
;
451 if( strstr( value
, "p8x8" ) ) p
->analyse
.inter
|= X264_ANALYSE_PSUB16x16
;
452 if( strstr( value
, "p4x4" ) ) p
->analyse
.inter
|= X264_ANALYSE_PSUB8x8
;
453 if( strstr( value
, "b8x8" ) ) p
->analyse
.inter
|= X264_ANALYSE_BSUB16x16
;
456 p
->analyse
.b_transform_8x8
= atobool(value
);
457 OPT2("weightb", "weight-b")
458 p
->analyse
.b_weighted_bipred
= atobool(value
);
459 OPT2("direct", "direct-pred")
460 b_error
|= parse_enum( value
, x264_direct_pred_names
, &p
->analyse
.i_direct_mv_pred
);
462 p
->analyse
.i_direct_8x8_inference
= atoi(value
);
463 OPT("chroma-qp-offset")
464 p
->analyse
.i_chroma_qp_offset
= atoi(value
);
466 b_error
|= parse_enum( value
, x264_motion_est_names
, &p
->analyse
.i_me_method
);
467 OPT2("merange", "me-range")
468 p
->analyse
.i_me_range
= atoi(value
);
469 OPT2("mvrange", "mv-range")
470 p
->analyse
.i_mv_range
= atoi(value
);
471 OPT2("mvrange-thread", "mv-range-thread")
472 p
->analyse
.i_mv_range_thread
= atoi(value
);
473 OPT2("subme", "subq")
474 p
->analyse
.i_subpel_refine
= atoi(value
);
477 if( 2 == sscanf( value
, "%f:%f", &p
->analyse
.f_psy_rd
, &p
->analyse
.f_psy_trellis
) ||
478 2 == sscanf( value
, "%f,%f", &p
->analyse
.f_psy_rd
, &p
->analyse
.f_psy_trellis
) )
480 else if( sscanf( value
, "%f", &p
->analyse
.f_psy_rd
) )
482 p
->analyse
.f_psy_trellis
= 0;
486 p
->analyse
.f_psy_rd
= 0;
487 p
->analyse
.f_psy_trellis
= 0;
491 p
->analyse
.b_chroma_me
= atobool(value
);
493 p
->analyse
.b_mixed_references
= atobool(value
);
495 p
->analyse
.i_trellis
= atoi(value
);
497 p
->analyse
.b_fast_pskip
= atobool(value
);
499 p
->analyse
.b_dct_decimate
= atobool(value
);
500 OPT("deadzone-inter")
501 p
->analyse
.i_luma_deadzone
[0] = atoi(value
);
502 OPT("deadzone-intra")
503 p
->analyse
.i_luma_deadzone
[1] = atoi(value
);
505 p
->analyse
.i_noise_reduction
= atoi(value
);
508 p
->rc
.i_bitrate
= atoi(value
);
509 p
->rc
.i_rc_method
= X264_RC_ABR
;
511 OPT2("qp", "qp_constant")
513 p
->rc
.i_qp_constant
= atoi(value
);
514 p
->rc
.i_rc_method
= X264_RC_CQP
;
518 p
->rc
.f_rf_constant
= atof(value
);
519 p
->rc
.i_rc_method
= X264_RC_CRF
;
521 OPT2("qpmin", "qp-min")
522 p
->rc
.i_qp_min
= atoi(value
);
523 OPT2("qpmax", "qp-max")
524 p
->rc
.i_qp_max
= atoi(value
);
525 OPT2("qpstep", "qp-step")
526 p
->rc
.i_qp_step
= atoi(value
);
528 p
->rc
.f_rate_tolerance
= !strncmp("inf", value
, 3) ? 1e9
: atof(value
);
530 p
->rc
.i_vbv_max_bitrate
= atoi(value
);
532 p
->rc
.i_vbv_buffer_size
= atoi(value
);
534 p
->rc
.f_vbv_buffer_init
= atof(value
);
535 OPT2("ipratio", "ip-factor")
536 p
->rc
.f_ip_factor
= atof(value
);
537 OPT2("pbratio", "pb-factor")
538 p
->rc
.f_pb_factor
= atof(value
);
540 p
->rc
.i_aq_mode
= atoi(value
);
542 p
->rc
.f_aq_strength
= atof(value
);
545 int i
= x264_clip3( atoi(value
), 0, 3 );
546 p
->rc
.b_stat_write
= i
& 1;
547 p
->rc
.b_stat_read
= i
& 2;
551 p
->rc
.psz_stat_in
= strdup(value
);
552 p
->rc
.psz_stat_out
= strdup(value
);
555 p
->rc
.f_qcompress
= atof(value
);
557 p
->rc
.f_qblur
= atof(value
);
558 OPT2("cplxblur", "cplx-blur")
559 p
->rc
.f_complexity_blur
= atof(value
);
561 p
->rc
.psz_zones
= strdup(value
);
563 p
->analyse
.b_psnr
= atobool(value
);
565 p
->analyse
.b_ssim
= atobool(value
);
567 p
->b_aud
= atobool(value
);
569 p
->i_sps_id
= atoi(value
);
571 p
->b_repeat_headers
= !atobool(value
);
572 OPT("repeat-headers")
573 p
->b_repeat_headers
= atobool(value
);
575 return X264_PARAM_BAD_NAME
;
585 b_error
|= value_was_null
&& !name_was_bool
;
586 return b_error
? X264_PARAM_BAD_VALUE
: 0;
589 /****************************************************************************
591 ****************************************************************************/
592 void x264_log( x264_t
*h
, int i_level
, const char *psz_fmt
, ... )
594 if( i_level
<= h
->param
.i_log_level
)
597 va_start( arg
, psz_fmt
);
598 h
->param
.pf_log( h
->param
.p_log_private
, i_level
, psz_fmt
, arg
);
603 static void x264_log_default( void *p_unused
, int i_level
, const char *psz_fmt
, va_list arg
)
609 psz_prefix
= "error";
611 case X264_LOG_WARNING
:
612 psz_prefix
= "warning";
618 psz_prefix
= "debug";
621 psz_prefix
= "unknown";
624 fprintf( stderr
, "x264 [%s]: ", psz_prefix
);
625 vfprintf( stderr
, psz_fmt
, arg
);
628 /****************************************************************************
629 * x264_picture_alloc:
630 ****************************************************************************/
631 void x264_picture_alloc( x264_picture_t
*pic
, int i_csp
, int i_width
, int i_height
)
633 pic
->i_type
= X264_TYPE_AUTO
;
635 pic
->img
.i_csp
= i_csp
;
636 pic
->img
.i_plane
= 3;
637 pic
->img
.plane
[0] = x264_malloc( 3 * i_width
* i_height
/ 2 );
638 pic
->img
.plane
[1] = pic
->img
.plane
[0] + i_width
* i_height
;
639 pic
->img
.plane
[2] = pic
->img
.plane
[1] + i_width
* i_height
/ 4;
640 pic
->img
.i_stride
[0] = i_width
;
641 pic
->img
.i_stride
[1] = i_width
/ 2;
642 pic
->img
.i_stride
[2] = i_width
/ 2;
645 /****************************************************************************
646 * x264_picture_clean:
647 ****************************************************************************/
648 void x264_picture_clean( x264_picture_t
*pic
)
650 x264_free( pic
->img
.plane
[0] );
652 /* just to be safe */
653 memset( pic
, 0, sizeof( x264_picture_t
) );
656 /****************************************************************************
658 ****************************************************************************/
659 int x264_nal_encode( void *p_data
, int *pi_data
, int b_annexeb
, x264_nal_t
*nal
)
661 uint8_t *dst
= p_data
;
662 uint8_t *src
= nal
->p_payload
;
663 uint8_t *end
= &nal
->p_payload
[nal
->i_payload
];
666 /* FIXME this code doesn't check overflow */
670 /* long nal start code (we always use long ones)*/
678 *dst
++ = ( 0x00 << 7 ) | ( nal
->i_ref_idc
<< 5 ) | nal
->i_type
;
682 if( i_count
== 2 && *src
<= 0x03 )
693 *pi_data
= dst
- (uint8_t*)p_data
;
700 /****************************************************************************
702 ****************************************************************************/
703 void *x264_malloc( int i_size
)
706 /* Mac OS X always returns 16 bytes aligned memory */
707 return malloc( i_size
);
708 #elif defined( HAVE_MALLOC_H )
709 return memalign( 16, i_size
);
713 buf
= (uint8_t *) malloc( i_size
+ 15 + sizeof( void ** ) +
715 align_buf
= buf
+ 15 + sizeof( void ** ) + sizeof( int );
716 align_buf
-= (long) align_buf
& 15;
717 *( (void **) ( align_buf
- sizeof( void ** ) ) ) = buf
;
718 *( (int *) ( align_buf
- sizeof( void ** ) - sizeof( int ) ) ) = i_size
;
723 /****************************************************************************
725 ****************************************************************************/
726 void x264_free( void *p
)
730 #if defined( HAVE_MALLOC_H ) || defined( SYS_MACOSX )
733 free( *( ( ( void **) p
) - 1 ) );
738 /****************************************************************************
740 ****************************************************************************/
741 void *x264_realloc( void *p
, int i_size
)
744 return realloc( p
, i_size
);
750 i_old_size
= *( (int*) ( (uint8_t*) p
- sizeof( void ** ) -
753 p_new
= x264_malloc( i_size
);
754 if( i_old_size
> 0 && i_size
> 0 )
756 memcpy( p_new
, p
, ( i_old_size
< i_size
) ? i_old_size
: i_size
);
763 /****************************************************************************
764 * x264_reduce_fraction:
765 ****************************************************************************/
766 void x264_reduce_fraction( int *n
, int *d
)
784 /****************************************************************************
786 ****************************************************************************/
787 char *x264_slurp_file( const char *filename
)
792 FILE *fh
= fopen( filename
, "rb" );
795 b_error
|= fseek( fh
, 0, SEEK_END
) < 0;
796 b_error
|= ( i_size
= ftell( fh
) ) <= 0;
797 b_error
|= fseek( fh
, 0, SEEK_SET
) < 0;
800 buf
= x264_malloc( i_size
+2 );
803 b_error
|= fread( buf
, 1, i_size
, fh
) != i_size
;
804 if( buf
[i_size
-1] != '\n' )
805 buf
[i_size
++] = '\n';
816 /****************************************************************************
818 ****************************************************************************/
819 char *x264_param2string( x264_param_t
*p
, int b_res
)
823 if( p
->rc
.psz_zones
)
824 len
+= strlen(p
->rc
.psz_zones
);
825 buf
= s
= x264_malloc( len
);
829 s
+= sprintf( s
, "%dx%d ", p
->i_width
, p
->i_height
);
830 s
+= sprintf( s
, "fps=%d/%d ", p
->i_fps_num
, p
->i_fps_den
);
833 s
+= sprintf( s
, "cabac=%d", p
->b_cabac
);
834 s
+= sprintf( s
, " ref=%d", p
->i_frame_reference
);
835 s
+= sprintf( s
, " deblock=%d:%d:%d", p
->b_deblocking_filter
,
836 p
->i_deblocking_filter_alphac0
, p
->i_deblocking_filter_beta
);
837 s
+= sprintf( s
, " analyse=%#x:%#x", p
->analyse
.intra
, p
->analyse
.inter
);
838 s
+= sprintf( s
, " me=%s", x264_motion_est_names
[ p
->analyse
.i_me_method
] );
839 s
+= sprintf( s
, " subme=%d", p
->analyse
.i_subpel_refine
);
840 s
+= sprintf( s
, " psy_rd=%.1f:%.1f", p
->analyse
.f_psy_rd
, p
->analyse
.f_psy_trellis
);
841 s
+= sprintf( s
, " mixed_ref=%d", p
->analyse
.b_mixed_references
);
842 s
+= sprintf( s
, " me_range=%d", p
->analyse
.i_me_range
);
843 s
+= sprintf( s
, " chroma_me=%d", p
->analyse
.b_chroma_me
);
844 s
+= sprintf( s
, " trellis=%d", p
->analyse
.i_trellis
);
845 s
+= sprintf( s
, " 8x8dct=%d", p
->analyse
.b_transform_8x8
);
846 s
+= sprintf( s
, " cqm=%d", p
->i_cqm_preset
);
847 s
+= sprintf( s
, " deadzone=%d,%d", p
->analyse
.i_luma_deadzone
[0], p
->analyse
.i_luma_deadzone
[1] );
848 s
+= sprintf( s
, " chroma_qp_offset=%d", p
->analyse
.i_chroma_qp_offset
);
849 s
+= sprintf( s
, " threads=%d", p
->i_threads
);
850 s
+= sprintf( s
, " nr=%d", p
->analyse
.i_noise_reduction
);
851 s
+= sprintf( s
, " decimate=%d", p
->analyse
.b_dct_decimate
);
852 s
+= sprintf( s
, " mbaff=%d", p
->b_interlaced
);
854 s
+= sprintf( s
, " bframes=%d", p
->i_bframe
);
857 s
+= sprintf( s
, " b_pyramid=%d b_adapt=%d b_bias=%d direct=%d wpredb=%d",
858 p
->b_bframe_pyramid
, p
->i_bframe_adaptive
, p
->i_bframe_bias
,
859 p
->analyse
.i_direct_mv_pred
, p
->analyse
.b_weighted_bipred
);
862 s
+= sprintf( s
, " keyint=%d keyint_min=%d scenecut=%d%s",
863 p
->i_keyint_max
, p
->i_keyint_min
, p
->i_scenecut_threshold
,
864 p
->b_pre_scenecut
? "(pre)" : "" );
866 s
+= sprintf( s
, " rc=%s", p
->rc
.i_rc_method
== X264_RC_ABR
?
867 ( p
->rc
.b_stat_read
? "2pass" : p
->rc
.i_vbv_buffer_size
? "cbr" : "abr" )
868 : p
->rc
.i_rc_method
== X264_RC_CRF
? "crf" : "cqp" );
869 if( p
->rc
.i_rc_method
== X264_RC_ABR
|| p
->rc
.i_rc_method
== X264_RC_CRF
)
871 if( p
->rc
.i_rc_method
== X264_RC_CRF
)
872 s
+= sprintf( s
, " crf=%.1f", p
->rc
.f_rf_constant
);
874 s
+= sprintf( s
, " bitrate=%d ratetol=%.1f",
875 p
->rc
.i_bitrate
, p
->rc
.f_rate_tolerance
);
876 s
+= sprintf( s
, " qcomp=%.2f qpmin=%d qpmax=%d qpstep=%d",
877 p
->rc
.f_qcompress
, p
->rc
.i_qp_min
, p
->rc
.i_qp_max
, p
->rc
.i_qp_step
);
878 if( p
->rc
.b_stat_read
)
879 s
+= sprintf( s
, " cplxblur=%.1f qblur=%.1f",
880 p
->rc
.f_complexity_blur
, p
->rc
.f_qblur
);
881 if( p
->rc
.i_vbv_buffer_size
)
882 s
+= sprintf( s
, " vbv_maxrate=%d vbv_bufsize=%d",
883 p
->rc
.i_vbv_max_bitrate
, p
->rc
.i_vbv_buffer_size
);
885 else if( p
->rc
.i_rc_method
== X264_RC_CQP
)
886 s
+= sprintf( s
, " qp=%d", p
->rc
.i_qp_constant
);
887 if( !(p
->rc
.i_rc_method
== X264_RC_CQP
&& p
->rc
.i_qp_constant
== 0) )
889 s
+= sprintf( s
, " ip_ratio=%.2f", p
->rc
.f_ip_factor
);
891 s
+= sprintf( s
, " pb_ratio=%.2f", p
->rc
.f_pb_factor
);
892 s
+= sprintf( s
, " aq=%d", p
->rc
.i_aq_mode
);
893 if( p
->rc
.i_aq_mode
)
894 s
+= sprintf( s
, ":%.2f", p
->rc
.f_aq_strength
);
895 if( p
->rc
.psz_zones
)
896 s
+= sprintf( s
, " zones=%s", p
->rc
.psz_zones
);
897 else if( p
->rc
.i_zones
)
898 s
+= sprintf( s
, " zones" );