Advertisement
Guest User

Dark Shikari

a guest
Aug 2nd, 2009
537
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 47.76 KB | None | 0 0
  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