vp8/encoder/firstpass.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "math.h"
  12 #include "limits.h"
  13 #include "block.h"
  14 #include "onyx_int.h"
  15 #include "variance.h"
  16 #include "encodeintra.h"
  17 #include "vp8/common/setupintrarecon.h"
  18 #include "mcomp.h"
  19 #include "vpx_scale/vpxscale.h"
  20 #include "encodemb.h"
  21 #include "vp8/common/extend.h"
  22 #include "vp8/common/systemdependent.h"
  23 #include "vpx_scale/yv12extend.h"
  24 #include "vpx_mem/vpx_mem.h"
  25 #include "vp8/common/swapyv12buffer.h"
  26 #include <stdio.h>
  27 #include "rdopt.h"
  28 #include "vp8/common/quant_common.h"
  29 #include "encodemv.h"
  30
  31 //#define OUTPUT_FPF 1
  32
  33 #if CONFIG_RUNTIME_CPU_DETECT
  34 #define IF_RTCD(x) (x)
  35 #else
  36 #define IF_RTCD(x) NULL
  37 #endif
  38
  39 extern void vp8_build_block_offsets(MACROBLOCK *x);
  40 extern void vp8_setup_block_ptrs(MACROBLOCK *x);
  41 extern void vp8cx_frame_init_quantizer(VP8_COMP *cpi);
  42 extern void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, int_mv *mv);
  43 extern void vp8_alloc_compressor_data(VP8_COMP *cpi);
  44
  45 //#define GFQ_ADJUSTMENT (40 + ((15*Q)/10))
  46 //#define GFQ_ADJUSTMENT (80 + ((15*Q)/10))
  47 #define GFQ_ADJUSTMENT vp8_gf_boost_qadjustment[Q]
  48 extern int vp8_kf_boost_qadjustment[QINDEX_RANGE];
  49
  50 extern const int vp8_gf_boost_qadjustment[QINDEX_RANGE];
  51
  52 #define IIFACTOR   1.4
  53 #define IIKFACTOR1 1.40
  54 #define IIKFACTOR2 1.5
  55 #define RMAX       14.0
  56 #define GF_RMAX    48.0
  57
  58 #define KF_MB_INTRA_MIN 300
  59 #define GF_MB_INTRA_MIN 200
  60
  61 #define DOUBLE_DIVIDE_CHECK(X) ((X)<0?(X)-.000001:(X)+.000001)
  62
  63 #define POW1 (double)cpi->oxcf.two_pass_vbrbias/100.0
  64 #define POW2 (double)cpi->oxcf.two_pass_vbrbias/100.0
  65
  66 static int vscale_lookup[7] = {0, 1, 1, 2, 2, 3, 3};
  67 static int hscale_lookup[7] = {0, 0, 1, 1, 2, 2, 3};
  68
  69
  70 static const int cq_level[QINDEX_RANGE] =
  71 {
  72     0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,
  73     9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20,
  74     20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31,
  75     32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43,
  76     44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56,
  77     57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70,
  78     71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85,
  79     86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100
  80 };
  81
  82 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame);
  83
  84 static int encode_intra(VP8_COMP *cpi, MACROBLOCK *x, int use_dc_pred)
  85 {
  86
  87     int i;
  88     int intra_pred_var = 0;
  89     (void) cpi;
  90
  91     if (use_dc_pred)
  92     {
  93         x->e_mbd.mode_info_context->mbmi.mode = DC_PRED;
  94         x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
  95         x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
  96
  97         vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
  98     }
  99     else
 100     {
 101         for (i = 0; i < 16; i++)
 102         {
 103             x->e_mbd.block[i].bmi.as_mode = B_DC_PRED;
 104             vp8_encode_intra4x4block(IF_RTCD(&cpi->rtcd), x, i);
 105         }
 106     }
 107
 108     intra_pred_var = VARIANCE_INVOKE(&cpi->rtcd.variance, getmbss)(x->src_diff);
 109
 110     return intra_pred_var;
 111 }
 112
 113 // Resets the first pass file to the given position using a relative seek from the current position
 114 static void reset_fpf_position(VP8_COMP *cpi, FIRSTPASS_STATS *Position)
 115 {
 116     cpi->twopass.stats_in = Position;
 117 }
 118
 119 static int lookup_next_frame_stats(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame)
 120 {
 121     if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end)
 122         return EOF;
 123
 124     *next_frame = *cpi->twopass.stats_in;
 125     return 1;
 126 }
 127
 128 // Calculate a modified Error used in distributing bits between easier and harder frames
 129 static double calculate_modified_err(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
 130 {
 131     double av_err = cpi->twopass.total_stats->ssim_weighted_pred_err;
 132     double this_err = this_frame->ssim_weighted_pred_err;
 133     double modified_err;
 134
 135     //double relative_next_iiratio;
 136     //double next_iiratio;
 137     //double sum_iiratio;
 138     //int i;
 139
 140     //FIRSTPASS_STATS next_frame;
 141     //FIRSTPASS_STATS *start_pos;
 142
 143     /*start_pos = cpi->twopass.stats_in;
 144     sum_iiratio = 0.0;
 145     i = 0;
 146     while ( (i < 1) && input_stats(cpi,&next_frame) != EOF )
 147     {
 148
 149         next_iiratio = next_frame.intra_error / DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
 150         next_iiratio = ( next_iiratio < 1.0 ) ? 1.0 : (next_iiratio > 20.0) ? 20.0 : next_iiratio;
 151         sum_iiratio += next_iiratio;
 152         i++;
 153     }
 154     if ( i > 0 )
 155     {
 156         relative_next_iiratio = sum_iiratio / DOUBLE_DIVIDE_CHECK(cpi->twopass.avg_iiratio * (double)i);
 157     }
 158     else
 159     {
 160         relative_next_iiratio = 1.0;
 161     }
 162     reset_fpf_position(cpi, start_pos);*/
 163
 164     if (this_err > av_err)
 165         modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW1);
 166     else
 167         modified_err = av_err * pow((this_err / DOUBLE_DIVIDE_CHECK(av_err)), POW2);
 168
 169     /*
 170     relative_next_iiratio = pow(relative_next_iiratio,0.25);
 171     modified_err = modified_err * relative_next_iiratio;
 172     */
 173
 174     return modified_err;
 175 }
 176
 177 static const double weight_table[256] = {
 178 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
 179 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
 180 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
 181 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000, 0.020000,
 182 0.020000, 0.031250, 0.062500, 0.093750, 0.125000, 0.156250, 0.187500, 0.218750,
 183 0.250000, 0.281250, 0.312500, 0.343750, 0.375000, 0.406250, 0.437500, 0.468750,
 184 0.500000, 0.531250, 0.562500, 0.593750, 0.625000, 0.656250, 0.687500, 0.718750,
 185 0.750000, 0.781250, 0.812500, 0.843750, 0.875000, 0.906250, 0.937500, 0.968750,
 186 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 187 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 188 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 189 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 190 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 191 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 192 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 193 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 194 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 195 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 196 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 197 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 198 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 199 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 200 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 201 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 202 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 203 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 204 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 205 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 206 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 207 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 208 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000,
 209 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000, 1.000000
 210 };
 211
 212 static double simple_weight(YV12_BUFFER_CONFIG *source)
 213 {
 214     int i, j;
 215
 216     unsigned char *src = source->y_buffer;
 217     double sum_weights = 0.0;
 218
 219     // Loop throught the Y plane raw examining levels and creating a weight for the image
 220     i = source->y_height;
 221     do
 222     {
 223         j = source->y_width;
 224         do
 225         {
 226             sum_weights += weight_table[ *src];
 227             src++;
 228         }while(--j);
 229         src -= source->y_width;
 230         src += source->y_stride;
 231     }while(--i);
 232
 233     sum_weights /= (source->y_height * source->y_width);
 234
 235     return sum_weights;
 236 }
 237
 238
 239 // This function returns the current per frame maximum bitrate target
 240 static int frame_max_bits(VP8_COMP *cpi)
 241 {
 242     // Max allocation for a single frame based on the max section guidelines passed in and how many bits are left
 243     int max_bits;
 244
 245     // For CBR we need to also consider buffer fullness.
 246     // If we are running below the optimal level then we need to gradually tighten up on max_bits.
 247     if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
 248     {
 249         double buffer_fullness_ratio = (double)cpi->buffer_level / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.optimal_buffer_level);
 250
 251         // For CBR base this on the target average bits per frame plus the maximum sedction rate passed in by the user
 252         max_bits = (int)(cpi->av_per_frame_bandwidth * ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0));
 253
 254         // If our buffer is below the optimum level
 255         if (buffer_fullness_ratio < 1.0)
 256         {
 257             // The lower of max_bits / 4 or cpi->av_per_frame_bandwidth / 4.
 258             int min_max_bits = ((cpi->av_per_frame_bandwidth >> 2) < (max_bits >> 2)) ? cpi->av_per_frame_bandwidth >> 2 : max_bits >> 2;
 259
 260             max_bits = (int)(max_bits * buffer_fullness_ratio);
 261
 262             if (max_bits < min_max_bits)
 263                 max_bits = min_max_bits;       // Lowest value we will set ... which should allow the buffer to refil.
 264         }
 265     }
 266     // VBR
 267     else
 268     {
 269         // For VBR base this on the bits and frames left plus the two_pass_vbrmax_section rate passed in by the user
 270         max_bits = (int)(((double)cpi->twopass.bits_left / (cpi->twopass.total_stats->count - (double)cpi->common.current_video_frame)) * ((double)cpi->oxcf.two_pass_vbrmax_section / 100.0));
 271     }
 272
 273     // Trap case where we are out of bits
 274     if (max_bits < 0)
 275         max_bits = 0;
 276
 277     return max_bits;
 278 }
 279
 280
 281 static void output_stats(const VP8_COMP            *cpi,
 282                          struct vpx_codec_pkt_list *pktlist,
 283                          FIRSTPASS_STATS            *stats)
 284 {
 285     struct vpx_codec_cx_pkt pkt;
 286     pkt.kind = VPX_CODEC_STATS_PKT;
 287     pkt.data.twopass_stats.buf = stats;
 288     pkt.data.twopass_stats.sz = sizeof(FIRSTPASS_STATS);
 289     vpx_codec_pkt_list_add(pktlist, &pkt);
 290
 291 // TEMP debug code
 292 #if OUTPUT_FPF
 293
 294     {
 295         FILE *fpfile;
 296         fpfile = fopen("firstpass.stt", "a");
 297
 298         fprintf(fpfile, "%12.0f %12.0f %12.0f %12.4f %12.4f %12.4f %12.4f"
 299                 " %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f %12.4f"
 300                 " %12.0f %12.4f\n",
 301                 stats->frame,
 302                 stats->intra_error,
 303                 stats->coded_error,
 304                 stats->ssim_weighted_pred_err,
 305                 stats->pcnt_inter,
 306                 stats->pcnt_motion,
 307                 stats->pcnt_second_ref,
 308                 stats->pcnt_neutral,
 309                 stats->MVr,
 310                 stats->mvr_abs,
 311                 stats->MVc,
 312                 stats->mvc_abs,
 313                 stats->MVrv,
 314                 stats->MVcv,
 315                 stats->mv_in_out_count,
 316                 stats->count,
 317                 stats->duration);
 318         fclose(fpfile);
 319     }
 320 #endif
 321 }
 322
 323 static int input_stats(VP8_COMP *cpi, FIRSTPASS_STATS *fps)
 324 {
 325     if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end)
 326         return EOF;
 327
 328     *fps = *cpi->twopass.stats_in;
 329     cpi->twopass.stats_in =
 330          (void*)((char *)cpi->twopass.stats_in + sizeof(FIRSTPASS_STATS));
 331     return 1;
 332 }
 333
 334 static void zero_stats(FIRSTPASS_STATS *section)
 335 {
 336     section->frame      = 0.0;
 337     section->intra_error = 0.0;
 338     section->coded_error = 0.0;
 339     section->ssim_weighted_pred_err = 0.0;
 340     section->pcnt_inter  = 0.0;
 341     section->pcnt_motion  = 0.0;
 342     section->pcnt_second_ref = 0.0;
 343     section->pcnt_neutral = 0.0;
 344     section->MVr        = 0.0;
 345     section->mvr_abs     = 0.0;
 346     section->MVc        = 0.0;
 347     section->mvc_abs     = 0.0;
 348     section->MVrv       = 0.0;
 349     section->MVcv       = 0.0;
 350     section->mv_in_out_count  = 0.0;
 351     section->count      = 0.0;
 352     section->duration   = 1.0;
 353 }
 354 static void accumulate_stats(FIRSTPASS_STATS *section, FIRSTPASS_STATS *frame)
 355 {
 356     section->frame += frame->frame;
 357     section->intra_error += frame->intra_error;
 358     section->coded_error += frame->coded_error;
 359     section->ssim_weighted_pred_err += frame->ssim_weighted_pred_err;
 360     section->pcnt_inter  += frame->pcnt_inter;
 361     section->pcnt_motion += frame->pcnt_motion;
 362     section->pcnt_second_ref += frame->pcnt_second_ref;
 363     section->pcnt_neutral += frame->pcnt_neutral;
 364     section->MVr        += frame->MVr;
 365     section->mvr_abs     += frame->mvr_abs;
 366     section->MVc        += frame->MVc;
 367     section->mvc_abs     += frame->mvc_abs;
 368     section->MVrv       += frame->MVrv;
 369     section->MVcv       += frame->MVcv;
 370     section->mv_in_out_count  += frame->mv_in_out_count;
 371     section->count      += frame->count;
 372     section->duration   += frame->duration;
 373 }
 374 static void avg_stats(FIRSTPASS_STATS *section)
 375 {
 376     if (section->count < 1.0)
 377         return;
 378
 379     section->intra_error /= section->count;
 380     section->coded_error /= section->count;
 381     section->ssim_weighted_pred_err /= section->count;
 382     section->pcnt_inter  /= section->count;
 383     section->pcnt_second_ref /= section->count;
 384     section->pcnt_neutral /= section->count;
 385     section->pcnt_motion /= section->count;
 386     section->MVr        /= section->count;
 387     section->mvr_abs     /= section->count;
 388     section->MVc        /= section->count;
 389     section->mvc_abs     /= section->count;
 390     section->MVrv       /= section->count;
 391     section->MVcv       /= section->count;
 392     section->mv_in_out_count   /= section->count;
 393     section->duration   /= section->count;
 394 }
 395
 396 void vp8_init_first_pass(VP8_COMP *cpi)
 397 {
 398     zero_stats(cpi->twopass.total_stats);
 399 }
 400
 401 void vp8_end_first_pass(VP8_COMP *cpi)
 402 {
 403     output_stats(cpi, cpi->output_pkt_list, cpi->twopass.total_stats);
 404 }
 405
 406 static void zz_motion_search( VP8_COMP *cpi, MACROBLOCK * x, YV12_BUFFER_CONFIG * recon_buffer, int * best_motion_err, int recon_yoffset )
 407 {
 408     MACROBLOCKD * const xd = & x->e_mbd;
 409     BLOCK *b = &x->block[0];
 410     BLOCKD *d = &x->e_mbd.block[0];
 411
 412     unsigned char *src_ptr = (*(b->base_src) + b->src);
 413     int src_stride = b->src_stride;
 414     unsigned char *ref_ptr;
 415     int ref_stride=d->pre_stride;
 416
 417     // Set up pointers for this macro block recon buffer
 418     xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
 419
 420     ref_ptr = (unsigned char *)(*(d->base_pre) + d->pre );
 421
 422     VARIANCE_INVOKE(IF_RTCD(&cpi->rtcd.variance), mse16x16) ( src_ptr, src_stride, ref_ptr, ref_stride, (unsigned int *)(best_motion_err));
 423 }
 424
 425 static void first_pass_motion_search(VP8_COMP *cpi, MACROBLOCK *x,
 426                                      int_mv *ref_mv, MV *best_mv,
 427                                      YV12_BUFFER_CONFIG *recon_buffer,
 428                                      int *best_motion_err, int recon_yoffset )
 429 {
 430     MACROBLOCKD *const xd = & x->e_mbd;
 431     BLOCK *b = &x->block[0];
 432     BLOCKD *d = &x->e_mbd.block[0];
 433     int num00;
 434
 435     int_mv tmp_mv;
 436
 437     int tmp_err;
 438     int step_param = 3;                                       //3;          // Dont search over full range for first pass
 439     int further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param; //3;
 440     int n;
 441     vp8_variance_fn_ptr_t v_fn_ptr = cpi->fn_ptr[BLOCK_16X16];
 442     int new_mv_mode_penalty = 256;
 443
 444     // override the default variance function to use MSE
 445     v_fn_ptr.vf    = VARIANCE_INVOKE(IF_RTCD(&cpi->rtcd.variance), mse16x16);
 446
 447     // Set up pointers for this macro block recon buffer
 448     xd->pre.y_buffer = recon_buffer->y_buffer + recon_yoffset;
 449
 450     // Initial step/diamond search centred on best mv
 451     tmp_mv.as_int = 0;
 452     tmp_err = cpi->diamond_search_sad(x, b, d, ref_mv, &tmp_mv, step_param,
 453                                       x->sadperbit16, &num00, &v_fn_ptr,
 454                                       x->mvcost, ref_mv);
 455     if ( tmp_err < INT_MAX-new_mv_mode_penalty )
 456         tmp_err += new_mv_mode_penalty;
 457
 458     if (tmp_err < *best_motion_err)
 459     {
 460         *best_motion_err = tmp_err;
 461         best_mv->row = tmp_mv.as_mv.row;
 462         best_mv->col = tmp_mv.as_mv.col;
 463     }
 464
 465     // Further step/diamond searches as necessary
 466     n = num00;
 467     num00 = 0;
 468
 469     while (n < further_steps)
 470     {
 471         n++;
 472
 473         if (num00)
 474             num00--;
 475         else
 476         {
 477             tmp_err = cpi->diamond_search_sad(x, b, d, ref_mv, &tmp_mv,
 478                                               step_param + n, x->sadperbit16,
 479                                               &num00, &v_fn_ptr, x->mvcost,
 480                                               ref_mv);
 481             if ( tmp_err < INT_MAX-new_mv_mode_penalty )
 482                 tmp_err += new_mv_mode_penalty;
 483
 484             if (tmp_err < *best_motion_err)
 485             {
 486                 *best_motion_err = tmp_err;
 487                 best_mv->row = tmp_mv.as_mv.row;
 488                 best_mv->col = tmp_mv.as_mv.col;
 489             }
 490         }
 491     }
 492 }
 493
 494 void vp8_first_pass(VP8_COMP *cpi)
 495 {
 496     int mb_row, mb_col;
 497     MACROBLOCK *const x = & cpi->mb;
 498     VP8_COMMON *const cm = & cpi->common;
 499     MACROBLOCKD *const xd = & x->e_mbd;
 500
 501     int recon_yoffset, recon_uvoffset;
 502     YV12_BUFFER_CONFIG *lst_yv12 = &cm->yv12_fb[cm->lst_fb_idx];
 503     YV12_BUFFER_CONFIG *new_yv12 = &cm->yv12_fb[cm->new_fb_idx];
 504     YV12_BUFFER_CONFIG *gld_yv12 = &cm->yv12_fb[cm->gld_fb_idx];
 505     int recon_y_stride = lst_yv12->y_stride;
 506     int recon_uv_stride = lst_yv12->uv_stride;
 507     long long intra_error = 0;
 508     long long coded_error = 0;
 509
 510     int sum_mvr = 0, sum_mvc = 0;
 511     int sum_mvr_abs = 0, sum_mvc_abs = 0;
 512     int sum_mvrs = 0, sum_mvcs = 0;
 513     int mvcount = 0;
 514     int intercount = 0;
 515     int second_ref_count = 0;
 516     int intrapenalty = 256;
 517     int neutral_count = 0;
 518
 519     int sum_in_vectors = 0;
 520
 521     int_mv zero_ref_mv;
 522
 523     zero_ref_mv.as_int = 0;
 524
 525     vp8_clear_system_state();  //__asm emms;
 526
 527     x->src = * cpi->Source;
 528     xd->pre = *lst_yv12;
 529     xd->dst = *new_yv12;
 530
 531     x->partition_info = x->pi;
 532
 533     xd->mode_info_context = cm->mi;
 534
 535     vp8_build_block_offsets(x);
 536
 537     vp8_setup_block_dptrs(&x->e_mbd);
 538
 539     vp8_setup_block_ptrs(x);
 540
 541     // set up frame new frame for intra coded blocks
 542     vp8_setup_intra_recon(new_yv12);
 543     vp8cx_frame_init_quantizer(cpi);
 544
 545     // Initialise the MV cost table to the defaults
 546     //if( cm->current_video_frame == 0)
 547     //if ( 0 )
 548     {
 549         int flag[2] = {1, 1};
 550         vp8_initialize_rd_consts(cpi, vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
 551         vpx_memcpy(cm->fc.mvc, vp8_default_mv_context, sizeof(vp8_default_mv_context));
 552         vp8_build_component_cost_table(cpi->mb.mvcost, (const MV_CONTEXT *) cm->fc.mvc, flag);
 553     }
 554
 555     // for each macroblock row in image
 556     for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
 557     {
 558         int_mv best_ref_mv;
 559
 560         best_ref_mv.as_int = 0;
 561
 562         // reset above block coeffs
 563         xd->up_available = (mb_row != 0);
 564         recon_yoffset = (mb_row * recon_y_stride * 16);
 565         recon_uvoffset = (mb_row * recon_uv_stride * 8);
 566
 567         // Set up limit values for motion vectors to prevent them extending outside the UMV borders
 568         x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
 569         x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16) + (VP8BORDERINPIXELS - 16);
 570
 571
 572         // for each macroblock col in image
 573         for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
 574         {
 575             int this_error;
 576             int gf_motion_error = INT_MAX;
 577             int use_dc_pred = (mb_col || mb_row) && (!mb_col || !mb_row);
 578
 579             xd->dst.y_buffer = new_yv12->y_buffer + recon_yoffset;
 580             xd->dst.u_buffer = new_yv12->u_buffer + recon_uvoffset;
 581             xd->dst.v_buffer = new_yv12->v_buffer + recon_uvoffset;
 582             xd->left_available = (mb_col != 0);
 583
 584             // do intra 16x16 prediction
 585             this_error = encode_intra(cpi, x, use_dc_pred);
 586
 587             // "intrapenalty" below deals with situations where the intra and inter error scores are very low (eg a plain black frame)
 588             // We do not have special cases in first pass for 0,0 and nearest etc so all inter modes carry an overhead cost estimate fot the mv.
 589             // When the error score is very low this causes us to pick all or lots of INTRA modes and throw lots of key frames.
 590             // This penalty adds a cost matching that of a 0,0 mv to the intra case.
 591             this_error += intrapenalty;
 592
 593             // Cumulative intra error total
 594             intra_error += (long long)this_error;
 595
 596             // Set up limit values for motion vectors to prevent them extending outside the UMV borders
 597             x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
 598             x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + (VP8BORDERINPIXELS - 16);
 599
 600             // Other than for the first frame do a motion search
 601             if (cm->current_video_frame > 0)
 602             {
 603                 BLOCKD *d = &x->e_mbd.block[0];
 604                 MV tmp_mv = {0, 0};
 605                 int tmp_err;
 606                 int motion_error = INT_MAX;
 607
 608                 // Simple 0,0 motion with no mv overhead
 609                 zz_motion_search( cpi, x, lst_yv12, &motion_error, recon_yoffset );
 610                 d->bmi.mv.as_mv.row = 0;
 611                 d->bmi.mv.as_mv.col = 0;
 612
 613                 // Test last reference frame using the previous best mv as the
 614                 // starting point (best reference) for the search
 615                 first_pass_motion_search(cpi, x, &best_ref_mv,
 616                                         &d->bmi.mv.as_mv, lst_yv12,
 617                                         &motion_error, recon_yoffset);
 618
 619                 // If the current best reference mv is not centred on 0,0 then do a 0,0 based search as well
 620                 if (best_ref_mv.as_int)
 621                 {
 622                    tmp_err = INT_MAX;
 623                    first_pass_motion_search(cpi, x, &zero_ref_mv, &tmp_mv,
 624                                      lst_yv12, &tmp_err, recon_yoffset);
 625
 626                    if ( tmp_err < motion_error )
 627                    {
 628                         motion_error = tmp_err;
 629                         d->bmi.mv.as_mv.row = tmp_mv.row;
 630                         d->bmi.mv.as_mv.col = tmp_mv.col;
 631                    }
 632                 }
 633
 634                 // Experimental search in a second reference frame ((0,0) based only)
 635                 if (cm->current_video_frame > 1)
 636                 {
 637                     first_pass_motion_search(cpi, x, &zero_ref_mv, &tmp_mv, gld_yv12, &gf_motion_error, recon_yoffset);
 638
 639                     if ((gf_motion_error < motion_error) && (gf_motion_error < this_error))
 640                     {
 641                         second_ref_count++;
 642                         //motion_error = gf_motion_error;
 643                         //d->bmi.mv.as_mv.row = tmp_mv.row;
 644                         //d->bmi.mv.as_mv.col = tmp_mv.col;
 645                     }
 646                     /*else
 647                     {
 648                         xd->pre.y_buffer = cm->last_frame.y_buffer + recon_yoffset;
 649                         xd->pre.u_buffer = cm->last_frame.u_buffer + recon_uvoffset;
 650                         xd->pre.v_buffer = cm->last_frame.v_buffer + recon_uvoffset;
 651                     }*/
 652
 653
 654                     // Reset to last frame as reference buffer
 655                     xd->pre.y_buffer = lst_yv12->y_buffer + recon_yoffset;
 656                     xd->pre.u_buffer = lst_yv12->u_buffer + recon_uvoffset;
 657                     xd->pre.v_buffer = lst_yv12->v_buffer + recon_uvoffset;
 658                 }
 659
 660                 /* Intra assumed best */
 661                 best_ref_mv.as_int = 0;
 662
 663                 if (motion_error <= this_error)
 664                 {
 665                     // Keep a count of cases where the inter and intra were
 666                     // very close and very low. This helps with scene cut
 667                     // detection for example in cropped clips with black bars
 668                     // at the sides or top and bottom.
 669                     if( (((this_error-intrapenalty) * 9) <=
 670                          (motion_error*10)) &&
 671                         (this_error < (2*intrapenalty)) )
 672                     {
 673                         neutral_count++;
 674                     }
 675
 676                     d->bmi.mv.as_mv.row <<= 3;
 677                     d->bmi.mv.as_mv.col <<= 3;
 678                     this_error = motion_error;
 679                     vp8_set_mbmode_and_mvs(x, NEWMV, &d->bmi.mv);
 680                     vp8_encode_inter16x16y(IF_RTCD(&cpi->rtcd), x);
 681                     sum_mvr += d->bmi.mv.as_mv.row;
 682                     sum_mvr_abs += abs(d->bmi.mv.as_mv.row);
 683                     sum_mvc += d->bmi.mv.as_mv.col;
 684                     sum_mvc_abs += abs(d->bmi.mv.as_mv.col);
 685                     sum_mvrs += d->bmi.mv.as_mv.row * d->bmi.mv.as_mv.row;
 686                     sum_mvcs += d->bmi.mv.as_mv.col * d->bmi.mv.as_mv.col;
 687                     intercount++;
 688
 689                     best_ref_mv.as_int = d->bmi.mv.as_int;
 690
 691                     // Was the vector non-zero
 692                     if (d->bmi.mv.as_int)
 693                     {
 694                         mvcount++;
 695
 696                         // Does the Row vector point inwards or outwards
 697                         if (mb_row < cm->mb_rows / 2)
 698                         {
 699                             if (d->bmi.mv.as_mv.row > 0)
 700                                 sum_in_vectors--;
 701                             else if (d->bmi.mv.as_mv.row < 0)
 702                                 sum_in_vectors++;
 703                         }
 704                         else if (mb_row > cm->mb_rows / 2)
 705                         {
 706                             if (d->bmi.mv.as_mv.row > 0)
 707                                 sum_in_vectors++;
 708                             else if (d->bmi.mv.as_mv.row < 0)
 709                                 sum_in_vectors--;
 710                         }
 711
 712                         // Does the Row vector point inwards or outwards
 713                         if (mb_col < cm->mb_cols / 2)
 714                         {
 715                             if (d->bmi.mv.as_mv.col > 0)
 716                                 sum_in_vectors--;
 717                             else if (d->bmi.mv.as_mv.col < 0)
 718                                 sum_in_vectors++;
 719                         }
 720                         else if (mb_col > cm->mb_cols / 2)
 721                         {
 722                             if (d->bmi.mv.as_mv.col > 0)
 723                                 sum_in_vectors++;
 724                             else if (d->bmi.mv.as_mv.col < 0)
 725                                 sum_in_vectors--;
 726                         }
 727                     }
 728                 }
 729             }
 730
 731             coded_error += (long long)this_error;
 732
 733             // adjust to the next column of macroblocks
 734             x->src.y_buffer += 16;
 735             x->src.u_buffer += 8;
 736             x->src.v_buffer += 8;
 737
 738             recon_yoffset += 16;
 739             recon_uvoffset += 8;
 740         }
 741
 742         // adjust to the next row of mbs
 743         x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
 744         x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
 745         x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
 746
 747         //extend the recon for intra prediction
 748         vp8_extend_mb_row(new_yv12, xd->dst.y_buffer + 16, xd->dst.u_buffer + 8, xd->dst.v_buffer + 8);
 749         vp8_clear_system_state();  //__asm emms;
 750     }
 751
 752     vp8_clear_system_state();  //__asm emms;
 753     {
 754         double weight = 0.0;
 755
 756         FIRSTPASS_STATS fps;
 757
 758         fps.frame      = cm->current_video_frame ;
 759         fps.intra_error = intra_error >> 8;
 760         fps.coded_error = coded_error >> 8;
 761         weight = simple_weight(cpi->Source);
 762
 763
 764         if (weight < 0.1)
 765             weight = 0.1;
 766
 767         fps.ssim_weighted_pred_err = fps.coded_error * weight;
 768
 769         fps.pcnt_inter  = 0.0;
 770         fps.pcnt_motion = 0.0;
 771         fps.MVr        = 0.0;
 772         fps.mvr_abs     = 0.0;
 773         fps.MVc        = 0.0;
 774         fps.mvc_abs     = 0.0;
 775         fps.MVrv       = 0.0;
 776         fps.MVcv       = 0.0;
 777         fps.mv_in_out_count  = 0.0;
 778         fps.count      = 1.0;
 779
 780         fps.pcnt_inter   = 1.0 * (double)intercount / cm->MBs;
 781         fps.pcnt_second_ref = 1.0 * (double)second_ref_count / cm->MBs;
 782         fps.pcnt_neutral = 1.0 * (double)neutral_count / cm->MBs;
 783
 784         if (mvcount > 0)
 785         {
 786             fps.MVr = (double)sum_mvr / (double)mvcount;
 787             fps.mvr_abs = (double)sum_mvr_abs / (double)mvcount;
 788             fps.MVc = (double)sum_mvc / (double)mvcount;
 789             fps.mvc_abs = (double)sum_mvc_abs / (double)mvcount;
 790             fps.MVrv = ((double)sum_mvrs - (fps.MVr * fps.MVr / (double)mvcount)) / (double)mvcount;
 791             fps.MVcv = ((double)sum_mvcs - (fps.MVc * fps.MVc / (double)mvcount)) / (double)mvcount;
 792             fps.mv_in_out_count = (double)sum_in_vectors / (double)(mvcount * 2);
 793
 794             fps.pcnt_motion = 1.0 * (double)mvcount / cpi->common.MBs;
 795         }
 796
 797         // TODO:  handle the case when duration is set to 0, or something less
 798         // than the full time between subsequent cpi->source_time_stamp s  .
 799         fps.duration = cpi->source->ts_end
 800                        - cpi->source->ts_start;
 801
 802         // don't want to do output stats with a stack variable!
 803         memcpy(cpi->twopass.this_frame_stats,
 804                &fps,
 805                sizeof(FIRSTPASS_STATS));
 806         output_stats(cpi, cpi->output_pkt_list, cpi->twopass.this_frame_stats);
 807         accumulate_stats(cpi->twopass.total_stats, &fps);
 808     }
 809
 810     // Copy the previous Last Frame into the GF buffer if specific conditions for doing so are met
 811     if ((cm->current_video_frame > 0) &&
 812         (cpi->twopass.this_frame_stats->pcnt_inter > 0.20) &&
 813         ((cpi->twopass.this_frame_stats->intra_error / cpi->twopass.this_frame_stats->coded_error) > 2.0))
 814     {
 815         vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
 816     }
 817
 818     // swap frame pointers so last frame refers to the frame we just compressed
 819     vp8_swap_yv12_buffer(lst_yv12, new_yv12);
 820     vp8_yv12_extend_frame_borders(lst_yv12);
 821
 822     // Special case for the first frame. Copy into the GF buffer as a second reference.
 823     if (cm->current_video_frame == 0)
 824     {
 825         vp8_yv12_copy_frame_ptr(lst_yv12, gld_yv12);
 826     }
 827
 828
 829     // use this to see what the first pass reconstruction looks like
 830     if (0)
 831     {
 832         char filename[512];
 833         FILE *recon_file;
 834         sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
 835
 836         if (cm->current_video_frame == 0)
 837             recon_file = fopen(filename, "wb");
 838         else
 839             recon_file = fopen(filename, "ab");
 840
 841         if(fwrite(lst_yv12->buffer_alloc, lst_yv12->frame_size, 1, recon_file));
 842         fclose(recon_file);
 843     }
 844
 845     cm->current_video_frame++;
 846
 847 }
 848 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
 849
 850 #define BASE_ERRPERMB   150
 851 static int estimate_max_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
 852 {
 853     int Q;
 854     int num_mbs = cpi->common.MBs;
 855     int target_norm_bits_per_mb;
 856
 857     double err_per_mb = section_err / num_mbs;
 858     double correction_factor;
 859     double corr_high;
 860     double speed_correction = 1.0;
 861     double rolling_ratio;
 862
 863     double pow_highq = 0.90;
 864     double pow_lowq = 0.40;
 865
 866     if (section_target_bandwitdh <= 0)
 867         return cpi->twopass.maxq_max_limit;          // Highest value allowed
 868
 869     target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20)) ? (512 * section_target_bandwitdh) / num_mbs : 512 * (section_target_bandwitdh / num_mbs);
 870
 871     // Calculate a corrective factor based on a rolling ratio of bits spent vs target bits
 872     if ((cpi->rolling_target_bits > 0.0) && (cpi->active_worst_quality < cpi->worst_quality))
 873     {
 874         rolling_ratio = (double)cpi->rolling_actual_bits / (double)cpi->rolling_target_bits;
 875
 876         //if ( cpi->twopass.est_max_qcorrection_factor > rolling_ratio )
 877         if (rolling_ratio < 0.95)
 878             //cpi->twopass.est_max_qcorrection_factor *= adjustment_rate;
 879             cpi->twopass.est_max_qcorrection_factor -= 0.005;
 880         //else if ( cpi->twopass.est_max_qcorrection_factor < rolling_ratio )
 881         else if (rolling_ratio > 1.05)
 882             cpi->twopass.est_max_qcorrection_factor += 0.005;
 883
 884         //cpi->twopass.est_max_qcorrection_factor /= adjustment_rate;
 885
 886         cpi->twopass.est_max_qcorrection_factor = (cpi->twopass.est_max_qcorrection_factor < 0.1) ? 0.1 : (cpi->twopass.est_max_qcorrection_factor > 10.0) ? 10.0 : cpi->twopass.est_max_qcorrection_factor;
 887     }
 888
 889     // Corrections for higher compression speed settings (reduced compression expected)
 890     if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
 891     {
 892         if (cpi->oxcf.cpu_used <= 5)
 893             speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
 894         else
 895             speed_correction = 1.25;
 896     }
 897
 898     // Correction factor used for Q values >= 20
 899     corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
 900     corr_high = (corr_high < 0.05)
 901                     ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
 902
 903     // Try and pick a max Q that will be high enough to encode the
 904     // content at the given rate.
 905     for (Q = cpi->twopass.maxq_min_limit; Q < cpi->twopass.maxq_max_limit; Q++)
 906     {
 907         int bits_per_mb_at_this_q;
 908
 909         if (Q < 50)
 910         {
 911             correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
 912             correction_factor = (correction_factor < 0.05) ? 0.05 : (correction_factor > 5.0) ? 5.0 : correction_factor;
 913         }
 914         else
 915             correction_factor = corr_high;
 916
 917         bits_per_mb_at_this_q = (int)(.5 + correction_factor
 918             * speed_correction * cpi->twopass.est_max_qcorrection_factor
 919             * cpi->twopass.section_max_qfactor
 920             * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
 921         //bits_per_mb_at_this_q = (int)(.5 + correction_factor * speed_correction * cpi->twopass.est_max_qcorrection_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
 922
 923         if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
 924             break;
 925     }
 926
 927     // Restriction on active max q for constrained quality mode.
 928     if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
 929          (Q < cpi->cq_target_quality) )
 930          //(Q < cpi->oxcf.cq_level;) )
 931     {
 932         Q = cpi->cq_target_quality;
 933         //Q = cpi->oxcf.cq_level;
 934     }
 935
 936     // Adjust maxq_min_limit and maxq_max_limit limits based on
 937     // averaga q observed in clip for non kf/gf.arf frames
 938     // Give average a chance to settle though.
 939     if ( (cpi->ni_frames >
 940                   ((unsigned int)cpi->twopass.total_stats->count >> 8)) &&
 941          (cpi->ni_frames > 150) )
 942     {
 943         cpi->twopass.maxq_max_limit = ((cpi->ni_av_qi + 32) < cpi->worst_quality)
 944                                   ? (cpi->ni_av_qi + 32) : cpi->worst_quality;
 945         cpi->twopass.maxq_min_limit = ((cpi->ni_av_qi - 32) > cpi->best_quality)
 946                                   ? (cpi->ni_av_qi - 32) : cpi->best_quality;
 947     }
 948
 949     return Q;
 950 }
 951 static int estimate_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
 952 {
 953     int Q;
 954     int num_mbs = cpi->common.MBs;
 955     int target_norm_bits_per_mb;
 956
 957     double err_per_mb = section_err / num_mbs;
 958     double correction_factor;
 959     double corr_high;
 960     double speed_correction = 1.0;
 961     double pow_highq = 0.90;
 962     double pow_lowq = 0.40;
 963
 964     target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20)) ? (512 * section_target_bandwitdh) / num_mbs : 512 * (section_target_bandwitdh / num_mbs);
 965
 966     // Corrections for higher compression speed settings (reduced compression expected)
 967     if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
 968     {
 969         if (cpi->oxcf.cpu_used <= 5)
 970             speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
 971         else
 972             speed_correction = 1.25;
 973     }
 974
 975     // Correction factor used for Q values >= 20
 976     corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
 977     corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
 978
 979     // Try and pick a Q that can encode the content at the given rate.
 980     for (Q = 0; Q < MAXQ; Q++)
 981     {
 982         int bits_per_mb_at_this_q;
 983
 984         if (Q < 50)
 985         {
 986             correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
 987             correction_factor = (correction_factor < 0.05) ? 0.05 : (correction_factor > 5.0) ? 5.0 : correction_factor;
 988         }
 989         else
 990             correction_factor = corr_high;
 991
 992         bits_per_mb_at_this_q = (int)(.5 + correction_factor * speed_correction * cpi->twopass.est_max_qcorrection_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
 993
 994         if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
 995             break;
 996     }
 997
 998     return Q;
 999 }
