git.sesse.net Git - x264/blob - encoder/encoder.c

   1 /*****************************************************************************
   2  * x264: h264 encoder
   3  *****************************************************************************
   4  * Copyright (C) 2003-2008 x264 project
   5  *
   6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   7  *          Loren Merritt <lorenm@u.washington.edu>
   8  *          Fiona Glaser <fiona@x264.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 #include <math.h>
  26
  27 #include "common/common.h"
  28 #include "common/cpu.h"
  29
  30 #include "set.h"
  31 #include "analyse.h"
  32 #include "ratecontrol.h"
  33 #include "macroblock.h"
  34 #include "me.h"
  35
  36 #ifdef HAVE_VISUALIZE
  37 #include "common/visualize.h"
  38 #endif
  39
  40 //#define DEBUG_MB_TYPE
  41
  42 #define bs_write_ue bs_write_ue_big
  43
  44 static int x264_encoder_frame_end( x264_t *h, x264_t *thread_current,
  45                                    x264_nal_t **pp_nal, int *pi_nal,
  46                                    x264_picture_t *pic_out );
  47
  48 /****************************************************************************
  49  *
  50  ******************************* x264 libs **********************************
  51  *
  52  ****************************************************************************/
  53 static float x264_psnr( int64_t i_sqe, int64_t i_size )
  54 {
  55     double f_mse = (double)i_sqe / ((double)65025.0 * (double)i_size);
  56     if( f_mse <= 0.0000000001 ) /* Max 100dB */
  57         return 100;
  58
  59     return (float)(-10.0 * log( f_mse ) / log( 10.0 ));
  60 }
  61
  62 static void x264_frame_dump( x264_t *h )
  63 {
  64     FILE *f = fopen( h->param.psz_dump_yuv, "r+b" );
  65     int i, y;
  66     if( !f )
  67         return;
  68     /* Write the frame in display order */
  69     fseek( f, (uint64_t)h->fdec->i_frame * h->param.i_height * h->param.i_width * 3/2, SEEK_SET );
  70     for( i = 0; i < h->fdec->i_plane; i++ )
  71         for( y = 0; y < h->param.i_height >> !!i; y++ )
  72             fwrite( &h->fdec->plane[i][y*h->fdec->i_stride[i]], 1, h->param.i_width >> !!i, f );
  73     fclose( f );
  74 }
  75
  76
  77 /* Fill "default" values */
  78 static void x264_slice_header_init( x264_t *h, x264_slice_header_t *sh,
  79                                     x264_sps_t *sps, x264_pps_t *pps,
  80                                     int i_idr_pic_id, int i_frame, int i_qp )
  81 {
  82     x264_param_t *param = &h->param;
  83     int i;
  84
  85     /* First we fill all fields */
  86     sh->sps = sps;
  87     sh->pps = pps;
  88
  89     sh->i_first_mb  = 0;
  90     sh->i_last_mb   = h->mb.i_mb_count - 1;
  91     sh->i_pps_id    = pps->i_id;
  92
  93     sh->i_frame_num = i_frame;
  94
  95     sh->b_mbaff = h->param.b_interlaced;
  96     sh->b_field_pic = 0;    /* no field support for now */
  97     sh->b_bottom_field = 0; /* not yet used */
  98
  99     sh->i_idr_pic_id = i_idr_pic_id;
 100
 101     /* poc stuff, fixed later */
 102     sh->i_poc = 0;
 103     sh->i_delta_poc_bottom = 0;
 104     sh->i_delta_poc[0] = 0;
 105     sh->i_delta_poc[1] = 0;
 106
 107     sh->i_redundant_pic_cnt = 0;
 108
 109     h->mb.b_direct_auto_write = h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO
 110                                 && h->param.i_bframe
 111                                 && ( h->param.rc.b_stat_write || !h->param.rc.b_stat_read );
 112
 113     if( !h->mb.b_direct_auto_read && sh->i_type == SLICE_TYPE_B )
 114     {
 115         if( h->fref1[0]->i_poc_l0ref0 == h->fref0[0]->i_poc )
 116         {
 117             if( h->mb.b_direct_auto_write )
 118                 sh->b_direct_spatial_mv_pred = ( h->stat.i_direct_score[1] > h->stat.i_direct_score[0] );
 119             else
 120                 sh->b_direct_spatial_mv_pred = ( param->analyse.i_direct_mv_pred == X264_DIRECT_PRED_SPATIAL );
 121         }
 122         else
 123         {
 124             h->mb.b_direct_auto_write = 0;
 125             sh->b_direct_spatial_mv_pred = 1;
 126         }
 127     }
 128     /* else b_direct_spatial_mv_pred was read from the 2pass statsfile */
 129
 130     sh->b_num_ref_idx_override = 0;
 131     sh->i_num_ref_idx_l0_active = 1;
 132     sh->i_num_ref_idx_l1_active = 1;
 133
 134     sh->b_ref_pic_list_reordering_l0 = h->b_ref_reorder[0];
 135     sh->b_ref_pic_list_reordering_l1 = h->b_ref_reorder[1];
 136
 137     /* If the ref list isn't in the default order, construct reordering header */
 138     /* List1 reordering isn't needed yet */
 139     if( sh->b_ref_pic_list_reordering_l0 )
 140     {
 141         int pred_frame_num = i_frame;
 142         for( i = 0; i < h->i_ref0; i++ )
 143         {
 144             int diff = h->fref0[i]->i_frame_num - pred_frame_num;
 145             if( diff == 0 )
 146                 x264_log( h, X264_LOG_ERROR, "diff frame num == 0\n" );
 147             sh->ref_pic_list_order[0][i].idc = ( diff > 0 );
 148             sh->ref_pic_list_order[0][i].arg = abs( diff ) - 1;
 149             pred_frame_num = h->fref0[i]->i_frame_num;
 150         }
 151     }
 152
 153     sh->i_cabac_init_idc = param->i_cabac_init_idc;
 154
 155     sh->i_qp = i_qp;
 156     sh->i_qp_delta = i_qp - pps->i_pic_init_qp;
 157     sh->b_sp_for_swidth = 0;
 158     sh->i_qs_delta = 0;
 159
 160     /* If effective qp <= 15, deblocking would have no effect anyway */
 161     if( param->b_deblocking_filter
 162         && ( h->mb.b_variable_qp
 163         || 15 < i_qp + 2 * X264_MIN(param->i_deblocking_filter_alphac0, param->i_deblocking_filter_beta) ) )
 164     {
 165         sh->i_disable_deblocking_filter_idc = 0;
 166     }
 167     else
 168     {
 169         sh->i_disable_deblocking_filter_idc = 1;
 170     }
 171     sh->i_alpha_c0_offset = param->i_deblocking_filter_alphac0 << 1;
 172     sh->i_beta_offset = param->i_deblocking_filter_beta << 1;
 173 }
 174
 175 static void x264_slice_header_write( bs_t *s, x264_slice_header_t *sh, int i_nal_ref_idc )
 176 {
 177     int i;
 178
 179     if( sh->b_mbaff )
 180     {
 181         assert( sh->i_first_mb % (2*sh->sps->i_mb_width) == 0 );
 182         bs_write_ue( s, sh->i_first_mb >> 1 );
 183     }
 184     else
 185         bs_write_ue( s, sh->i_first_mb );
 186
 187     bs_write_ue( s, sh->i_type + 5 );   /* same type things */
 188     bs_write_ue( s, sh->i_pps_id );
 189     bs_write( s, sh->sps->i_log2_max_frame_num, sh->i_frame_num & ((1<<sh->sps->i_log2_max_frame_num)-1) );
 190
 191     if( !sh->sps->b_frame_mbs_only )
 192     {
 193         bs_write1( s, sh->b_field_pic );
 194         if( sh->b_field_pic )
 195             bs_write1( s, sh->b_bottom_field );
 196     }
 197
 198     if( sh->i_idr_pic_id >= 0 ) /* NAL IDR */
 199     {
 200         bs_write_ue( s, sh->i_idr_pic_id );
 201     }
 202
 203     if( sh->sps->i_poc_type == 0 )
 204     {
 205         bs_write( s, sh->sps->i_log2_max_poc_lsb, sh->i_poc & ((1<<sh->sps->i_log2_max_poc_lsb)-1) );
 206         if( sh->pps->b_pic_order && !sh->b_field_pic )
 207         {
 208             bs_write_se( s, sh->i_delta_poc_bottom );
 209         }
 210     }
 211     else if( sh->sps->i_poc_type == 1 && !sh->sps->b_delta_pic_order_always_zero )
 212     {
 213         bs_write_se( s, sh->i_delta_poc[0] );
 214         if( sh->pps->b_pic_order && !sh->b_field_pic )
 215         {
 216             bs_write_se( s, sh->i_delta_poc[1] );
 217         }
 218     }
 219
 220     if( sh->pps->b_redundant_pic_cnt )
 221     {
 222         bs_write_ue( s, sh->i_redundant_pic_cnt );
 223     }
 224
 225     if( sh->i_type == SLICE_TYPE_B )
 226     {
 227         bs_write1( s, sh->b_direct_spatial_mv_pred );
 228     }
 229     if( sh->i_type == SLICE_TYPE_P || sh->i_type == SLICE_TYPE_SP || sh->i_type == SLICE_TYPE_B )
 230     {
 231         bs_write1( s, sh->b_num_ref_idx_override );
 232         if( sh->b_num_ref_idx_override )
 233         {
 234             bs_write_ue( s, sh->i_num_ref_idx_l0_active - 1 );
 235             if( sh->i_type == SLICE_TYPE_B )
 236             {
 237                 bs_write_ue( s, sh->i_num_ref_idx_l1_active - 1 );
 238             }
 239         }
 240     }
 241
 242     /* ref pic list reordering */
 243     if( sh->i_type != SLICE_TYPE_I )
 244     {
 245         bs_write1( s, sh->b_ref_pic_list_reordering_l0 );
 246         if( sh->b_ref_pic_list_reordering_l0 )
 247         {
 248             for( i = 0; i < sh->i_num_ref_idx_l0_active; i++ )
 249             {
 250                 bs_write_ue( s, sh->ref_pic_list_order[0][i].idc );
 251                 bs_write_ue( s, sh->ref_pic_list_order[0][i].arg );
 252
 253             }
 254             bs_write_ue( s, 3 );
 255         }
 256     }
 257     if( sh->i_type == SLICE_TYPE_B )
 258     {
 259         bs_write1( s, sh->b_ref_pic_list_reordering_l1 );
 260         if( sh->b_ref_pic_list_reordering_l1 )
 261         {
 262             for( i = 0; i < sh->i_num_ref_idx_l1_active; i++ )
 263             {
 264                 bs_write_ue( s, sh->ref_pic_list_order[1][i].idc );
 265                 bs_write_ue( s, sh->ref_pic_list_order[1][i].arg );
 266             }
 267             bs_write_ue( s, 3 );
 268         }
 269     }
 270
 271     if( sh->pps->b_weighted_pred && ( sh->i_type == SLICE_TYPE_P || sh->i_type == SLICE_TYPE_SP ) )
 272     {
 273         /* pred_weight_table() */
 274         bs_write_ue( s, sh->weight[0][0].i_denom );
 275         bs_write_ue( s, sh->weight[0][1].i_denom );
 276         for( i = 0; i < sh->i_num_ref_idx_l0_active; i++ )
 277         {
 278             int luma_weight_l0_flag = !!sh->weight[i][0].weightfn;
 279             int chroma_weight_l0_flag = !!sh->weight[i][1].weightfn || !!sh->weight[i][2].weightfn;
 280             bs_write1( s, luma_weight_l0_flag );
 281             if( luma_weight_l0_flag )
 282             {
 283                 bs_write_se( s, sh->weight[i][0].i_scale );
 284                 bs_write_se( s, sh->weight[i][0].i_offset );
 285             }
 286             bs_write1( s, chroma_weight_l0_flag );
 287             if( chroma_weight_l0_flag )
 288             {
 289                 int j;
 290                 for( j = 1; j < 3; j++ )
 291                 {
 292                     bs_write_se( s, sh->weight[i][j].i_scale );
 293                     bs_write_se( s, sh->weight[i][j].i_offset );
 294                 }
 295             }
 296         }
 297     }
 298     else if( sh->pps->b_weighted_bipred == 1 && sh->i_type == SLICE_TYPE_B )
 299     {
 300       /* TODO */
 301     }
 302
 303     if( i_nal_ref_idc != 0 )
 304     {
 305         if( sh->i_idr_pic_id >= 0 )
 306         {
 307             bs_write1( s, 0 );  /* no output of prior pics flag */
 308             bs_write1( s, 0 );  /* long term reference flag */
 309         }
 310         else
 311         {
 312             bs_write1( s, sh->i_mmco_command_count > 0 ); /* adaptive_ref_pic_marking_mode_flag */
 313             if( sh->i_mmco_command_count > 0 )
 314             {
 315                 int i;
 316                 for( i = 0; i < sh->i_mmco_command_count; i++ )
 317                 {
 318                     bs_write_ue( s, 1 ); /* mark short term ref as unused */
 319                     bs_write_ue( s, sh->mmco[i].i_difference_of_pic_nums - 1 );
 320                 }
 321                 bs_write_ue( s, 0 ); /* end command list */
 322             }
 323         }
 324     }
 325
 326     if( sh->pps->b_cabac && sh->i_type != SLICE_TYPE_I )
 327     {
 328         bs_write_ue( s, sh->i_cabac_init_idc );
 329     }
 330     bs_write_se( s, sh->i_qp_delta );      /* slice qp delta */
 331
 332     if( sh->pps->b_deblocking_filter_control )
 333     {
 334         bs_write_ue( s, sh->i_disable_deblocking_filter_idc );
 335         if( sh->i_disable_deblocking_filter_idc != 1 )
 336         {
 337             bs_write_se( s, sh->i_alpha_c0_offset >> 1 );
 338             bs_write_se( s, sh->i_beta_offset >> 1 );
 339         }
 340     }
 341 }
 342
 343 /* If we are within a reasonable distance of the end of the memory allocated for the bitstream, */
 344 /* reallocate, adding an arbitrary amount of space (100 kilobytes). */
 345 static int x264_bitstream_check_buffer( x264_t *h )
 346 {
 347     uint8_t *bs_bak = h->out.p_bitstream;
 348     if( ( h->param.b_cabac && (h->cabac.p_end - h->cabac.p < 2500) )
 349      || ( h->out.bs.p_end - h->out.bs.p < 2500 ) )
 350     {
 351         intptr_t delta;
 352         int i;
 353
 354         h->out.i_bitstream += 100000;
 355         CHECKED_MALLOC( h->out.p_bitstream, h->out.i_bitstream );
 356         h->mc.memcpy_aligned( h->out.p_bitstream, bs_bak, (h->out.i_bitstream - 100000) & ~15 );
 357         delta = h->out.p_bitstream - bs_bak;
 358
 359         h->out.bs.p_start += delta;
 360         h->out.bs.p += delta;
 361         h->out.bs.p_end = h->out.p_bitstream + h->out.i_bitstream;
 362
 363         h->cabac.p_start += delta;
 364         h->cabac.p += delta;
 365         h->cabac.p_end = h->out.p_bitstream + h->out.i_bitstream;
 366
 367         for( i = 0; i <= h->out.i_nal; i++ )
 368             h->out.nal[i].p_payload += delta;
 369         x264_free( bs_bak );
 370     }
 371     return 0;
 372 fail:
 373     x264_free( bs_bak );
 374     return -1;
 375 }
 376
 377 /****************************************************************************
 378  *
 379  ****************************************************************************
 380  ****************************** External API*********************************
 381  ****************************************************************************
 382  *
 383  ****************************************************************************/
 384
 385 static int x264_validate_parameters( x264_t *h )
 386 {
 387 #ifdef HAVE_MMX
 388     if( !(x264_cpu_detect() & X264_CPU_SSE) )
 389     {
 390         x264_log( h, X264_LOG_ERROR, "your cpu does not support SSE1, but x264 was compiled with asm support\n");
 391         x264_log( h, X264_LOG_ERROR, "to run x264, recompile without asm support (configure --disable-asm)\n");
 392         return -1;
 393     }
 394 #endif
 395     if( h->param.i_width <= 0 || h->param.i_height <= 0 )
 396     {
 397         x264_log( h, X264_LOG_ERROR, "invalid width x height (%dx%d)\n",
 398                   h->param.i_width, h->param.i_height );
 399         return -1;
 400     }
 401
 402     if( h->param.i_width % 2 || h->param.i_height % 2 )
 403     {
 404         x264_log( h, X264_LOG_ERROR, "width or height not divisible by 2 (%dx%d)\n",
 405                   h->param.i_width, h->param.i_height );
 406         return -1;
 407     }
 408     int i_csp = h->param.i_csp & X264_CSP_MASK;
 409     if( i_csp != X264_CSP_I420 && i_csp != X264_CSP_YV12 )
 410     {
 411         x264_log( h, X264_LOG_ERROR, "invalid CSP (only I420/YV12 supported)\n" );
 412         return -1;
 413     }
 414
 415     if( h->param.i_threads == X264_THREADS_AUTO )
 416         h->param.i_threads = x264_cpu_num_processors() * (h->param.b_sliced_threads?2:3)/2;
 417     h->param.i_threads = x264_clip3( h->param.i_threads, 1, X264_THREAD_MAX );
 418     if( h->param.i_threads > 1 )
 419     {
 420 #ifndef HAVE_PTHREAD
 421         x264_log( h, X264_LOG_WARNING, "not compiled with pthread support!\n");
 422         h->param.i_threads = 1;
 423 #endif
 424         /* Avoid absurdly small thread slices as they can reduce performance
 425          * and VBV compliance.  Capped at an arbitrary 4 rows per thread. */
 426         if( h->param.b_sliced_threads )
 427         {
 428             int max_threads = (h->param.i_height+15)/16 / 4;
 429             h->param.i_threads = X264_MIN( h->param.i_threads, max_threads );
 430         }
 431     }
 432     else
 433         h->param.b_sliced_threads = 0;
 434     h->i_thread_frames = h->param.b_sliced_threads ? 1 : h->param.i_threads;
 435
 436     if( h->param.b_interlaced )
 437     {
 438         if( h->param.analyse.i_me_method >= X264_ME_ESA )
 439         {
 440             x264_log( h, X264_LOG_WARNING, "interlace + me=esa is not implemented\n" );
 441             h->param.analyse.i_me_method = X264_ME_UMH;
 442         }
 443         if( h->param.analyse.i_weighted_pred > 0 )
 444         {
 445             x264_log( h, X264_LOG_WARNING, "interlace + weightp is not implemented\n" );
 446             h->param.analyse.i_weighted_pred = X264_WEIGHTP_NONE;
 447         }
 448     }
 449
 450     /* Detect default ffmpeg settings and terminate with an error. */
 451     {
 452         int score = 0;
 453         score += h->param.analyse.i_me_range == 0;
 454         score += h->param.rc.i_qp_step == 3;
 455         score += h->param.i_keyint_max == 12;
 456         score += h->param.rc.i_qp_min == 2;
 457         score += h->param.rc.i_qp_max == 31;
 458         score += h->param.rc.f_qcompress == 0.5;
 459         score += fabs(h->param.rc.f_ip_factor - 1.25) < 0.01;
 460         score += fabs(h->param.rc.f_pb_factor - 1.25) < 0.01;
 461         score += h->param.analyse.inter == 0 && h->param.analyse.i_subpel_refine == 8;
 462         if( score >= 5 )
 463         {
 464             x264_log( h, X264_LOG_ERROR, "broken ffmpeg default settings detected\n" );
 465             x264_log( h, X264_LOG_ERROR, "use an encoding preset (vpre)\n" );
 466             return -1;
 467         }
 468     }
 469
 470     if( h->param.rc.i_rc_method < 0 || h->param.rc.i_rc_method > 2 )
 471     {
 472         x264_log( h, X264_LOG_ERROR, "no ratecontrol method specified\n" );
 473         return -1;
 474     }
 475     h->param.rc.f_rf_constant = x264_clip3f( h->param.rc.f_rf_constant, 0, 51 );
 476     h->param.rc.i_qp_constant = x264_clip3( h->param.rc.i_qp_constant, 0, 51 );
 477     if( h->param.rc.i_rc_method == X264_RC_CRF )
 478     {
 479         h->param.rc.i_qp_constant = h->param.rc.f_rf_constant;
 480         h->param.rc.i_bitrate = 0;
 481     }
 482     if( (h->param.rc.i_rc_method == X264_RC_CQP || h->param.rc.i_rc_method == X264_RC_CRF)
 483         && h->param.rc.i_qp_constant == 0 )
 484     {
 485         h->mb.b_lossless = 1;
 486         h->param.i_cqm_preset = X264_CQM_FLAT;
 487         h->param.psz_cqm_file = NULL;
 488         h->param.rc.i_rc_method = X264_RC_CQP;
 489         h->param.rc.f_ip_factor = 1;
 490         h->param.rc.f_pb_factor = 1;
 491         h->param.analyse.b_psnr = 0;
 492         h->param.analyse.b_ssim = 0;
 493         h->param.analyse.i_chroma_qp_offset = 0;
 494         h->param.analyse.i_trellis = 0;
 495         h->param.analyse.b_fast_pskip = 0;
 496         h->param.analyse.i_noise_reduction = 0;
 497         h->param.analyse.f_psy_rd = 0;
 498         h->param.i_bframe = 0;
 499         /* 8x8dct is not useful at all in CAVLC lossless */
 500         if( !h->param.b_cabac )
 501             h->param.analyse.b_transform_8x8 = 0;
 502     }
 503     if( h->param.rc.i_rc_method == X264_RC_CQP )
 504     {
 505         float qp_p = h->param.rc.i_qp_constant;
 506         float qp_i = qp_p - 6*log(h->param.rc.f_ip_factor)/log(2);
 507         float qp_b = qp_p + 6*log(h->param.rc.f_pb_factor)/log(2);
 508         h->param.rc.i_qp_min = x264_clip3( (int)(X264_MIN3( qp_p, qp_i, qp_b )), 0, 51 );
 509         h->param.rc.i_qp_max = x264_clip3( (int)(X264_MAX3( qp_p, qp_i, qp_b ) + .999), 0, 51 );
 510         h->param.rc.i_aq_mode = 0;
 511         h->param.rc.b_mb_tree = 0;
 512     }
 513     h->param.rc.i_qp_max = x264_clip3( h->param.rc.i_qp_max, 0, 51 );
 514     h->param.rc.i_qp_min = x264_clip3( h->param.rc.i_qp_min, 0, h->param.rc.i_qp_max );
 515     if( h->param.rc.i_vbv_buffer_size )
 516     {
 517         if( h->param.rc.i_rc_method == X264_RC_CQP )
 518         {
 519             x264_log( h, X264_LOG_WARNING, "VBV is incompatible with constant QP, ignored.\n" );
 520             h->param.rc.i_vbv_max_bitrate = 0;
 521             h->param.rc.i_vbv_buffer_size = 0;
 522         }
 523         else if( h->param.rc.i_vbv_max_bitrate == 0 )
 524         {
 525             if( h->param.rc.i_rc_method == X264_RC_ABR )
 526             {
 527                 x264_log( h, X264_LOG_WARNING, "VBV maxrate unspecified, assuming CBR\n" );
 528                 h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate;
 529             }
 530             else
 531             {
 532                 x264_log( h, X264_LOG_WARNING, "VBV bufsize set but maxrate unspecified, ignored\n" );
 533                 h->param.rc.i_vbv_buffer_size = 0;
 534             }
 535         }
 536         else if( h->param.rc.i_vbv_max_bitrate < h->param.rc.i_bitrate &&
 537                  h->param.rc.i_rc_method == X264_RC_ABR )
 538         {
 539             x264_log( h, X264_LOG_WARNING, "max bitrate less than average bitrate, assuming CBR\n" );
 540             h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate;
 541         }
 542     }
 543     else if( h->param.rc.i_vbv_max_bitrate )
 544     {
 545         x264_log( h, X264_LOG_WARNING, "VBV maxrate specified, but no bufsize, ignored\n" );
 546         h->param.rc.i_vbv_max_bitrate = 0;
 547     }
 548
 549     int max_slices = (h->param.i_height+((16<<h->param.b_interlaced)-1))/(16<<h->param.b_interlaced);
 550     if( h->param.b_sliced_threads )
 551         h->param.i_slice_count = x264_clip3( h->param.i_threads, 0, max_slices );
 552     else
 553     {
 554         h->param.i_slice_count = x264_clip3( h->param.i_slice_count, 0, max_slices );
 555         h->param.i_slice_max_size = X264_MAX( h->param.i_slice_max_size, 0 );
 556         h->param.i_slice_max_mbs = X264_MAX( h->param.i_slice_max_mbs, 0 );
 557         if( h->param.b_interlaced && h->param.i_slice_max_size )
 558         {
 559             x264_log( h, X264_LOG_WARNING, "interlaced + slice-max-size is not implemented\n" );
 560             h->param.i_slice_max_size = 0;
 561         }
 562         if( h->param.b_interlaced && h->param.i_slice_max_mbs )
 563         {
 564             x264_log( h, X264_LOG_WARNING, "interlaced + slice-max-mbs is not implemented\n" );
 565             h->param.i_slice_max_mbs = 0;
 566         }
 567         if( h->param.i_slice_max_mbs || h->param.i_slice_max_size )
 568             h->param.i_slice_count = 0;
 569     }
 570
 571     h->param.i_frame_reference = x264_clip3( h->param.i_frame_reference, 1, 16 );
 572     if( h->param.i_keyint_max <= 0 )
 573         h->param.i_keyint_max = 1;
 574     if( h->param.i_scenecut_threshold < 0 )
 575         h->param.i_scenecut_threshold = 0;
 576     if( !h->param.analyse.i_subpel_refine && h->param.analyse.i_direct_mv_pred > X264_DIRECT_PRED_SPATIAL )
 577     {
 578         x264_log( h, X264_LOG_WARNING, "subme=0 + direct=temporal is not supported\n" );
 579         h->param.analyse.i_direct_mv_pred = X264_DIRECT_PRED_SPATIAL;
 580     }
 581     h->param.i_bframe = x264_clip3( h->param.i_bframe, 0, X264_BFRAME_MAX );
 582     if( h->param.i_keyint_max == 1 )
 583     {
 584         h->param.i_bframe = 0;
 585         h->param.b_intra_refresh = 0;
 586     }
 587     h->param.i_bframe_bias = x264_clip3( h->param.i_bframe_bias, -90, 100 );
 588     if( h->param.i_bframe <= 1 )
 589         h->param.i_bframe_pyramid = X264_B_PYRAMID_NONE;
 590     h->param.i_bframe_pyramid = x264_clip3( h->param.i_bframe_pyramid, X264_B_PYRAMID_NONE, X264_B_PYRAMID_NORMAL );
 591     if( !h->param.i_bframe )
 592     {
 593         h->param.i_bframe_adaptive = X264_B_ADAPT_NONE;
 594         h->param.analyse.i_direct_mv_pred = 0;
 595         h->param.analyse.b_weighted_bipred = 0;
 596     }
 597     if( h->param.b_intra_refresh && h->param.i_bframe_pyramid == X264_B_PYRAMID_NORMAL )
 598     {
 599         x264_log( h, X264_LOG_WARNING, "b-pyramid normal + intra-refresh is not supported\n" );
 600         h->param.i_bframe_pyramid = X264_B_PYRAMID_STRICT;
 601     }
 602     if( h->param.b_intra_refresh && h->param.i_frame_reference > 1 )
 603     {
 604         x264_log( h, X264_LOG_WARNING, "ref > 1 + intra-refresh is not supported\n" );
 605         h->param.i_frame_reference = 1;
 606     }
 607     h->param.i_keyint_min = x264_clip3( h->param.i_keyint_min, 1, h->param.i_keyint_max/2+1 );
 608     h->param.rc.i_lookahead = x264_clip3( h->param.rc.i_lookahead, 0, X264_LOOKAHEAD_MAX );
 609     {
 610         int maxrate = X264_MAX( h->param.rc.i_vbv_max_bitrate, h->param.rc.i_bitrate );
 611         float bufsize = maxrate ? (float)h->param.rc.i_vbv_buffer_size / maxrate : 0;
 612         float fps = h->param.i_fps_num > 0 && h->param.i_fps_den > 0 ? (float) h->param.i_fps_num / h->param.i_fps_den : 25.0;
 613         h->param.rc.i_lookahead = X264_MIN( h->param.rc.i_lookahead, X264_MAX( h->param.i_keyint_max, bufsize*fps ) );
 614     }
 615
 616     if( !h->param.i_timebase_num || !h->param.i_timebase_den )
 617     {
 618         h->param.i_timebase_num = h->param.i_fps_den;
 619         h->param.i_timebase_den = h->param.i_fps_num;
 620     }
 621
 622     h->param.rc.f_qcompress = x264_clip3f( h->param.rc.f_qcompress, 0.0, 1.0 );
 623     if( !h->param.rc.i_lookahead || h->param.i_keyint_max == 1 || h->param.rc.f_qcompress == 1 )
 624         h->param.rc.b_mb_tree = 0;
 625     if( h->param.rc.b_stat_read )
 626         h->param.rc.i_lookahead = 0;
 627 #ifdef HAVE_PTHREAD
 628     if( h->param.i_sync_lookahead )
 629         h->param.i_sync_lookahead = x264_clip3( h->param.i_sync_lookahead, h->i_thread_frames + h->param.i_bframe, X264_LOOKAHEAD_MAX );
 630     if( h->param.rc.b_stat_read || h->i_thread_frames == 1 )
 631         h->param.i_sync_lookahead = 0;
 632 #else
 633     h->param.i_sync_lookahead = 0;
 634 #endif
 635
 636     h->param.i_deblocking_filter_alphac0 = x264_clip3( h->param.i_deblocking_filter_alphac0, -6, 6 );
 637     h->param.i_deblocking_filter_beta    = x264_clip3( h->param.i_deblocking_filter_beta, -6, 6 );
 638     h->param.analyse.i_luma_deadzone[0] = x264_clip3( h->param.analyse.i_luma_deadzone[0], 0, 32 );
 639     h->param.analyse.i_luma_deadzone[1] = x264_clip3( h->param.analyse.i_luma_deadzone[1], 0, 32 );
 640
 641     h->param.i_cabac_init_idc = x264_clip3( h->param.i_cabac_init_idc, 0, 2 );
 642
 643     if( h->param.i_cqm_preset < X264_CQM_FLAT || h->param.i_cqm_preset > X264_CQM_CUSTOM )
 644         h->param.i_cqm_preset = X264_CQM_FLAT;
 645
 646     if( h->param.analyse.i_me_method < X264_ME_DIA ||
 647         h->param.analyse.i_me_method > X264_ME_TESA )
 648         h->param.analyse.i_me_method = X264_ME_HEX;
 649     if( h->param.analyse.i_me_range < 4 )
 650         h->param.analyse.i_me_range = 4;
 651     if( h->param.analyse.i_me_range > 16 && h->param.analyse.i_me_method <= X264_ME_HEX )
 652         h->param.analyse.i_me_range = 16;
 653     if( h->param.analyse.i_me_method == X264_ME_TESA &&
 654         (h->mb.b_lossless || h->param.analyse.i_subpel_refine <= 1) )
 655         h->param.analyse.i_me_method = X264_ME_ESA;
 656     h->param.analyse.i_subpel_refine = x264_clip3( h->param.analyse.i_subpel_refine, 0, 10 );
 657     h->param.analyse.b_mixed_references = h->param.analyse.b_mixed_references && h->param.i_frame_reference > 1;
 658     h->param.analyse.inter &= X264_ANALYSE_PSUB16x16|X264_ANALYSE_PSUB8x8|X264_ANALYSE_BSUB16x16|
 659                               X264_ANALYSE_I4x4|X264_ANALYSE_I8x8;
 660     h->param.analyse.intra &= X264_ANALYSE_I4x4|X264_ANALYSE_I8x8;
 661     if( !(h->param.analyse.inter & X264_ANALYSE_PSUB16x16) )
 662         h->param.analyse.inter &= ~X264_ANALYSE_PSUB8x8;
 663     if( !h->param.analyse.b_transform_8x8 )
 664     {
 665         h->param.analyse.inter &= ~X264_ANALYSE_I8x8;
 666         h->param.analyse.intra &= ~X264_ANALYSE_I8x8;
 667     }
 668     h->param.analyse.i_chroma_qp_offset = x264_clip3(h->param.analyse.i_chroma_qp_offset, -12, 12);
 669     if( !h->param.b_cabac )
 670         h->param.analyse.i_trellis = 0;
 671     h->param.analyse.i_trellis = x264_clip3( h->param.analyse.i_trellis, 0, 2 );
 672     if( !h->param.analyse.b_psy )
 673     {
 674         h->param.analyse.f_psy_rd = 0;
 675         h->param.analyse.f_psy_trellis = 0;
 676     }
 677     if( !h->param.analyse.i_trellis )
 678         h->param.analyse.f_psy_trellis = 0;
 679     h->param.analyse.f_psy_rd = x264_clip3f( h->param.analyse.f_psy_rd, 0, 10 );
 680     h->param.analyse.f_psy_trellis = x264_clip3f( h->param.analyse.f_psy_trellis, 0, 10 );
 681     if( h->param.analyse.i_subpel_refine < 6 )
 682         h->param.analyse.f_psy_rd = 0;
 683     h->mb.i_psy_rd = FIX8( h->param.analyse.f_psy_rd );
 684     /* Psy RDO increases overall quantizers to improve the quality of luma--this indirectly hurts chroma quality */
 685     /* so we lower the chroma QP offset to compensate */
 686     /* This can be triggered repeatedly on multiple calls to parameter_validate, but since encoding
 687      * uses the pps chroma qp offset not the param chroma qp offset, this is not a problem. */
 688     if( h->mb.i_psy_rd )
 689         h->param.analyse.i_chroma_qp_offset -= h->param.analyse.f_psy_rd < 0.25 ? 1 : 2;
 690     h->mb.i_psy_trellis = FIX8( h->param.analyse.f_psy_trellis / 4 );
 691     /* Psy trellis has a similar effect. */
 692     if( h->mb.i_psy_trellis )
 693         h->param.analyse.i_chroma_qp_offset -= h->param.analyse.f_psy_trellis < 0.25 ? 1 : 2;
 694     h->param.analyse.i_chroma_qp_offset = x264_clip3(h->param.analyse.i_chroma_qp_offset, -12, 12);
 695     h->param.rc.i_aq_mode = x264_clip3( h->param.rc.i_aq_mode, 0, 2 );
 696     h->param.rc.f_aq_strength = x264_clip3f( h->param.rc.f_aq_strength, 0, 3 );
 697     if( h->param.rc.f_aq_strength == 0 )
 698         h->param.rc.i_aq_mode = 0;
 699     /* MB-tree requires AQ to be on, even if the strength is zero. */
 700     if( !h->param.rc.i_aq_mode && h->param.rc.b_mb_tree )
 701     {
 702         h->param.rc.i_aq_mode = 1;
 703         h->param.rc.f_aq_strength = 0;
 704     }
 705     h->param.analyse.i_noise_reduction = x264_clip3( h->param.analyse.i_noise_reduction, 0, 1<<16 );
 706     if( h->param.analyse.i_subpel_refine == 10 && (h->param.analyse.i_trellis != 2 || !h->param.rc.i_aq_mode) )
 707         h->param.analyse.i_subpel_refine = 9;
 708
 709     {
 710         const x264_level_t *l = x264_levels;
 711         if( h->param.i_level_idc < 0 )
 712         {
 713             int maxrate_bak = h->param.rc.i_vbv_max_bitrate;
 714             if( h->param.rc.i_rc_method == X264_RC_ABR && h->param.rc.i_vbv_buffer_size <= 0 )
 715                 h->param.rc.i_vbv_max_bitrate = h->param.rc.i_bitrate * 2;
 716             h->sps = h->sps_array;
 717             x264_sps_init( h->sps, h->param.i_sps_id, &h->param );
 718             do h->param.i_level_idc = l->level_idc;
 719                 while( l[1].level_idc && x264_validate_levels( h, 0 ) && l++ );
 720             h->param.rc.i_vbv_max_bitrate = maxrate_bak;
 721         }
 722         else
 723         {
 724             while( l->level_idc && l->level_idc != h->param.i_level_idc )
 725                 l++;
 726             if( l->level_idc == 0 )
 727             {
 728                 x264_log( h, X264_LOG_ERROR, "invalid level_idc: %d\n", h->param.i_level_idc );
 729                 return -1;
 730             }
 731         }
 732         if( h->param.analyse.i_mv_range <= 0 )
 733             h->param.analyse.i_mv_range = l->mv_range >> h->param.b_interlaced;
 734         else
 735             h->param.analyse.i_mv_range = x264_clip3(h->param.analyse.i_mv_range, 32, 512 >> h->param.b_interlaced);
 736     }
 737
 738     h->param.analyse.i_weighted_pred = x264_clip3( h->param.analyse.i_weighted_pred, 0, X264_WEIGHTP_SMART );
 739     if( !h->param.analyse.i_weighted_pred && h->param.rc.b_mb_tree && h->param.analyse.b_psy && !h->param.b_interlaced )
 740         h->param.analyse.i_weighted_pred = X264_WEIGHTP_FAKE;
 741
 742     if( h->i_thread_frames > 1 )
 743     {
 744         int r = h->param.analyse.i_mv_range_thread;
 745         int r2;
 746         if( r <= 0 )
 747         {
 748             // half of the available space is reserved and divided evenly among the threads,
 749             // the rest is allocated to whichever thread is far enough ahead to use it.
 750             // reserving more space increases quality for some videos, but costs more time
 751             // in thread synchronization.
 752             int max_range = (h->param.i_height + X264_THREAD_HEIGHT) / h->i_thread_frames - X264_THREAD_HEIGHT;
 753             r = max_range / 2;
 754         }
 755         r = X264_MAX( r, h->param.analyse.i_me_range );
 756         r = X264_MIN( r, h->param.analyse.i_mv_range );
 757         // round up to use the whole mb row
 758         r2 = (r & ~15) + ((-X264_THREAD_HEIGHT) & 15);
 759         if( r2 < r )
 760             r2 += 16;
 761         x264_log( h, X264_LOG_DEBUG, "using mv_range_thread = %d\n", r2 );
 762         h->param.analyse.i_mv_range_thread = r2;
 763     }
 764
 765     if( h->param.rc.f_qblur < 0 )
 766         h->param.rc.f_qblur = 0;
 767     if( h->param.rc.f_complexity_blur < 0 )
 768         h->param.rc.f_complexity_blur = 0;
 769
 770     h->param.i_sps_id &= 31;
 771
 772     if( h->param.i_log_level < X264_LOG_INFO )
 773     {
 774         h->param.analyse.b_psnr = 0;
 775         h->param.analyse.b_ssim = 0;
 776     }
 777
 778     if( h->param.b_interlaced )
 779         h->param.b_pic_struct = 1;
 780
 781     if( h->param.i_nal_hrd && !h->param.rc.i_vbv_buffer_size )
 782     {
 783         x264_log( h, X264_LOG_WARNING, "NAL HRD parameters require VBV parameters\n" );
 784         h->param.i_nal_hrd = X264_NAL_HRD_NONE;
 785     }
 786
 787     if( h->param.i_nal_hrd == X264_NAL_HRD_CBR &&
 788        (h->param.rc.i_bitrate != h->param.rc.i_vbv_max_bitrate || !h->param.rc.i_vbv_max_bitrate) )
 789     {
 790         x264_log( h, X264_LOG_WARNING, "CBR HRD requires constant bitrate\n" );
 791         h->param.i_nal_hrd = X264_NAL_HRD_VBR;
 792     }
 793
 794     /* ensure the booleans are 0 or 1 so they can be used in math */
 795 #define BOOLIFY(x) h->param.x = !!h->param.x
 796     BOOLIFY( b_cabac );
 797     BOOLIFY( b_constrained_intra );
 798     BOOLIFY( b_deblocking_filter );
 799     BOOLIFY( b_deterministic );
 800     BOOLIFY( b_sliced_threads );
 801     BOOLIFY( b_interlaced );
 802     BOOLIFY( b_intra_refresh );
 803     BOOLIFY( b_visualize );
 804     BOOLIFY( b_aud );
 805     BOOLIFY( b_repeat_headers );
 806     BOOLIFY( b_annexb );
 807     BOOLIFY( b_vfr_input );
 808     BOOLIFY( b_pic_struct );
 809     BOOLIFY( analyse.b_transform_8x8 );
 810     BOOLIFY( analyse.b_weighted_bipred );
 811     BOOLIFY( analyse.b_chroma_me );
 812     BOOLIFY( analyse.b_mixed_references );
 813     BOOLIFY( analyse.b_fast_pskip );
 814     BOOLIFY( analyse.b_dct_decimate );
 815     BOOLIFY( analyse.b_psy );
 816     BOOLIFY( analyse.b_psnr );
 817     BOOLIFY( analyse.b_ssim );
 818     BOOLIFY( rc.b_stat_write );
 819     BOOLIFY( rc.b_stat_read );
 820     BOOLIFY( rc.b_mb_tree );
 821 #undef BOOLIFY
 822
 823     return 0;
 824 }
 825
 826 static void mbcmp_init( x264_t *h )
 827 {
 828     int satd = !h->mb.b_lossless && h->param.analyse.i_subpel_refine > 1;
 829     memcpy( h->pixf.mbcmp, satd ? h->pixf.satd : h->pixf.sad_aligned, sizeof(h->pixf.mbcmp) );
 830     memcpy( h->pixf.mbcmp_unaligned, satd ? h->pixf.satd : h->pixf.sad, sizeof(h->pixf.mbcmp_unaligned) );
 831     h->pixf.intra_mbcmp_x3_16x16 = satd ? h->pixf.intra_satd_x3_16x16 : h->pixf.intra_sad_x3_16x16;
 832     h->pixf.intra_mbcmp_x3_8x8c = satd ? h->pixf.intra_satd_x3_8x8c : h->pixf.intra_sad_x3_8x8c;
 833     h->pixf.intra_mbcmp_x3_4x4 = satd ? h->pixf.intra_satd_x3_4x4 : h->pixf.intra_sad_x3_4x4;
 834     satd &= h->param.analyse.i_me_method == X264_ME_TESA;
 835     memcpy( h->pixf.fpelcmp, satd ? h->pixf.satd : h->pixf.sad, sizeof(h->pixf.fpelcmp) );
 836     memcpy( h->pixf.fpelcmp_x3, satd ? h->pixf.satd_x3 : h->pixf.sad_x3, sizeof(h->pixf.fpelcmp_x3) );
 837     memcpy( h->pixf.fpelcmp_x4, satd ? h->pixf.satd_x4 : h->pixf.sad_x4, sizeof(h->pixf.fpelcmp_x4) );
 838 }
 839
 840 static void x264_set_aspect_ratio( x264_t *h, x264_param_t *param, int initial )
 841 {
 842     /* VUI */
 843     if( param->vui.i_sar_width > 0 && param->vui.i_sar_height > 0 )
 844     {
 845         int i_w = param->vui.i_sar_width;
 846         int i_h = param->vui.i_sar_height;
 847         int old_w = h->param.vui.i_sar_width;
 848         int old_h = h->param.vui.i_sar_height;
 849
 850         x264_reduce_fraction( &i_w, &i_h );
 851
 852         while( i_w > 65535 || i_h > 65535 )
 853         {
 854             i_w /= 2;
 855             i_h /= 2;
 856         }
 857
 858         x264_reduce_fraction( &i_w, &i_h );
 859
 860         if( i_w != old_w || i_h != old_h || initial )
 861         {
 862             h->param.vui.i_sar_width = 0;
 863             h->param.vui.i_sar_height = 0;
 864             if( i_w == 0 || i_h == 0 )
 865                 x264_log( h, X264_LOG_WARNING, "cannot create valid sample aspect ratio\n" );
 866             else
 867             {
 868                 x264_log( h, initial?X264_LOG_INFO:X264_LOG_DEBUG, "using SAR=%d/%d\n", i_w, i_h );
 869                 h->param.vui.i_sar_width = i_w;
 870                 h->param.vui.i_sar_height = i_h;
 871             }
 872         }
 873     }
 874 }
 875
 876 /****************************************************************************
 877  * x264_encoder_open:
 878  ****************************************************************************/
 879 x264_t *x264_encoder_open( x264_param_t *param )
 880 {
 881     x264_t *h;
 882     char buf[1000], *p;
 883     int i, qp, i_slicetype_length;
 884
 885     CHECKED_MALLOCZERO( h, sizeof(x264_t) );
 886
 887     /* Create a copy of param */
 888     memcpy( &h->param, param, sizeof(x264_param_t) );
 889
 890     if( param->param_free )
 891         param->param_free( param );
 892
 893     if( x264_validate_parameters( h ) < 0 )
 894         goto fail;
 895
 896     if( h->param.psz_cqm_file )
 897         if( x264_cqm_parse_file( h, h->param.psz_cqm_file ) < 0 )
 898             goto fail;
 899
 900     if( h->param.rc.psz_stat_out )
 901         h->param.rc.psz_stat_out = strdup( h->param.rc.psz_stat_out );
 902     if( h->param.rc.psz_stat_in )
 903         h->param.rc.psz_stat_in = strdup( h->param.rc.psz_stat_in );
 904
 905     x264_set_aspect_ratio( h, &h->param, 1 );
 906
 907     x264_reduce_fraction( &h->param.i_fps_num, &h->param.i_fps_den );
 908     x264_reduce_fraction( &h->param.i_timebase_num, &h->param.i_timebase_den );
 909
 910     /* Init x264_t */
 911     h->i_frame = -1;
 912     h->i_frame_num = 0;
 913     h->i_idr_pic_id = 0;
 914     if( h->param.b_dts_compress )
 915     {
 916         /* h->i_dts_compress_multiplier == h->frames.i_bframe_delay + 1 */
 917         h->i_dts_compress_multiplier = h->param.i_bframe ? (h->param.i_bframe_pyramid ? 3 : 2) : 1;
 918         if( h->i_dts_compress_multiplier != 1 )
 919         {
 920             x264_log( h, X264_LOG_DEBUG, "DTS compresion changed timebase: %d/%d -> %d/%d\n",
 921                       h->param.i_timebase_num, h->param.i_timebase_den,
 922                       h->param.i_timebase_num, h->param.i_timebase_den * h->i_dts_compress_multiplier );
 923             h->param.i_timebase_den *= h->i_dts_compress_multiplier;
 924         }
 925     }
 926     else
 927         h->i_dts_compress_multiplier = 1;
 928
 929     h->sps = &h->sps_array[0];
 930     x264_sps_init( h->sps, h->param.i_sps_id, &h->param );
 931
 932     h->pps = &h->pps_array[0];
 933     x264_pps_init( h->pps, h->param.i_sps_id, &h->param, h->sps );
 934
 935     x264_validate_levels( h, 1 );
 936
 937     h->chroma_qp_table = i_chroma_qp_table + 12 + h->pps->i_chroma_qp_index_offset;
 938
 939     if( x264_cqm_init( h ) < 0 )
 940         goto fail;
 941
 942     h->mb.i_mb_count = h->sps->i_mb_width * h->sps->i_mb_height;
 943
 944     /* Init frames. */
 945     if( h->param.i_bframe_adaptive == X264_B_ADAPT_TRELLIS )
 946         h->frames.i_delay = X264_MAX(h->param.i_bframe,3)*4;
 947     else
 948         h->frames.i_delay = h->param.i_bframe;
 949     if( h->param.rc.b_mb_tree || h->param.rc.i_vbv_buffer_size )
 950         h->frames.i_delay = X264_MAX( h->frames.i_delay, h->param.rc.i_lookahead );
 951     i_slicetype_length = h->frames.i_delay;
 952     h->frames.i_delay += h->i_thread_frames - 1;
 953     h->frames.i_delay = X264_MIN( h->frames.i_delay, X264_LOOKAHEAD_MAX );
 954     h->frames.i_delay += h->param.i_sync_lookahead;
 955     h->frames.i_delay += h->param.b_vfr_input && (h->param.rc.i_rc_method == X264_RC_ABR || h->param.rc.b_stat_write
 956                                                  || h->param.rc.i_vbv_buffer_size);
 957     h->frames.i_bframe_delay = h->param.i_bframe ? (h->param.i_bframe_pyramid ? 2 : 1) : 0;
 958
 959     h->frames.i_max_ref0 = h->param.i_frame_reference;
 960     h->frames.i_max_ref1 = h->sps->vui.i_num_reorder_frames;
 961     h->frames.i_max_dpb  = h->sps->vui.i_max_dec_frame_buffering;
 962     h->frames.b_have_lowres = !h->param.rc.b_stat_read
 963         && ( h->param.rc.i_rc_method == X264_RC_ABR
 964           || h->param.rc.i_rc_method == X264_RC_CRF
 965           || h->param.i_bframe_adaptive
 966           || h->param.i_scenecut_threshold
 967           || h->param.rc.b_mb_tree
 968           || h->param.analyse.i_weighted_pred == X264_WEIGHTP_SMART );
 969     h->frames.b_have_lowres |= h->param.rc.b_stat_read && h->param.rc.i_vbv_buffer_size > 0;
 970     h->frames.b_have_sub8x8_esa = !!(h->param.analyse.inter & X264_ANALYSE_PSUB8x8);
 971
 972     h->frames.i_last_keyframe = - h->param.i_keyint_max;
 973     h->frames.i_input    = 0;
 974     h->frames.i_largest_pts = h->frames.i_second_largest_pts = -1;
 975
 976     CHECKED_MALLOCZERO( h->frames.unused[0], (h->frames.i_delay + 3) * sizeof(x264_frame_t *) );
 977     /* Allocate room for max refs plus a few extra just in case. */
 978     CHECKED_MALLOCZERO( h->frames.unused[1], (h->i_thread_frames + 20) * sizeof(x264_frame_t *) );
 979     CHECKED_MALLOCZERO( h->frames.current, (h->param.i_sync_lookahead + h->param.i_bframe
 980                         + h->i_thread_frames + 3) * sizeof(x264_frame_t *) );
 981     if( h->param.analyse.i_weighted_pred > 0 )
 982         CHECKED_MALLOCZERO( h->frames.blank_unused, h->i_thread_frames * 4 * sizeof(x264_frame_t *) );
 983     h->i_ref0 = 0;
 984     h->i_ref1 = 0;
 985     h->i_cpb_delay = h->i_coded_fields = h->i_disp_fields = h->i_prev_duration = 0;
 986     h->i_disp_fields_last_frame = -1;
 987     x264_rdo_init();
 988
 989     /* init CPU functions */
 990     x264_predict_16x16_init( h->param.cpu, h->predict_16x16 );
 991     x264_predict_8x8c_init( h->param.cpu, h->predict_8x8c );
 992     x264_predict_8x8_init( h->param.cpu, h->predict_8x8, &h->predict_8x8_filter );
 993     x264_predict_4x4_init( h->param.cpu, h->predict_4x4 );
 994     if( !h->param.b_cabac )
 995         x264_init_vlc_tables();
 996     x264_pixel_init( h->param.cpu, &h->pixf );
 997     x264_dct_init( h->param.cpu, &h->dctf );
 998     x264_zigzag_init( h->param.cpu, &h->zigzagf, h->param.b_interlaced );
 999     x264_mc_init( h->param.cpu, &h->mc );
1000     x264_quant_init( h, h->param.cpu, &h->quantf );
1001     x264_deblock_init( h->param.cpu, &h->loopf );
1002     x264_dct_init_weights();
1003
1004     mbcmp_init( h );
1005
1006     p = buf + sprintf( buf, "using cpu capabilities:" );
1007     for( i=0; x264_cpu_names[i].flags; i++ )
1008     {
1009         if( !strcmp(x264_cpu_names[i].name, "SSE2")
1010             && h->param.cpu & (X264_CPU_SSE2_IS_FAST|X264_CPU_SSE2_IS_SLOW) )
1011             continue;
1012         if( !strcmp(x264_cpu_names[i].name, "SSE3")
1013             && (h->param.cpu & X264_CPU_SSSE3 || !(h->param.cpu & X264_CPU_CACHELINE_64)) )
1014             continue;
1015         if( !strcmp(x264_cpu_names[i].name, "SSE4.1")
1016             && (h->param.cpu & X264_CPU_SSE42) )
1017             continue;
1018         if( (h->param.cpu & x264_cpu_names[i].flags) == x264_cpu_names[i].flags
1019             && (!i || x264_cpu_names[i].flags != x264_cpu_names[i-1].flags) )
1020             p += sprintf( p, " %s", x264_cpu_names[i].name );
1021     }
1022     if( !h->param.cpu )
1023         p += sprintf( p, " none!" );
1024     x264_log( h, X264_LOG_INFO, "%s\n", buf );
1025
1026     for( qp = h->param.rc.i_qp_min; qp <= h->param.rc.i_qp_max; qp++ )
1027         if( x264_analyse_init_costs( h, qp ) )
1028             goto fail;
1029     if( x264_analyse_init_costs( h, X264_LOOKAHEAD_QP ) )
1030         goto fail;
1031     if( h->cost_mv[1][2013] != 24 )
1032     {
1033         x264_log( h, X264_LOG_ERROR, "MV cost test failed: x264 has been miscompiled!\n" );
1034         goto fail;
1035     }
1036
1037     h->out.i_nal = 0;
1038     h->out.i_bitstream = X264_MAX( 1000000, h->param.i_width * h->param.i_height * 4
1039         * ( h->param.rc.i_rc_method == X264_RC_ABR ? pow( 0.95, h->param.rc.i_qp_min )
1040           : pow( 0.95, h->param.rc.i_qp_constant ) * X264_MAX( 1, h->param.rc.f_ip_factor )));
1041
1042     CHECKED_MALLOC( h->nal_buffer, h->out.i_bitstream * 3/2 + 4 );
1043     h->nal_buffer_size = h->out.i_bitstream * 3/2 + 4;
1044
1045     h->thread[0] = h;
1046     for( i = 1; i < h->param.i_threads + !!h->param.i_sync_lookahead; i++ )
1047         CHECKED_MALLOC( h->thread[i], sizeof(x264_t) );
1048
1049     if( x264_lookahead_init( h, i_slicetype_length ) )
1050         goto fail;
1051
1052     for( i = 0; i < h->param.i_threads; i++ )
1053     {
1054         int init_nal_count = h->param.i_slice_count + 3;
1055         int allocate_threadlocal_data = !h->param.b_sliced_threads || !i;
1056         if( i > 0 )
1057             *h->thread[i] = *h;
1058
1059         if( allocate_threadlocal_data )
1060         {
1061             h->thread[i]->fdec = x264_frame_pop_unused( h, 1 );
1062             if( !h->thread[i]->fdec )
1063                 goto fail;
1064         }
1065         else
1066             h->thread[i]->fdec = h->thread[0]->fdec;
1067
1068         CHECKED_MALLOC( h->thread[i]->out.p_bitstream, h->out.i_bitstream );
1069         /* Start each thread with room for init_nal_count NAL units; it'll realloc later if needed. */
1070         CHECKED_MALLOC( h->thread[i]->out.nal, init_nal_count*sizeof(x264_nal_t) );
1071         h->thread[i]->out.i_nals_allocated = init_nal_count;
1072
1073         if( allocate_threadlocal_data && x264_macroblock_cache_init( h->thread[i] ) < 0 )
1074             goto fail;
1075     }
1076
1077     /* Allocate scratch buffer */
1078     for( i = 0; i < h->param.i_threads + !!h->param.i_sync_lookahead; i++ )
1079     {
1080         int buf_hpel = (h->fdec->i_width[0]+48) * sizeof(int16_t);
1081         int buf_ssim = h->param.analyse.b_ssim * 8 * (h->param.i_width/4+3) * sizeof(int);
1082         int me_range = X264_MIN(h->param.analyse.i_me_range, h->param.analyse.i_mv_range);
1083         int buf_tesa = (h->param.analyse.i_me_method >= X264_ME_ESA) *
1084             ((me_range*2+18) * sizeof(int16_t) + (me_range+4) * (me_range+1) * 4 * sizeof(mvsad_t));
1085         int buf_mbtree = h->param.rc.b_mb_tree * ((h->sps->i_mb_width+3)&~3) * sizeof(int);
1086         int buf_nnz = !h->param.b_cabac * h->pps->b_transform_8x8_mode * (h->sps->i_mb_width * 4 * 16 * sizeof(uint8_t));
1087         int scratch_size = X264_MAX4( buf_hpel, buf_ssim, buf_tesa, X264_MAX( buf_mbtree, buf_nnz ) );
1088         CHECKED_MALLOC( h->thread[i]->scratch_buffer, scratch_size );
1089     }
1090
1091     if( x264_ratecontrol_new( h ) < 0 )
1092         goto fail;
1093
1094     if( h->param.i_nal_hrd )
1095     {
1096         x264_log( h, X264_LOG_DEBUG, "HRD bitrate: %i bits/sec\n", h->sps->vui.hrd.i_bit_rate_unscaled );
1097         x264_log( h, X264_LOG_DEBUG, "CPB size: %i bits\n", h->sps->vui.hrd.i_cpb_size_unscaled );
1098     }
1099
1100     if( h->param.psz_dump_yuv )
1101     {
1102         /* create or truncate the reconstructed video file */
1103         FILE *f = fopen( h->param.psz_dump_yuv, "w" );
1104         if( !f )
1105         {
1106             x264_log( h, X264_LOG_ERROR, "dump_yuv: can't write to %s\n", h->param.psz_dump_yuv );
1107             goto fail;
1108         }
1109         else if( !x264_is_regular_file( f ) )
1110         {
1111             x264_log( h, X264_LOG_ERROR, "dump_yuv: incompatible with non-regular file %s\n", h->param.psz_dump_yuv );
1112             goto fail;
1113         }
1114         fclose( f );
1115     }
1116
1117     x264_log( h, X264_LOG_INFO, "profile %s, level %d.%d\n",
1118         h->sps->i_profile_idc == PROFILE_BASELINE ? "Baseline" :
1119         h->sps->i_profile_idc == PROFILE_MAIN ? "Main" :
1120         h->sps->i_profile_idc == PROFILE_HIGH ? "High" :
1121         "High 4:4:4 Predictive", h->sps->i_level_idc/10, h->sps->i_level_idc%10 );
1122
1123     return h;
1124 fail:
1125     x264_free( h );
1126     return NULL;
1127 }
1128
1129 /****************************************************************************
1130  * x264_encoder_reconfig:
1131  ****************************************************************************/
1132 int x264_encoder_reconfig( x264_t *h, x264_param_t *param )
1133 {
1134     int rc_reconfig = 0;
1135     h = h->thread[h->thread[0]->i_thread_phase];
1136     x264_set_aspect_ratio( h, param, 0 );
1137 #define COPY(var) h->param.var = param->var
1138     COPY( i_frame_reference ); // but never uses more refs than initially specified
1139     COPY( i_bframe_bias );
1140     if( h->param.i_scenecut_threshold )
1141         COPY( i_scenecut_threshold ); // can't turn it on or off, only vary the threshold
1142     COPY( b_deblocking_filter );
1143     COPY( i_deblocking_filter_alphac0 );
1144     COPY( i_deblocking_filter_beta );
1145     COPY( analyse.inter );
1146     COPY( analyse.intra );
1147     COPY( analyse.i_direct_mv_pred );
1148     /* Scratch buffer prevents me_range from being increased for esa/tesa */
1149     if( h->param.analyse.i_me_method < X264_ME_ESA || param->analyse.i_me_range < h->param.analyse.i_me_range )
1150         COPY( analyse.i_me_range );
1151     COPY( analyse.i_noise_reduction );
1152     /* We can't switch out of subme=0 during encoding. */
1153     if( h->param.analyse.i_subpel_refine )
1154         COPY( analyse.i_subpel_refine );
1155     COPY( analyse.i_trellis );
1156     COPY( analyse.b_chroma_me );
1157     COPY( analyse.b_dct_decimate );
1158     COPY( analyse.b_fast_pskip );
1159     COPY( analyse.b_mixed_references );
1160     COPY( analyse.f_psy_rd );
1161     COPY( analyse.f_psy_trellis );
1162     // can only twiddle these if they were enabled to begin with:
1163     if( h->param.analyse.i_me_method >= X264_ME_ESA || param->analyse.i_me_method < X264_ME_ESA )
1164         COPY( analyse.i_me_method );
1165     if( h->param.analyse.i_me_method >= X264_ME_ESA && !h->frames.b_have_sub8x8_esa )
1166         h->param.analyse.inter &= ~X264_ANALYSE_PSUB8x8;
1167     if( h->pps->b_transform_8x8_mode )
1168         COPY( analyse.b_transform_8x8 );
1169     if( h->frames.i_max_ref1 > 1 )
1170         COPY( i_bframe_pyramid );
1171     COPY( i_slice_max_size );
1172     COPY( i_slice_max_mbs );
1173     COPY( i_slice_count );
1174
1175     /* VBV can't be turned on if it wasn't on to begin with */
1176     if( h->param.rc.i_vbv_max_bitrate > 0 && h->param.rc.i_vbv_buffer_size > 0 &&
1177           param->rc.i_vbv_max_bitrate > 0 &&   param->rc.i_vbv_buffer_size > 0 )
1178     {
1179         COPY( rc.i_vbv_max_bitrate );
1180         COPY( rc.i_vbv_buffer_size );
1181         COPY( rc.i_bitrate );
1182         rc_reconfig = 1;
1183     }
1184     if( h->param.rc.f_rf_constant != param->rc.f_rf_constant )
1185     {
1186         COPY( rc.f_rf_constant );
1187         rc_reconfig = 1;
1188     }
1189     if( h->param.rc.f_rf_constant_max != param->rc.f_rf_constant_max )
1190     {
1191         COPY( rc.f_rf_constant_max );
1192         rc_reconfig = 1;
1193     }
1194
1195 #undef COPY
1196
1197     mbcmp_init( h );
1198
1199     int ret = x264_validate_parameters( h );
1200
1201     /* Supported reconfiguration options (1-pass only):
1202      * vbv-maxrate
1203      * vbv-bufsize
1204      * crf
1205      * bitrate (CBR only) */
1206     if( !ret && rc_reconfig )
1207         x264_ratecontrol_init_reconfigurable( h, 0 );
1208
1209     return ret;
1210 }
1211
1212 /****************************************************************************
1213  * x264_encoder_parameters:
1214  ****************************************************************************/
1215 void x264_encoder_parameters( x264_t *h, x264_param_t *param )
1216 {
1217     memcpy( param, &h->thread[h->i_thread_phase]->param, sizeof(x264_param_t) );
1218 }
1219
1220 /* internal usage */
1221 static void x264_nal_start( x264_t *h, int i_type, int i_ref_idc )
1222 {
1223     x264_nal_t *nal = &h->out.nal[h->out.i_nal];
1224
1225     nal->i_ref_idc = i_ref_idc;
1226     nal->i_type    = i_type;
1227
1228     nal->i_payload= 0;
1229     nal->p_payload= &h->out.p_bitstream[bs_pos( &h->out.bs ) / 8];
1230 }
1231 /* if number of allocated nals is not enough, re-allocate a larger one. */
1232 static int x264_nal_check_buffer( x264_t *h )
1233 {
1234     if( h->out.i_nal >= h->out.i_nals_allocated )
1235     {
1236         x264_nal_t *new_out = x264_malloc( sizeof(x264_nal_t) * (h->out.i_nals_allocated*2) );
1237         if( !new_out )
1238             return -1;
1239         memcpy( new_out, h->out.nal, sizeof(x264_nal_t) * (h->out.i_nals_allocated) );
1240         x264_free( h->out.nal );
1241         h->out.nal = new_out;
1242         h->out.i_nals_allocated *= 2;
1243     }
1244     return 0;
1245 }
1246 static int x264_nal_end( x264_t *h )
1247 {
1248     x264_nal_t *nal = &h->out.nal[h->out.i_nal];
1249     nal->i_payload = &h->out.p_bitstream[bs_pos( &h->out.bs ) / 8] - nal->p_payload;
1250     h->out.i_nal++;
1251
1252     return x264_nal_check_buffer( h );
1253 }
1254
1255 static int x264_encoder_encapsulate_nals( x264_t *h, int start )
1256 {
1257     int nal_size = 0, previous_nal_size = 0, i;
1258
1259     for( i = 0; i < start; i++ )
1260         previous_nal_size += h->out.nal[i].i_payload;
1261
1262     for( i = start; i < h->out.i_nal; i++ )
1263         nal_size += h->out.nal[i].i_payload;
1264
1265     /* Worst-case NAL unit escaping: reallocate the buffer if it's too small. */
1266     if( h->nal_buffer_size < nal_size * 3/2 + h->out.i_nal * 4 )
1267     {
1268         uint8_t *buf = x264_malloc( nal_size * 2 + h->out.i_nal * 4 );
1269         if( !buf )
1270             return -1;
1271         if( previous_nal_size )
1272             memcpy( buf, h->nal_buffer, previous_nal_size );
1273         x264_free( h->nal_buffer );
1274         h->nal_buffer = buf;
1275     }
1276
1277     uint8_t *nal_buffer = h->nal_buffer + previous_nal_size;
1278
1279     for( i = start; i < h->out.i_nal; i++ )
1280     {
1281         int long_startcode = !i || h->out.nal[i].i_type == NAL_SPS || h->out.nal[i].i_type == NAL_PPS;
1282         int size = x264_nal_encode( nal_buffer, &h->out.nal[i], h->param.b_annexb, long_startcode );
1283         h->out.nal[i].i_payload = size;
1284         h->out.nal[i].p_payload = nal_buffer;
1285         nal_buffer += size;
1286     }
1287
1288     return nal_buffer - (h->nal_buffer + previous_nal_size);
1289 }
1290
1291 /****************************************************************************
1292  * x264_encoder_headers:
1293  ****************************************************************************/
1294 int x264_encoder_headers( x264_t *h, x264_nal_t **pp_nal, int *pi_nal )
1295 {
1296     int frame_size = 0;
1297     /* init bitstream context */
1298     h->out.i_nal = 0;
1299     bs_init( &h->out.bs, h->out.p_bitstream, h->out.i_bitstream );
1300
1301     /* Write SEI, SPS and PPS. */
1302
1303     /* generate sequence parameters */
1304     x264_nal_start( h, NAL_SPS, NAL_PRIORITY_HIGHEST );
1305     x264_sps_write( &h->out.bs, h->sps );
1306     if( x264_nal_end( h ) )
1307         return -1;
1308
1309     /* generate picture parameters */
1310     x264_nal_start( h, NAL_PPS, NAL_PRIORITY_HIGHEST );
1311     x264_pps_write( &h->out.bs, h->pps );
1312     if( x264_nal_end( h ) )
1313         return -1;
1314
1315     /* identify ourselves */
1316     x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
1317     if( x264_sei_version_write( h, &h->out.bs ) )
1318         return -1;
1319     if( x264_nal_end( h ) )
1320         return -1;
1321
1322     frame_size = x264_encoder_encapsulate_nals( h, 0 );
1323
1324     /* now set output*/
1325     *pi_nal = h->out.i_nal;
1326     *pp_nal = &h->out.nal[0];
1327     h->out.i_nal = 0;
1328
1329     return frame_size;
1330 }
1331
1332 /* Check to see whether we have chosen a reference list ordering different
1333  * from the standard's default. */
1334 static inline void x264_reference_check_reorder( x264_t *h )
1335 {
1336     int i;
1337     for( i = 0; i < h->i_ref0 - 1; i++ )
1338         /* P and B-frames use different default orders. */
1339         if( h->sh.i_type == SLICE_TYPE_P ? h->fref0[i]->i_frame_num < h->fref0[i+1]->i_frame_num
1340                                          : h->fref0[i]->i_poc < h->fref0[i+1]->i_poc )
1341         {
1342             h->b_ref_reorder[0] = 1;
1343             break;
1344         }
1345 }
1346
1347 /* return -1 on failure, else return the index of the new reference frame */
1348 int x264_weighted_reference_duplicate( x264_t *h, int i_ref, const x264_weight_t *w )
1349 {
1350     int i = h->i_ref0;
1351     int j;
1352     x264_frame_t *newframe;
1353     if( i <= 1 ) /* empty list, definitely can't duplicate frame */
1354         return -1;
1355
1356     /* Find a place to insert the duplicate in the reference list. */
1357     for( j = 0; j < i; j++ )
1358         if( h->fref0[i_ref]->i_frame != h->fref0[j]->i_frame )
1359         {
1360             /* found a place, after j, make sure there is not already a duplicate there */
1361             if( j == i-1 || ( h->fref0[j+1] && h->fref0[i_ref]->i_frame != h->fref0[j+1]->i_frame ) )
1362                 break;
1363         }
1364
1365     if( j == i ) /* No room in the reference list for the duplicate. */
1366         return -1;
1367     j++;
1368
1369     newframe = x264_frame_pop_blank_unused( h );
1370
1371     //FIXME: probably don't need to copy everything
1372     *newframe = *h->fref0[i_ref];
1373     newframe->i_reference_count = 1;
1374     newframe->orig = h->fref0[i_ref];
1375     newframe->b_duplicate = 1;
1376     memcpy( h->fenc->weight[j], w, sizeof(h->fenc->weight[i]) );
1377
1378     /* shift the frames to make space for the dupe. */
1379     h->b_ref_reorder[0] = 1;
1380     if( h->i_ref0 < 16 )
1381         ++h->i_ref0;
1382     h->fref0[15] = NULL;
1383     x264_frame_unshift( &h->fref0[j], newframe );
1384
1385     return j;
1386 }
1387
1388 static void x264_weighted_pred_init( x264_t *h )
1389 {
1390     int i_ref;
1391     int i;
1392
1393     /* for now no analysis and set all weights to nothing */
1394     for( i_ref = 0; i_ref < h->i_ref0; i_ref++ )
1395         h->fenc->weighted[i_ref] = h->fref0[i_ref]->filtered[0];
1396
1397     // FIXME: This only supports weighting of one reference frame
1398     // and duplicates of that frame.
1399     h->fenc->i_lines_weighted = 0;
1400
1401     for( i_ref = 0; i_ref < (h->i_ref0 << h->sh.b_mbaff); i_ref++ )
1402         for( i = 0; i < 3; i++ )
1403             h->sh.weight[i_ref][i].weightfn = NULL;
1404
1405
1406     if( h->sh.i_type != SLICE_TYPE_P || h->param.analyse.i_weighted_pred <= 0 )
1407         return;
1408
1409     int i_padv = PADV << h->param.b_interlaced;
1410     int denom = -1;
1411     int weightluma = 0;
1412     int buffer_next = 0;
1413     int j;
1414     //FIXME: when chroma support is added, move this into loop
1415     h->sh.weight[0][1].weightfn = h->sh.weight[0][2].weightfn = NULL;
1416     h->sh.weight[0][1].i_denom = h->sh.weight[0][2].i_denom = 0;
1417     for( j = 0; j < h->i_ref0; j++ )
1418     {
1419         if( h->fenc->weight[j][0].weightfn )
1420         {
1421             h->sh.weight[j][0] = h->fenc->weight[j][0];
1422             // if weight is useless, don't write it to stream
1423             if( h->sh.weight[j][0].i_scale == 1<<h->sh.weight[j][0].i_denom && h->sh.weight[j][0].i_offset == 0 )
1424                 h->sh.weight[j][0].weightfn = NULL;
1425             else
1426             {
1427                 if( !weightluma )
1428                 {
1429                     weightluma = 1;
1430                     h->sh.weight[0][0].i_denom = denom = h->sh.weight[j][0].i_denom;
1431                     assert( x264_clip3( denom, 0, 7 ) == denom );
1432                 }
1433                 assert( h->sh.weight[j][0].i_denom == denom );
1434                 assert( x264_clip3( h->sh.weight[j][0].i_scale, 0, 127 ) == h->sh.weight[j][0].i_scale );
1435                 assert( x264_clip3( h->sh.weight[j][0].i_offset, -128, 127 ) == h->sh.weight[j][0].i_offset );
1436                 h->fenc->weighted[j] = h->mb.p_weight_buf[buffer_next++] +
1437                     h->fenc->i_stride[0] * i_padv + PADH;
1438             }
1439         }
1440
1441         //scale full resolution frame
1442         if( h->sh.weight[j][0].weightfn && h->param.i_threads == 1 )
1443         {
1444             uint8_t *src = h->fref0[j]->filtered[0] - h->fref0[j]->i_stride[0]*i_padv - PADH;
1445             uint8_t *dst = h->fenc->weighted[j] - h->fenc->i_stride[0]*i_padv - PADH;
1446             int stride = h->fenc->i_stride[0];
1447             int width = h->fenc->i_width[0] + PADH*2;
1448             int height = h->fenc->i_lines[0] + i_padv*2;
1449             x264_weight_scale_plane( h, dst, stride, src, stride, width, height, &h->sh.weight[j][0] );
1450             h->fenc->i_lines_weighted = height;
1451         }
1452     }
1453     if( !weightluma )
1454         h->sh.weight[0][0].i_denom = 0;
1455 }
1456
1457 static inline void x264_reference_build_list( x264_t *h, int i_poc )
1458 {
1459     int i, b_ok;
1460
1461     /* build ref list 0/1 */
1462     h->mb.pic.i_fref[0] = h->i_ref0 = 0;
1463     h->mb.pic.i_fref[1] = h->i_ref1 = 0;
1464     if( h->sh.i_type == SLICE_TYPE_I )
1465         return;
1466
1467     for( i = 0; h->frames.reference[i]; i++ )
1468     {
1469         if( h->frames.reference[i]->i_poc < i_poc )
1470         {
1471             h->fref0[h->i_ref0++] = h->frames.reference[i];
1472         }
1473         else if( h->frames.reference[i]->i_poc > i_poc )
1474         {
1475             h->fref1[h->i_ref1++] = h->frames.reference[i];
1476         }
1477     }
1478
1479     /* Order ref0 from higher to lower poc */
1480     do
1481     {
1482         b_ok = 1;
1483         for( i = 0; i < h->i_ref0 - 1; i++ )
1484         {
1485             if( h->fref0[i]->i_poc < h->fref0[i+1]->i_poc )
1486             {
1487                 XCHG( x264_frame_t*, h->fref0[i], h->fref0[i+1] );
1488                 b_ok = 0;
1489                 break;
1490             }
1491         }
1492     } while( !b_ok );
1493
1494     if( h->sh.i_mmco_remove_from_end )
1495         for( i = h->i_ref0-1; i >= h->i_ref0 - h->sh.i_mmco_remove_from_end; i-- )
1496         {
1497             int diff = h->i_frame_num - h->fref0[i]->i_frame_num;
1498             h->sh.mmco[h->sh.i_mmco_command_count].i_poc = h->fref0[i]->i_poc;
1499             h->sh.mmco[h->sh.i_mmco_command_count++].i_difference_of_pic_nums = diff;
1500         }
1501
1502     /* Order ref1 from lower to higher poc (bubble sort) for B-frame */
1503     do
1504     {
1505         b_ok = 1;
1506         for( i = 0; i < h->i_ref1 - 1; i++ )
1507         {
1508             if( h->fref1[i]->i_poc > h->fref1[i+1]->i_poc )
1509             {
1510                 XCHG( x264_frame_t*, h->fref1[i], h->fref1[i+1] );
1511                 b_ok = 0;
1512                 break;
1513             }
1514         }
1515     } while( !b_ok );
1516
1517     x264_reference_check_reorder( h );
1518
1519     h->i_ref1 = X264_MIN( h->i_ref1, h->frames.i_max_ref1 );
1520     h->i_ref0 = X264_MIN( h->i_ref0, h->frames.i_max_ref0 );
1521     h->i_ref0 = X264_MIN( h->i_ref0, h->param.i_frame_reference ); // if reconfig() has lowered the limit
1522
1523     /* add duplicates */
1524     if( h->fenc->i_type == X264_TYPE_P )
1525     {
1526         int idx = -1;
1527         if( h->param.analyse.i_weighted_pred == X264_WEIGHTP_SMART )
1528         {
1529             x264_weight_t w[3];
1530             w[1].weightfn = w[2].weightfn = NULL;
1531             if( h->param.rc.b_stat_read )
1532                 x264_ratecontrol_set_weights( h, h->fenc );
1533
1534             if( !h->fenc->weight[0][0].weightfn )
1535             {
1536                 h->fenc->weight[0][0].i_denom = 0;
1537                 SET_WEIGHT( w[0], 1, 1, 0, -1 );
1538                 idx = x264_weighted_reference_duplicate( h, 0, w );
1539             }
1540             else
1541             {
1542                 if( h->fenc->weight[0][0].i_scale == 1<<h->fenc->weight[0][0].i_denom )
1543                 {
1544                     SET_WEIGHT( h->fenc->weight[0][0], 1, 1, 0, h->fenc->weight[0][0].i_offset );
1545                 }
1546                 x264_weighted_reference_duplicate( h, 0, weight_none );
1547                 if( h->fenc->weight[0][0].i_offset > -128 )
1548                 {
1549                     w[0] = h->fenc->weight[0][0];
1550                     w[0].i_offset--;
1551                     h->mc.weight_cache( h, &w[0] );
1552                     idx = x264_weighted_reference_duplicate( h, 0, w );
1553                 }
1554             }
1555         }
1556         else if( h->param.analyse.i_weighted_pred == X264_WEIGHTP_BLIND )
1557         {
1558             //weighted offset=-1
1559             x264_weight_t w[3];
1560             SET_WEIGHT( w[0], 1, 1, 0, -1 );
1561             h->fenc->weight[0][0].i_denom = 0;
1562             w[1].weightfn = w[2].weightfn = NULL;
1563             idx = x264_weighted_reference_duplicate( h, 0, w );
1564         }
1565         h->mb.ref_blind_dupe = idx;
1566     }
1567
1568     assert( h->i_ref0 + h->i_ref1 <= 16 );
1569     h->mb.pic.i_fref[0] = h->i_ref0;
1570     h->mb.pic.i_fref[1] = h->i_ref1;
1571 }
1572
1573 static void x264_fdec_filter_row( x264_t *h, int mb_y )
1574 {
1575     /* mb_y is the mb to be encoded next, not the mb to be filtered here */
1576     int b_hpel = h->fdec->b_kept_as_ref;
1577     int b_deblock = !h->sh.i_disable_deblocking_filter_idc;
1578     int b_end = mb_y == h->sps->i_mb_height;
1579     int min_y = mb_y - (1 << h->sh.b_mbaff);
1580     int max_y = b_end ? h->sps->i_mb_height : mb_y;
1581     b_deblock &= b_hpel || h->param.psz_dump_yuv;
1582     if( mb_y & h->sh.b_mbaff )
1583         return;
1584     if( min_y < 0 )
1585         return;
1586
1587     if( !b_end && !h->param.b_sliced_threads )
1588     {
1589         int i, j;
1590         for( j=0; j<=h->sh.b_mbaff; j++ )
1591             for( i=0; i<3; i++ )
1592             {
1593                 memcpy( h->mb.intra_border_backup[j][i],
1594                         h->fdec->plane[i] + ((mb_y*16 >> !!i) + j - 1 - h->sh.b_mbaff) * h->fdec->i_stride[i],
1595                         h->sps->i_mb_width*16 >> !!i );
1596             }
1597     }
1598
1599     if( b_deblock )
1600     {
1601         int y;
1602         for( y = min_y; y < max_y; y += (1 << h->sh.b_mbaff) )
1603             x264_frame_deblock_row( h, y );
1604     }
1605
1606     if( b_hpel )
1607     {
1608         x264_frame_expand_border( h, h->fdec, min_y, b_end );
1609         if( h->param.analyse.i_subpel_refine )
1610         {
1611             x264_frame_filter( h, h->fdec, min_y, b_end );
1612             x264_frame_expand_border_filtered( h, h->fdec, min_y, b_end );
1613         }
1614     }
1615
1616     if( h->i_thread_frames > 1 && h->fdec->b_kept_as_ref )
1617         x264_frame_cond_broadcast( h->fdec, mb_y*16 + (b_end ? 10000 : -(X264_THREAD_HEIGHT << h->sh.b_mbaff)) );
1618
1619     min_y = X264_MAX( min_y*16-8, 0 );
1620     max_y = b_end ? h->param.i_height : mb_y*16-8;
1621
1622     if( h->param.analyse.b_psnr )
1623     {
1624         int i;
1625         for( i=0; i<3; i++ )
1626             h->stat.frame.i_ssd[i] +=
1627                 x264_pixel_ssd_wxh( &h->pixf,
1628                     h->fdec->plane[i] + (min_y>>!!i) * h->fdec->i_stride[i], h->fdec->i_stride[i],
1629                     h->fenc->plane[i] + (min_y>>!!i) * h->fenc->i_stride[i], h->fenc->i_stride[i],
1630                     h->param.i_width >> !!i, (max_y-min_y) >> !!i );
1631     }
1632
1633     if( h->param.analyse.b_ssim )
1634     {
1635         x264_emms();
1636         /* offset by 2 pixels to avoid alignment of ssim blocks with dct blocks,
1637          * and overlap by 4 */
1638         min_y += min_y == 0 ? 2 : -6;
1639         h->stat.frame.f_ssim +=
1640             x264_pixel_ssim_wxh( &h->pixf,
1641                 h->fdec->plane[0] + 2+min_y*h->fdec->i_stride[0], h->fdec->i_stride[0],
1642                 h->fenc->plane[0] + 2+min_y*h->fenc->i_stride[0], h->fenc->i_stride[0],
1643                 h->param.i_width-2, max_y-min_y, h->scratch_buffer );
1644     }
1645 }
1646
1647 static inline int x264_reference_update( x264_t *h )
1648 {
1649     int i, j;
1650     if( !h->fdec->b_kept_as_ref )
1651     {
1652         if( h->i_thread_frames > 1 )
1653         {
1654             x264_frame_push_unused( h, h->fdec );
1655             h->fdec = x264_frame_pop_unused( h, 1 );
1656             if( !h->fdec )
1657                 return -1;
1658         }
1659         return 0;
1660     }
1661
1662     /* apply mmco from previous frame. */
1663     for( i = 0; i < h->sh.i_mmco_command_count; i++ )
1664         for( j = 0; h->frames.reference[j]; j++ )
1665             if( h->frames.reference[j]->i_poc == h->sh.mmco[i].i_poc )
1666                 x264_frame_push_unused( h, x264_frame_shift( &h->frames.reference[j] ) );
1667
1668     /* move frame in the buffer */
1669     x264_frame_push( h->frames.reference, h->fdec );
1670     if( h->frames.reference[h->sps->i_num_ref_frames] )
1671         x264_frame_push_unused( h, x264_frame_shift( h->frames.reference ) );
1672     h->fdec = x264_frame_pop_unused( h, 1 );
1673     if( !h->fdec )
1674         return -1;
1675     return 0;
1676 }
1677
1678 static inline void x264_reference_reset( x264_t *h )
1679 {
1680     while( h->frames.reference[0] )
1681         x264_frame_push_unused( h, x264_frame_pop( h->frames.reference ) );
1682     h->fdec->i_poc =
1683     h->fenc->i_poc = 0;
1684 }
1685
1686 static inline void x264_reference_hierarchy_reset( x264_t *h )
1687 {
1688     int i, ref;
1689     int b_hasdelayframe = 0;
1690     if( !h->param.i_bframe_pyramid )
1691         return;
1692
1693     /* look for delay frames -- chain must only contain frames that are disposable */
1694     for( i = 0; h->frames.current[i] && IS_DISPOSABLE( h->frames.current[i]->i_type ); i++ )
1695         b_hasdelayframe |= h->frames.current[i]->i_coded
1696                         != h->frames.current[i]->i_frame + h->sps->vui.i_num_reorder_frames;
1697
1698     if( h->param.i_bframe_pyramid != X264_B_PYRAMID_STRICT && !b_hasdelayframe )
1699         return;
1700
1701     /* Remove last BREF. There will never be old BREFs in the
1702      * dpb during a BREF decode when pyramid == STRICT */
1703     for( ref = 0; h->frames.reference[ref]; ref++ )
1704     {
1705         if( h->param.i_bframe_pyramid == X264_B_PYRAMID_STRICT
1706             && h->frames.reference[ref]->i_type == X264_TYPE_BREF )
1707         {
1708             int diff = h->i_frame_num - h->frames.reference[ref]->i_frame_num;
1709             h->sh.mmco[h->sh.i_mmco_command_count].i_difference_of_pic_nums = diff;
1710             h->sh.mmco[h->sh.i_mmco_command_count++].i_poc = h->frames.reference[ref]->i_poc;
1711             x264_frame_push_unused( h, x264_frame_pop( h->frames.reference ) );
1712             h->b_ref_reorder[0] = 1;
1713             break;
1714         }
1715     }
1716
1717     /* Prepare to room in the dpb for the delayed display time of the later b-frame's */
1718     h->sh.i_mmco_remove_from_end = X264_MAX( ref + 2 - h->frames.i_max_dpb, 0 );
1719 }
1720
1721 static inline void x264_slice_init( x264_t *h, int i_nal_type, int i_global_qp )
1722 {
1723     /* ------------------------ Create slice header  ----------------------- */
1724     if( i_nal_type == NAL_SLICE_IDR )
1725     {
1726         x264_slice_header_init( h, &h->sh, h->sps, h->pps, h->i_idr_pic_id, h->i_frame_num, i_global_qp );
1727
1728         /* increment id */
1729         h->i_idr_pic_id = ( h->i_idr_pic_id + 1 ) % 65536;
1730     }
1731     else
1732     {
1733         x264_slice_header_init( h, &h->sh, h->sps, h->pps, -1, h->i_frame_num, i_global_qp );
1734
1735         h->sh.i_num_ref_idx_l0_active = h->i_ref0 <= 0 ? 1 : h->i_ref0;
1736         h->sh.i_num_ref_idx_l1_active = h->i_ref1 <= 0 ? 1 : h->i_ref1;
1737         if( h->sh.i_num_ref_idx_l0_active != h->pps->i_num_ref_idx_l0_default_active ||
1738             (h->sh.i_type == SLICE_TYPE_B && h->sh.i_num_ref_idx_l1_active != h->pps->i_num_ref_idx_l1_default_active) )
1739         {
1740             h->sh.b_num_ref_idx_override = 1;
1741         }
1742     }
1743
1744     h->fdec->i_frame_num = h->sh.i_frame_num;
1745
1746     if( h->sps->i_poc_type == 0 )
1747     {
1748         h->sh.i_poc = h->fdec->i_poc;
1749         if( h->param.b_interlaced )
1750         {
1751             h->sh.i_delta_poc_bottom = h->param.b_tff ? 1 : -1;
1752             if( h->sh.i_delta_poc_bottom == -1 )
1753                 h->sh.i_poc = h->fdec->i_poc + 1;
1754         }
1755         else
1756             h->sh.i_delta_poc_bottom = 0;
1757     }
1758     else if( h->sps->i_poc_type == 1 )
1759     {
1760         /* FIXME TODO FIXME */
1761     }
1762     else
1763     {
1764         /* Nothing to do ? */
1765     }
1766
1767     x264_macroblock_slice_init( h );
1768 }
1769
1770 static int x264_slice_write( x264_t *h )
1771 {
1772     int i_skip;
1773     int mb_xy, i_mb_x, i_mb_y;
1774     int i, i_list, i_ref, i_skip_bak = 0; /* Shut up GCC. */
1775     bs_t bs_bak;
1776     x264_cabac_t cabac_bak;
1777     uint8_t cabac_prevbyte_bak = 0; /* Shut up GCC. */
1778     /* Assume no more than 3 bytes of NALU escaping.
1779      * NALUs other than the first use a 3-byte startcode. */
1780     int overhead_guess = (NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal)) + 3;
1781     int slice_max_size = h->param.i_slice_max_size > 0 ? (h->param.i_slice_max_size-overhead_guess)*8 : INT_MAX;
1782     int starting_bits = bs_pos(&h->out.bs);
1783     bs_realign( &h->out.bs );
1784
1785     /* Slice */
1786     x264_nal_start( h, h->i_nal_type, h->i_nal_ref_idc );
1787
1788     /* Slice header */
1789     x264_macroblock_thread_init( h );
1790     x264_slice_header_write( &h->out.bs, &h->sh, h->i_nal_ref_idc );
1791     if( h->param.b_cabac )
1792     {
1793         /* alignment needed */
1794         bs_align_1( &h->out.bs );
1795
1796         /* init cabac */
1797         x264_cabac_context_init( &h->cabac, h->sh.i_type, h->sh.i_qp, h->sh.i_cabac_init_idc );
1798         x264_cabac_encode_init ( &h->cabac, h->out.bs.p, h->out.bs.p_end );
1799     }
1800     h->mb.i_last_qp = h->sh.i_qp;
1801     h->mb.i_last_dqp = 0;
1802
1803     i_mb_y = h->sh.i_first_mb / h->sps->i_mb_width;
1804     i_mb_x = h->sh.i_first_mb % h->sps->i_mb_width;
1805     i_skip = 0;
1806
1807     while( (mb_xy = i_mb_x + i_mb_y * h->sps->i_mb_width) <= h->sh.i_last_mb )
1808     {
1809         int mb_spos = bs_pos(&h->out.bs) + x264_cabac_pos(&h->cabac);
1810         if( h->param.i_slice_max_size > 0 )
1811         {
1812             /* We don't need the contexts because flushing the CABAC encoder has no context
1813              * dependency and macroblocks are only re-encoded in the case where a slice is
1814              * ended (and thus the content of all contexts are thrown away). */
1815             if( h->param.b_cabac )
1816             {
1817                 memcpy( &cabac_bak, &h->cabac, offsetof(x264_cabac_t, f8_bits_encoded) );
1818                 /* x264's CABAC writer modifies the previous byte during carry, so it has to be
1819                  * backed up. */
1820                 cabac_prevbyte_bak = h->cabac.p[-1];
1821             }
1822             else
1823             {
1824                 bs_bak = h->out.bs;
1825                 i_skip_bak = i_skip;
1826             }
1827         }
1828
1829         if( i_mb_x == 0 && !h->mb.b_reencode_mb && !h->param.b_sliced_threads )
1830             x264_fdec_filter_row( h, i_mb_y );
1831
1832         /* load cache */
1833         x264_macroblock_cache_load( h, i_mb_x, i_mb_y );
1834
1835         x264_macroblock_analyse( h );
1836
1837         /* encode this macroblock -> be careful it can change the mb type to P_SKIP if needed */
1838         x264_macroblock_encode( h );
1839
1840         if( x264_bitstream_check_buffer( h ) )
1841             return -1;
1842
1843         if( h->param.b_cabac )
1844         {
1845             if( mb_xy > h->sh.i_first_mb && !(h->sh.b_mbaff && (i_mb_y&1)) )
1846                 x264_cabac_encode_terminal( &h->cabac );
1847
1848             if( IS_SKIP( h->mb.i_type ) )
1849                 x264_cabac_mb_skip( h, 1 );
1850             else
1851             {
1852                 if( h->sh.i_type != SLICE_TYPE_I )
1853                     x264_cabac_mb_skip( h, 0 );
1854                 x264_macroblock_write_cabac( h, &h->cabac );
1855             }
1856         }
1857         else
1858         {
1859             if( IS_SKIP( h->mb.i_type ) )
1860                 i_skip++;
1861             else
1862             {
1863                 if( h->sh.i_type != SLICE_TYPE_I )
1864                 {
1865                     bs_write_ue( &h->out.bs, i_skip );  /* skip run */
1866                     i_skip = 0;
1867                 }
1868                 x264_macroblock_write_cavlc( h );
1869             }
1870         }
1871
1872         int total_bits = bs_pos(&h->out.bs) + x264_cabac_pos(&h->cabac);
1873         int mb_size = total_bits - mb_spos;
1874
1875         /* We'll just re-encode this last macroblock if we go over the max slice size. */
1876         if( total_bits - starting_bits > slice_max_size && !h->mb.b_reencode_mb )
1877         {
1878             if( mb_xy != h->sh.i_first_mb )
1879             {
1880                 if( h->param.b_cabac )
1881                 {
1882                     memcpy( &h->cabac, &cabac_bak, offsetof(x264_cabac_t, f8_bits_encoded) );
1883                     h->cabac.p[-1] = cabac_prevbyte_bak;
1884                 }
1885                 else
1886                 {
1887                     h->out.bs = bs_bak;
1888                     i_skip = i_skip_bak;
1889                 }
1890                 h->mb.b_reencode_mb = 1;
1891                 h->sh.i_last_mb = mb_xy-1;
1892                 break;
1893             }
1894             else
1895             {
1896                 h->sh.i_last_mb = mb_xy;
1897                 h->mb.b_reencode_mb = 0;
1898             }
1899         }
1900         else
1901             h->mb.b_reencode_mb = 0;
1902
1903 #ifdef HAVE_VISUALIZE
1904         if( h->param.b_visualize )
1905             x264_visualize_mb( h );
1906 #endif
1907
1908         /* save cache */
1909         x264_macroblock_cache_save( h );
1910
1911         /* accumulate mb stats */
1912         h->stat.frame.i_mb_count[h->mb.i_type]++;
1913
1914         if( !IS_INTRA(h->mb.i_type) && !IS_SKIP(h->mb.i_type) && !IS_DIRECT(h->mb.i_type) )
1915         {
1916             if( h->mb.i_partition != D_8x8 )
1917                     h->stat.frame.i_mb_partition[h->mb.i_partition] += 4;
1918                 else
1919                     for( i = 0; i < 4; i++ )
1920                         h->stat.frame.i_mb_partition[h->mb.i_sub_partition[i]] ++;
1921             if( h->param.i_frame_reference > 1 )
1922                 for( i_list = 0; i_list <= (h->sh.i_type == SLICE_TYPE_B); i_list++ )
1923                     for( i = 0; i < 4; i++ )
1924                     {
1925                         i_ref = h->mb.cache.ref[i_list][ x264_scan8[4*i] ];
1926                         if( i_ref >= 0 )
1927                             h->stat.frame.i_mb_count_ref[i_list][i_ref] ++;
1928                     }
1929         }
1930
1931         if( h->param.i_log_level >= X264_LOG_INFO )
1932         {
1933             if( h->mb.i_cbp_luma || h->mb.i_cbp_chroma )
1934             {
1935                 int cbpsum = (h->mb.i_cbp_luma&1) + ((h->mb.i_cbp_luma>>1)&1)
1936                            + ((h->mb.i_cbp_luma>>2)&1) + (h->mb.i_cbp_luma>>3);
1937                 int b_intra = IS_INTRA(h->mb.i_type);
1938                 h->stat.frame.i_mb_cbp[!b_intra + 0] += cbpsum;
1939                 h->stat.frame.i_mb_cbp[!b_intra + 2] += h->mb.i_cbp_chroma >= 1;
1940                 h->stat.frame.i_mb_cbp[!b_intra + 4] += h->mb.i_cbp_chroma == 2;
1941             }
1942             if( h->mb.i_cbp_luma && !IS_INTRA(h->mb.i_type) )
1943             {
1944                 h->stat.frame.i_mb_count_8x8dct[0] ++;
1945                 h->stat.frame.i_mb_count_8x8dct[1] += h->mb.b_transform_8x8;
1946             }
1947             if( IS_INTRA(h->mb.i_type) && h->mb.i_type != I_PCM )
1948             {
1949                 if( h->mb.i_type == I_16x16 )
1950                     h->stat.frame.i_mb_pred_mode[0][h->mb.i_intra16x16_pred_mode]++;
1951                 else if( h->mb.i_type == I_8x8 )
1952                     for( i = 0; i < 16; i += 4 )
1953                         h->stat.frame.i_mb_pred_mode[1][h->mb.cache.intra4x4_pred_mode[x264_scan8[i]]]++;
1954                 else //if( h->mb.i_type == I_4x4 )
1955                     for( i = 0; i < 16; i++ )
1956                         h->stat.frame.i_mb_pred_mode[2][h->mb.cache.intra4x4_pred_mode[x264_scan8[i]]]++;
1957             }
1958         }
1959
1960         x264_ratecontrol_mb( h, mb_size );
1961
1962         if( h->sh.b_mbaff )
1963         {
1964             i_mb_x += i_mb_y & 1;
1965             i_mb_y ^= i_mb_x < h->sps->i_mb_width;
1966         }
1967         else
1968             i_mb_x++;
1969         if( i_mb_x == h->sps->i_mb_width )
1970         {
1971             i_mb_y++;
1972             i_mb_x = 0;
1973         }
1974     }
1975
1976     if( h->param.b_cabac )
1977     {
1978         x264_cabac_encode_flush( h, &h->cabac );
1979         h->out.bs.p = h->cabac.p;
1980     }
1981     else
1982     {
1983         if( i_skip > 0 )
1984             bs_write_ue( &h->out.bs, i_skip );  /* last skip run */
1985         /* rbsp_slice_trailing_bits */
1986         bs_rbsp_trailing( &h->out.bs );
1987         bs_flush( &h->out.bs );
1988     }
1989     if( x264_nal_end( h ) )
1990         return -1;
1991
1992     if( h->sh.i_last_mb == h->mb.i_mb_count-1 )
1993     {
1994         h->stat.frame.i_misc_bits = bs_pos( &h->out.bs )
1995                                   + (h->out.i_nal*NALU_OVERHEAD * 8)
1996                                   - h->stat.frame.i_tex_bits
1997                                   - h->stat.frame.i_mv_bits;
1998         if( !h->param.b_sliced_threads )
1999             x264_fdec_filter_row( h, h->sps->i_mb_height );
2000     }
2001
2002     return 0;
2003 }
2004
2005 static void x264_thread_sync_context( x264_t *dst, x264_t *src )
2006 {
2007     if( dst == src )
2008         return;
2009
2010     // reference counting
2011     x264_frame_t **f;
2012     for( f = src->frames.reference; *f; f++ )
2013         (*f)->i_reference_count++;
2014     for( f = dst->frames.reference; *f; f++ )
2015         x264_frame_push_unused( src, *f );
2016     src->fdec->i_reference_count++;
2017     x264_frame_push_unused( src, dst->fdec );
2018
2019     // copy everything except the per-thread pointers and the constants.
2020     memcpy( &dst->i_frame, &src->i_frame, offsetof(x264_t, mb.type) - offsetof(x264_t, i_frame) );
2021     dst->param = src->param;
2022     dst->stat = src->stat;
2023 }
2024
2025 static void x264_thread_sync_stat( x264_t *dst, x264_t *src )
2026 {
2027     if( dst == src )
2028         return;
2029     memcpy( &dst->stat.i_frame_count, &src->stat.i_frame_count, sizeof(dst->stat) - sizeof(dst->stat.frame) );
2030 }
2031
2032 static void *x264_slices_write( x264_t *h )
2033 {
2034     int i_slice_num = 0;
2035     int last_thread_mb = h->sh.i_last_mb;
2036     if( h->param.i_sync_lookahead )
2037         x264_lower_thread_priority( 10 );
2038
2039 #ifdef HAVE_MMX
2040     /* Misalign mask has to be set separately for each thread. */
2041     if( h->param.cpu&X264_CPU_SSE_MISALIGN )
2042         x264_cpu_mask_misalign_sse();
2043 #endif
2044
2045 #ifdef HAVE_VISUALIZE
2046     if( h->param.b_visualize )
2047         if( x264_visualize_init( h ) )
2048             return (void *)-1;
2049 #endif
2050
2051     /* init stats */
2052     memset( &h->stat.frame, 0, sizeof(h->stat.frame) );
2053     h->mb.b_reencode_mb = 0;
2054     while( h->sh.i_first_mb <= last_thread_mb )
2055     {
2056         h->sh.i_last_mb = last_thread_mb;
2057         if( h->param.i_slice_max_mbs )
2058             h->sh.i_last_mb = h->sh.i_first_mb + h->param.i_slice_max_mbs - 1;
2059         else if( h->param.i_slice_count && !h->param.b_sliced_threads )
2060         {
2061             int height = h->sps->i_mb_height >> h->param.b_interlaced;
2062             int width = h->sps->i_mb_width << h->param.b_interlaced;
2063             i_slice_num++;
2064             h->sh.i_last_mb = (height * i_slice_num + h->param.i_slice_count/2) / h->param.i_slice_count * width - 1;
2065         }
2066         h->sh.i_last_mb = X264_MIN( h->sh.i_last_mb, last_thread_mb );
2067         if( x264_stack_align( x264_slice_write, h ) )
2068             return (void *)-1;
2069         h->sh.i_first_mb = h->sh.i_last_mb + 1;
2070     }
2071
2072 #ifdef HAVE_VISUALIZE
2073     if( h->param.b_visualize )
2074     {
2075         x264_visualize_show( h );
2076         x264_visualize_close( h );
2077     }
2078 #endif
2079
2080     return (void *)0;
2081 }
2082
2083 static int x264_threaded_slices_write( x264_t *h )
2084 {
2085     int i, j;
2086     void *ret = NULL;
2087     /* set first/last mb and sync contexts */
2088     for( i = 0; i < h->param.i_threads; i++ )
2089     {
2090         x264_t *t = h->thread[i];
2091         if( i )
2092         {
2093             t->param = h->param;
2094             memcpy( &t->i_frame, &h->i_frame, offsetof(x264_t, rc) - offsetof(x264_t, i_frame) );
2095         }
2096         int height = h->sps->i_mb_height >> h->param.b_interlaced;
2097         t->i_threadslice_start = ((height *  i    + h->param.i_slice_count/2) / h->param.i_threads) << h->param.b_interlaced;
2098         t->i_threadslice_end   = ((height * (i+1) + h->param.i_slice_count/2) / h->param.i_threads) << h->param.b_interlaced;
2099         t->sh.i_first_mb = t->i_threadslice_start * h->sps->i_mb_width;
2100         t->sh.i_last_mb  =   t->i_threadslice_end * h->sps->i_mb_width - 1;
2101     }
2102
2103     x264_analyse_weight_frame( h, h->sps->i_mb_height*16 + 16 );
2104
2105     x264_threads_distribute_ratecontrol( h );
2106
2107     /* dispatch */
2108     for( i = 0; i < h->param.i_threads; i++ )
2109     {
2110         if( x264_pthread_create( &h->thread[i]->thread_handle, NULL, (void*)x264_slices_write, (void*)h->thread[i] ) )
2111             return -1;
2112         h->thread[i]->b_thread_active = 1;
2113     }
2114     for( i = 0; i < h->param.i_threads; i++ )
2115     {
2116         x264_pthread_join( h->thread[i]->thread_handle, &ret );
2117         h->thread[i]->b_thread_active = 0;
2118         if( (intptr_t)ret )
2119             return (intptr_t)ret;
2120     }
2121
2122     /* deblocking and hpel filtering */
2123     for( i = 0; i <= h->sps->i_mb_height; i++ )
2124         x264_fdec_filter_row( h, i );
2125
2126     x264_threads_merge_ratecontrol( h );
2127
2128     for( i = 1; i < h->param.i_threads; i++ )
2129     {
2130         x264_t *t = h->thread[i];
2131         for( j = 0; j < t->out.i_nal; j++ )
2132         {
2133             h->out.nal[h->out.i_nal] = t->out.nal[j];
2134             h->out.i_nal++;
2135             x264_nal_check_buffer( h );
2136         }
2137         /* All entries in stat.frame are ints except for ssd/ssim,
2138          * which are only calculated in the main thread. */
2139         for( j = 0; j < (offsetof(x264_t,stat.frame.i_ssd) - offsetof(x264_t,stat.frame.i_mv_bits)) / sizeof(int); j++ )
2140             ((int*)&h->stat.frame)[j] += ((int*)&t->stat.frame)[j];
2141     }
2142
2143     return 0;
2144 }
2145
2146 /****************************************************************************
2147  * x264_encoder_encode:
2148  *  XXX: i_poc   : is the poc of the current given picture
2149  *       i_frame : is the number of the frame being coded
2150  *  ex:  type frame poc
2151  *       I      0   2*0
2152  *       P      1   2*3
2153  *       B      2   2*1
2154  *       B      3   2*2
2155  *       P      4   2*6
2156  *       B      5   2*4
2157  *       B      6   2*5
2158  ****************************************************************************/
2159 int     x264_encoder_encode( x264_t *h,
2160                              x264_nal_t **pp_nal, int *pi_nal,
2161                              x264_picture_t *pic_in,
2162                              x264_picture_t *pic_out )
2163 {
2164     x264_t *thread_current, *thread_prev, *thread_oldest;
2165     int i_nal_type, i_nal_ref_idc, i_global_qp, i;
2166     int overhead = NALU_OVERHEAD;
2167
2168     if( h->i_thread_frames > 1 )
2169     {
2170         thread_prev    = h->thread[ h->i_thread_phase ];
2171         h->i_thread_phase = (h->i_thread_phase + 1) % h->i_thread_frames;
2172         thread_current = h->thread[ h->i_thread_phase ];
2173         thread_oldest  = h->thread[ (h->i_thread_phase + 1) % h->i_thread_frames ];
2174         x264_thread_sync_context( thread_current, thread_prev );
2175         x264_thread_sync_ratecontrol( thread_current, thread_prev, thread_oldest );
2176         h = thread_current;
2177 //      fprintf(stderr, "current: %p  prev: %p  oldest: %p \n", thread_current, thread_prev, thread_oldest);
2178     }
2179     else
2180     {
2181         thread_current =
2182         thread_oldest  = h;
2183     }
2184
2185     // ok to call this before encoding any frames, since the initial values of fdec have b_kept_as_ref=0
2186     if( x264_reference_update( h ) )
2187         return -1;
2188     h->fdec->i_lines_completed = -1;
2189
2190     /* no data out */
2191     *pi_nal = 0;
2192     *pp_nal = NULL;
2193
2194     /* ------------------- Setup new frame from picture -------------------- */
2195     if( pic_in != NULL )
2196     {
2197         /* 1: Copy the picture to a frame and move it to a buffer */
2198         x264_frame_t *fenc = x264_frame_pop_unused( h, 0 );
2199         if( !fenc )
2200             return -1;
2201
2202         if( x264_frame_copy_picture( h, fenc, pic_in ) < 0 )
2203             return -1;
2204
2205         if( h->param.i_width != 16 * h->sps->i_mb_width ||
2206             h->param.i_height != 16 * h->sps->i_mb_height )
2207             x264_frame_expand_border_mod16( h, fenc );
2208
2209         fenc->i_frame = h->frames.i_input++;
2210
2211         if( h->frames.i_bframe_delay && fenc->i_frame == h->frames.i_bframe_delay )
2212             h->frames.i_bframe_delay_time = fenc->i_pts;
2213
2214         if( h->param.b_vfr_input && fenc->i_pts <= h->frames.i_largest_pts )
2215             x264_log( h, X264_LOG_WARNING, "non-strictly-monotonic PTS\n" );
2216
2217         h->frames.i_second_largest_pts = h->frames.i_largest_pts;
2218         h->frames.i_largest_pts = fenc->i_pts;
2219
2220         if( (fenc->i_pic_struct < PIC_STRUCT_AUTO) || (fenc->i_pic_struct > PIC_STRUCT_TRIPLE) )
2221             fenc->i_pic_struct = PIC_STRUCT_AUTO;
2222
2223         if( fenc->i_pic_struct == PIC_STRUCT_AUTO )
2224         {
2225             int b_interlaced = fenc->param ? fenc->param->b_interlaced : h->param.b_interlaced;
2226             if( b_interlaced )
2227             {
2228                 int b_tff = fenc->param ? fenc->param->b_tff : h->param.b_tff;
2229                 fenc->i_pic_struct = b_tff ? PIC_STRUCT_TOP_BOTTOM : PIC_STRUCT_BOTTOM_TOP;
2230             }
2231             else
2232                 fenc->i_pic_struct = PIC_STRUCT_PROGRESSIVE;
2233         }
2234
2235         if( h->frames.b_have_lowres )
2236         {
2237             if( h->param.analyse.i_weighted_pred == X264_WEIGHTP_FAKE || h->param.analyse.i_weighted_pred == X264_WEIGHTP_SMART )
2238                 x264_weight_plane_analyse( h, fenc );
2239             x264_frame_init_lowres( h, fenc );
2240         }
2241
2242         if( h->param.rc.b_mb_tree && h->param.rc.b_stat_read )
2243         {
2244             if( x264_macroblock_tree_read( h, fenc ) )
2245                 return -1;
2246         }
2247         else if( h->param.rc.i_aq_mode )
2248             x264_adaptive_quant_frame( h, fenc );
2249
2250         /* 2: Place the frame into the queue for its slice type decision */
2251         x264_lookahead_put_frame( h, fenc );
2252
2253         if( h->frames.i_input <= h->frames.i_delay + 1 - h->i_thread_frames )
2254         {
2255             /* Nothing yet to encode, waiting for filling of buffers */
2256             pic_out->i_type = X264_TYPE_AUTO;
2257             return 0;
2258         }
2259     }
2260     else
2261     {
2262         /* signal kills for lookahead thread */
2263         x264_pthread_mutex_lock( &h->lookahead->ifbuf.mutex );
2264         h->lookahead->b_exit_thread = 1;
2265         x264_pthread_cond_broadcast( &h->lookahead->ifbuf.cv_fill );
2266         x264_pthread_mutex_unlock( &h->lookahead->ifbuf.mutex );
2267     }
2268
2269     h->i_frame++;
2270     /* 3: The picture is analyzed in the lookahead */
2271     if( !h->frames.current[0] )
2272         x264_lookahead_get_frames( h );
2273
2274     if( !h->frames.current[0] && x264_lookahead_is_empty( h ) )
2275         return x264_encoder_frame_end( thread_oldest, thread_current, pp_nal, pi_nal, pic_out );
2276
2277     /* ------------------- Get frame to be encoded ------------------------- */
2278     /* 4: get picture to encode */
2279     h->fenc = x264_frame_shift( h->frames.current );
2280     if( h->i_frame == 0 )
2281         h->first_pts = h->fenc->i_reordered_pts;
2282     if( h->fenc->param )
2283     {
2284         x264_encoder_reconfig( h, h->fenc->param );
2285         if( h->fenc->param->param_free )
2286             h->fenc->param->param_free( h->fenc->param );
2287     }
2288
2289     if( h->fenc->b_keyframe )
2290     {
2291         h->frames.i_last_keyframe = h->fenc->i_frame;
2292         if( h->fenc->i_type == X264_TYPE_IDR )
2293             h->i_frame_num = 0;
2294     }
2295     h->sh.i_mmco_command_count =
2296     h->sh.i_mmco_remove_from_end = 0;
2297     h->b_ref_reorder[0] =
2298     h->b_ref_reorder[1] = 0;
2299
2300     /* ------------------- Setup frame context ----------------------------- */
2301     /* 5: Init data dependent of frame type */
2302     if( h->fenc->i_type == X264_TYPE_IDR )
2303     {
2304         /* reset ref pictures */
2305         i_nal_type    = NAL_SLICE_IDR;
2306         i_nal_ref_idc = NAL_PRIORITY_HIGHEST;
2307         h->sh.i_type = SLICE_TYPE_I;
2308         x264_reference_reset( h );
2309     }
2310     else if( h->fenc->i_type == X264_TYPE_I )
2311     {
2312         i_nal_type    = NAL_SLICE;
2313         i_nal_ref_idc = NAL_PRIORITY_HIGH; /* Not completely true but for now it is (as all I/P are kept as ref)*/
2314         h->sh.i_type = SLICE_TYPE_I;
2315         x264_reference_hierarchy_reset( h );
2316     }
2317     else if( h->fenc->i_type == X264_TYPE_P )
2318     {
2319         i_nal_type    = NAL_SLICE;
2320         i_nal_ref_idc = NAL_PRIORITY_HIGH; /* Not completely true but for now it is (as all I/P are kept as ref)*/
2321         h->sh.i_type = SLICE_TYPE_P;
2322         x264_reference_hierarchy_reset( h );
2323     }
2324     else if( h->fenc->i_type == X264_TYPE_BREF )
2325     {
2326         i_nal_type    = NAL_SLICE;
2327         i_nal_ref_idc = h->param.i_bframe_pyramid == X264_B_PYRAMID_STRICT ? NAL_PRIORITY_LOW : NAL_PRIORITY_HIGH;
2328         h->sh.i_type = SLICE_TYPE_B;
2329         x264_reference_hierarchy_reset( h );
2330     }
2331     else    /* B frame */
2332     {
2333         i_nal_type    = NAL_SLICE;
2334         i_nal_ref_idc = NAL_PRIORITY_DISPOSABLE;
2335         h->sh.i_type = SLICE_TYPE_B;
2336     }
2337
2338     h->fdec->i_poc =
2339     h->fenc->i_poc = 2 * (h->fenc->i_frame - h->frames.i_last_keyframe);
2340     h->fdec->i_type = h->fenc->i_type;
2341     h->fdec->i_frame = h->fenc->i_frame;
2342     h->fenc->b_kept_as_ref =
2343     h->fdec->b_kept_as_ref = i_nal_ref_idc != NAL_PRIORITY_DISPOSABLE && h->param.i_keyint_max > 1;
2344
2345
2346
2347     /* ------------------- Init                ----------------------------- */
2348     /* build ref list 0/1 */
2349     x264_reference_build_list( h, h->fdec->i_poc );
2350
2351     /* ---------------------- Write the bitstream -------------------------- */
2352     /* Init bitstream context */
2353     if( h->param.b_sliced_threads )
2354     {
2355         for( i = 0; i < h->param.i_threads; i++ )
2356         {
2357             bs_init( &h->thread[i]->out.bs, h->thread[i]->out.p_bitstream, h->thread[i]->out.i_bitstream );
2358             h->thread[i]->out.i_nal = 0;
2359         }
2360     }
2361     else
2362     {
2363         bs_init( &h->out.bs, h->out.p_bitstream, h->out.i_bitstream );
2364         h->out.i_nal = 0;
2365     }
2366
2367     if( h->param.b_aud )
2368     {
2369         int pic_type;
2370
2371         if( h->sh.i_type == SLICE_TYPE_I )
2372             pic_type = 0;
2373         else if( h->sh.i_type == SLICE_TYPE_P )
2374             pic_type = 1;
2375         else if( h->sh.i_type == SLICE_TYPE_B )
2376             pic_type = 2;
2377         else
2378             pic_type = 7;
2379
2380         x264_nal_start( h, NAL_AUD, NAL_PRIORITY_DISPOSABLE );
2381         bs_write( &h->out.bs, 3, pic_type );
2382         bs_rbsp_trailing( &h->out.bs );
2383         if( x264_nal_end( h ) )
2384             return -1;
2385         overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
2386     }
2387
2388     h->i_nal_type = i_nal_type;
2389     h->i_nal_ref_idc = i_nal_ref_idc;
2390
2391     if( h->param.b_intra_refresh && h->fenc->i_type == X264_TYPE_P )
2392     {
2393         int pocdiff = (h->fdec->i_poc - h->fref0[0]->i_poc)/2;
2394         float increment = X264_MAX( ((float)h->sps->i_mb_width-1) / h->param.i_keyint_max, 1 );
2395         int max_position = (int)(increment * h->param.i_keyint_max);
2396         if( IS_X264_TYPE_I( h->fref0[0]->i_type ) )
2397             h->fdec->f_pir_position = 0;
2398         else
2399         {
2400             h->fdec->f_pir_position = h->fref0[0]->f_pir_position;
2401             if( h->fdec->f_pir_position+0.5 >= max_position )
2402             {
2403                 h->fdec->f_pir_position = 0;
2404                 h->fenc->b_keyframe = 1;
2405             }
2406         }
2407         h->fdec->i_pir_start_col = h->fdec->f_pir_position+0.5;
2408         h->fdec->f_pir_position += increment * pocdiff;
2409         h->fdec->i_pir_end_col = h->fdec->f_pir_position+0.5;
2410     }
2411
2412     if( h->fenc->b_keyframe )
2413     {
2414         /* Write SPS and PPS */
2415         if( h->param.b_repeat_headers )
2416         {
2417             /* generate sequence parameters */
2418             x264_nal_start( h, NAL_SPS, NAL_PRIORITY_HIGHEST );
2419             x264_sps_write( &h->out.bs, h->sps );
2420             if( x264_nal_end( h ) )
2421                 return -1;
2422             overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD;
2423
2424             /* generate picture parameters */
2425             x264_nal_start( h, NAL_PPS, NAL_PRIORITY_HIGHEST );
2426             x264_pps_write( &h->out.bs, h->pps );
2427             if( x264_nal_end( h ) )
2428                 return -1;
2429             overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD;
2430         }
2431
2432         /* generate sei buffering period */
2433         if( h->sps->vui.b_nal_hrd_parameters_present )
2434         {
2435             h->initial_cpb_removal_delay = x264_hrd_fullness( h, overhead*8 );
2436
2437             x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
2438             x264_sei_buffering_period_write( h, &h->out.bs, h->initial_cpb_removal_delay );
2439             if( x264_nal_end( h ) )
2440                return -1;
2441             overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
2442         }
2443
2444         if( h->param.b_repeat_headers && h->fenc->i_frame == 0 )
2445         {
2446             /* identify ourself */
2447             x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
2448             if( x264_sei_version_write( h, &h->out.bs ) )
2449                 return -1;
2450             if( x264_nal_end( h ) )
2451                 return -1;
2452             overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
2453         }
2454
2455         if( h->fenc->i_type != X264_TYPE_IDR )
2456         {
2457             int time_to_recovery = X264_MIN( h->sps->i_mb_width - 1, h->param.i_keyint_max ) + h->param.i_bframe;
2458             x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
2459             x264_sei_recovery_point_write( h, &h->out.bs, time_to_recovery );
2460             x264_nal_end( h );
2461             overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
2462         }
2463     }
2464
2465     /* generate sei pic timing */
2466     if( h->sps->vui.b_pic_struct_present || h->sps->vui.b_nal_hrd_parameters_present )
2467     {
2468         x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
2469         x264_sei_pic_timing_write( h, &h->out.bs, h->fenc->i_cpb_delay, h->fenc->i_dpb_output_delay, h->fenc->i_pic_struct );
2470         if( x264_nal_end( h ) )
2471             return -1;
2472         overhead += h->out.nal[h->out.i_nal-1].i_payload + NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal-1);
2473     }
2474
2475     /* Init the rate control */
2476     /* FIXME: Include slice header bit cost. */
2477     x264_ratecontrol_start( h, h->fenc->i_qpplus1, overhead*8 );
2478     i_global_qp = x264_ratecontrol_qp( h );
2479
2480     pic_out->i_qpplus1 =
2481     h->fdec->i_qpplus1 = i_global_qp + 1;
2482
2483     if( h->param.rc.b_stat_read && h->sh.i_type != SLICE_TYPE_I )
2484     {
2485         x264_reference_build_list_optimal( h );
2486         x264_reference_check_reorder( h );
2487     }
2488
2489     if( h->i_ref0 )
2490         h->fdec->i_poc_l0ref0 = h->fref0[0]->i_poc;
2491
2492     if( h->sh.i_type == SLICE_TYPE_B )
2493         x264_macroblock_bipred_init( h );
2494
2495     /*------------------------- Weights -------------------------------------*/
2496     x264_weighted_pred_init( h );
2497
2498     /* ------------------------ Create slice header  ----------------------- */
2499     x264_slice_init( h, i_nal_type, i_global_qp );
2500
2501     if( i_nal_ref_idc != NAL_PRIORITY_DISPOSABLE )
2502         h->i_frame_num++;
2503
2504     /* Write frame */
2505     h->i_threadslice_start = 0;
2506     h->i_threadslice_end = h->sps->i_mb_height;
2507     if( h->i_thread_frames > 1 )
2508     {
2509         if( x264_pthread_create( &h->thread_handle, NULL, (void*)x264_slices_write, h ) )
2510             return -1;
2511         h->b_thread_active = 1;
2512     }
2513     else if( h->param.b_sliced_threads )
2514     {
2515         if( x264_threaded_slices_write( h ) )
2516             return -1;
2517     }
2518     else
2519         if( (intptr_t)x264_slices_write( h ) )
2520             return -1;
2521
2522     return x264_encoder_frame_end( thread_oldest, thread_current, pp_nal, pi_nal, pic_out );
2523 }
2524
2525 static int x264_encoder_frame_end( x264_t *h, x264_t *thread_current,
2526                                    x264_nal_t **pp_nal, int *pi_nal,
2527                                    x264_picture_t *pic_out )
2528 {
2529     int i, j, i_list, frame_size;
2530     char psz_message[80];
2531
2532     if( h->b_thread_active )
2533     {
2534         void *ret = NULL;
2535         x264_pthread_join( h->thread_handle, &ret );
2536         h->b_thread_active = 0;
2537         if( (intptr_t)ret )
2538             return (intptr_t)ret;
2539     }
2540     if( !h->out.i_nal )
2541     {
2542         pic_out->i_type = X264_TYPE_AUTO;
2543         return 0;
2544     }
2545
2546     x264_frame_push_unused( thread_current, h->fenc );
2547
2548     frame_size = x264_encoder_encapsulate_nals( h, 0 );
2549
2550     /* Set output picture properties */
2551     if( h->sh.i_type == SLICE_TYPE_I )
2552         pic_out->i_type = h->i_nal_type == NAL_SLICE_IDR ? X264_TYPE_IDR : X264_TYPE_I;
2553     else if( h->sh.i_type == SLICE_TYPE_P )
2554         pic_out->i_type = X264_TYPE_P;
2555     else
2556         pic_out->i_type = X264_TYPE_B;
2557
2558     pic_out->b_keyframe = h->fenc->b_keyframe;
2559
2560     pic_out->i_pts = h->fenc->i_pts *= h->i_dts_compress_multiplier;
2561     if( h->frames.i_bframe_delay )
2562     {
2563         int64_t *prev_reordered_pts = thread_current->frames.i_prev_reordered_pts;
2564         if( h->i_frame <= h->frames.i_bframe_delay )
2565         {
2566             if( h->i_dts_compress_multiplier == 1 )
2567                 pic_out->i_dts = h->fenc->i_reordered_pts - h->frames.i_bframe_delay_time;
2568             else
2569             {
2570                 /* DTS compression */
2571                 if( h->i_frame == 1 )
2572                     thread_current->frames.i_init_delta = h->fenc->i_reordered_pts * h->i_dts_compress_multiplier;
2573                 pic_out->i_dts = h->i_frame * thread_current->frames.i_init_delta / h->i_dts_compress_multiplier;
2574             }
2575         }
2576         else
2577             pic_out->i_dts = prev_reordered_pts[ (h->i_frame - h->frames.i_bframe_delay) % h->frames.i_bframe_delay ];
2578         prev_reordered_pts[ h->i_frame % h->frames.i_bframe_delay ] = h->fenc->i_reordered_pts * h->i_dts_compress_multiplier;
2579     }
2580     else
2581         pic_out->i_dts = h->fenc->i_reordered_pts;
2582     if( pic_out->i_pts < pic_out->i_dts )
2583         x264_log( h, X264_LOG_WARNING, "invalid DTS: PTS is less than DTS\n" );
2584
2585     pic_out->img.i_plane = h->fdec->i_plane;
2586     for(i = 0; i < 3; i++)
2587     {
2588         pic_out->img.i_stride[i] = h->fdec->i_stride[i];
2589         pic_out->img.plane[i] = h->fdec->plane[i];
2590     }
2591
2592     /* ---------------------- Update encoder state ------------------------- */
2593
2594     /* update rc */
2595     x264_emms();
2596     int filler = 0;
2597     if( x264_ratecontrol_end( h, frame_size * 8, &filler ) < 0 )
2598         return -1;
2599
2600     pic_out->hrd_timing = h->fenc->hrd_timing;
2601
2602     while( filler > 0 )
2603     {
2604         int f, overhead;
2605         overhead = (FILLER_OVERHEAD - h->param.b_annexb);
2606         if( h->param.i_slice_max_size && filler > h->param.i_slice_max_size )
2607         {
2608             int next_size = filler - h->param.i_slice_max_size;
2609             int overflow = X264_MAX( overhead - next_size, 0 );
2610             f = h->param.i_slice_max_size - overhead - overflow;
2611         }
2612         else
2613             f = X264_MAX( 0, filler - overhead );
2614
2615         x264_nal_start( h, NAL_FILLER, NAL_PRIORITY_DISPOSABLE );
2616         x264_filler_write( h, &h->out.bs, f );
2617         if( x264_nal_end( h ) )
2618             return -1;
2619         int total_size = x264_encoder_encapsulate_nals( h, h->out.i_nal-1 );
2620         frame_size += total_size;
2621         filler -= total_size;
2622     }
2623
2624     /* End bitstream, set output  */
2625     *pi_nal = h->out.i_nal;
2626     *pp_nal = h->out.nal;
2627
2628     h->out.i_nal = 0;
2629
2630     x264_noise_reduction_update( h );
2631
2632     /* ---------------------- Compute/Print statistics --------------------- */
2633     x264_thread_sync_stat( h, h->thread[0] );
2634
2635     /* Slice stat */
2636     h->stat.i_frame_count[h->sh.i_type]++;
2637     h->stat.i_frame_size[h->sh.i_type] += frame_size;
2638     h->stat.f_frame_qp[h->sh.i_type] += h->fdec->f_qp_avg_aq;
2639
2640     for( i = 0; i < X264_MBTYPE_MAX; i++ )
2641         h->stat.i_mb_count[h->sh.i_type][i] += h->stat.frame.i_mb_count[i];
2642     for( i = 0; i < X264_PARTTYPE_MAX; i++ )
2643         h->stat.i_mb_partition[h->sh.i_type][i] += h->stat.frame.i_mb_partition[i];
2644     for( i = 0; i < 2; i++ )
2645         h->stat.i_mb_count_8x8dct[i] += h->stat.frame.i_mb_count_8x8dct[i];
2646     for( i = 0; i < 6; i++ )
2647         h->stat.i_mb_cbp[i] += h->stat.frame.i_mb_cbp[i];
2648     for( i = 0; i < 3; i++ )
2649         for( j = 0; j < 13; j++ )
2650             h->stat.i_mb_pred_mode[i][j] += h->stat.frame.i_mb_pred_mode[i][j];
2651     if( h->sh.i_type != SLICE_TYPE_I )
2652         for( i_list = 0; i_list < 2; i_list++ )
2653             for( i = 0; i < 32; i++ )
2654                 h->stat.i_mb_count_ref[h->sh.i_type][i_list][i] += h->stat.frame.i_mb_count_ref[i_list][i];
2655     if( h->sh.i_type == SLICE_TYPE_P )
2656     {
2657         h->stat.i_consecutive_bframes[h->fdec->i_frame - h->fref0[0]->i_frame - 1]++;
2658         if( h->param.analyse.i_weighted_pred == X264_WEIGHTP_SMART )
2659         {
2660             for( i = 0; i < 3; i++ )
2661                 for( j = 0; j < h->i_ref0; j++ )
2662                     if( h->sh.weight[0][i].i_denom != 0 )
2663                     {
2664                         h->stat.i_wpred[i]++;
2665                         break;
2666                     }
2667         }
2668     }
2669     if( h->sh.i_type == SLICE_TYPE_B )
2670     {
2671         h->stat.i_direct_frames[ h->sh.b_direct_spatial_mv_pred ] ++;
2672         if( h->mb.b_direct_auto_write )
2673         {
2674             //FIXME somewhat arbitrary time constants
2675             if( h->stat.i_direct_score[0] + h->stat.i_direct_score[1] > h->mb.i_mb_count )
2676             {
2677                 for( i = 0; i < 2; i++ )
2678                     h->stat.i_direct_score[i] = h->stat.i_direct_score[i] * 9/10;
2679             }
2680             for( i = 0; i < 2; i++ )
2681                 h->stat.i_direct_score[i] += h->stat.frame.i_direct_score[i];
2682         }
2683     }
2684
2685     psz_message[0] = '\0';
2686     if( h->param.analyse.b_psnr )
2687     {
2688         int64_t ssd[3] = {
2689             h->stat.frame.i_ssd[0],
2690             h->stat.frame.i_ssd[1],
2691             h->stat.frame.i_ssd[2],
2692         };
2693
2694         h->stat.i_ssd_global[h->sh.i_type] += ssd[0] + ssd[1] + ssd[2];
2695         h->stat.f_psnr_average[h->sh.i_type] += x264_psnr( ssd[0] + ssd[1] + ssd[2], 3 * h->param.i_width * h->param.i_height / 2 );
2696         h->stat.f_psnr_mean_y[h->sh.i_type] += x264_psnr( ssd[0], h->param.i_width * h->param.i_height );
2697         h->stat.f_psnr_mean_u[h->sh.i_type] += x264_psnr( ssd[1], h->param.i_width * h->param.i_height / 4 );
2698         h->stat.f_psnr_mean_v[h->sh.i_type] += x264_psnr( ssd[2], h->param.i_width * h->param.i_height / 4 );
2699
2700         snprintf( psz_message, 80, " PSNR Y:%5.2f U:%5.2f V:%5.2f",
2701                   x264_psnr( ssd[0], h->param.i_width * h->param.i_height ),
2702                   x264_psnr( ssd[1], h->param.i_width * h->param.i_height / 4),
2703                   x264_psnr( ssd[2], h->param.i_width * h->param.i_height / 4) );
2704     }
2705
2706     if( h->param.analyse.b_ssim )
2707     {
2708         double ssim_y = h->stat.frame.f_ssim
2709                       / (((h->param.i_width-6)>>2) * ((h->param.i_height-6)>>2));
2710         h->stat.f_ssim_mean_y[h->sh.i_type] += ssim_y;
2711         snprintf( psz_message + strlen(psz_message), 80 - strlen(psz_message),
2712                   " SSIM Y:%.5f", ssim_y );
2713     }
2714     psz_message[79] = '\0';
2715
2716     x264_log( h, X264_LOG_DEBUG,
2717                   "frame=%4d QP=%.2f NAL=%d Slice:%c Poc:%-3d I:%-4d P:%-4d SKIP:%-4d size=%d bytes%s\n",
2718               h->i_frame,
2719               h->fdec->f_qp_avg_aq,
2720               h->i_nal_ref_idc,
2721               h->sh.i_type == SLICE_TYPE_I ? 'I' : (h->sh.i_type == SLICE_TYPE_P ? 'P' : 'B' ),
2722               h->fdec->i_poc,
2723               h->stat.frame.i_mb_count_i,
2724               h->stat.frame.i_mb_count_p,
2725               h->stat.frame.i_mb_count_skip,
2726               frame_size,
2727               psz_message );
2728
2729     // keep stats all in one place
2730     x264_thread_sync_stat( h->thread[0], h );
2731     // for the use of the next frame
2732     x264_thread_sync_stat( thread_current, h );
2733
2734 #ifdef DEBUG_MB_TYPE
2735 {
2736     static const char mb_chars[] = { 'i', 'i', 'I', 'C', 'P', '8', 'S',
2737         'D', '<', 'X', 'B', 'X', '>', 'B', 'B', 'B', 'B', '8', 'S' };
2738     int mb_xy;
2739     for( mb_xy = 0; mb_xy < h->sps->i_mb_width * h->sps->i_mb_height; mb_xy++ )
2740     {
2741         if( h->mb.type[mb_xy] < X264_MBTYPE_MAX && h->mb.type[mb_xy] >= 0 )
2742             fprintf( stderr, "%c ", mb_chars[ h->mb.type[mb_xy] ] );
2743         else
2744             fprintf( stderr, "? " );
2745
2746         if( (mb_xy+1) % h->sps->i_mb_width == 0 )
2747             fprintf( stderr, "\n" );
2748     }
2749 }
2750 #endif
2751
2752     /* Remove duplicates, must be done near the end as breaks h->fref0 array
2753      * by freeing some of its pointers. */
2754      for( i = 0; i < h->i_ref0; i++ )
2755          if( h->fref0[i] && h->fref0[i]->b_duplicate )
2756          {
2757              x264_frame_push_blank_unused( h, h->fref0[i] );
2758              h->fref0[i] = 0;
2759          }
2760
2761     if( h->param.psz_dump_yuv )
2762         x264_frame_dump( h );
2763
2764     return frame_size;
2765 }
2766
2767 static void x264_print_intra( int64_t *i_mb_count, double i_count, int b_print_pcm, char *intra )
2768 {
2769     intra += sprintf( intra, "I16..4%s: %4.1f%% %4.1f%% %4.1f%%",
2770         b_print_pcm ? "..PCM" : "",
2771         i_mb_count[I_16x16]/ i_count,
2772         i_mb_count[I_8x8]  / i_count,
2773         i_mb_count[I_4x4]  / i_count );
2774     if( b_print_pcm )
2775         sprintf( intra, " %4.1f%%", i_mb_count[I_PCM]  / i_count );
2776 }
2777
2778 /****************************************************************************
2779  * x264_encoder_close:
2780  ****************************************************************************/
2781 void    x264_encoder_close  ( x264_t *h )
2782 {
2783     int64_t i_yuv_size = 3 * h->param.i_width * h->param.i_height / 2;
2784     int64_t i_mb_count_size[2][7] = {{0}};
2785     char buf[200];
2786     int i, j, i_list, i_type;
2787     int b_print_pcm = h->stat.i_mb_count[SLICE_TYPE_I][I_PCM]
2788                    || h->stat.i_mb_count[SLICE_TYPE_P][I_PCM]
2789                    || h->stat.i_mb_count[SLICE_TYPE_B][I_PCM];
2790
2791     x264_lookahead_delete( h );
2792
2793     if( h->param.i_threads > 1 )
2794     {
2795         // don't strictly have to wait for the other threads, but it's simpler than canceling them
2796         for( i = 0; i < h->param.i_threads; i++ )
2797             if( h->thread[i]->b_thread_active )
2798                 x264_pthread_join( h->thread[i]->thread_handle, NULL );
2799         if( h->i_thread_frames > 1 )
2800         {
2801             for( i = 0; i < h->i_thread_frames; i++ )
2802             {
2803                 if( h->thread[i]->b_thread_active )
2804                 {
2805                     assert( h->thread[i]->fenc->i_reference_count == 1 );
2806                     x264_frame_delete( h->thread[i]->fenc );
2807                 }
2808             }
2809
2810             x264_t *thread_prev = h->thread[h->i_thread_phase];
2811             x264_thread_sync_ratecontrol( h, thread_prev, h );
2812             x264_thread_sync_ratecontrol( thread_prev, thread_prev, h );
2813             h->i_frame = thread_prev->i_frame + 1 - h->i_thread_frames;
2814         }
2815     }
2816     h->i_frame++;
2817
2818     /* Slices used and PSNR */
2819     for( i=0; i<5; i++ )
2820     {
2821         static const int slice_order[] = { SLICE_TYPE_I, SLICE_TYPE_SI, SLICE_TYPE_P, SLICE_TYPE_SP, SLICE_TYPE_B };
2822         static const char *slice_name[] = { "P", "B", "I", "SP", "SI" };
2823         int i_slice = slice_order[i];
2824
2825         if( h->stat.i_frame_count[i_slice] > 0 )
2826         {
2827             const int i_count = h->stat.i_frame_count[i_slice];
2828             if( h->param.analyse.b_psnr )
2829             {
2830                 x264_log( h, X264_LOG_INFO,
2831                           "frame %s:%-5d Avg QP:%5.2f  size:%6.0f  PSNR Mean Y:%5.2f U:%5.2f V:%5.2f Avg:%5.2f Global:%5.2f\n",
2832                           slice_name[i_slice],
2833                           i_count,
2834                           h->stat.f_frame_qp[i_slice] / i_count,
2835                           (double)h->stat.i_frame_size[i_slice] / i_count,
2836                           h->stat.f_psnr_mean_y[i_slice] / i_count, h->stat.f_psnr_mean_u[i_slice] / i_count, h->stat.f_psnr_mean_v[i_slice] / i_count,
2837                           h->stat.f_psnr_average[i_slice] / i_count,
2838                           x264_psnr( h->stat.i_ssd_global[i_slice], i_count * i_yuv_size ) );
2839             }
2840             else
2841             {
2842                 x264_log( h, X264_LOG_INFO,
2843                           "frame %s:%-5d Avg QP:%5.2f  size:%6.0f\n",
2844                           slice_name[i_slice],
2845                           i_count,
2846                           h->stat.f_frame_qp[i_slice] / i_count,
2847                           (double)h->stat.i_frame_size[i_slice] / i_count );
2848             }
2849         }
2850     }
2851     if( h->param.i_bframe && h->stat.i_frame_count[SLICE_TYPE_P] )
2852     {
2853         char *p = buf;
2854         int den = 0;
2855         // weight by number of frames (including the P-frame) that are in a sequence of N B-frames
2856         for( i=0; i<=h->param.i_bframe; i++ )
2857             den += (i+1) * h->stat.i_consecutive_bframes[i];
2858         for( i=0; i<=h->param.i_bframe; i++ )
2859             p += sprintf( p, " %4.1f%%", 100. * (i+1) * h->stat.i_consecutive_bframes[i] / den );
2860         x264_log( h, X264_LOG_INFO, "consecutive B-frames:%s\n", buf );
2861     }
2862
2863     for( i_type = 0; i_type < 2; i_type++ )
2864         for( i = 0; i < X264_PARTTYPE_MAX; i++ )
2865         {
2866             if( i == D_DIRECT_8x8 ) continue; /* direct is counted as its own type */
2867             i_mb_count_size[i_type][x264_mb_partition_pixel_table[i]] += h->stat.i_mb_partition[i_type][i];
2868         }
2869
2870     /* MB types used */
2871     if( h->stat.i_frame_count[SLICE_TYPE_I] > 0 )
2872     {
2873         int64_t *i_mb_count = h->stat.i_mb_count[SLICE_TYPE_I];
2874         double i_count = h->stat.i_frame_count[SLICE_TYPE_I] * h->mb.i_mb_count / 100.0;
2875         x264_print_intra( i_mb_count, i_count, b_print_pcm, buf );
2876         x264_log( h, X264_LOG_INFO, "mb I  %s\n", buf );
2877     }
2878     if( h->stat.i_frame_count[SLICE_TYPE_P] > 0 )
2879     {
2880         int64_t *i_mb_count = h->stat.i_mb_count[SLICE_TYPE_P];
2881         double i_count = h->stat.i_frame_count[SLICE_TYPE_P] * h->mb.i_mb_count / 100.0;
2882         int64_t *i_mb_size = i_mb_count_size[SLICE_TYPE_P];
2883         x264_print_intra( i_mb_count, i_count, b_print_pcm, buf );
2884         x264_log( h, X264_LOG_INFO,
2885                   "mb P  %s  P16..4: %4.1f%% %4.1f%% %4.1f%% %4.1f%% %4.1f%%    skip:%4.1f%%\n",
2886                   buf,
2887                   i_mb_size[PIXEL_16x16] / (i_count*4),
2888                   (i_mb_size[PIXEL_16x8] + i_mb_size[PIXEL_8x16]) / (i_count*4),
2889                   i_mb_size[PIXEL_8x8] / (i_count*4),
2890                   (i_mb_size[PIXEL_8x4] + i_mb_size[PIXEL_4x8]) / (i_count*4),
2891                   i_mb_size[PIXEL_4x4] / (i_count*4),
2892                   i_mb_count[P_SKIP] / i_count );
2893     }
2894     if( h->stat.i_frame_count[SLICE_TYPE_B] > 0 )
2895     {
2896         int64_t *i_mb_count = h->stat.i_mb_count[SLICE_TYPE_B];
2897         double i_count = h->stat.i_frame_count[SLICE_TYPE_B] * h->mb.i_mb_count / 100.0;
2898         double i_mb_list_count;
2899         int64_t *i_mb_size = i_mb_count_size[SLICE_TYPE_B];
2900         int64_t list_count[3] = {0}; /* 0 == L0, 1 == L1, 2 == BI */
2901         x264_print_intra( i_mb_count, i_count, b_print_pcm, buf );
2902         for( i = 0; i < X264_PARTTYPE_MAX; i++ )
2903             for( j = 0; j < 2; j++ )
2904             {
2905                 int l0 = x264_mb_type_list_table[i][0][j];
2906                 int l1 = x264_mb_type_list_table[i][1][j];
2907                 if( l0 || l1 )
2908                     list_count[l1+l0*l1] += h->stat.i_mb_count[SLICE_TYPE_B][i] * 2;
2909             }
2910         list_count[0] += h->stat.i_mb_partition[SLICE_TYPE_B][D_L0_8x8];
2911         list_count[1] += h->stat.i_mb_partition[SLICE_TYPE_B][D_L1_8x8];
2912         list_count[2] += h->stat.i_mb_partition[SLICE_TYPE_B][D_BI_8x8];
2913         i_mb_count[B_DIRECT] += (h->stat.i_mb_partition[SLICE_TYPE_B][D_DIRECT_8x8]+2)/4;
2914         i_mb_list_count = (list_count[0] + list_count[1] + list_count[2]) / 100.0;
2915         x264_log( h, X264_LOG_INFO,
2916                   "mb B  %s  B16..8: %4.1f%% %4.1f%% %4.1f%%  direct:%4.1f%%  skip:%4.1f%%  L0:%4.1f%% L1:%4.1f%% BI:%4.1f%%\n",
2917                   buf,
2918                   i_mb_size[PIXEL_16x16] / (i_count*4),
2919                   (i_mb_size[PIXEL_16x8] + i_mb_size[PIXEL_8x16]) / (i_count*4),
2920                   i_mb_size[PIXEL_8x8] / (i_count*4),
2921                   i_mb_count[B_DIRECT] / i_count,
2922                   i_mb_count[B_SKIP]   / i_count,
2923                   list_count[0] / i_mb_list_count,
2924                   list_count[1] / i_mb_list_count,
2925                   list_count[2] / i_mb_list_count );
2926     }
2927
2928     x264_ratecontrol_summary( h );
2929
2930     if( h->stat.i_frame_count[SLICE_TYPE_I] + h->stat.i_frame_count[SLICE_TYPE_P] + h->stat.i_frame_count[SLICE_TYPE_B] > 0 )
2931     {
2932 #define SUM3(p) (p[SLICE_TYPE_I] + p[SLICE_TYPE_P] + p[SLICE_TYPE_B])
2933 #define SUM3b(p,o) (p[SLICE_TYPE_I][o] + p[SLICE_TYPE_P][o] + p[SLICE_TYPE_B][o])
2934         int64_t i_i8x8 = SUM3b( h->stat.i_mb_count, I_8x8 );
2935         int64_t i_intra = i_i8x8 + SUM3b( h->stat.i_mb_count, I_4x4 )
2936                                  + SUM3b( h->stat.i_mb_count, I_16x16 );
2937         int64_t i_all_intra = i_intra + SUM3b( h->stat.i_mb_count, I_PCM);
2938         const int i_count = h->stat.i_frame_count[SLICE_TYPE_I] +
2939                             h->stat.i_frame_count[SLICE_TYPE_P] +
2940                             h->stat.i_frame_count[SLICE_TYPE_B];
2941         int64_t i_mb_count = i_count * h->mb.i_mb_count;
2942         float fps = (float) h->param.i_fps_num / h->param.i_fps_den;
2943         float f_bitrate;
2944         /* duration algorithm fails with one frame */
2945         if( i_count == 1 )
2946             f_bitrate = fps * SUM3(h->stat.i_frame_size) / i_count / 125;
2947         else
2948         {
2949             float duration = (float)(2 * h->frames.i_largest_pts - h->frames.i_second_largest_pts) * h->param.i_timebase_num / h->param.i_timebase_den;
2950             f_bitrate = SUM3(h->stat.i_frame_size) / duration / 125;
2951         }
2952
2953         if( h->pps->b_transform_8x8_mode )
2954         {
2955             buf[0] = 0;
2956             if( h->stat.i_mb_count_8x8dct[0] )
2957                 sprintf( buf, " inter:%.1f%%", 100. * h->stat.i_mb_count_8x8dct[1] / h->stat.i_mb_count_8x8dct[0] );
2958             x264_log( h, X264_LOG_INFO, "8x8 transform intra:%.1f%%%s\n", 100. * i_i8x8 / i_intra, buf );
2959         }
2960
2961         if( (h->param.analyse.i_direct_mv_pred == X264_DIRECT_PRED_AUTO ||
2962             (h->stat.i_direct_frames[0] && h->stat.i_direct_frames[1]))
2963             && h->stat.i_frame_count[SLICE_TYPE_B] )
2964         {
2965             x264_log( h, X264_LOG_INFO, "direct mvs  spatial:%.1f%% temporal:%.1f%%\n",
2966                       h->stat.i_direct_frames[1] * 100. / h->stat.i_frame_count[SLICE_TYPE_B],
2967                       h->stat.i_direct_frames[0] * 100. / h->stat.i_frame_count[SLICE_TYPE_B] );
2968         }
2969
2970         buf[0] = 0;
2971         if( i_mb_count != i_all_intra )
2972             sprintf( buf, " inter: %.1f%% %.1f%% %.1f%%",
2973                      h->stat.i_mb_cbp[1] * 100.0 / ((i_mb_count - i_all_intra)*4),
2974                      h->stat.i_mb_cbp[3] * 100.0 / ((i_mb_count - i_all_intra)  ),
2975                      h->stat.i_mb_cbp[5] * 100.0 / ((i_mb_count - i_all_intra)) );
2976         x264_log( h, X264_LOG_INFO, "coded y,uvDC,uvAC intra: %.1f%% %.1f%% %.1f%%%s\n",
2977                   h->stat.i_mb_cbp[0] * 100.0 / (i_all_intra*4),
2978                   h->stat.i_mb_cbp[2] * 100.0 / (i_all_intra  ),
2979                   h->stat.i_mb_cbp[4] * 100.0 / (i_all_intra  ), buf );
2980
2981         int64_t fixed_pred_modes[3][9] = {{0}};
2982         int64_t sum_pred_modes[3] = {0};
2983         for( i = 0; i <= I_PRED_16x16_DC_128; i++ )
2984         {
2985             fixed_pred_modes[0][x264_mb_pred_mode16x16_fix[i]] += h->stat.i_mb_pred_mode[0][i];
2986             sum_pred_modes[0] += h->stat.i_mb_pred_mode[0][i];
2987         }
2988         if( sum_pred_modes[0] )
2989             x264_log( h, X264_LOG_INFO, "i16 v,h,dc,p: %2.0f%% %2.0f%% %2.0f%% %2.0f%%\n",
2990                       fixed_pred_modes[0][0] * 100.0 / sum_pred_modes[0],
2991                       fixed_pred_modes[0][1] * 100.0 / sum_pred_modes[0],
2992                       fixed_pred_modes[0][2] * 100.0 / sum_pred_modes[0],
2993                       fixed_pred_modes[0][3] * 100.0 / sum_pred_modes[0] );
2994         for( i = 1; i <= 2; i++ )
2995         {
2996             for( j = 0; j <= I_PRED_8x8_DC_128; j++ )
2997             {
2998                 fixed_pred_modes[i][x264_mb_pred_mode4x4_fix(j)] += h->stat.i_mb_pred_mode[i][j];
2999                 sum_pred_modes[i] += h->stat.i_mb_pred_mode[i][j];
3000             }
3001             if( sum_pred_modes[i] )
3002                 x264_log( h, X264_LOG_INFO, "i%d v,h,dc,ddl,ddr,vr,hd,vl,hu: %2.0f%% %2.0f%% %2.0f%% %2.0f%% %2.0f%% %2.0f%% %2.0f%% %2.0f%% %2.0f%%\n", (3-i)*4,
3003                           fixed_pred_modes[i][0] * 100.0 / sum_pred_modes[i],
3004                           fixed_pred_modes[i][1] * 100.0 / sum_pred_modes[i],
3005                           fixed_pred_modes[i][2] * 100.0 / sum_pred_modes[i],
3006                           fixed_pred_modes[i][3] * 100.0 / sum_pred_modes[i],
3007                           fixed_pred_modes[i][4] * 100.0 / sum_pred_modes[i],
3008                           fixed_pred_modes[i][5] * 100.0 / sum_pred_modes[i],
3009                           fixed_pred_modes[i][6] * 100.0 / sum_pred_modes[i],
3010                           fixed_pred_modes[i][7] * 100.0 / sum_pred_modes[i],
3011                           fixed_pred_modes[i][8] * 100.0 / sum_pred_modes[i] );
3012         }
3013
3014         if( h->param.analyse.i_weighted_pred == X264_WEIGHTP_SMART && h->stat.i_frame_count[SLICE_TYPE_P] > 0 )
3015             x264_log( h, X264_LOG_INFO, "Weighted P-Frames: Y:%.1f%%\n",
3016                       h->stat.i_wpred[0] * 100.0 / h->stat.i_frame_count[SLICE_TYPE_P] );
3017
3018         for( i_list = 0; i_list < 2; i_list++ )
3019         {
3020             int i_slice;
3021             for( i_slice = 0; i_slice < 2; i_slice++ )
3022             {
3023                 char *p = buf;
3024                 int64_t i_den = 0;
3025                 int i_max = 0;
3026                 for( i = 0; i < 32; i++ )
3027                     if( h->stat.i_mb_count_ref[i_slice][i_list][i] )
3028                     {
3029                         i_den += h->stat.i_mb_count_ref[i_slice][i_list][i];
3030                         i_max = i;
3031                     }
3032                 if( i_max == 0 )
3033                     continue;
3034                 for( i = 0; i <= i_max; i++ )
3035                     p += sprintf( p, " %4.1f%%", 100. * h->stat.i_mb_count_ref[i_slice][i_list][i] / i_den );
3036                 x264_log( h, X264_LOG_INFO, "ref %c L%d:%s\n", "PB"[i_slice], i_list, buf );
3037             }
3038         }
3039
3040         if( h->param.analyse.b_ssim )
3041         {
3042             x264_log( h, X264_LOG_INFO,
3043                       "SSIM Mean Y:%.7f\n",
3044                       SUM3( h->stat.f_ssim_mean_y ) / i_count );
3045         }
3046         if( h->param.analyse.b_psnr )
3047         {
3048             x264_log( h, X264_LOG_INFO,
3049                       "PSNR Mean Y:%6.3f U:%6.3f V:%6.3f Avg:%6.3f Global:%6.3f kb/s:%.2f\n",
3050                       SUM3( h->stat.f_psnr_mean_y ) / i_count,
3051                       SUM3( h->stat.f_psnr_mean_u ) / i_count,
3052                       SUM3( h->stat.f_psnr_mean_v ) / i_count,
3053                       SUM3( h->stat.f_psnr_average ) / i_count,
3054                       x264_psnr( SUM3( h->stat.i_ssd_global ), i_count * i_yuv_size ),
3055                       f_bitrate );
3056         }
3057         else
3058             x264_log( h, X264_LOG_INFO, "kb/s:%.2f\n", f_bitrate );
3059     }
3060
3061     /* rc */
3062     x264_ratecontrol_delete( h );
3063
3064     /* param */
3065     if( h->param.rc.psz_stat_out )
3066         free( h->param.rc.psz_stat_out );
3067     if( h->param.rc.psz_stat_in )
3068         free( h->param.rc.psz_stat_in );
3069
3070     x264_cqm_delete( h );
3071     x264_free( h->nal_buffer );
3072     x264_analyse_free_costs( h );
3073
3074     if( h->i_thread_frames > 1)
3075         h = h->thread[h->i_thread_phase];
3076
3077     /* frames */
3078     x264_frame_delete_list( h->frames.unused[0] );
3079     x264_frame_delete_list( h->frames.unused[1] );
3080     x264_frame_delete_list( h->frames.current );
3081     x264_frame_delete_list( h->frames.blank_unused );
3082
3083     h = h->thread[0];
3084
3085     for( i = h->param.i_threads - 1; i >= 0; i-- )
3086     {
3087         x264_frame_t **frame;
3088
3089         if( !h->param.b_sliced_threads || i == 0 )
3090         {
3091             for( frame = h->thread[i]->frames.reference; *frame; frame++ )
3092             {
3093                 assert( (*frame)->i_reference_count > 0 );
3094                 (*frame)->i_reference_count--;
3095                 if( (*frame)->i_reference_count == 0 )
3096                     x264_frame_delete( *frame );
3097             }
3098             frame = &h->thread[i]->fdec;
3099             assert( (*frame)->i_reference_count > 0 );
3100             (*frame)->i_reference_count--;
3101             if( (*frame)->i_reference_count == 0 )
3102                 x264_frame_delete( *frame );
3103             x264_macroblock_cache_end( h->thread[i] );
3104         }
3105         x264_free( h->thread[i]->scratch_buffer );
3106         x264_free( h->thread[i]->out.p_bitstream );
3107         x264_free( h->thread[i]->out.nal);
3108         x264_free( h->thread[i] );
3109     }
3110 }
3111
3112 /****************************************************************************
3113  * x264_encoder_delayed_frames:
3114  ****************************************************************************/
3115 int x264_encoder_delayed_frames( x264_t *h )
3116 {
3117     int delayed_frames = 0;
3118     int i;
3119     if( h->i_thread_frames > 1 )
3120     {
3121         for( i=0; i<h->i_thread_frames; i++ )
3122             delayed_frames += h->thread[i]->b_thread_active;
3123         h = h->thread[h->i_thread_phase];
3124     }
3125     for( i=0; h->frames.current[i]; i++ )
3126         delayed_frames++;
3127     x264_pthread_mutex_lock( &h->lookahead->ofbuf.mutex );
3128     x264_pthread_mutex_lock( &h->lookahead->ifbuf.mutex );
3129     x264_pthread_mutex_lock( &h->lookahead->next.mutex );
3130     delayed_frames += h->lookahead->ifbuf.i_size + h->lookahead->next.i_size + h->lookahead->ofbuf.i_size;
3131     x264_pthread_mutex_unlock( &h->lookahead->next.mutex );
3132     x264_pthread_mutex_unlock( &h->lookahead->ifbuf.mutex );
3133     x264_pthread_mutex_unlock( &h->lookahead->ofbuf.mutex );
3134     return delayed_frames;
3135 }