API tools faq
paste
Advertisement
Guest User

Dark Shikari

a guest
Aug 2nd, 2009
498
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 47.76 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/common/common.c b/common/common.c
  2. index 9260c64..37fd332 100644
  3. --- a/common/common.c
  4. +++ b/common/common.c
  5. @@ -72,6 +72,7 @@ void x264_param_default( x264_param_t *param )
  6. param->i_bframe_adaptive = X264_B_ADAPT_FAST;
  7. param->i_bframe_bias = 0;
  8. param->b_bframe_pyramid = 0;
  9. + param->i_lookahead = 50;
  10.  
  11. param->b_deblocking_filter = 1;
  12. param->i_deblocking_filter_alphac0 = 0;
  13. @@ -104,6 +105,7 @@ void x264_param_default( x264_param_t *param )
  14. param->rc.f_qblur = 0.5;
  15. param->rc.f_complexity_blur = 20;
  16. param->rc.i_zones = 0;
  17. + param->rc.b_mb_tree = 0;
  18.  
  19. /* Log */
  20. param->pf_log = x264_log_default;
  21. @@ -337,6 +339,8 @@ int x264_param_parse( x264_param_t *p, const char *name, const char *value )
  22. }
  23. OPT("bframes")
  24. p->i_bframe = atoi(value);
  25. + OPT("lookahead")
  26. + p->i_lookahead = atoi(value);
  27. OPT("b-adapt")
  28. {
  29. p->i_bframe_adaptive = atobool(value);
  30. @@ -559,6 +563,8 @@ int x264_param_parse( x264_param_t *p, const char *name, const char *value )
  31. }
  32. OPT("qcomp")
  33. p->rc.f_qcompress = atof(value);
  34. + OPT("mbtree")
  35. + p->rc.b_mb_tree = atobool(value);
  36. OPT("qblur")
  37. p->rc.f_qblur = atof(value);
  38. OPT2("cplxblur", "cplx-blur")
  39. @@ -868,9 +874,12 @@ char *x264_param2string( x264_param_t *p, int b_res )
  40. s += sprintf( s, " keyint=%d keyint_min=%d scenecut=%d",
  41. p->i_keyint_max, p->i_keyint_min, p->i_scenecut_threshold );
  42.  
  43. - s += sprintf( s, " rc=%s", p->rc.i_rc_method == X264_RC_ABR ?
  44. + if( p->i_bframe_adaptive == X264_B_ADAPT_TRELLIS )
  45. + s += sprintf( s, " lookahead=%d", p->i_lookahead );
  46. +
  47. + s += sprintf( s, " rc=%s mbtree=%d", p->rc.i_rc_method == X264_RC_ABR ?
  48. ( p->rc.b_stat_read ? "2pass" : p->rc.i_vbv_buffer_size ? "cbr" : "abr" )
  49. - : p->rc.i_rc_method == X264_RC_CRF ? "crf" : "cqp" );
  50. + : p->rc.i_rc_method == X264_RC_CRF ? "crf" : "cqp", p->rc.b_mb_tree );
  51. if( p->rc.i_rc_method == X264_RC_ABR || p->rc.i_rc_method == X264_RC_CRF )
  52. {
  53. if( p->rc.i_rc_method == X264_RC_CRF )
  54. @@ -878,8 +887,10 @@ char *x264_param2string( x264_param_t *p, int b_res )
  55. else
  56. s += sprintf( s, " bitrate=%d ratetol=%.1f",
  57. p->rc.i_bitrate, p->rc.f_rate_tolerance );
  58. - s += sprintf( s, " qcomp=%.2f qpmin=%d qpmax=%d qpstep=%d",
  59. - p->rc.f_qcompress, p->rc.i_qp_min, p->rc.i_qp_max, p->rc.i_qp_step );
  60. + if( !p->rc.b_mb_tree )
  61. + s += sprintf( s, " qcomp=%.2f", p->rc.f_qcompress );
  62. + s += sprintf( s, " qpmin=%d qpmax=%d qpstep=%d",
  63. + p->rc.i_qp_min, p->rc.i_qp_max, p->rc.i_qp_step );
  64. if( p->rc.b_stat_read )
  65. s += sprintf( s, " cplxblur=%.1f qblur=%.1f",
  66. p->rc.f_complexity_blur, p->rc.f_qblur );
  67. @@ -892,7 +903,7 @@ char *x264_param2string( x264_param_t *p, int b_res )
  68. if( !(p->rc.i_rc_method == X264_RC_CQP && p->rc.i_qp_constant == 0) )
  69. {
  70. s += sprintf( s, " ip_ratio=%.2f", p->rc.f_ip_factor );
  71. - if( p->i_bframe )
  72. + if( p->i_bframe && !p->rc.b_mb_tree )
  73. s += sprintf( s, " pb_ratio=%.2f", p->rc.f_pb_factor );
  74. s += sprintf( s, " aq=%d", p->rc.i_aq_mode );
  75. if( p->rc.i_aq_mode )
  76. diff --git a/common/common.h b/common/common.h
  77. index 8a25a13..5f9284e 100644
  78. --- a/common/common.h
  79. +++ b/common/common.h
  80. @@ -51,6 +51,7 @@
  81. #define X264_SLICE_MAX 4
  82. #define X264_NAL_MAX (4 + X264_SLICE_MAX)
  83. #define X264_PCM_COST (386*8)
  84. +#define X264_LOOKAHEAD_MAX 250
  85.  
  86. // number of pixels (per thread) in progress at any given time.
  87. // 16 for the macroblock in progress + 3 for deblocking + 3 for motion compensation filter + 2 for extra safety
  88. @@ -152,6 +153,24 @@ static inline uint32_t x264_cabac_amvd_sum( int16_t *mvdleft, int16_t *mvdtop )
  89. return amvd0 + (amvd1<<16);
  90. }
  91.  
  92. +static const uint8_t exp2_lut[64] = {
  93. + 1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 44, 47,
  94. + 50, 53, 57, 60, 64, 67, 71, 74, 78, 81, 85, 89, 93, 96, 100, 104,
  95. + 108, 112, 116, 120, 124, 128, 132, 137, 141, 145, 150, 154, 159, 163, 168, 172,
  96. + 177, 182, 186, 191, 196, 201, 206, 211, 216, 221, 226, 232, 237, 242, 248, 253,
  97. +};
  98. +
  99. +static ALWAYS_INLINE int x264_exp2fix8( float x )
  100. +{
  101. + int i, f;
  102. + x += 8;
  103. + if( x <= 0 ) return 0;
  104. + if( x >= 16 ) return 0xffff;
  105. + i = x;
  106. + f = (x-i)*64;
  107. + return (exp2_lut[f]+256) << i >> 8;
  108. +}
  109. +
  110. /****************************************************************************
  111. *
  112. ****************************************************************************/
  113. @@ -327,11 +346,11 @@ struct x264_t
  114. struct
  115. {
  116. /* Frames to be encoded (whose types have been decided) */
  117. - x264_frame_t *current[X264_BFRAME_MAX*4+3];
  118. + x264_frame_t *current[X264_LOOKAHEAD_MAX+3];
  119. /* Temporary buffer (frames types not yet decided) */
  120. - x264_frame_t *next[X264_BFRAME_MAX*4+3];
  121. + x264_frame_t *next[X264_LOOKAHEAD_MAX+3];
  122. /* Unused frames */
  123. - x264_frame_t *unused[X264_BFRAME_MAX*4 + X264_THREAD_MAX*2 + 16+4];
  124. + x264_frame_t *unused[X264_LOOKAHEAD_MAX + X264_THREAD_MAX*2 + 16+4];
  125. /* For adaptive B decision */
  126. x264_frame_t *last_nonb;
  127.  
  128. diff --git a/common/frame.c b/common/frame.c
  129. index 23e6824..4cba313 100644
  130. --- a/common/frame.c
  131. +++ b/common/frame.c
  132. @@ -96,6 +96,15 @@ x264_frame_t *x264_frame_new( x264_t *h )
  133. memset( frame->lowres_mvs[j][i], 0, 2*h->mb.i_mb_count*sizeof(int16_t) );
  134. CHECKED_MALLOC( frame->lowres_mv_costs[j][i], h->mb.i_mb_count*sizeof(int) );
  135. }
  136. + CHECKED_MALLOC( frame->i_intra_cost, i_mb_count * sizeof(uint16_t) );
  137. + memset( frame->i_intra_cost, -1, i_mb_count * sizeof(int16_t) );
  138. + CHECKED_MALLOC( frame->i_propagate_cost, i_mb_count * sizeof(uint32_t) );
  139. + for( j = 0; j <= h->param.i_bframe+1; j++ )
  140. + for( i = 0; i <= h->param.i_bframe+1; i++ )
  141. + {
  142. + CHECKED_MALLOC( frame->lowres_costs[j][i], i_mb_count * sizeof(uint16_t) );
  143. + CHECKED_MALLOC( frame->lowres_inter_types[j][i], i_mb_count * sizeof(uint8_t) );
  144. + }
  145. }
  146.  
  147. if( h->param.analyse.i_me_method >= X264_ME_ESA )
  148. @@ -116,7 +125,6 @@ x264_frame_t *x264_frame_new( x264_t *h )
  149. CHECKED_MALLOC( frame->mb_type, i_mb_count * sizeof(int8_t));
  150. CHECKED_MALLOC( frame->mv[0], 2*16 * i_mb_count * sizeof(int16_t) );
  151. CHECKED_MALLOC( frame->ref[0], 4 * i_mb_count * sizeof(int8_t) );
  152. - CHECKED_MALLOC( frame->i_intra_cost, i_mb_count * sizeof(uint16_t) );
  153. if( h->param.i_bframe )
  154. {
  155. CHECKED_MALLOC( frame->mv[1], 2*16 * i_mb_count * sizeof(int16_t) );
  156. @@ -141,6 +149,7 @@ x264_frame_t *x264_frame_new( x264_t *h )
  157. CHECKED_MALLOC( frame->i_inv_qscale_factor, h->mb.i_mb_count * sizeof(uint16_t) );
  158. }
  159.  
  160. +
  161. x264_pthread_mutex_init( &frame->mutex, NULL );
  162. x264_pthread_cond_init( &frame->cv, NULL );
  163.  
  164. diff --git a/common/frame.h b/common/frame.h
  165. index aad77f5..a3da4e4 100644
  166. --- a/common/frame.h
  167. +++ b/common/frame.h
  168. @@ -63,6 +63,8 @@ typedef struct
  169. int8_t *mb_type;
  170. int16_t (*mv[2])[2];
  171. int16_t (*lowres_mvs[2][X264_BFRAME_MAX+1])[2];
  172. + uint16_t (*lowres_costs[X264_BFRAME_MAX+2][X264_BFRAME_MAX+2]);
  173. + uint8_t (*lowres_inter_types[X264_BFRAME_MAX+2][X264_BFRAME_MAX+2]);
  174. int *lowres_mv_costs[2][X264_BFRAME_MAX+1];
  175. int8_t *ref[2];
  176. int i_ref[2];
  177. @@ -83,6 +85,7 @@ typedef struct
  178. float *f_qp_offset;
  179. int b_intra_calculated;
  180. uint16_t *i_intra_cost;
  181. + uint32_t *i_propagate_cost;
  182. uint16_t *i_inv_qscale_factor;
  183.  
  184. /* threading */
  185. diff --git a/encoder/encoder.c b/encoder/encoder.c
  186. index 0f1ccc8..add6b75 100644
  187. --- a/encoder/encoder.c
  188. +++ b/encoder/encoder.c
  189. @@ -441,6 +441,7 @@ static int x264_validate_parameters( x264_t *h )
  190. h->param.rc.i_qp_min = x264_clip3( (int)(X264_MIN3( qp_p, qp_i, qp_b )), 0, 51 );
  191. h->param.rc.i_qp_max = x264_clip3( (int)(X264_MAX3( qp_p, qp_i, qp_b ) + .999), 0, 51 );
  192. h->param.rc.i_aq_mode = 0;
  193. + h->param.rc.b_mb_tree = 0;
  194. }
  195. h->param.rc.i_qp_max = x264_clip3( h->param.rc.i_qp_max, 0, 51 );
  196. h->param.rc.i_qp_min = x264_clip3( h->param.rc.i_qp_min, 0, h->param.rc.i_qp_max );
  197. @@ -473,6 +474,14 @@ static int x264_validate_parameters( x264_t *h )
  198. if( !h->param.i_bframe )
  199. h->param.i_bframe_adaptive = X264_B_ADAPT_NONE;
  200. h->param.analyse.b_weighted_bipred = h->param.analyse.b_weighted_bipred && h->param.i_bframe > 0;
  201. + h->param.i_lookahead = X264_MIN( h->param.i_lookahead, X264_LOOKAHEAD_MAX );
  202. + if( h->param.rc.b_mb_tree && h->param.i_bframe && h->param.i_bframe_adaptive == X264_B_ADAPT_FAST )
  203. + {
  204. + x264_log( h, X264_LOG_WARNING, "mb_tree + b-adapt 1 is not supported\n" );
  205. + h->param.i_lookahead = 0;
  206. + h->param.rc.b_mb_tree = 0;
  207. + }
  208. +
  209. h->mb.b_direct_auto_write = h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO
  210. && h->param.i_bframe
  211. && ( h->param.rc.b_stat_write || !h->param.rc.b_stat_read );
  212. @@ -537,6 +546,17 @@ static int x264_validate_parameters( x264_t *h )
  213. h->param.rc.f_aq_strength = x264_clip3f( h->param.rc.f_aq_strength, 0, 3 );
  214. if( h->param.rc.f_aq_strength == 0 )
  215. h->param.rc.i_aq_mode = 0;
  216. + /* MB-tree requires AQ to be on, even if the strength is zero. */
  217. + if( !h->param.rc.i_aq_mode && h->param.rc.b_mb_tree )
  218. + {
  219. + h->param.rc.i_aq_mode = 1;
  220. + h->param.rc.f_aq_strength = 0;
  221. + if( h->param.b_bframe_pyramid )
  222. + {
  223. + x264_log( h, X264_LOG_WARNING, "b-pyramid + mb-tree is not supported\n" );
  224. + h->param.b_bframe_pyramid = 0;
  225. + }
  226. + }
  227. h->param.analyse.i_noise_reduction = x264_clip3( h->param.analyse.i_noise_reduction, 0, 1<<16 );
  228. if( h->param.analyse.i_subpel_refine == 10 && (h->param.analyse.i_trellis != 2 || !h->param.rc.i_aq_mode) )
  229. h->param.analyse.i_subpel_refine = 9;
  230. @@ -723,6 +743,9 @@ x264_t *x264_encoder_open ( x264_param_t *param )
  231. h->frames.i_delay = X264_MAX(h->param.i_bframe,3)*4 + h->param.i_threads - 1;
  232. else
  233. h->frames.i_delay = h->param.i_bframe + h->param.i_threads - 1;
  234. + if( h->param.rc.b_mb_tree )
  235. + h->frames.i_delay = X264_MAX( h->frames.i_delay, h->param.i_lookahead );
  236. +
  237. h->frames.i_max_ref0 = h->param.i_frame_reference;
  238. h->frames.i_max_ref1 = h->sps->vui.i_num_reorder_frames;
  239. h->frames.i_max_dpb = h->sps->vui.i_max_dec_frame_buffering;
  240. @@ -730,7 +753,8 @@ x264_t *x264_encoder_open ( x264_param_t *param )
  241. && ( h->param.rc.i_rc_method == X264_RC_ABR
  242. || h->param.rc.i_rc_method == X264_RC_CRF
  243. || h->param.i_bframe_adaptive
  244. - || h->param.i_scenecut_threshold );
  245. + || h->param.i_scenecut_threshold
  246. + || h->param.rc.b_mb_tree );
  247. h->frames.b_have_lowres |= (h->param.rc.b_stat_read && h->param.rc.i_vbv_buffer_size > 0);
  248. h->frames.b_have_sub8x8_esa = !!(h->param.analyse.inter & X264_ANALYSE_PSUB8x8);
  249.  
  250. @@ -1443,7 +1467,12 @@ int x264_encoder_encode( x264_t *h,
  251. if( h->frames.b_have_lowres )
  252. x264_frame_init_lowres( h, fenc );
  253.  
  254. - if( h->param.rc.i_aq_mode )
  255. + if( h->param.rc.b_mb_tree && h->param.rc.b_stat_read )
  256. + {
  257. + if( x264_macroblock_tree_read( h, fenc ) )
  258. + return -1;
  259. + }
  260. + else if( h->param.rc.i_aq_mode )
  261. x264_adaptive_quant_frame( h, fenc );
  262.  
  263. if( h->frames.i_input <= h->frames.i_delay + 1 - h->param.i_threads )
  264. diff --git a/encoder/ratecontrol.c b/encoder/ratecontrol.c
  265. index 2f88708..a34e581 100644
  266. --- a/encoder/ratecontrol.c
  267. +++ b/encoder/ratecontrol.c
  268. @@ -105,6 +105,10 @@ struct x264_ratecontrol_t
  269. /* 2pass stuff */
  270. FILE *p_stat_file_out;
  271. char *psz_stat_file_tmpname;
  272. + FILE *p_mbtree_stat_file_out;
  273. + char *psz_mbtree_stat_file_tmpname;
  274. + char *psz_mbtree_stat_file_name;
  275. + FILE *p_mbtree_stat_file_in;
  276.  
  277. int num_entries; /* number of ratecontrol_entry_ts */
  278. ratecontrol_entry_t *entry; /* FIXME: copy needed data and free this once init is done */
  279. @@ -209,30 +213,12 @@ static const float log2_lut[128] = {
  280. 0.95420, 0.96000, 0.96578, 0.97154, 0.97728, 0.98299, 0.98868, 0.99435,
  281. };
  282.  
  283. -static const uint8_t exp2_lut[64] = {
  284. - 1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 44, 47,
  285. - 50, 53, 57, 60, 64, 67, 71, 74, 78, 81, 85, 89, 93, 96, 100, 104,
  286. - 108, 112, 116, 120, 124, 128, 132, 137, 141, 145, 150, 154, 159, 163, 168, 172,
  287. - 177, 182, 186, 191, 196, 201, 206, 211, 216, 221, 226, 232, 237, 242, 248, 253,
  288. -};
  289. -
  290. static ALWAYS_INLINE float x264_log2( uint32_t x )
  291. {
  292. int lz = x264_clz( x );
  293. return log2_lut[(x<<lz>>24)&0x7f] + (31 - lz);
  294. }
  295.  
  296. -static ALWAYS_INLINE int x264_exp2fix8( float x )
  297. -{
  298. - int i, f;
  299. - x += 8;
  300. - if( x <= 0 ) return 0;
  301. - if( x >= 16 ) return 0xffff;
  302. - i = x;
  303. - f = (x-i)*64;
  304. - return (exp2_lut[f]+256) << i >> 8;
  305. -}
  306. -
  307. void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame )
  308. {
  309. /* constants chosen to result in approximately the same overall bitrate as without AQ.
  310. @@ -240,6 +226,17 @@ void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame )
  311. int mb_x, mb_y;
  312. float strength;
  313. float avg_adj = 0.f;
  314. + /* Need to init it anyways for MB tree. */
  315. + if( h->param.rc.f_aq_strength == 0 )
  316. + {
  317. + int mb_xy;
  318. + memset( frame->f_qp_offset, 0, sizeof(float) * h->mb.i_mb_count );
  319. + if( h->frames.b_have_lowres )
  320. + for( mb_xy = 0; mb_xy < h->mb.i_mb_count; mb_xy++ )
  321. + frame->i_inv_qscale_factor[mb_xy] = 256;
  322. + return;
  323. + }
  324. +
  325. if( h->param.rc.i_aq_mode == X264_AQ_AUTOVARIANCE )
  326. {
  327. for( mb_y = 0; mb_y < h->sps->i_mb_height; mb_y++ )
  328. @@ -256,6 +253,7 @@ void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame )
  329. }
  330. else
  331. strength = h->param.rc.f_aq_strength * 1.0397f;
  332. +
  333. for( mb_y = 0; mb_y < h->sps->i_mb_height; mb_y++ )
  334. for( mb_x = 0; mb_x < h->sps->i_mb_width; mb_x++ )
  335. {
  336. @@ -290,6 +288,34 @@ void x264_adaptive_quant( x264_t *h )
  337. h->mb.i_qp = x264_clip3( h->rc->f_qpm + h->fenc->f_qp_offset[h->mb.i_mb_xy] + .5, h->param.rc.i_qp_min, h->param.rc.i_qp_max );
  338. }
  339.  
  340. +int x264_macroblock_tree_read( x264_t *h, x264_frame_t *frame )
  341. +{
  342. + x264_ratecontrol_t *rc = h->rc;
  343. + uint8_t i_type_actual = rc->entry[frame->i_frame].pict_type;
  344. +
  345. + if( i_type_actual != SLICE_TYPE_B )
  346. + {
  347. + uint8_t i_type;
  348. + if( !fread( &i_type, 1, 1, rc->p_mbtree_stat_file_in ) )
  349. + goto fail;
  350. +
  351. + if( i_type != i_type_actual )
  352. + {
  353. + x264_log(h, X264_LOG_ERROR, "MB-tree frametype %d doesn't match actual frametype %d.\n", i_type,i_type_actual);
  354. + return -1;
  355. + }
  356. +
  357. + if( fread( frame->f_qp_offset, sizeof(float), h->mb.i_mb_count, rc->p_mbtree_stat_file_in ) != h->mb.i_mb_count )
  358. + goto fail;
  359. + }
  360. + else
  361. + x264_adaptive_quant_frame( h, frame );
  362. + return 0;
  363. +fail:
  364. + x264_log(h, X264_LOG_ERROR, "Incomplete MB-tree stats file.\n");
  365. + return -1;
  366. +}
  367. +
  368. int x264_ratecontrol_new( x264_t *h )
  369. {
  370. x264_ratecontrol_t *rc;
  371. @@ -309,6 +335,18 @@ int x264_ratecontrol_new( x264_t *h )
  372. else
  373. rc->fps = 25.0;
  374.  
  375. + if( h->param.rc.b_mb_tree )
  376. + {
  377. + h->param.rc.f_pb_factor = 1;
  378. + h->param.rc.f_qcompress = 1;
  379. + if( h->param.rc.i_vbv_buffer_size || h->param.rc.i_vbv_max_bitrate )
  380. + {
  381. + x264_log(h, X264_LOG_WARNING, "VBV is not currently supported with MB-tree.\n");
  382. + h->param.rc.i_vbv_buffer_size = 0;
  383. + h->param.rc.i_vbv_max_bitrate = 0;
  384. + }
  385. + }
  386. +
  387. rc->bitrate = h->param.rc.i_bitrate * 1000.;
  388. rc->rate_tolerance = h->param.rc.f_rate_tolerance;
  389. rc->nmb = h->mb.i_mb_count;
  390. @@ -385,10 +423,11 @@ int x264_ratecontrol_new( x264_t *h )
  391.  
  392. if( h->param.rc.i_rc_method == X264_RC_CRF )
  393. {
  394. - /* arbitrary rescaling to make CRF somewhat similar to QP */
  395. + /* Arbitrary rescaling to make CRF somewhat similar to QP.
  396. + * Try to compensate for MB-tree's effects as well. */
  397. double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
  398. rc->rate_factor_constant = pow( base_cplx, 1 - h->param.rc.f_qcompress )
  399. - / qp2qscale( h->param.rc.f_rf_constant );
  400. + / qp2qscale( h->param.rc.f_rf_constant + (h->param.rc.b_mb_tree?5:0) );
  401. }
  402.  
  403. rc->ip_offset = 6.0 * log(h->param.rc.f_ip_factor) / log(2.0);
  404. @@ -434,6 +473,19 @@ int x264_ratecontrol_new( x264_t *h )
  405. x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open stats file\n");
  406. return -1;
  407. }
  408. + if( h->param.rc.b_mb_tree )
  409. + {
  410. + char *mbtree_stats_in = x264_malloc( strlen(h->param.rc.psz_stat_in) + 8 );
  411. + strcpy( mbtree_stats_in, h->param.rc.psz_stat_in );
  412. + strcat( mbtree_stats_in, ".mbtree" );
  413. + rc->p_mbtree_stat_file_in = fopen( mbtree_stats_in, "rb" );
  414. + x264_free( mbtree_stats_in );
  415. + if( !rc->p_mbtree_stat_file_in )
  416. + {
  417. + x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open mbtree stats file\n");
  418. + return -1;
  419. + }
  420. + }
  421.  
  422. /* check whether 1st pass options were compatible with current options */
  423. if( !strncmp( stats_buf, "#options:", 9 ) )
  424. @@ -597,6 +649,22 @@ int x264_ratecontrol_new( x264_t *h )
  425. p = x264_param2string( &h->param, 1 );
  426. fprintf( rc->p_stat_file_out, "#options: %s\n", p );
  427. x264_free( p );
  428. + if( h->param.rc.b_mb_tree && !h->param.rc.b_stat_read )
  429. + {
  430. + rc->psz_mbtree_stat_file_tmpname = x264_malloc( strlen(h->param.rc.psz_stat_out) + 13 );
  431. + strcpy( rc->psz_mbtree_stat_file_tmpname, h->param.rc.psz_stat_out );
  432. + strcat( rc->psz_mbtree_stat_file_tmpname, ".mbtree.temp" );
  433. + rc->psz_mbtree_stat_file_name = x264_malloc( strlen(h->param.rc.psz_stat_out) + 8 );
  434. + strcpy( rc->psz_mbtree_stat_file_name, h->param.rc.psz_stat_out );
  435. + strcat( rc->psz_mbtree_stat_file_name, ".mbtree" );
  436. +
  437. + rc->p_mbtree_stat_file_out = fopen( rc->psz_mbtree_stat_file_tmpname, "wb" );
  438. + if( rc->p_mbtree_stat_file_out == NULL )
  439. + {
  440. + x264_log(h, X264_LOG_ERROR, "ratecontrol_init: can't open mbtree stats file\n");
  441. + return -1;
  442. + }
  443. + }
  444. }
  445.  
  446. for( i=0; i<h->param.i_threads; i++ )
  447. @@ -737,7 +805,7 @@ void x264_ratecontrol_summary( x264_t *h )
  448. double base_cplx = h->mb.i_mb_count * (h->param.i_bframe ? 120 : 80);
  449. x264_log( h, X264_LOG_INFO, "final ratefactor: %.2f\n",
  450. qscale2qp( pow( base_cplx, 1 - h->param.rc.f_qcompress )
  451. - * rc->cplxr_sum / rc->wanted_bits_window ) );
  452. + * rc->cplxr_sum / rc->wanted_bits_window ) - (h->param.rc.b_mb_tree?5:0) );
  453. }
  454. }
  455.  
  456. @@ -757,6 +825,18 @@ void x264_ratecontrol_delete( x264_t *h )
  457. }
  458. x264_free( rc->psz_stat_file_tmpname );
  459. }
  460. + if( rc->p_mbtree_stat_file_out )
  461. + {
  462. + fclose( rc->p_mbtree_stat_file_out );
  463. + if( h->i_frame >= rc->num_entries )
  464. + if( rename( rc->psz_mbtree_stat_file_tmpname, rc->psz_mbtree_stat_file_name ) != 0 )
  465. + {
  466. + x264_log( h, X264_LOG_ERROR, "failed to rename \"%s\" to \"%s\"\n",
  467. + rc->psz_mbtree_stat_file_tmpname, rc->psz_mbtree_stat_file_name );
  468. + }
  469. + x264_free( rc->psz_mbtree_stat_file_tmpname );
  470. + x264_free( rc->psz_mbtree_stat_file_name );
  471. + }
  472. x264_free( rc->pred );
  473. x264_free( rc->pred_b_from_p );
  474. x264_free( rc->entry );
  475. @@ -1122,6 +1202,15 @@ void x264_ratecontrol_end( x264_t *h, int bits )
  476. h->stat.frame.i_mb_count_p,
  477. h->stat.frame.i_mb_count_skip,
  478. c_direct);
  479. +
  480. + /* TODO: deal with endianness.
  481. + * Don't re-write the data in multi-pass mode. */
  482. + if( h->param.rc.b_mb_tree && h->fenc->b_kept_as_ref && !h->param.rc.b_stat_read )
  483. + {
  484. + uint8_t i_type = h->sh.i_type;
  485. + fwrite( &i_type, 1, 1, rc->p_mbtree_stat_file_out );
  486. + fwrite( h->fenc->f_qp_offset, sizeof(float), h->mb.i_mb_count, rc->p_mbtree_stat_file_out );
  487. + }
  488. }
  489.  
  490. if( rc->b_abr )
  491. diff --git a/encoder/ratecontrol.h b/encoder/ratecontrol.h
  492. index 3310d3c..a0b62b2 100644
  493. --- a/encoder/ratecontrol.h
  494. +++ b/encoder/ratecontrol.h
  495. @@ -29,6 +29,7 @@ void x264_ratecontrol_delete( x264_t * );
  496.  
  497. void x264_adaptive_quant_frame( x264_t *h, x264_frame_t *frame );
  498. void x264_adaptive_quant( x264_t * );
  499. +int x264_macroblock_tree_read( x264_t *h, x264_frame_t *frame );
  500. void x264_thread_sync_ratecontrol( x264_t *cur, x264_t *prev, x264_t *next );
  501. void x264_ratecontrol_start( x264_t *, int i_force_qp );
  502. int x264_ratecontrol_slice_type( x264_t *, int i_frame );
  503. diff --git a/encoder/slicetype.c b/encoder/slicetype.c
  504. index 2c16429..ca71c5a 100644
  505. --- a/encoder/slicetype.c
  506. +++ b/encoder/slicetype.c
  507. @@ -63,6 +63,7 @@ static int x264_slicetype_mb_cost( x264_t *h, x264_mb_analysis_t *a,
  508. x264_me_t m[2];
  509. int i_bcost = COST_MAX;
  510. int l, i;
  511. + int list_used = 0;
  512.  
  513. h->mb.pic.p_fenc[0] = h->mb.pic.fenc_buf;
  514. h->mc.copy[PIXEL_8x8]( h->mb.pic.p_fenc[0], FENC_STRIDE, &fenc->lowres[0][i_pel_offset], i_stride, 8 );
  515. @@ -107,8 +108,7 @@ static int x264_slicetype_mb_cost( x264_t *h, x264_mb_analysis_t *a,
  516. h->mc.avg[PIXEL_8x8]( pix1, 16, src1, stride1, src2, stride2, i_bipred_weight ); \
  517. i_cost = penalty + h->pixf.mbcmp[PIXEL_8x8]( \
  518. m[0].p_fenc[0], FENC_STRIDE, pix1, 16 ); \
  519. - if( i_bcost > i_cost ) \
  520. - i_bcost = i_cost; \
  521. + COPY2_IF_LT( i_bcost, i_cost, list_used, 3 ); \
  522. }
  523.  
  524. m[0].i_pixel = PIXEL_8x8;
  525. @@ -138,8 +138,7 @@ static int x264_slicetype_mb_cost( x264_t *h, x264_mb_analysis_t *a,
  526. int i_cost;
  527. h->mc.avg[PIXEL_8x8]( pix1, 16, m[0].p_fref[0], m[0].i_stride[0], m[1].p_fref[0], m[1].i_stride[0], i_bipred_weight );
  528. i_cost = h->pixf.mbcmp[PIXEL_8x8]( m[0].p_fenc[0], FENC_STRIDE, pix1, 16 );
  529. - if( i_bcost > i_cost )
  530. - i_bcost = i_cost;
  531. + COPY2_IF_LT( i_bcost, i_cost, list_used, 3 );
  532. }
  533. }
  534.  
  535. @@ -181,16 +180,18 @@ static int x264_slicetype_mb_cost( x264_t *h, x264_mb_analysis_t *a,
  536. *(uint32_t*)m[l].mv = *(uint32_t*)fenc_mvs[l];
  537. m[l].cost = *fenc_costs[l];
  538. }
  539. - i_bcost = X264_MIN( i_bcost, m[l].cost );
  540. + COPY2_IF_LT( i_bcost, m[l].cost, list_used, l+1 );
  541. }
  542.  
  543. if( b_bidir && ( *(uint32_t*)m[0].mv || *(uint32_t*)m[1].mv ) )
  544. TRY_BIDIR( m[0].mv, m[1].mv, 5 );
  545.  
  546. + frames[b]->lowres_inter_types[b-p0][p1-b][i_mb_xy] = list_used;
  547. +
  548. lowres_intra_mb:
  549. /* forbid intra-mbs in B-frames, because it's rare and not worth checking */
  550. /* FIXME: Should we still forbid them now that we cache intra scores? */
  551. - if( !b_bidir )
  552. + if( !b_bidir || h->param.rc.b_mb_tree )
  553. {
  554. int i_icost, b_intra;
  555. if( !fenc->b_intra_calculated )
  556. @@ -237,18 +238,23 @@ lowres_intra_mb:
  557. }
  558. else
  559. i_icost = fenc->i_intra_cost[i_mb_xy];
  560. - b_intra = i_icost < i_bcost;
  561. - if( b_intra )
  562. - i_bcost = i_icost;
  563. - if( (i_mb_x > 0 && i_mb_x < h->sps->i_mb_width - 1
  564. - && i_mb_y > 0 && i_mb_y < h->sps->i_mb_height - 1)
  565. - || h->sps->i_mb_width <= 2 || h->sps->i_mb_height <= 2 )
  566. + if( !b_bidir )
  567. {
  568. - fenc->i_intra_mbs[b-p0] += b_intra;
  569. - fenc->i_cost_est[0][0] += i_icost;
  570. + b_intra = i_icost < i_bcost;
  571. + if( b_intra )
  572. + i_bcost = i_icost;
  573. + if( (i_mb_x > 0 && i_mb_x < h->sps->i_mb_width - 1
  574. + && i_mb_y > 0 && i_mb_y < h->sps->i_mb_height - 1)
  575. + || h->sps->i_mb_width <= 2 || h->sps->i_mb_height <= 2 )
  576. + {
  577. + fenc->i_intra_mbs[b-p0] += b_intra;
  578. + fenc->i_cost_est[0][0] += i_icost;
  579. + }
  580. }
  581. }
  582.  
  583. + frames[b]->lowres_costs[b-p0][p1-b][i_mb_xy] = i_bcost;
  584. +
  585. return i_bcost;
  586. }
  587. #undef TRY_BIDIR
  588. @@ -262,6 +268,7 @@ static int x264_slicetype_frame_cost( x264_t *h, x264_mb_analysis_t *a,
  589. x264_frame_t **frames, int p0, int p1, int b,
  590. int b_intra_penalty )
  591. {
  592. +
  593. int i_score = 0;
  594. /* Don't use the AQ'd scores for slicetype decision. */
  595. int i_score_aq = 0;
  596. @@ -299,7 +306,8 @@ static int x264_slicetype_frame_cost( x264_t *h, x264_mb_analysis_t *a,
  597.  
  598. /* the edge mbs seem to reduce the predictive quality of the
  599. * whole frame's score, but are needed for a spatial distribution. */
  600. - if( h->param.rc.i_vbv_buffer_size || h->sps->i_mb_width <= 2 || h->sps->i_mb_height <= 2 )
  601. + if( h->param.rc.b_mb_tree || h->param.rc.i_vbv_buffer_size ||
  602. + h->sps->i_mb_width <= 2 || h->sps->i_mb_height <= 2 )
  603. {
  604. for( h->mb.i_mb_y = h->sps->i_mb_height - 1; h->mb.i_mb_y >= 0; h->mb.i_mb_y-- )
  605. {
  606. @@ -355,7 +363,169 @@ static int x264_slicetype_frame_cost( x264_t *h, x264_mb_analysis_t *a,
  607. return i_score;
  608. }
  609.  
  610. -#define MAX_LENGTH (X264_BFRAME_MAX*4)
  611. +/* If MB-tree changes the quantizers, we need to recalculate the frame cost without
  612. + * re-running lookahead. */
  613. +static int x264_slicetype_frame_cost_recalculate( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames,
  614. + int p0, int p1, int b )
  615. +{
  616. + int i_score = 0;
  617. + int *row_satd = frames[b]->i_row_satds[b-p0][p1-b];
  618. + x264_emms();
  619. + for( h->mb.i_mb_y = h->sps->i_mb_height - 1; h->mb.i_mb_y >= 0; h->mb.i_mb_y-- )
  620. + {
  621. + row_satd[ h->mb.i_mb_y ] = 0;
  622. + for( h->mb.i_mb_x = h->sps->i_mb_width - 1; h->mb.i_mb_x >= 0; h->mb.i_mb_x-- )
  623. + {
  624. + int i_mb_xy = h->mb.i_mb_x + h->mb.i_mb_y*h->mb.i_mb_stride;
  625. + int i_mb_cost = frames[b]->lowres_costs[b-p0][p1-b][i_mb_xy];
  626. + float qp_adj = frames[b]->f_qp_offset[i_mb_xy];
  627. + i_mb_cost = (i_mb_cost * x264_exp2fix8(qp_adj*(-1.f/6.f)) + 128) >> 8;
  628. + row_satd[ h->mb.i_mb_y ] += i_mb_cost;
  629. + if( (h->mb.i_mb_y > 0 && h->mb.i_mb_y < h->sps->i_mb_height - 1 &&
  630. + h->mb.i_mb_x > 0 && h->mb.i_mb_x < h->sps->i_mb_width - 1) ||
  631. + h->sps->i_mb_width <= 2 || h->sps->i_mb_height <= 2 )
  632. + {
  633. + i_score += i_mb_cost;
  634. + }
  635. + }
  636. + }
  637. + return i_score;
  638. +}
  639. +
  640. +static void x264_macroblock_tree_propagate( x264_t *h, x264_frame_t **frames, int p0, int p1, int b )
  641. +{
  642. + int refs[2] = {p0,p1};
  643. + int dist_scale_factor = p1 != p0 ? 128 : ( ((b-p0) << 8) + ((p1-p0) >> 1) ) / (p1-p0);
  644. + int i_bipred_weight = h->param.analyse.b_weighted_bipred ? 64 - (dist_scale_factor>>2) : 32;
  645. +
  646. + for( h->mb.i_mb_y = 0; h->mb.i_mb_y < h->sps->i_mb_height; h->mb.i_mb_y++ )
  647. + {
  648. + for( h->mb.i_mb_x = 0; h->mb.i_mb_x < h->sps->i_mb_width; h->mb.i_mb_x++ )
  649. + {
  650. + int mb_index = h->mb.i_mb_x + h->mb.i_mb_y*h->mb.i_mb_stride;
  651. + int inter_cost = frames[b]->lowres_costs[b-p0][p1-b][mb_index];
  652. + int intra_cost = (frames[b]->i_intra_cost[mb_index] * frames[b]->i_inv_qscale_factor[mb_index]+128)>>8;
  653. + int lists_used = frames[b]->lowres_inter_types[b-p0][p1-b][mb_index];
  654. + /* The approximate amount of data that this block contains. */
  655. + int propagate_amount = intra_cost + frames[b]->i_propagate_cost[mb_index];
  656. +
  657. + /* Divide by 64 for per-pixel summing. */
  658. + propagate_amount = (((uint64_t)propagate_amount*(intra_cost-inter_cost)) / intra_cost + 32) >> 6;
  659. +
  660. + /* Don't propagate for an intra block. */
  661. + if( inter_cost < intra_cost )
  662. + {
  663. + int mv[2][2], list;
  664. + mv[0][0] = frames[b]->lowres_mvs[0][b-p0-1][mb_index][0];
  665. + mv[0][1] = frames[b]->lowres_mvs[0][b-p0-1][mb_index][1];
  666. + if( b != p1 )
  667. + {
  668. + mv[1][0] = frames[b]->lowres_mvs[1][p1-b-1][mb_index][0];
  669. + mv[1][1] = frames[b]->lowres_mvs[1][p1-b-1][mb_index][1];
  670. + }
  671. +
  672. + /* Follow the MVs to the previous frame(s). */
  673. + for( list = 0; list < 2; list++ )
  674. + if( (lists_used >> list)&1 )
  675. + {
  676. + int x = mv[list][0];
  677. + int y = mv[list][1];
  678. + int listamount = propagate_amount;
  679. + int mbx = (x>>5)+h->mb.i_mb_x;
  680. + int mby = ((y>>5)+h->mb.i_mb_y);
  681. + int idx0 = mbx + mby*h->mb.i_mb_stride;
  682. + int idx1 = idx0 + 1;
  683. + int idx2 = idx0 + h->mb.i_mb_stride;
  684. + int idx3 = idx0 + h->mb.i_mb_stride + 1;
  685. + int idx0weight = (32-(y&31))*(32-(x&31));
  686. + int idx1weight = (32-(y&31))*(x&31);
  687. + int idx2weight = (y&31)*(32-(x&31));
  688. + int idx3weight = (y&31)*(x&31);
  689. +
  690. + /* Apply bipred weighting. */
  691. + if( lists_used == 3 )
  692. + listamount = (listamount * (list?(64-i_bipred_weight):i_bipred_weight) + 32) >> 6;
  693. +
  694. + /* We could just clip the MVs, but pixels that lie outside the frame probably shouldn't
  695. + * be counted. */
  696. + if( mbx < h->sps->i_mb_width-1 && mby < h->sps->i_mb_height-1 && mbx >= 0 && mby >= 0 )
  697. + {
  698. + frames[refs[list]]->i_propagate_cost[idx0] += (listamount*idx0weight+8)>>4;
  699. + frames[refs[list]]->i_propagate_cost[idx1] += (listamount*idx1weight+8)>>4;
  700. + frames[refs[list]]->i_propagate_cost[idx2] += (listamount*idx2weight+8)>>4;
  701. + frames[refs[list]]->i_propagate_cost[idx3] += (listamount*idx3weight+8)>>4;
  702. + }
  703. + else /* Check offsets individually */
  704. + {
  705. + if( mbx < h->sps->i_mb_width && mby < h->sps->i_mb_height && mbx >= 0 && mby >= 0 )
  706. + frames[refs[list]]->i_propagate_cost[idx0] += (listamount*idx0weight+8)>>4;
  707. + if( mbx+1 < h->sps->i_mb_width && mby < h->sps->i_mb_height && mbx+1 >= 0 && mby >= 0 )
  708. + frames[refs[list]]->i_propagate_cost[idx1] += (listamount*idx1weight+8)>>4;
  709. + if( mbx < h->sps->i_mb_width && mby+1 < h->sps->i_mb_height && mbx >= 0 && mby+1 >= 0 )
  710. + frames[refs[list]]->i_propagate_cost[idx2] += (listamount*idx2weight+8)>>4;
  711. + if( mbx+1 < h->sps->i_mb_width && mby+1 < h->sps->i_mb_height && mbx+1 >= 0 && mby+1 >= 0 )
  712. + frames[refs[list]]->i_propagate_cost[idx3] += (listamount*idx3weight+8)>>4;
  713. + }
  714. + }
  715. + }
  716. + }
  717. + }
  718. +}
  719. +
  720. +static void x264_macroblock_tree( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames, int num_frames, int b_intra )
  721. +{
  722. + int i, idx = !b_intra;
  723. + int last_nonb, cur_nonb = 1;
  724. + if( b_intra )
  725. + x264_slicetype_frame_cost( h, a, frames, 0, 0, 0, 0 );
  726. +
  727. + i = num_frames-1;
  728. + while( i > 0 && frames[i]->i_type == X264_TYPE_B )
  729. + i--;
  730. + last_nonb = i;
  731. +
  732. + if( last_nonb < 0 )
  733. + return;
  734. +
  735. + memset( frames[last_nonb]->i_propagate_cost, 0, h->mb.i_mb_count * sizeof(uint32_t) );
  736. + while( i-- > idx )
  737. + {
  738. + cur_nonb = i;
  739. + while( frames[cur_nonb]->i_type == X264_TYPE_B && cur_nonb > 0 )
  740. + cur_nonb--;
  741. + if( cur_nonb < idx )
  742. + break;
  743. + x264_slicetype_frame_cost( h, a, frames, cur_nonb, last_nonb, last_nonb, 0 );
  744. + memset( frames[cur_nonb]->i_propagate_cost, 0, h->mb.i_mb_count * sizeof(uint32_t) );
  745. + x264_macroblock_tree_propagate( h, frames, cur_nonb, last_nonb, last_nonb );
  746. + while( frames[i]->i_type == X264_TYPE_B && i > 0 )
  747. + {
  748. + x264_slicetype_frame_cost( h, a, frames, cur_nonb, last_nonb, i, 0 );
  749. + memset( frames[i]->i_propagate_cost, 0, h->mb.i_mb_count * sizeof(uint32_t) );
  750. + x264_macroblock_tree_propagate( h, frames, cur_nonb, last_nonb, i );
  751. + i--;
  752. + }
  753. + last_nonb = cur_nonb;
  754. + }
  755. + x264_emms();
  756. +
  757. + for( h->mb.i_mb_y = 0; h->mb.i_mb_y < h->sps->i_mb_height; h->mb.i_mb_y++ )
  758. + {
  759. + for( h->mb.i_mb_x = 0; h->mb.i_mb_x < h->sps->i_mb_width; h->mb.i_mb_x++ )
  760. + {
  761. + int mb_index = h->mb.i_mb_x + h->mb.i_mb_y*h->mb.i_mb_stride;
  762. + float intra_cost = (frames[last_nonb]->i_intra_cost[mb_index] * frames[last_nonb]->i_inv_qscale_factor[mb_index]+128)>>8;
  763. +
  764. + if( intra_cost )
  765. + {
  766. + float propagate_cost = frames[last_nonb]->i_propagate_cost[mb_index];
  767. + float ratio = (intra_cost + propagate_cost) / (intra_cost);
  768. + /* Magic formula is made of magic. */
  769. + frames[last_nonb]->f_qp_offset[mb_index] -= 2.0 * log2f(ratio);
  770. + }
  771. + }
  772. + }
  773. +}
  774.  
  775. static int x264_slicetype_path_cost( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames, char *path, int threshold )
  776. {
  777. @@ -393,14 +563,14 @@ static int x264_slicetype_path_cost( x264_t *h, x264_mb_analysis_t *a, x264_fram
  778. /* Uses strings due to the fact that the speed of the control functions is
  779. negligable compared to the cost of running slicetype_frame_cost, and because
  780. it makes debugging easier. */
  781. -static void x264_slicetype_path( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames, int length, int max_bframes, int buffer_size, char (*best_paths)[MAX_LENGTH] )
  782. +static void x264_slicetype_path( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames, int length, int max_bframes, int buffer_size, char (*best_paths)[X264_LOOKAHEAD_MAX] )
  783. {
  784. - char paths[X264_BFRAME_MAX+2][MAX_LENGTH] = {{0}};
  785. + char paths[X264_BFRAME_MAX+2][X264_LOOKAHEAD_MAX] = {{0}};
  786. int num_paths = X264_MIN(max_bframes+1, length);
  787. int suffix_size, loc, path;
  788. int best_cost = COST_MAX;
  789. int best_path_index = 0;
  790. - length = X264_MIN(length,MAX_LENGTH);
  791. + length = X264_MIN(length,X264_LOOKAHEAD_MAX);
  792.  
  793. /* Iterate over all currently possible paths and add suffixes to each one */
  794. for( suffix_size = 0; suffix_size < num_paths; suffix_size++ )
  795. @@ -426,15 +596,6 @@ static void x264_slicetype_path( x264_t *h, x264_mb_analysis_t *a, x264_frame_t
  796. memcpy( best_paths[length], paths[best_path_index], length );
  797. }
  798.  
  799. -static int x264_slicetype_path_search( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames, int length, int bframes, int buffer )
  800. -{
  801. - char best_paths[MAX_LENGTH][MAX_LENGTH] = {"","P"};
  802. - int n;
  803. - for( n = 2; n < length-1; n++ )
  804. - x264_slicetype_path( h, a, frames, n, bframes, buffer, best_paths );
  805. - return strspn( best_paths[length-2], "B" );
  806. -}
  807. -
  808. static int scenecut( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames, int p0, int p1 )
  809. {
  810. x264_frame_t *frame = frames[p1];
  811. @@ -477,10 +638,10 @@ static int scenecut( x264_t *h, x264_mb_analysis_t *a, x264_frame_t **frames, in
  812. return res;
  813. }
  814.  
  815. -static void x264_slicetype_analyse( x264_t *h )
  816. +static void x264_slicetype_analyse( x264_t *h, int keyframe )
  817. {
  818. x264_mb_analysis_t a;
  819. - x264_frame_t *frames[X264_BFRAME_MAX*4+3] = { NULL, };
  820. + x264_frame_t *frames[X264_LOOKAHEAD_MAX+3] = { NULL, };
  821. int num_frames;
  822. int keyint_limit;
  823. int j;
  824. @@ -497,13 +658,14 @@ static void x264_slicetype_analyse( x264_t *h )
  825. frames[j+1] = h->frames.next[j];
  826. keyint_limit = h->param.i_keyint_max - frames[0]->i_frame + h->frames.i_last_idr - 1;
  827. num_frames = X264_MIN( j, keyint_limit );
  828. - if( num_frames == 0 )
  829. +
  830. + if( num_frames == 0 && (!j || !h->param.rc.b_mb_tree) )
  831. return;
  832.  
  833. x264_lowres_context_init( h, &a );
  834. idr_frame_type = frames[1]->i_frame - h->frames.i_last_idr >= h->param.i_keyint_min ? X264_TYPE_IDR : X264_TYPE_I;
  835.  
  836. - if( num_frames == 1 )
  837. + if( num_frames == 1 && !h->param.rc.b_mb_tree )
  838. {
  839. no_b_frames:
  840. frames[1]->i_type = X264_TYPE_P;
  841. @@ -512,28 +674,84 @@ no_b_frames:
  842. return;
  843. }
  844.  
  845. - if( h->param.i_bframe_adaptive == X264_B_ADAPT_TRELLIS )
  846. + if( h->param.i_bframe_adaptive == X264_B_ADAPT_TRELLIS || h->param.rc.b_mb_tree )
  847. {
  848. - int num_bframes;
  849. + /* This is important psy-wise: if we have a non-scenecut keyframe,
  850. + * there will be significant visual artifacts if the frames just before
  851. + * go down in quality due to being referenced less, despite it being
  852. + * more RD-optimal. */
  853. + num_frames = j;
  854. +
  855. + char best_paths[X264_LOOKAHEAD_MAX][X264_LOOKAHEAD_MAX] = {"","P"};
  856. + int n;
  857. + int num_bframes = 0;
  858. int max_bframes = X264_MIN(num_frames-1, h->param.i_bframe);
  859. + int num_analysed_frames = num_frames;
  860. + int reset_start;
  861. if( h->param.i_scenecut_threshold && scenecut( h, &a, frames, 0, 1 ) )
  862. {
  863. frames[1]->i_type = idr_frame_type;
  864. return;
  865. }
  866. - num_bframes = x264_slicetype_path_search( h, &a, frames, num_frames, max_bframes, num_frames-max_bframes );
  867. - assert(num_bframes < num_frames);
  868.  
  869. - for( j = 1; j < num_bframes+1; j++ )
  870. + if( h->param.i_bframe )
  871. {
  872. - if( h->param.i_scenecut_threshold && scenecut( h, &a, frames, j, j+1 ) )
  873. + if( h->param.i_bframe_adaptive == X264_B_ADAPT_TRELLIS )
  874. {
  875. - frames[j]->i_type = X264_TYPE_P;
  876. - return;
  877. + /* Perform the frametype analysis. */
  878. + for( n = 2; n < num_frames-1; n++ )
  879. + x264_slicetype_path( h, &a, frames, n, max_bframes, num_frames-max_bframes, best_paths );
  880. + num_bframes = strspn( best_paths[num_frames-2], "B" );
  881. + /* Load the results of the analysis into the frame types. */
  882. + for( j = 1; j < num_frames-1; j++ )
  883. + frames[j]->i_type = best_paths[num_frames-2][j-1] == 'B' ? X264_TYPE_B : X264_TYPE_P;
  884. + frames[num_frames-1]->i_type = X264_TYPE_P;
  885. }
  886. - frames[j]->i_type = X264_TYPE_B;
  887. + else /* No b-adapt, fast isn't currently supported. */
  888. + {
  889. + num_bframes = X264_MIN(num_frames-1, h->param.i_bframe);
  890. + for( j = 1; j < num_frames-1; j++ )
  891. + frames[j]->i_type = (j%(num_bframes+1)) ? X264_TYPE_B : X264_TYPE_P;
  892. + frames[num_frames-1]->i_type = X264_TYPE_P;
  893. + }
  894. +
  895. + /* Check scenecut on the first minigop. */
  896. + for( j = 1; j < num_bframes+1; j++ )
  897. + if( h->param.i_scenecut_threshold && scenecut( h, &a, frames, j, j+1 ) )
  898. + {
  899. + frames[j]->i_type = X264_TYPE_P;
  900. + num_analysed_frames = j;
  901. + break;
  902. + }
  903. +
  904. + reset_start = keyframe ? 1 : X264_MIN( num_bframes+2, num_analysed_frames+1 );
  905. + }
  906. + else
  907. + {
  908. + for( j = 1; j < num_frames; j++ )
  909. + frames[j]->i_type = X264_TYPE_P;
  910. + reset_start = !keyframe + 1;
  911. }
  912. - frames[num_bframes+1]->i_type = X264_TYPE_P;
  913. +
  914. + /* Perform the actual macroblock tree analysis. */
  915. + if( h->param.rc.b_mb_tree )
  916. + x264_macroblock_tree( h, &a, frames, num_analysed_frames, keyframe );
  917. +
  918. + /* Enforce keyframe limit. */
  919. + if( h->param.i_bframe )
  920. + for( j = 0; j <= num_bframes+1; j++ )
  921. + if( j+1 >= keyint_limit )
  922. + {
  923. + if( j )
  924. + frames[j]->i_type = X264_TYPE_P;
  925. + frames[j+1]->i_type = idr_frame_type;
  926. + reset_start = j+2;
  927. + break;
  928. + }
  929. +
  930. + /* Restore frametypes for all frames that haven't actually been decided yet. */
  931. + for( j = reset_start; j < num_frames; j++ )
  932. + frames[j]->i_type = X264_TYPE_AUTO;
  933. }
  934. else if( h->param.i_bframe_adaptive == X264_B_ADAPT_FAST )
  935. {
  936. @@ -606,8 +824,9 @@ void x264_slicetype_decide( x264_t *h )
  937. x264_ratecontrol_slice_type( h, h->frames.next[i]->i_frame );
  938. }
  939. else if( (h->param.i_bframe && h->param.i_bframe_adaptive)
  940. - || h->param.i_scenecut_threshold )
  941. - x264_slicetype_analyse( h );
  942. + || h->param.i_scenecut_threshold
  943. + || h->param.rc.b_mb_tree )
  944. + x264_slicetype_analyse( h, 0 );
  945.  
  946. for( bframes = 0;; bframes++ )
  947. {
  948. @@ -645,7 +864,11 @@ void x264_slicetype_decide( x264_t *h )
  949. frm->i_type = X264_TYPE_P;
  950. }
  951.  
  952. - if( frm->i_type == X264_TYPE_AUTO ) frm->i_type = X264_TYPE_B;
  953. + if( frm->i_type == X264_TYPE_AUTO )
  954. + {
  955. + assert(0);
  956. + frm->i_type = X264_TYPE_B;
  957. + }
  958. else if( !IS_X264_TYPE_B( frm->i_type ) ) break;
  959. }
  960. }
  961. @@ -653,7 +876,7 @@ void x264_slicetype_decide( x264_t *h )
  962. int x264_rc_analyse_slice( x264_t *h )
  963. {
  964. x264_mb_analysis_t a;
  965. - x264_frame_t *frames[X264_BFRAME_MAX*4+2] = { NULL, };
  966. + x264_frame_t *frames[X264_LOOKAHEAD_MAX+2] = { NULL, };
  967. int p0=0, p1, b;
  968. int cost;
  969.  
  970. @@ -662,6 +885,12 @@ int x264_rc_analyse_slice( x264_t *h )
  971. if( IS_X264_TYPE_I(h->fenc->i_type) )
  972. {
  973. p1 = b = 0;
  974. + /* For MB-tree, we have to perform propagation analysis on I-frames too. */
  975. + if( h->param.rc.b_mb_tree )
  976. + {
  977. + h->frames.last_nonb = h->fenc;
  978. + x264_slicetype_analyse( h, 1 );
  979. + }
  980. }
  981. else if( X264_TYPE_P == h->fenc->i_type )
  982. {
  983. @@ -680,11 +909,16 @@ int x264_rc_analyse_slice( x264_t *h )
  984. frames[p0] = h->fref0[0];
  985. frames[b] = h->fenc;
  986.  
  987. - cost = x264_slicetype_frame_cost( h, &a, frames, p0, p1, b, 0 );
  988. + if( h->param.rc.b_mb_tree )
  989. + cost = x264_slicetype_frame_cost_recalculate( h, &a, frames, p0, p1, b );
  990. + else
  991. + {
  992. + cost = x264_slicetype_frame_cost( h, &a, frames, p0, p1, b, 0 );
  993.  
  994. - /* In AQ, use the weighted score instead. */
  995. - if( h->param.rc.i_aq_mode )
  996. - cost = frames[b]->i_cost_est[b-p0][p1-b];
  997. + /* In AQ, use the weighted score instead. */
  998. + if( h->param.rc.i_aq_mode )
  999. + cost = frames[b]->i_cost_est[b-p0][p1-b];
  1000. + }
  1001.  
  1002. h->fenc->i_row_satd = h->fenc->i_row_satds[b-p0][p1-b];
  1003. h->fdec->i_row_satd = h->fdec->i_row_satds[b-p0][p1-b];
  1004. diff --git a/x264.c b/x264.c
  1005. index c3b4f29..886abed 100644
  1006. --- a/x264.c
  1007. +++ b/x264.c
  1008. @@ -184,6 +184,7 @@ static void Help( x264_param_t *defaults, int b_longhelp )
  1009. H1( " -i, --min-keyint <integer> Minimum GOP size [%d]\n", defaults->i_keyint_min );
  1010. H1( " --no-scenecut Disable adaptive I-frame decision\n" );
  1011. H1( " --scenecut <integer> How aggressively to insert extra I-frames [%d]\n", defaults->i_scenecut_threshold );
  1012. + H0( " --lookahead <integer> Number of frames for frametype lookahead [%d]\n", defaults->i_lookahead );
  1013. H0( " -b, --bframes <integer> Number of B-frames between I and P [%d]\n", defaults->i_bframe );
  1014. H1( " --b-adapt Adaptive B-frame decision method [%d]\n"
  1015. " Higher values may lower threading efficiency.\n"
  1016. @@ -228,6 +229,8 @@ static void Help( x264_param_t *defaults, int b_longhelp )
  1017. " - 2: Last pass, does not overwrite stats file\n"
  1018. " - 3: Nth pass, overwrites stats file\n" );
  1019. H0( " --stats <string> Filename for 2 pass stats [\"%s\"]\n", defaults->rc.psz_stat_out );
  1020. + H0( " --mbtree Enable mb-tree. Requires b-adapt 2 if b-frames\n"
  1021. + " are enabled. Experimental.\n" );
  1022. H0( " --qcomp <float> QP curve compression: 0.0 => CBR, 1.0 => CQP [%.2f]\n", defaults->rc.f_qcompress );
  1023. H1( " --cplxblur <float> Reduce fluctuations in QP (before curve compression) [%.1f]\n", defaults->rc.f_complexity_blur );
  1024. H1( " --qblur <float> Reduce fluctuations in QP (after curve compression) [%.1f]\n", defaults->rc.f_qblur );
  1025. @@ -383,6 +386,7 @@ static struct option long_options[] =
  1026. { "slow-firstpass", no_argument, NULL, OPT_SLOWFIRSTPASS },
  1027. { "bitrate", required_argument, NULL, 'B' },
  1028. { "bframes", required_argument, NULL, 'b' },
  1029. + { "lookahead", required_argument, NULL, 0 },
  1030. { "b-adapt", required_argument, NULL, 0 },
  1031. { "no-b-adapt", no_argument, NULL, 0 },
  1032. { "b-bias", required_argument, NULL, 0 },
  1033. @@ -446,6 +450,8 @@ static struct option long_options[] =
  1034. { "pass", required_argument, NULL, 'p' },
  1035. { "stats", required_argument, NULL, 0 },
  1036. { "qcomp", required_argument, NULL, 0 },
  1037. + { "mbtree", no_argument, NULL, 0 },
  1038. + { "no-mbtree", no_argument, NULL, 0 },
  1039. { "qblur", required_argument, NULL, 0 },
  1040. { "cplxblur", required_argument, NULL, 0 },
  1041. { "zones", required_argument, NULL, 0 },
  1042. @@ -662,7 +668,6 @@ static int Parse( int argc, char **argv,
  1043. param->i_deblocking_filter_alphac0 = -1;
  1044. param->i_deblocking_filter_beta = -1;
  1045. param->analyse.f_psy_trellis = 0.2;
  1046. - param->rc.f_ip_factor = 2.1;
  1047. param->rc.f_aq_strength = 1.3;
  1048. if( param->analyse.inter & X264_ANALYSE_PSUB16x16 )
  1049. param->analyse.inter |= X264_ANALYSE_PSUB8x8;
  1050. diff --git a/x264.h b/x264.h
  1051. index 2dfcc8d..122d4ba 100644
  1052. --- a/x264.h
  1053. +++ b/x264.h
  1054. @@ -188,6 +188,7 @@ typedef struct x264_param_t
  1055. int i_keyint_max; /* Force an IDR keyframe at this interval */
  1056. int i_keyint_min; /* Scenecuts closer together than this are coded as I, not IDR. */
  1057. int i_scenecut_threshold; /* how aggressively to insert extra I frames */
  1058. + int i_lookahead;
  1059. int i_bframe; /* how many b-frame between 2 references pictures */
  1060. int i_bframe_adaptive;
  1061. int i_bframe_bias;
  1062. @@ -271,6 +272,7 @@ typedef struct x264_param_t
  1063.  
  1064. int i_aq_mode; /* psy adaptive QP. (X264_AQ_*) */
  1065. float f_aq_strength;
  1066. + int b_mb_tree; /* Macroblock-tree ratecontrol. */
  1067.  
  1068. /* 2pass */
  1069. int b_stat_write; /* Enable stat writing in psz_stat_out */
  1070.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!