1000
1001 // Estimate a worst case Q for a KF group
1002 static int estimate_kf_group_q(VP8_COMP *cpi, double section_err, int section_target_bandwitdh, double group_iiratio)
1003 {
1004     int Q;
1005     int num_mbs = cpi->common.MBs;
1006     int target_norm_bits_per_mb = (512 * section_target_bandwitdh) / num_mbs;
1007     int bits_per_mb_at_this_q;
1008
1009     double err_per_mb = section_err / num_mbs;
1010     double err_correction_factor;
1011     double corr_high;
1012     double speed_correction = 1.0;
1013     double current_spend_ratio = 1.0;
1014
1015     double pow_highq = (POW1 < 0.6) ? POW1 + 0.3 : 0.90;
1016     double pow_lowq = (POW1 < 0.7) ? POW1 + 0.1 : 0.80;
1017
1018     double iiratio_correction_factor = 1.0;
1019
1020     double combined_correction_factor;
1021
1022     // Trap special case where the target is <= 0
1023     if (target_norm_bits_per_mb <= 0)
1024         return MAXQ * 2;
1025
1026     // Calculate a corrective factor based on a rolling ratio of bits spent vs target bits
1027     // This is clamped to the range 0.1 to 10.0
1028     if (cpi->long_rolling_target_bits <= 0)
1029         current_spend_ratio = 10.0;
1030     else
1031     {
1032         current_spend_ratio = (double)cpi->long_rolling_actual_bits / (double)cpi->long_rolling_target_bits;
1033         current_spend_ratio = (current_spend_ratio > 10.0) ? 10.0 : (current_spend_ratio < 0.1) ? 0.1 : current_spend_ratio;
1034     }
1035
1036     // Calculate a correction factor based on the quality of prediction in the sequence as indicated by intra_inter error score ratio (IIRatio)
1037     // The idea here is to favour subsampling in the hardest sections vs the easyest.
1038     iiratio_correction_factor = 1.0 - ((group_iiratio - 6.0) * 0.1);
1039
1040     if (iiratio_correction_factor < 0.5)
1041         iiratio_correction_factor = 0.5;
1042
1043     // Corrections for higher compression speed settings (reduced compression expected)
1044     if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
1045     {
1046         if (cpi->oxcf.cpu_used <= 5)
1047             speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1048         else
1049             speed_correction = 1.25;
1050     }
1051
1052     // Combine the various factors calculated above
1053     combined_correction_factor = speed_correction * iiratio_correction_factor * current_spend_ratio;
1054
1055     // Correction factor used for Q values >= 20
1056     corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
1057     corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
1058
1059     // Try and pick a Q that should be high enough to encode the content at the given rate.
1060     for (Q = 0; Q < MAXQ; Q++)
1061     {
1062         // Q values < 20 treated as a special case
1063         if (Q < 20)
1064         {
1065             err_correction_factor = pow(err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
1066             err_correction_factor = (err_correction_factor < 0.05) ? 0.05 : (err_correction_factor > 5.0) ? 5.0 : err_correction_factor;
1067         }
1068         else
1069             err_correction_factor = corr_high;
1070
1071         bits_per_mb_at_this_q = (int)(.5 + err_correction_factor * combined_correction_factor * (double)vp8_bits_per_mb[INTER_FRAME][Q]);
1072
1073         if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
1074             break;
1075     }
1076
1077     // If we could not hit the target even at Max Q then estimate what Q would have bee required
1078     while ((bits_per_mb_at_this_q > target_norm_bits_per_mb)  && (Q < (MAXQ * 2)))
1079     {
1080
1081         bits_per_mb_at_this_q = (int)(0.96 * bits_per_mb_at_this_q);
1082         Q++;
1083     }
1084
1085     if (0)
1086     {
1087         FILE *f = fopen("estkf_q.stt", "a");
1088         fprintf(f, "%8d %8d %8d %8.2f %8.3f %8.2f %8.3f %8.3f %8.3f %8d\n", cpi->common.current_video_frame, bits_per_mb_at_this_q,
1089                 target_norm_bits_per_mb, err_per_mb, err_correction_factor,
1090                 current_spend_ratio, group_iiratio, iiratio_correction_factor,
1091                 (double)cpi->buffer_level / (double)cpi->oxcf.optimal_buffer_level, Q);
1092         fclose(f);
1093     }
1094
1095     return Q;
1096 }
1097
1098 // For cq mode estimate a cq level that matches the observed
1099 // complexity and data rate.
1100 static int estimate_cq(VP8_COMP *cpi, double section_err, int section_target_bandwitdh)
1101 {
1102     int Q;
1103     int num_mbs = cpi->common.MBs;
1104     int target_norm_bits_per_mb;
1105
1106     double err_per_mb = section_err / num_mbs;
1107     double correction_factor;
1108     double corr_high;
1109     double speed_correction = 1.0;
1110     double pow_highq = 0.90;
1111     double pow_lowq = 0.40;
1112     double clip_iiratio;
1113     double clip_iifactor;
1114
1115     target_norm_bits_per_mb = (section_target_bandwitdh < (1 << 20))
1116                               ? (512 * section_target_bandwitdh) / num_mbs
1117                               : 512 * (section_target_bandwitdh / num_mbs);
1118
1119     // Corrections for higher compression speed settings
1120     // (reduced compression expected)
1121     if ((cpi->compressor_speed == 3) || (cpi->compressor_speed == 1))
1122     {
1123         if (cpi->oxcf.cpu_used <= 5)
1124             speed_correction = 1.04 + (cpi->oxcf.cpu_used * 0.04);
1125         else
1126             speed_correction = 1.25;
1127     }
1128     // II ratio correction factor for clip as a whole
1129     clip_iiratio = cpi->twopass.total_stats->intra_error /
1130                    DOUBLE_DIVIDE_CHECK(cpi->twopass.total_stats->coded_error);
1131     clip_iifactor = 1.0 - ((clip_iiratio - 10.0) * 0.025);
1132     if (clip_iifactor < 0.80)
1133         clip_iifactor = 0.80;
1134
1135     // Correction factor used for Q values >= 20
1136     corr_high = pow(err_per_mb / BASE_ERRPERMB, pow_highq);
1137     corr_high = (corr_high < 0.05) ? 0.05 : (corr_high > 5.0) ? 5.0 : corr_high;
1138
1139     // Try and pick a Q that can encode the content at the given rate.
1140     for (Q = 0; Q < MAXQ; Q++)
1141     {
1142         int bits_per_mb_at_this_q;
1143
1144         if (Q < 50)
1145         {
1146             correction_factor =
1147                 pow( err_per_mb / BASE_ERRPERMB, (pow_lowq + Q * 0.01));
1148
1149             correction_factor = (correction_factor < 0.05) ? 0.05
1150                                     : (correction_factor > 5.0) ? 5.0
1151                                         : correction_factor;
1152         }
1153         else
1154             correction_factor = corr_high;
1155
1156         bits_per_mb_at_this_q =
1157             (int)( .5 + correction_factor *
1158                         speed_correction *
1159                         clip_iifactor *
1160                         (double)vp8_bits_per_mb[INTER_FRAME][Q] / 1.0);
1161
1162         if (bits_per_mb_at_this_q <= target_norm_bits_per_mb)
1163             break;
1164     }
1165
1166     return cq_level[Q];
1167 }
1168
1169 extern void vp8_new_frame_rate(VP8_COMP *cpi, double framerate);
1170
1171 void vp8_init_second_pass(VP8_COMP *cpi)
1172 {
1173     FIRSTPASS_STATS this_frame;
1174     FIRSTPASS_STATS *start_pos;
1175
1176     double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
1177
1178     zero_stats(cpi->twopass.total_stats);
1179
1180     if (!cpi->twopass.stats_in_end)
1181         return;
1182
1183     *cpi->twopass.total_stats = *cpi->twopass.stats_in_end;
1184
1185     cpi->twopass.total_error_left = cpi->twopass.total_stats->ssim_weighted_pred_err;
1186     cpi->twopass.total_intra_error_left = cpi->twopass.total_stats->intra_error;
1187     cpi->twopass.total_coded_error_left = cpi->twopass.total_stats->coded_error;
1188     cpi->twopass.start_tot_err_left = cpi->twopass.total_error_left;
1189
1190     //cpi->twopass.bits_left = (long long)(cpi->twopass.total_stats->count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
1191     //cpi->twopass.bits_left -= (long long)(cpi->twopass.total_stats->count * two_pass_min_rate / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
1192
1193     // each frame can have a different duration, as the frame rate in the source
1194     // isn't guaranteed to be constant.   The frame rate prior to the first frame
1195     // encoded in the second pass is a guess.  However the sum duration is not.
1196     // Its calculated based on the actual durations of all frames from the first
1197     // pass.
1198     vp8_new_frame_rate(cpi, 10000000.0 * cpi->twopass.total_stats->count / cpi->twopass.total_stats->duration);
1199
1200     cpi->output_frame_rate = cpi->oxcf.frame_rate;
1201     cpi->twopass.bits_left = (long long)(cpi->twopass.total_stats->duration * cpi->oxcf.target_bandwidth / 10000000.0) ;
1202     cpi->twopass.bits_left -= (long long)(cpi->twopass.total_stats->duration * two_pass_min_rate / 10000000.0);
1203     cpi->twopass.clip_bits_total = cpi->twopass.bits_left;
1204
1205     // Calculate a minimum intra value to be used in determining the IIratio
1206     // scores used in the second pass. We have this minimum to make sure
1207     // that clips that are static but "low complexity" in the intra domain
1208     // are still boosted appropriately for KF/GF/ARF
1209     cpi->twopass.kf_intra_err_min = KF_MB_INTRA_MIN * cpi->common.MBs;
1210     cpi->twopass.gf_intra_err_min = GF_MB_INTRA_MIN * cpi->common.MBs;
1211
1212     avg_stats(cpi->twopass.total_stats);
1213
1214     // Scan the first pass file and calculate an average Intra / Inter error score ratio for the sequence
1215     {
1216         double sum_iiratio = 0.0;
1217         double IIRatio;
1218
1219         start_pos = cpi->twopass.stats_in;               // Note starting "file" position
1220
1221         while (input_stats(cpi, &this_frame) != EOF)
1222         {
1223             IIRatio = this_frame.intra_error / DOUBLE_DIVIDE_CHECK(this_frame.coded_error);
1224             IIRatio = (IIRatio < 1.0) ? 1.0 : (IIRatio > 20.0) ? 20.0 : IIRatio;
1225             sum_iiratio += IIRatio;
1226         }
1227
1228         cpi->twopass.avg_iiratio = sum_iiratio / DOUBLE_DIVIDE_CHECK((double)cpi->twopass.total_stats->count);
1229
1230         // Reset file position
1231         reset_fpf_position(cpi, start_pos);
1232     }
1233
1234     // Scan the first pass file and calculate a modified total error based upon the bias/power function
1235     // used to allocate bits
1236     {
1237         start_pos = cpi->twopass.stats_in;               // Note starting "file" position
1238
1239         cpi->twopass.modified_error_total = 0.0;
1240         cpi->twopass.modified_error_used = 0.0;
1241
1242         while (input_stats(cpi, &this_frame) != EOF)
1243         {
1244             cpi->twopass.modified_error_total += calculate_modified_err(cpi, &this_frame);
1245         }
1246         cpi->twopass.modified_error_left = cpi->twopass.modified_error_total;
1247
1248         reset_fpf_position(cpi, start_pos);            // Reset file position
1249
1250     }
1251 }
1252
1253 void vp8_end_second_pass(VP8_COMP *cpi)
1254 {
1255 }
1256
1257 // This function gives and estimate of how badly we believe
1258 // the prediction quality is decaying from frame to frame.
1259 static double get_prediction_decay_rate(VP8_COMP *cpi, FIRSTPASS_STATS *next_frame)
1260 {
1261     double prediction_decay_rate;
1262     double motion_decay;
1263     double motion_pct = next_frame->pcnt_motion;
1264
1265
1266     // Initial basis is the % mbs inter coded
1267     prediction_decay_rate = next_frame->pcnt_inter;
1268
1269     // High % motion -> somewhat higher decay rate
1270     motion_decay = (1.0 - (motion_pct / 20.0));
1271     if (motion_decay < prediction_decay_rate)
1272         prediction_decay_rate = motion_decay;
1273
1274     // Adjustment to decay rate based on speed of motion
1275     {
1276         double this_mv_rabs;
1277         double this_mv_cabs;
1278         double distance_factor;
1279
1280         this_mv_rabs = fabs(next_frame->mvr_abs * motion_pct);
1281         this_mv_cabs = fabs(next_frame->mvc_abs * motion_pct);
1282
1283         distance_factor = sqrt((this_mv_rabs * this_mv_rabs) +
1284                                (this_mv_cabs * this_mv_cabs)) / 250.0;
1285         distance_factor = ((distance_factor > 1.0)
1286                                 ? 0.0 : (1.0 - distance_factor));
1287         if (distance_factor < prediction_decay_rate)
1288             prediction_decay_rate = distance_factor;
1289     }
1290
1291     return prediction_decay_rate;
1292 }
1293
1294 // Function to test for a condition where a complex transition is followed
1295 // by a static section. For example in slide shows where there is a fade
1296 // between slides. This is to help with more optimal kf and gf positioning.
1297 static int detect_transition_to_still(
1298     VP8_COMP *cpi,
1299     int frame_interval,
1300     int still_interval,
1301     double loop_decay_rate,
1302     double decay_accumulator )
1303 {
1304     BOOL trans_to_still = FALSE;
1305
1306     // Break clause to detect very still sections after motion
1307     // For example a static image after a fade or other transition
1308     // instead of a clean scene cut.
1309     if ( (frame_interval > MIN_GF_INTERVAL) &&
1310          (loop_decay_rate >= 0.999) &&
1311          (decay_accumulator < 0.9) )
1312     {
1313         int j;
1314         FIRSTPASS_STATS * position = cpi->twopass.stats_in;
1315         FIRSTPASS_STATS tmp_next_frame;
1316         double decay_rate;
1317
1318         // Look ahead a few frames to see if static condition
1319         // persists...
1320         for ( j = 0; j < still_interval; j++ )
1321         {
1322             if (EOF == input_stats(cpi, &tmp_next_frame))
1323                 break;
1324
1325             decay_rate = get_prediction_decay_rate(cpi, &tmp_next_frame);
1326             if ( decay_rate < 0.999 )
1327                 break;
1328         }
1329         // Reset file position
1330         reset_fpf_position(cpi, position);
1331
1332         // Only if it does do we signal a transition to still
1333         if ( j == still_interval )
1334             trans_to_still = TRUE;
1335     }
1336
1337     return trans_to_still;
1338 }
1339
1340 // Analyse and define a gf/arf group .
1341 static void define_gf_group(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
1342 {
1343     FIRSTPASS_STATS next_frame;
1344     FIRSTPASS_STATS *start_pos;
1345     int i;
1346     double boost_score = 0.0;
1347     double old_boost_score = 0.0;
1348     double gf_group_err = 0.0;
1349     double gf_first_frame_err = 0.0;
1350     double mod_frame_err = 0.0;
1351
1352     double mv_accumulator_rabs  = 0.0;
1353     double mv_accumulator_cabs  = 0.0;
1354     double mv_ratio_accumulator = 0.0;
1355     double decay_accumulator = 1.0;
1356
1357     double boost_factor = IIFACTOR;
1358     double loop_decay_rate = 1.00;          // Starting decay rate
1359
1360     double this_frame_mv_in_out = 0.0;
1361     double mv_in_out_accumulator = 0.0;
1362     double abs_mv_in_out_accumulator = 0.0;
1363     double mod_err_per_mb_accumulator = 0.0;
1364
1365     int max_bits = frame_max_bits(cpi);     // Max for a single frame
1366
1367     unsigned int allow_alt_ref =
1368                     cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames;
1369
1370     cpi->twopass.gf_group_bits = 0;
1371     cpi->twopass.gf_decay_rate = 0;
1372
1373     vp8_clear_system_state();  //__asm emms;
1374
1375     start_pos = cpi->twopass.stats_in;
1376
1377     vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
1378
1379     // Preload the stats for the next frame.
1380     mod_frame_err = calculate_modified_err(cpi, this_frame);
1381
1382     // Note the error of the frame at the start of the group (this will be
1383     // the GF frame error if we code a normal gf
1384     gf_first_frame_err = mod_frame_err;
1385
1386     // Special treatment if the current frame is a key frame (which is also
1387     // a gf). If it is then its error score (and hence bit allocation) need
1388     // to be subtracted out from the calculation for the GF group
1389     if (cpi->common.frame_type == KEY_FRAME)
1390         gf_group_err -= gf_first_frame_err;
1391
1392     // Scan forward to try and work out how many frames the next gf group
1393     // should contain and what level of boost is appropriate for the GF
1394     // or ARF that will be coded with the group
1395     i = 0;
1396
1397     while (((i < cpi->twopass.static_scene_max_gf_interval) ||
1398             ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)) &&
1399            (i < cpi->twopass.frames_to_key))
1400     {
1401         double r;
1402         double this_frame_mvr_ratio;
1403         double this_frame_mvc_ratio;
1404         //double motion_pct = next_frame.pcnt_motion;
1405         double motion_pct;
1406
1407         i++;    // Increment the loop counter
1408
1409         // Accumulate error score of frames in this gf group
1410         mod_frame_err = calculate_modified_err(cpi, this_frame);
1411
1412         gf_group_err += mod_frame_err;
1413
1414         mod_err_per_mb_accumulator +=
1415             mod_frame_err / DOUBLE_DIVIDE_CHECK((double)cpi->common.MBs);
1416
1417         if (EOF == input_stats(cpi, &next_frame))
1418             break;
1419
1420         // Accumulate motion stats.
1421         motion_pct = next_frame.pcnt_motion;
1422         mv_accumulator_rabs += fabs(next_frame.mvr_abs * motion_pct);
1423         mv_accumulator_cabs += fabs(next_frame.mvc_abs * motion_pct);
1424
1425         //Accumulate Motion In/Out of frame stats
1426         this_frame_mv_in_out =
1427             next_frame.mv_in_out_count * motion_pct;
1428         mv_in_out_accumulator +=
1429             next_frame.mv_in_out_count * motion_pct;
1430         abs_mv_in_out_accumulator +=
1431             fabs(next_frame.mv_in_out_count * motion_pct);
1432
1433         // If there is a significant amount of motion
1434         if (motion_pct > 0.05)
1435         {
1436             this_frame_mvr_ratio = fabs(next_frame.mvr_abs) /
1437                                    DOUBLE_DIVIDE_CHECK(fabs(next_frame.MVr));
1438
1439             this_frame_mvc_ratio = fabs(next_frame.mvc_abs) /
1440                                    DOUBLE_DIVIDE_CHECK(fabs(next_frame.MVc));
1441
1442             mv_ratio_accumulator +=
1443                 (this_frame_mvr_ratio < next_frame.mvr_abs)
1444                     ? (this_frame_mvr_ratio * motion_pct)
1445                     : next_frame.mvr_abs * motion_pct;
1446
1447             mv_ratio_accumulator +=
1448                 (this_frame_mvc_ratio < next_frame.mvc_abs)
1449                     ? (this_frame_mvc_ratio * motion_pct)
1450                     : next_frame.mvc_abs * motion_pct;
1451         }
1452         else
1453         {
1454             mv_ratio_accumulator += 0.0;
1455             this_frame_mvr_ratio = 1.0;
1456             this_frame_mvc_ratio = 1.0;
1457         }
1458
1459         // Underlying boost factor is based on inter intra error ratio
1460         r = ( boost_factor *
1461               ( next_frame.intra_error /
1462                 DOUBLE_DIVIDE_CHECK(next_frame.coded_error)));
1463
1464         if (next_frame.intra_error > cpi->twopass.gf_intra_err_min)
1465             r = (IIKFACTOR2 * next_frame.intra_error /
1466                      DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
1467         else
1468             r = (IIKFACTOR2 * cpi->twopass.gf_intra_err_min /
1469                      DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
1470
1471         // Increase boost for frames where new data coming into frame
1472         // (eg zoom out). Slightly reduce boost if there is a net balance
1473         // of motion out of the frame (zoom in).
1474         // The range for this_frame_mv_in_out is -1.0 to +1.0
1475         if (this_frame_mv_in_out > 0.0)
1476             r += r * (this_frame_mv_in_out * 2.0);
1477         // In extreme case boost is halved
1478         else
1479             r += r * (this_frame_mv_in_out / 2.0);
1480
1481         if (r > GF_RMAX)
1482             r = GF_RMAX;
1483
1484         loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
1485
1486         // Cumulative effect of decay
1487         decay_accumulator = decay_accumulator * loop_decay_rate;
1488         decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
1489
1490         boost_score += (decay_accumulator * r);
1491
1492         // Break clause to detect very still sections after motion
1493         // For example a staic image after a fade or other transition.
1494         if ( detect_transition_to_still( cpi, i, 5,
1495                                          loop_decay_rate, decay_accumulator ) )
1496         {
1497             allow_alt_ref = FALSE;
1498             boost_score = old_boost_score;
1499             break;
1500         }
1501
1502         // Break out conditions.
1503         if  (   /* i>4 || */
1504             // Break at cpi->max_gf_interval unless almost totally static
1505             (i >= cpi->max_gf_interval && (decay_accumulator < 0.995)) ||
1506             (
1507                 // Dont break out with a very short interval
1508                 (i > MIN_GF_INTERVAL) &&
1509                 // Dont break out very close to a key frame
1510                 ((cpi->twopass.frames_to_key - i) >= MIN_GF_INTERVAL) &&
1511                 ((boost_score > 20.0) || (next_frame.pcnt_inter < 0.75)) &&
1512                 ((mv_ratio_accumulator > 100.0) ||
1513                  (abs_mv_in_out_accumulator > 3.0) ||
1514                  (mv_in_out_accumulator < -2.0) ||
1515                  ((boost_score - old_boost_score) < 2.0))
1516             ) )
1517         {
1518             boost_score = old_boost_score;
1519             break;
1520         }
1521
1522         vpx_memcpy(this_frame, &next_frame, sizeof(*this_frame));
1523
1524         old_boost_score = boost_score;
1525     }
1526
1527     cpi->twopass.gf_decay_rate =
1528         (i > 0) ? (int)(100.0 * (1.0 - decay_accumulator)) / i : 0;
1529
1530     // When using CBR apply additional buffer related upper limits
1531     if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1532     {
1533         double max_boost;
1534
1535         // For cbr apply buffer related limits
1536         if (cpi->drop_frames_allowed)
1537         {
1538             int df_buffer_level = cpi->oxcf.drop_frames_water_mark *
1539                                   (cpi->oxcf.optimal_buffer_level / 100);
1540
1541             if (cpi->buffer_level > df_buffer_level)
1542                 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1543             else
1544                 max_boost = 0.0;
1545         }
1546         else if (cpi->buffer_level > 0)
1547         {
1548             max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
1549         }
1550         else
1551         {
1552             max_boost = 0.0;
1553         }
1554
1555         if (boost_score > max_boost)
1556             boost_score = max_boost;
1557     }
1558
1559     cpi->gfu_boost = (int)(boost_score * 100.0) >> 4;
1560
1561     // Dont allow conventional gf too near the next kf
1562     if ((cpi->twopass.frames_to_key - i) < MIN_GF_INTERVAL)
1563     {
1564         while (i < cpi->twopass.frames_to_key)
1565         {
1566             i++;
1567
1568             if (EOF == input_stats(cpi, this_frame))
1569                 break;
1570
1571             if (i < cpi->twopass.frames_to_key)
1572             {
1573                 mod_frame_err = calculate_modified_err(cpi, this_frame);
1574                 gf_group_err += mod_frame_err;
1575             }
1576         }
1577     }
1578
1579     // Should we use the alternate refernce frame
1580     if (allow_alt_ref &&
1581         (i >= MIN_GF_INTERVAL) &&
1582         // dont use ARF very near next kf
1583         (i <= (cpi->twopass.frames_to_key - MIN_GF_INTERVAL)) &&
1584         (((next_frame.pcnt_inter > 0.75) &&
1585           ((mv_in_out_accumulator / (double)i > -0.2) || (mv_in_out_accumulator > -2.0)) &&
1586           //(cpi->gfu_boost>150) &&
1587           (cpi->gfu_boost > 100) &&
1588           //(cpi->gfu_boost>AF_THRESH2) &&
1589           //((cpi->gfu_boost/i)>AF_THRESH) &&
1590           //(decay_accumulator > 0.5) &&
1591           (cpi->twopass.gf_decay_rate <= (ARF_DECAY_THRESH + (cpi->gfu_boost / 200)))
1592          )
1593         )
1594        )
1595     {
1596         int Boost;
1597         int allocation_chunks;
1598         int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1599         int tmp_q;
1600         int arf_frame_bits = 0;
1601         int group_bits;
1602
1603         // Estimate the bits to be allocated to the group as a whole
1604         if ((cpi->twopass.kf_group_bits > 0) && (cpi->twopass.kf_group_error_left > 0))
1605             group_bits = (int)((double)cpi->twopass.kf_group_bits * (gf_group_err / (double)cpi->twopass.kf_group_error_left));
1606         else
1607             group_bits = 0;
1608
1609         // Boost for arf frame
1610         Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
1611         Boost += (i * 50);
1612         allocation_chunks = (i * 100) + Boost;
1613
1614         // Normalize Altboost and allocations chunck down to prevent overflow
1615         while (Boost > 1000)
1616         {
1617             Boost /= 2;
1618             allocation_chunks /= 2;
1619         }
1620
1621         // Calculate the number of bits to be spent on the arf based on the boost number
1622         arf_frame_bits = (int)((double)Boost * (group_bits / (double)allocation_chunks));
1623
1624         // Estimate if there are enough bits available to make worthwhile use of an arf.
1625         tmp_q = estimate_q(cpi, mod_frame_err, (int)arf_frame_bits);
1626
1627         // Only use an arf if it is likely we will be able to code it at a lower Q than the surrounding frames.
1628         if (tmp_q < cpi->worst_quality)
1629         {
1630             int half_gf_int;
1631             int frames_after_arf;
1632             int frames_bwd = cpi->oxcf.arnr_max_frames - 1;
1633             int frames_fwd = cpi->oxcf.arnr_max_frames - 1;
1634
1635             cpi->source_alt_ref_pending = TRUE;
1636
1637             // For alt ref frames the error score for the end frame of the group (the alt ref frame) should not contribute to the group total and hence
1638             // the number of bit allocated to the group. Rather it forms part of the next group (it is the GF at the start of the next group)
1639             gf_group_err -= mod_frame_err;
1640
1641             // Set the interval till the next gf or arf. For ARFs this is the number of frames to be coded before the future frame that is coded as an ARF.
1642             // The future frame itself is part of the next group
1643             cpi->baseline_gf_interval = i - 1;
1644
1645             // Define the arnr filter width for this group of frames:
1646             // We only filter frames that lie within a distance of half
1647             // the GF interval from the ARF frame. We also have to trap
1648             // cases where the filter extends beyond the end of clip.
1649             // Note: this_frame->frame has been updated in the loop
1650             // so it now points at the ARF frame.
1651             half_gf_int = cpi->baseline_gf_interval >> 1;
1652             frames_after_arf = cpi->twopass.total_stats->count - this_frame->frame - 1;
1653
1654             switch (cpi->oxcf.arnr_type)
1655             {
1656             case 1: // Backward filter
1657                 frames_fwd = 0;
1658                 if (frames_bwd > half_gf_int)
1659                     frames_bwd = half_gf_int;
1660                 break;
1661
1662             case 2: // Forward filter
1663                 if (frames_fwd > half_gf_int)
1664                     frames_fwd = half_gf_int;
1665                 if (frames_fwd > frames_after_arf)
1666                     frames_fwd = frames_after_arf;
1667                 frames_bwd = 0;
1668                 break;
1669
1670             case 3: // Centered filter
1671             default:
1672                 frames_fwd >>= 1;
1673                 if (frames_fwd > frames_after_arf)
1674                     frames_fwd = frames_after_arf;
1675                 if (frames_fwd > half_gf_int)
1676                     frames_fwd = half_gf_int;
1677
1678                 frames_bwd = frames_fwd;
1679
1680                 // For even length filter there is one more frame backward
1681                 // than forward: e.g. len=6 ==> bbbAff, len=7 ==> bbbAfff.
1682                 if (frames_bwd < half_gf_int)
1683                     frames_bwd += (cpi->oxcf.arnr_max_frames+1) & 0x1;
1684                 break;
1685             }
1686
1687             cpi->active_arnr_frames = frames_bwd + 1 + frames_fwd;
1688         }
1689         else
1690         {
1691             cpi->source_alt_ref_pending = FALSE;
1692             cpi->baseline_gf_interval = i;
1693         }
1694     }
1695     else
1696     {
1697         cpi->source_alt_ref_pending = FALSE;
1698         cpi->baseline_gf_interval = i;
1699     }
1700
1701     // Now decide how many bits should be allocated to the GF group as  a proportion of those remaining in the kf group.
1702     // The final key frame group in the clip is treated as a special case where cpi->twopass.kf_group_bits is tied to cpi->twopass.bits_left.
1703     // This is also important for short clips where there may only be one key frame.
1704     if (cpi->twopass.frames_to_key >= (int)(cpi->twopass.total_stats->count - cpi->common.current_video_frame))
1705     {
1706         cpi->twopass.kf_group_bits = (cpi->twopass.bits_left > 0) ? cpi->twopass.bits_left : 0;
1707     }
1708
1709     // Calculate the bits to be allocated to the group as a whole
1710     if ((cpi->twopass.kf_group_bits > 0) && (cpi->twopass.kf_group_error_left > 0))
1711         cpi->twopass.gf_group_bits = (int)((double)cpi->twopass.kf_group_bits * (gf_group_err / (double)cpi->twopass.kf_group_error_left));
1712     else
1713         cpi->twopass.gf_group_bits = 0;
1714
1715     cpi->twopass.gf_group_bits = (cpi->twopass.gf_group_bits < 0) ? 0 : (cpi->twopass.gf_group_bits > cpi->twopass.kf_group_bits) ? cpi->twopass.kf_group_bits : cpi->twopass.gf_group_bits;
1716
1717     // Clip cpi->twopass.gf_group_bits based on user supplied data rate variability limit (cpi->oxcf.two_pass_vbrmax_section)
1718     if (cpi->twopass.gf_group_bits > max_bits * cpi->baseline_gf_interval)
1719         cpi->twopass.gf_group_bits = max_bits * cpi->baseline_gf_interval;
1720
1721     // Reset the file position
1722     reset_fpf_position(cpi, start_pos);
1723
1724     // Update the record of error used so far (only done once per gf group)
1725     cpi->twopass.modified_error_used += gf_group_err;
1726
1727     // Assign  bits to the arf or gf.
1728     {
1729         int Boost;
1730         int frames_in_section;
1731         int allocation_chunks;
1732         int Q = (cpi->oxcf.fixed_q < 0) ? cpi->last_q[INTER_FRAME] : cpi->oxcf.fixed_q;
1733
1734         // For ARF frames
1735         if (cpi->source_alt_ref_pending)
1736         {
1737             Boost = (cpi->gfu_boost * 3 * GFQ_ADJUSTMENT) / (2 * 100);
1738             //Boost += (cpi->baseline_gf_interval * 25);
1739             Boost += (cpi->baseline_gf_interval * 50);
1740
1741             // Set max and minimum boost and hence minimum allocation
1742             if (Boost > ((cpi->baseline_gf_interval + 1) * 200))
1743                 Boost = ((cpi->baseline_gf_interval + 1) * 200);
1744             else if (Boost < 125)
1745                 Boost = 125;
1746
1747             frames_in_section = cpi->baseline_gf_interval + 1;
1748             allocation_chunks = (frames_in_section * 100) + Boost;
1749         }
1750         // Else for standard golden frames
1751         else
1752         {
1753             // boost based on inter / intra ratio of subsequent frames
1754             Boost = (cpi->gfu_boost * GFQ_ADJUSTMENT) / 100;
1755
1756             // Set max and minimum boost and hence minimum allocation
1757             if (Boost > (cpi->baseline_gf_interval * 150))
1758                 Boost = (cpi->baseline_gf_interval * 150);
1759             else if (Boost < 125)
1760                 Boost = 125;
1761
1762             frames_in_section = cpi->baseline_gf_interval;
1763             allocation_chunks = (frames_in_section * 100) + (Boost - 100);
1764         }
1765
1766         // Normalize Altboost and allocations chunck down to prevent overflow
1767         while (Boost > 1000)
1768         {
1769             Boost /= 2;
1770             allocation_chunks /= 2;
1771         }
1772
1773         // Calculate the number of bits to be spent on the gf or arf based on the boost number
1774         cpi->twopass.gf_bits = (int)((double)Boost * (cpi->twopass.gf_group_bits / (double)allocation_chunks));
1775
1776         // If the frame that is to be boosted is simpler than the average for
1777         // the gf/arf group then use an alternative calculation
1778         // based on the error score of the frame itself
1779         if (mod_frame_err < gf_group_err / (double)cpi->baseline_gf_interval)
1780         {
1781             double  alt_gf_grp_bits;
1782             int     alt_gf_bits;
1783
1784             alt_gf_grp_bits =
1785                 (double)cpi->twopass.kf_group_bits  *
1786                 (mod_frame_err * (double)cpi->baseline_gf_interval) /
1787                 DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left);
1788
1789             alt_gf_bits = (int)((double)Boost * (alt_gf_grp_bits /
1790                                                  (double)allocation_chunks));
1791
1792             if (cpi->twopass.gf_bits > alt_gf_bits)
1793             {
1794                 cpi->twopass.gf_bits = alt_gf_bits;
1795             }
1796         }
1797         // Else if it is harder than other frames in the group make sure it at
1798         // least receives an allocation in keeping with its relative error
1799         // score, otherwise it may be worse off than an "un-boosted" frame
1800         else
1801         {
1802             int alt_gf_bits =
1803                 (int)((double)cpi->twopass.kf_group_bits *
1804                       mod_frame_err /
1805                       DOUBLE_DIVIDE_CHECK((double)cpi->twopass.kf_group_error_left));
1806
1807             if (alt_gf_bits > cpi->twopass.gf_bits)
1808             {
1809                 cpi->twopass.gf_bits = alt_gf_bits;
1810             }
1811         }
1812
1813         // Apply an additional limit for CBR
1814         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
1815         {
1816             if (cpi->twopass.gf_bits > (cpi->buffer_level >> 1))
1817                 cpi->twopass.gf_bits = cpi->buffer_level >> 1;
1818         }
1819
1820         // Dont allow a negative value for gf_bits
1821         if (cpi->twopass.gf_bits < 0)
1822             cpi->twopass.gf_bits = 0;
1823
1824         // Adjust KF group bits and error remainin
1825         cpi->twopass.kf_group_error_left -= gf_group_err;
1826         cpi->twopass.kf_group_bits -= cpi->twopass.gf_group_bits;
1827
1828         if (cpi->twopass.kf_group_bits < 0)
1829             cpi->twopass.kf_group_bits = 0;
1830
1831         // Note the error score left in the remaining frames of the group.
1832         // For normal GFs we want to remove the error score for the first frame of the group (except in Key frame case where this has already happened)
1833         if (!cpi->source_alt_ref_pending && cpi->common.frame_type != KEY_FRAME)
1834             cpi->twopass.gf_group_error_left = gf_group_err - gf_first_frame_err;
1835         else
1836             cpi->twopass.gf_group_error_left = gf_group_err;
1837
1838         cpi->twopass.gf_group_bits -= cpi->twopass.gf_bits;
1839
1840         if (cpi->twopass.gf_group_bits < 0)
1841             cpi->twopass.gf_group_bits = 0;
1842
1843         // Set aside some bits for a mid gf sequence boost
1844         if ((cpi->gfu_boost > 150) && (cpi->baseline_gf_interval > 5))
1845         {
1846             int pct_extra = (cpi->gfu_boost - 100) / 50;
1847             pct_extra = (pct_extra > 10) ? 10 : pct_extra;
1848
1849             cpi->twopass.mid_gf_extra_bits = (cpi->twopass.gf_group_bits * pct_extra) / 100;
1850             cpi->twopass.gf_group_bits -= cpi->twopass.mid_gf_extra_bits;
1851         }
1852         else
1853             cpi->twopass.mid_gf_extra_bits = 0;
1854
1855         cpi->twopass.gf_bits += cpi->min_frame_bandwidth;                                              // Add in minimum for a frame
1856     }
1857
1858     if (!cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))                  // Normal GF and not a KF
1859     {
1860         cpi->per_frame_bandwidth = cpi->twopass.gf_bits;                                               // Per frame bit target for this frame
1861     }
1862
1863     // Adjustment to estimate_max_q based on a measure of complexity of the section
1864     if (cpi->common.frame_type != KEY_FRAME)
1865     {
1866         FIRSTPASS_STATS sectionstats;
1867         double Ratio;
1868
1869         zero_stats(&sectionstats);
1870         reset_fpf_position(cpi, start_pos);
1871
1872         for (i = 0 ; i < cpi->baseline_gf_interval ; i++)
1873         {
1874             input_stats(cpi, &next_frame);
1875             accumulate_stats(&sectionstats, &next_frame);
1876         }
1877
1878         avg_stats(&sectionstats);
1879
1880         cpi->twopass.section_intra_rating =
1881             sectionstats.intra_error /
1882             DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
1883
1884         Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
1885         //if( (Ratio > 11) ) //&& (sectionstats.pcnt_second_ref < .20) )
1886         //{
1887         cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
1888
1889         if (cpi->twopass.section_max_qfactor < 0.80)
1890             cpi->twopass.section_max_qfactor = 0.80;
1891
1892         //}
1893         //else
1894         //    cpi->twopass.section_max_qfactor = 1.0;
1895
1896         reset_fpf_position(cpi, start_pos);
1897     }
1898 }
1899
1900 // Allocate bits to a normal frame that is neither a gf an arf or a key frame.
1901 static void assign_std_frame_bits(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
1902 {
1903     int    target_frame_size;                                                             // gf_group_error_left
1904
1905     double modified_err;
1906     double err_fraction;                                                                 // What portion of the remaining GF group error is used by this frame
1907
1908     int max_bits = frame_max_bits(cpi);    // Max for a single frame
1909
1910     // The final few frames have special treatment
1911     if (cpi->frames_till_gf_update_due >= (int)(cpi->twopass.total_stats->count - cpi->common.current_video_frame))
1912     {
1913         cpi->twopass.gf_group_bits = (cpi->twopass.bits_left > 0) ? cpi->twopass.bits_left : 0;;
1914     }
1915
1916     // Calculate modified prediction error used in bit allocation
1917     modified_err = calculate_modified_err(cpi, this_frame);
1918
1919     if (cpi->twopass.gf_group_error_left > 0)
1920         err_fraction = modified_err / cpi->twopass.gf_group_error_left;                              // What portion of the remaining GF group error is used by this frame
1921     else
1922         err_fraction = 0.0;
1923
1924     target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction);                    // How many of those bits available for allocation should we give it?
1925
1926     // Clip to target size to 0 - max_bits (or cpi->twopass.gf_group_bits) at the top end.
1927     if (target_frame_size < 0)
1928         target_frame_size = 0;
1929     else
1930     {
1931         if (target_frame_size > max_bits)
1932             target_frame_size = max_bits;
1933
1934         if (target_frame_size > cpi->twopass.gf_group_bits)
1935             target_frame_size = cpi->twopass.gf_group_bits;
1936     }
1937
1938     cpi->twopass.gf_group_error_left -= modified_err;                                               // Adjust error remaining
1939     cpi->twopass.gf_group_bits -= target_frame_size;                                                // Adjust bits remaining
1940
1941     if (cpi->twopass.gf_group_bits < 0)
1942         cpi->twopass.gf_group_bits = 0;
1943
1944     target_frame_size += cpi->min_frame_bandwidth;                                          // Add in the minimum number of bits that is set aside for every frame.
1945
1946     // Special case for the frame that lies half way between two gfs
1947     if (cpi->common.frames_since_golden == cpi->baseline_gf_interval / 2)
1948         target_frame_size += cpi->twopass.mid_gf_extra_bits;
1949
1950     cpi->per_frame_bandwidth = target_frame_size;                                           // Per frame bit target for this frame
1951 }
1952
1953 void vp8_second_pass(VP8_COMP *cpi)
1954 {
1955     int tmp_q;
1956     int frames_left = (int)(cpi->twopass.total_stats->count - cpi->common.current_video_frame);
1957
1958     FIRSTPASS_STATS this_frame;
1959     FIRSTPASS_STATS this_frame_copy;
1960
1961     double this_frame_error;
1962     double this_frame_intra_error;
1963     double this_frame_coded_error;
1964
1965     FIRSTPASS_STATS *start_pos;
1966
1967     if (!cpi->twopass.stats_in)
1968     {
1969         return ;
1970     }
1971
1972     vp8_clear_system_state();
1973
1974     if (EOF == input_stats(cpi, &this_frame))
1975         return;
1976
1977     this_frame_error = this_frame.ssim_weighted_pred_err;
1978     this_frame_intra_error = this_frame.intra_error;
1979     this_frame_coded_error = this_frame.coded_error;
1980
1981     start_pos = cpi->twopass.stats_in;
1982
1983     // keyframe and section processing !
1984     if (cpi->twopass.frames_to_key == 0)
1985     {
1986         // Define next KF group and assign bits to it
1987         vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
1988         find_next_key_frame(cpi, &this_frame_copy);
1989
1990         // Special case: Error error_resilient_mode mode does not make much sense for two pass but with its current meaning but this code is designed to stop
1991         // outlandish behaviour if someone does set it when using two pass. It effectively disables GF groups.
1992         // This is temporary code till we decide what should really happen in this case.
1993         if (cpi->oxcf.error_resilient_mode)
1994         {
1995             cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits;
1996             cpi->twopass.gf_group_error_left = cpi->twopass.kf_group_error_left;
1997             cpi->baseline_gf_interval = cpi->twopass.frames_to_key;
1998             cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
1999             cpi->source_alt_ref_pending = FALSE;
2000         }
2001
2002     }
2003
2004     // Is this a GF / ARF (Note that a KF is always also a GF)
2005     if (cpi->frames_till_gf_update_due == 0)
2006     {
2007         // Define next gf group and assign bits to it
2008         vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2009         define_gf_group(cpi, &this_frame_copy);
2010
2011         // If we are going to code an altref frame at the end of the group and the current frame is not a key frame....
2012         // If the previous group used an arf this frame has already benefited from that arf boost and it should not be given extra bits
2013         // If the previous group was NOT coded using arf we may want to apply some boost to this GF as well
2014         if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))
2015         {
2016             // Assign a standard frames worth of bits from those allocated to the GF group
2017             vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2018             assign_std_frame_bits(cpi, &this_frame_copy);
2019
2020             // If appropriate (we are switching into ARF active but it was not previously active) apply a boost for the gf at the start of the group.
2021             //if ( !cpi->source_alt_ref_active && (cpi->gfu_boost > 150) )
2022             if (FALSE)
2023             {
2024                 int extra_bits;
2025                 int pct_extra = (cpi->gfu_boost - 100) / 50;
2026
2027                 pct_extra = (pct_extra > 20) ? 20 : pct_extra;
2028
2029                 extra_bits = (cpi->twopass.gf_group_bits * pct_extra) / 100;
2030                 cpi->twopass.gf_group_bits -= extra_bits;
2031                 cpi->per_frame_bandwidth += extra_bits;
2032             }
2033         }
2034     }
2035
2036     // Otherwise this is an ordinary frame
2037     else
2038     {
2039         // Special case: Error error_resilient_mode mode does not make much sense for two pass but with its current meaning but this code is designed to stop
2040         // outlandish behaviour if someone does set it when using two pass. It effectively disables GF groups.
2041         // This is temporary code till we decide what should really happen in this case.
2042         if (cpi->oxcf.error_resilient_mode)
2043         {
2044             cpi->frames_till_gf_update_due = cpi->twopass.frames_to_key;
2045
2046             if (cpi->common.frame_type != KEY_FRAME)
2047             {
2048                 // Assign bits from those allocated to the GF group
2049                 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2050                 assign_std_frame_bits(cpi, &this_frame_copy);
2051             }
2052         }
2053         else
2054         {
2055             // Assign bits from those allocated to the GF group
2056             vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2057             assign_std_frame_bits(cpi, &this_frame_copy);
2058         }
2059     }
2060
2061     // Keep a globally available copy of this and the next frame's iiratio.
2062     cpi->twopass.this_iiratio = this_frame_intra_error /
2063                         DOUBLE_DIVIDE_CHECK(this_frame_coded_error);
2064     {
2065         FIRSTPASS_STATS next_frame;
2066         if ( lookup_next_frame_stats(cpi, &next_frame) != EOF )
2067         {
2068             cpi->twopass.next_iiratio = next_frame.intra_error /
2069                                 DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
2070         }
2071     }
2072
2073     // Set nominal per second bandwidth for this frame
2074     cpi->target_bandwidth = cpi->per_frame_bandwidth * cpi->output_frame_rate;
2075     if (cpi->target_bandwidth < 0)
2076         cpi->target_bandwidth = 0;
2077
2078     if (cpi->common.current_video_frame == 0)
2079     {
2080         cpi->twopass.est_max_qcorrection_factor = 1.0;
2081
2082         // Experimental code to try and set a cq_level in constrained
2083         // quality mode.
2084         if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY )
2085         {
2086             int est_cq;
2087
2088             est_cq =
2089                 estimate_cq( cpi,
2090                              (cpi->twopass.total_coded_error_left / frames_left),
2091                              (int)(cpi->twopass.bits_left / frames_left));
2092
2093             cpi->cq_target_quality = cpi->oxcf.cq_level;
2094             if ( est_cq > cpi->cq_target_quality )
2095                 cpi->cq_target_quality = est_cq;
2096         }
2097
2098         // guess at maxq needed in 2nd pass
2099         cpi->twopass.maxq_max_limit = cpi->worst_quality;
2100         cpi->twopass.maxq_min_limit = cpi->best_quality;
2101         tmp_q = estimate_max_q( cpi,
2102                                 (cpi->twopass.total_coded_error_left / frames_left),
2103                                 (int)(cpi->twopass.bits_left / frames_left));
2104
2105         // Limit the maxq value returned subsequently.
2106         // This increases the risk of overspend or underspend if the initial
2107         // estimate for the clip is bad, but helps prevent excessive
2108         // variation in Q, especially near the end of a clip
2109         // where for example a small overspend may cause Q to crash
2110         cpi->twopass.maxq_max_limit = ((tmp_q + 32) < cpi->worst_quality)
2111                                   ? (tmp_q + 32) : cpi->worst_quality;
2112         cpi->twopass.maxq_min_limit = ((tmp_q - 32) > cpi->best_quality)
2113                                   ? (tmp_q - 32) : cpi->best_quality;
2114
2115         cpi->active_worst_quality         = tmp_q;
2116         cpi->ni_av_qi                     = tmp_q;
2117     }
2118
2119     // The last few frames of a clip almost always have to few or too many
2120     // bits and for the sake of over exact rate control we dont want to make
2121     // radical adjustments to the allowed quantizer range just to use up a
2122     // few surplus bits or get beneath the target rate.
2123     else if ( (cpi->common.current_video_frame <
2124                   (((unsigned int)cpi->twopass.total_stats->count * 255)>>8)) &&
2125               ((cpi->common.current_video_frame + cpi->baseline_gf_interval) <
2126                   (unsigned int)cpi->twopass.total_stats->count) )
2127     {
2128         if (frames_left < 1)
2129             frames_left = 1;
2130
2131         tmp_q = estimate_max_q(cpi, (cpi->twopass.total_coded_error_left / frames_left), (int)(cpi->twopass.bits_left / frames_left));
2132
2133         // Move active_worst_quality but in a damped way
2134         if (tmp_q > cpi->active_worst_quality)
2135             cpi->active_worst_quality ++;
2136         else if (tmp_q < cpi->active_worst_quality)
2137             cpi->active_worst_quality --;
2138
2139         cpi->active_worst_quality = ((cpi->active_worst_quality * 3) + tmp_q + 2) / 4;
2140     }
2141
2142     cpi->twopass.frames_to_key --;
2143     cpi->twopass.total_error_left      -= this_frame_error;
2144     cpi->twopass.total_intra_error_left -= this_frame_intra_error;
2145     cpi->twopass.total_coded_error_left -= this_frame_coded_error;
2146 }
2147
2148
2149 static BOOL test_candidate_kf(VP8_COMP *cpi,  FIRSTPASS_STATS *last_frame, FIRSTPASS_STATS *this_frame, FIRSTPASS_STATS *next_frame)
2150 {
2151     BOOL is_viable_kf = FALSE;
2152
2153     // Does the frame satisfy the primary criteria of a key frame
2154     //      If so, then examine how well it predicts subsequent frames
2155     if ((this_frame->pcnt_second_ref < 0.10) &&
2156         (next_frame->pcnt_second_ref < 0.10) &&
2157         ((this_frame->pcnt_inter < 0.05) ||
2158          (
2159              ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) &&
2160              ((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
2161              ((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) ||
2162               (fabs(last_frame->intra_error - this_frame->intra_error) / DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > .40) ||
2163               ((next_frame->intra_error / DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5)
2164              )
2165          )
2166         )
2167        )
2168     {
2169         int i;
2170         FIRSTPASS_STATS *start_pos;
2171
2172         FIRSTPASS_STATS local_next_frame;
2173
2174         double boost_score = 0.0;
2175         double old_boost_score = 0.0;
2176         double decay_accumulator = 1.0;
2177         double next_iiratio;
2178
2179         vpx_memcpy(&local_next_frame, next_frame, sizeof(*next_frame));
2180
2181         // Note the starting file position so we can reset to it
2182         start_pos = cpi->twopass.stats_in;
2183
2184         // Examine how well the key frame predicts subsequent frames
2185         for (i = 0 ; i < 16; i++)
2186         {
2187             next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)) ;
2188
2189             if (next_iiratio > RMAX)
2190                 next_iiratio = RMAX;
2191
2192             // Cumulative effect of decay in prediction quality
2193             if (local_next_frame.pcnt_inter > 0.85)
2194                 decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2195             else
2196                 decay_accumulator = decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0);
2197
2198             //decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2199
2200             // Keep a running total
2201             boost_score += (decay_accumulator * next_iiratio);
2202
2203             // Test various breakout clauses
2204             if ((local_next_frame.pcnt_inter < 0.05) ||
2205                 (next_iiratio < 1.5) ||
2206                 (((local_next_frame.pcnt_inter -
2207                    local_next_frame.pcnt_neutral) < 0.20) &&
2208                  (next_iiratio < 3.0)) ||
2209                 ((boost_score - old_boost_score) < 0.5) ||
2210                 (local_next_frame.intra_error < 200)
2211                )
2212             {
2213                 break;
2214             }
2215
2216             old_boost_score = boost_score;
2217
2218             // Get the next frame details
2219             if (EOF == input_stats(cpi, &local_next_frame))
2220                 break;
2221         }
2222
2223         // If there is tolerable prediction for at least the next 3 frames then break out else discard this pottential key frame and move on
2224         if (boost_score > 5.0 && (i > 3))
2225             is_viable_kf = TRUE;
2226         else
2227         {
2228             // Reset the file position
2229             reset_fpf_position(cpi, start_pos);
2230
2231             is_viable_kf = FALSE;
2232         }
2233     }
2234
2235     return is_viable_kf;
2236 }
2237 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
2238 {
2239     int i,j;
2240     FIRSTPASS_STATS last_frame;
2241     FIRSTPASS_STATS first_frame;
2242     FIRSTPASS_STATS next_frame;
2243     FIRSTPASS_STATS *start_position;
2244
2245     double decay_accumulator = 1.0;
2246     double boost_score = 0;
2247     double old_boost_score = 0.0;
2248     double loop_decay_rate;
2249
2250     double kf_mod_err = 0.0;
2251     double kf_group_err = 0.0;
2252     double kf_group_intra_err = 0.0;
2253     double kf_group_coded_err = 0.0;
2254     double recent_loop_decay[8] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0};
2255
2256     vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
2257
2258     vp8_clear_system_state();  //__asm emms;
2259     start_position = cpi->twopass.stats_in;
2260
2261     cpi->common.frame_type = KEY_FRAME;
2262
2263     // is this a forced key frame by interval
2264     cpi->this_key_frame_forced = cpi->next_key_frame_forced;
2265
2266     // Clear the alt ref active flag as this can never be active on a key frame
2267     cpi->source_alt_ref_active = FALSE;
2268
2269     // Kf is always a gf so clear frames till next gf counter
2270     cpi->frames_till_gf_update_due = 0;
2271
2272     cpi->twopass.frames_to_key = 1;
2273
2274     // Take a copy of the initial frame details
2275     vpx_memcpy(&first_frame, this_frame, sizeof(*this_frame));
2276
2277     cpi->twopass.kf_group_bits = 0;        // Total bits avaialable to kf group
2278     cpi->twopass.kf_group_error_left = 0;  // Group modified error score.
2279
2280     kf_mod_err = calculate_modified_err(cpi, this_frame);
2281
2282     // find the next keyframe
2283     i = 0;
2284     while (cpi->twopass.stats_in < cpi->twopass.stats_in_end)
2285     {
2286         // Accumulate kf group error
2287         kf_group_err += calculate_modified_err(cpi, this_frame);
2288
2289         // These figures keep intra and coded error counts for all frames including key frames in the group.
2290         // The effect of the key frame itself can be subtracted out using the first_frame data collected above
2291         kf_group_intra_err += this_frame->intra_error;
2292         kf_group_coded_err += this_frame->coded_error;
2293
2294         // load a the next frame's stats
2295         vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame));
2296         input_stats(cpi, this_frame);
2297
2298         // Provided that we are not at the end of the file...
2299         if (cpi->oxcf.auto_key
2300             && lookup_next_frame_stats(cpi, &next_frame) != EOF)
2301         {
2302             // Normal scene cut check
2303             if (test_candidate_kf(cpi, &last_frame, this_frame, &next_frame))
2304                 break;
2305
2306             // How fast is prediction quality decaying
2307             loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2308
2309             // We want to know something about the recent past... rather than
2310             // as used elsewhere where we are concened with decay in prediction
2311             // quality since the last GF or KF.
2312             recent_loop_decay[i%8] = loop_decay_rate;
2313             decay_accumulator = 1.0;
2314             for (j = 0; j < 8; j++)
2315             {
2316                 decay_accumulator = decay_accumulator * recent_loop_decay[j];
2317             }
2318
2319             // Special check for transition or high motion followed by a
2320             // to a static scene.
2321             if ( detect_transition_to_still( cpi, i,
2322                                              (cpi->key_frame_frequency-i),
2323                                              loop_decay_rate,
2324                                              decay_accumulator ) )
2325             {
2326                 break;
2327             }
2328
2329
2330             // Step on to the next frame
2331             cpi->twopass.frames_to_key ++;
2332
2333             // If we don't have a real key frame within the next two
2334             // forcekeyframeevery intervals then break out of the loop.
2335             if (cpi->twopass.frames_to_key >= 2 *(int)cpi->key_frame_frequency)
2336                 break;
2337         } else
2338             cpi->twopass.frames_to_key ++;
2339
2340         i++;
2341     }
2342
2343     // If there is a max kf interval set by the user we must obey it.
2344     // We already breakout of the loop above at 2x max.
2345     // This code centers the extra kf if the actual natural
2346     // interval is between 1x and 2x
2347     if (cpi->oxcf.auto_key
2348         && cpi->twopass.frames_to_key > (int)cpi->key_frame_frequency )
2349     {
2350         FIRSTPASS_STATS *current_pos = cpi->twopass.stats_in;
2351         FIRSTPASS_STATS tmp_frame;
2352
2353         cpi->twopass.frames_to_key /= 2;
2354
2355         // Copy first frame details
2356         vpx_memcpy(&tmp_frame, &first_frame, sizeof(first_frame));
2357
2358         // Reset to the start of the group
2359         reset_fpf_position(cpi, start_position);
2360
2361         kf_group_err = 0;
2362         kf_group_intra_err = 0;
2363         kf_group_coded_err = 0;
2364
2365         // Rescan to get the correct error data for the forced kf group
2366         for( i = 0; i < cpi->twopass.frames_to_key; i++ )
2367         {
2368             // Accumulate kf group errors
2369             kf_group_err += calculate_modified_err(cpi, &tmp_frame);
2370             kf_group_intra_err += tmp_frame.intra_error;
2371             kf_group_coded_err += tmp_frame.coded_error;
2372
2373             // Load a the next frame's stats
2374             input_stats(cpi, &tmp_frame);
2375         }
2376
2377         // Reset to the start of the group
2378         reset_fpf_position(cpi, current_pos);
2379
2380         cpi->next_key_frame_forced = TRUE;
2381     }
2382     else
2383         cpi->next_key_frame_forced = FALSE;
2384
2385     // Special case for the last frame of the file
2386     if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end)
2387     {
2388         // Accumulate kf group error
2389         kf_group_err += calculate_modified_err(cpi, this_frame);
2390
2391         // These figures keep intra and coded error counts for all frames including key frames in the group.
2392         // The effect of the key frame itself can be subtracted out using the first_frame data collected above
2393         kf_group_intra_err += this_frame->intra_error;
2394         kf_group_coded_err += this_frame->coded_error;
2395     }
2396
2397     // Calculate the number of bits that should be assigned to the kf group.
2398     if ((cpi->twopass.bits_left > 0) && (cpi->twopass.modified_error_left > 0.0))
2399     {
2400         // Max for a single normal frame (not key frame)
2401         int max_bits = frame_max_bits(cpi);
2402
2403         // Maximum bits for the kf group
2404         long long max_grp_bits;
2405
2406         // Default allocation based on bits left and relative
2407         // complexity of the section
2408         cpi->twopass.kf_group_bits = (long long)( cpi->twopass.bits_left *
2409                                           ( kf_group_err /
2410                                             cpi->twopass.modified_error_left ));
2411
2412         // Clip based on maximum per frame rate defined by the user.
2413         max_grp_bits = (long long)max_bits * (long long)cpi->twopass.frames_to_key;
2414         if (cpi->twopass.kf_group_bits > max_grp_bits)
2415             cpi->twopass.kf_group_bits = max_grp_bits;
2416
2417         // Additional special case for CBR if buffer is getting full.
2418         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2419         {
2420             int opt_buffer_lvl = cpi->oxcf.optimal_buffer_level;
2421             int buffer_lvl = cpi->buffer_level;
2422
2423             // If the buffer is near or above the optimal and this kf group is
2424             // not being allocated much then increase the allocation a bit.
2425             if (buffer_lvl >= opt_buffer_lvl)
2426             {
2427                 int high_water_mark = (opt_buffer_lvl +
2428                                        cpi->oxcf.maximum_buffer_size) >> 1;
2429
2430                 long long av_group_bits;
2431
2432                 // Av bits per frame * number of frames
2433                 av_group_bits = (long long)cpi->av_per_frame_bandwidth *
2434                                 (long long)cpi->twopass.frames_to_key;
2435
2436                 // We are at or above the maximum.
2437                 if (cpi->buffer_level >= high_water_mark)
2438                 {
2439                     long long min_group_bits;
2440
2441                     min_group_bits = av_group_bits +
2442                                      (long long)(buffer_lvl -
2443                                                  high_water_mark);
2444
2445                     if (cpi->twopass.kf_group_bits < min_group_bits)
2446                         cpi->twopass.kf_group_bits = min_group_bits;
2447                 }
2448                 // We are above optimal but below the maximum
2449                 else if (cpi->twopass.kf_group_bits < av_group_bits)
2450                 {
2451                     long long bits_below_av = av_group_bits -
2452                                               cpi->twopass.kf_group_bits;
2453
2454                     cpi->twopass.kf_group_bits +=
2455                        (long long)((double)bits_below_av *
2456                                    (double)(buffer_lvl - opt_buffer_lvl) /
2457                                    (double)(high_water_mark - opt_buffer_lvl));
2458                 }
2459             }
2460         }
2461     }
2462     else
2463         cpi->twopass.kf_group_bits = 0;
2464
2465     // Reset the first pass file position
2466     reset_fpf_position(cpi, start_position);
2467
2468     // determine how big to make this keyframe based on how well the subsequent frames use inter blocks
2469     decay_accumulator = 1.0;
2470     boost_score = 0.0;
2471     loop_decay_rate = 1.00;       // Starting decay rate
2472
2473     for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
2474     {
2475         double r;
2476
2477         if (EOF == input_stats(cpi, &next_frame))
2478             break;
2479
2480         if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
2481             r = (IIKFACTOR2 * next_frame.intra_error /
2482                      DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2483         else
2484             r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min /
2485                      DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2486
2487         if (r > RMAX)
2488             r = RMAX;
2489
2490         // How fast is prediction quality decaying
2491         loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2492
2493         decay_accumulator = decay_accumulator * loop_decay_rate;
2494         decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
2495
2496         boost_score += (decay_accumulator * r);
2497
2498         if ((i > MIN_GF_INTERVAL) &&
2499             ((boost_score - old_boost_score) < 1.0))
2500         {
2501             break;
2502         }
2503
2504         old_boost_score = boost_score;
2505     }
2506
2507     if (1)
2508     {
2509         FIRSTPASS_STATS sectionstats;
2510         double Ratio;
2511
2512         zero_stats(&sectionstats);
2513         reset_fpf_position(cpi, start_position);
2514
2515         for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
2516         {
2517             input_stats(cpi, &next_frame);
2518             accumulate_stats(&sectionstats, &next_frame);
2519         }
2520
2521         avg_stats(&sectionstats);
2522
2523         cpi->twopass.section_intra_rating =
2524             sectionstats.intra_error
2525             / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2526
2527         Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2528         // if( (Ratio > 11) ) //&& (sectionstats.pcnt_second_ref < .20) )
2529         //{
2530         cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
2531
2532         if (cpi->twopass.section_max_qfactor < 0.80)
2533             cpi->twopass.section_max_qfactor = 0.80;
2534
2535         //}
2536         //else
2537         //    cpi->twopass.section_max_qfactor = 1.0;
2538     }
2539
2540     // When using CBR apply additional buffer fullness related upper limits
2541     if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2542     {
2543         double max_boost;
2544
2545         if (cpi->drop_frames_allowed)
2546         {
2547             int df_buffer_level = cpi->oxcf.drop_frames_water_mark * (cpi->oxcf.optimal_buffer_level / 100);
2548
2549             if (cpi->buffer_level > df_buffer_level)
2550                 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2551             else
2552                 max_boost = 0.0;
2553         }
2554         else if (cpi->buffer_level > 0)
2555         {
2556             max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2557         }
2558         else
2559         {
2560             max_boost = 0.0;
2561         }
2562
2563         if (boost_score > max_boost)
2564             boost_score = max_boost;
2565     }
2566
2567     // Reset the first pass file position
2568     reset_fpf_position(cpi, start_position);
2569
2570     // Work out how many bits to allocate for the key frame itself
2571     if (1)
2572     {
2573         int kf_boost = boost_score;
2574         int allocation_chunks;
2575         int Counter = cpi->twopass.frames_to_key;
2576         int alt_kf_bits;
2577         YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2578         // Min boost based on kf interval
2579 #if 0
2580
2581         while ((kf_boost < 48) && (Counter > 0))
2582         {
2583             Counter -= 2;
2584             kf_boost ++;
2585         }
2586
2587 #endif
2588
2589         if (kf_boost < 48)
2590         {
2591             kf_boost += ((Counter + 1) >> 1);
2592
2593             if (kf_boost > 48) kf_boost = 48;
2594         }
2595
2596         // bigger frame sizes need larger kf boosts, smaller frames smaller boosts...
2597         if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240))
2598             kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240);
2599         else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240))
2600             kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height);
2601
2602         kf_boost = (int)((double)kf_boost * 100.0) >> 4;                          // Scale 16 to 100
2603
2604         // Adjustment to boost based on recent average q
2605         //kf_boost = kf_boost * vp8_kf_boost_qadjustment[cpi->ni_av_qi] / 100;
2606
2607         if (kf_boost < 250)                                                      // Min KF boost
2608             kf_boost = 250;
2609
2610         // We do three calculations for kf size.
2611         // The first is based on the error score for the whole kf group.
2612         // The second (optionaly) on the key frames own error if this is smaller than the average for the group.
2613         // The final one insures that the frame receives at least the allocation it would have received based on its own error score vs the error score remaining
2614
2615         allocation_chunks = ((cpi->twopass.frames_to_key - 1) * 100) + kf_boost;           // cpi->twopass.frames_to_key-1 because key frame itself is taken care of by kf_boost
2616
2617         // Normalize Altboost and allocations chunck down to prevent overflow
2618         while (kf_boost > 1000)
2619         {
2620             kf_boost /= 2;
2621             allocation_chunks /= 2;
2622         }
2623
2624         cpi->twopass.kf_group_bits = (cpi->twopass.kf_group_bits < 0) ? 0 : cpi->twopass.kf_group_bits;
2625
2626         // Calculate the number of bits to be spent on the key frame
2627         cpi->twopass.kf_bits  = (int)((double)kf_boost * ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks));
2628
2629         // Apply an additional limit for CBR
2630         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2631         {
2632             if (cpi->twopass.kf_bits > ((3 * cpi->buffer_level) >> 2))
2633                 cpi->twopass.kf_bits = (3 * cpi->buffer_level) >> 2;
2634         }
2635
2636         // If the key frame is actually easier than the average for the
2637         // kf group (which does sometimes happen... eg a blank intro frame)
2638         // Then use an alternate calculation based on the kf error score
2639         // which should give a smaller key frame.
2640         if (kf_mod_err < kf_group_err / cpi->twopass.frames_to_key)
2641         {
2642             double  alt_kf_grp_bits =
2643                         ((double)cpi->twopass.bits_left *
2644                          (kf_mod_err * (double)cpi->twopass.frames_to_key) /
2645                          DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left));
2646
2647             alt_kf_bits = (int)((double)kf_boost *
2648                                 (alt_kf_grp_bits / (double)allocation_chunks));
2649
2650             if (cpi->twopass.kf_bits > alt_kf_bits)
2651             {
2652                 cpi->twopass.kf_bits = alt_kf_bits;
2653             }
2654         }
2655         // Else if it is much harder than other frames in the group make sure
2656         // it at least receives an allocation in keeping with its relative
2657         // error score
2658         else
2659         {
2660             alt_kf_bits =
2661                 (int)((double)cpi->twopass.bits_left *
2662                       (kf_mod_err /
2663                        DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left)));
2664
2665             if (alt_kf_bits > cpi->twopass.kf_bits)
2666             {
2667                 cpi->twopass.kf_bits = alt_kf_bits;
2668             }
2669         }
2670
2671         cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
2672         cpi->twopass.kf_bits += cpi->min_frame_bandwidth;                                          // Add in the minimum frame allowance
2673
2674         cpi->per_frame_bandwidth = cpi->twopass.kf_bits;                                           // Peer frame bit target for this frame
2675         cpi->target_bandwidth = cpi->twopass.kf_bits * cpi->output_frame_rate;                      // Convert to a per second bitrate
2676     }
2677
2678     // Note the total error score of the kf group minus the key frame itself
2679     cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err);
2680
2681     // Adjust the count of total modified error left.
2682     // The count of bits left is adjusted elsewhere based on real coded frame sizes
2683     cpi->twopass.modified_error_left -= kf_group_err;
2684
2685     if (cpi->oxcf.allow_spatial_resampling)
2686     {
2687         int resample_trigger = FALSE;
2688         int last_kf_resampled = FALSE;
2689         int kf_q;
2690         int scale_val = 0;
2691         int hr, hs, vr, vs;
2692         int new_width = cpi->oxcf.Width;
2693         int new_height = cpi->oxcf.Height;
2694
2695         int projected_buffer_level = cpi->buffer_level;
2696         int tmp_q;
2697
2698         double projected_bits_perframe;
2699         double group_iiratio = (kf_group_intra_err - first_frame.intra_error) / (kf_group_coded_err - first_frame.coded_error);
2700         double err_per_frame = kf_group_err / cpi->twopass.frames_to_key;
2701         double bits_per_frame;
2702         double av_bits_per_frame;
2703         double effective_size_ratio;
2704
2705         if ((cpi->common.Width != cpi->oxcf.Width) || (cpi->common.Height != cpi->oxcf.Height))
2706             last_kf_resampled = TRUE;
2707
2708         // Set back to unscaled by defaults
2709         cpi->common.horiz_scale = NORMAL;
2710         cpi->common.vert_scale = NORMAL;
2711
2712         // Calculate Average bits per frame.
2713         //av_bits_per_frame = cpi->twopass.bits_left/(double)(cpi->twopass.total_stats->count - cpi->common.current_video_frame);
2714         av_bits_per_frame = cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate);
2715         //if ( av_bits_per_frame < 0.0 )
2716         //  av_bits_per_frame = 0.0
2717
2718         // CBR... Use the clip average as the target for deciding resample
2719         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2720         {
2721             bits_per_frame = av_bits_per_frame;
2722         }
2723
2724         // In VBR we want to avoid downsampling in easy section unless we are under extreme pressure
2725         // So use the larger of target bitrate for this sectoion or average bitrate for sequence
2726         else
2727         {
2728             bits_per_frame = cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key;     // This accounts for how hard the section is...
2729
2730             if (bits_per_frame < av_bits_per_frame)                      // Dont turn to resampling in easy sections just because they have been assigned a small number of bits
2731                 bits_per_frame = av_bits_per_frame;
2732         }
2733
2734         // bits_per_frame should comply with our minimum
2735         if (bits_per_frame < (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100))
2736             bits_per_frame = (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
2737
2738         // Work out if spatial resampling is necessary
2739         kf_q = estimate_kf_group_q(cpi, err_per_frame, bits_per_frame, group_iiratio);
2740
2741         // If we project a required Q higher than the maximum allowed Q then make a guess at the actual size of frames in this section
2742         projected_bits_perframe = bits_per_frame;
2743         tmp_q = kf_q;
2744
2745         while (tmp_q > cpi->worst_quality)
2746         {
2747             projected_bits_perframe *= 1.04;
2748             tmp_q--;
2749         }
2750
2751         // Guess at buffer level at the end of the section
2752         projected_buffer_level = cpi->buffer_level - (int)((projected_bits_perframe - av_bits_per_frame) * cpi->twopass.frames_to_key);
2753
2754         if (0)
2755         {
2756             FILE *f = fopen("Subsamle.stt", "a");
2757             fprintf(f, " %8d %8d %8d %8d %12.0f %8d %8d %8d\n",  cpi->common.current_video_frame, kf_q, cpi->common.horiz_scale, cpi->common.vert_scale,  kf_group_err / cpi->twopass.frames_to_key, (int)(cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key), new_height, new_width);
2758             fclose(f);
2759         }
2760
2761         // The trigger for spatial resampling depends on the various parameters such as whether we are streaming (CBR) or VBR.
2762         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2763         {
2764             // Trigger resample if we are projected to fall below down sample level or
2765             // resampled last time and are projected to remain below the up sample level
2766             if ((projected_buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100)) ||
2767                 (last_kf_resampled && (projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))))
2768                 //( ((cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))) &&
2769                 //  ((projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))) ))
2770                 resample_trigger = TRUE;
2771             else
2772                 resample_trigger = FALSE;
2773         }
2774         else
2775         {
2776             long long clip_bits = (long long)(cpi->twopass.total_stats->count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
2777             long long over_spend = cpi->oxcf.starting_buffer_level - cpi->buffer_level;
2778
2779             if ((last_kf_resampled && (kf_q > cpi->worst_quality)) ||                                               // If triggered last time the threshold for triggering again is reduced
2780                 ((kf_q > cpi->worst_quality) &&                                                                  // Projected Q higher than allowed and ...
2781                  (over_spend > clip_bits / 20)))                                                               // ... Overspend > 5% of total bits
2782                 resample_trigger = TRUE;
2783             else
2784                 resample_trigger = FALSE;
2785
2786         }
2787
2788         if (resample_trigger)
2789         {
2790             while ((kf_q >= cpi->worst_quality) && (scale_val < 6))
2791             {
2792                 scale_val ++;
2793
2794                 cpi->common.vert_scale   = vscale_lookup[scale_val];
2795                 cpi->common.horiz_scale  = hscale_lookup[scale_val];
2796
2797                 Scale2Ratio(cpi->common.horiz_scale, &hr, &hs);
2798                 Scale2Ratio(cpi->common.vert_scale, &vr, &vs);
2799
2800                 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2801                 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2802
2803                 // Reducing the area to 1/4 does not reduce the complexity (err_per_frame) to 1/4...
2804                 // effective_sizeratio attempts to provide a crude correction for this
2805                 effective_size_ratio = (double)(new_width * new_height) / (double)(cpi->oxcf.Width * cpi->oxcf.Height);
2806                 effective_size_ratio = (1.0 + (3.0 * effective_size_ratio)) / 4.0;
2807
2808                 // Now try again and see what Q we get with the smaller image size
2809                 kf_q = estimate_kf_group_q(cpi, err_per_frame * effective_size_ratio, bits_per_frame, group_iiratio);
2810
2811                 if (0)
2812                 {
2813                     FILE *f = fopen("Subsamle.stt", "a");
2814                     fprintf(f, "******** %8d %8d %8d %12.0f %8d %8d %8d\n",  kf_q, cpi->common.horiz_scale, cpi->common.vert_scale,  kf_group_err / cpi->twopass.frames_to_key, (int)(cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key), new_height, new_width);
2815                     fclose(f);
2816                 }
2817             }
2818         }
2819
2820         if ((cpi->common.Width != new_width) || (cpi->common.Height != new_height))
2821         {
2822             cpi->common.Width = new_width;
2823             cpi->common.Height = new_height;
2824             vp8_alloc_compressor_data(cpi);
2825         }
2826     }
2827 }