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     // Calculate modified prediction error used in bit allocation
1911     modified_err = calculate_modified_err(cpi, this_frame);
1912
1913     if (cpi->twopass.gf_group_error_left > 0)
1914         err_fraction = modified_err / cpi->twopass.gf_group_error_left;                              // What portion of the remaining GF group error is used by this frame
1915     else
1916         err_fraction = 0.0;
1917
1918     target_frame_size = (int)((double)cpi->twopass.gf_group_bits * err_fraction);                    // How many of those bits available for allocation should we give it?
1919
1920     // Clip to target size to 0 - max_bits (or cpi->twopass.gf_group_bits) at the top end.
1921     if (target_frame_size < 0)
1922         target_frame_size = 0;
1923     else
1924     {
1925         if (target_frame_size > max_bits)
1926             target_frame_size = max_bits;
1927
1928         if (target_frame_size > cpi->twopass.gf_group_bits)
1929             target_frame_size = cpi->twopass.gf_group_bits;
1930     }
1931
1932     cpi->twopass.gf_group_error_left -= modified_err;                                               // Adjust error remaining
1933     cpi->twopass.gf_group_bits -= target_frame_size;                                                // Adjust bits remaining
1934
1935     if (cpi->twopass.gf_group_bits < 0)
1936         cpi->twopass.gf_group_bits = 0;
1937
1938     target_frame_size += cpi->min_frame_bandwidth;                                          // Add in the minimum number of bits that is set aside for every frame.
1939
1940     // Special case for the frame that lies half way between two gfs
1941     if (cpi->common.frames_since_golden == cpi->baseline_gf_interval / 2)
1942         target_frame_size += cpi->twopass.mid_gf_extra_bits;
1943
1944     cpi->per_frame_bandwidth = target_frame_size;                                           // Per frame bit target for this frame
1945 }
1946
1947 void vp8_second_pass(VP8_COMP *cpi)
1948 {
1949     int tmp_q;
1950     int frames_left = (int)(cpi->twopass.total_stats->count - cpi->common.current_video_frame);
1951
1952     FIRSTPASS_STATS this_frame;
1953     FIRSTPASS_STATS this_frame_copy;
1954
1955     double this_frame_error;
1956     double this_frame_intra_error;
1957     double this_frame_coded_error;
1958
1959     FIRSTPASS_STATS *start_pos;
1960
1961     if (!cpi->twopass.stats_in)
1962     {
1963         return ;
1964     }
1965
1966     vp8_clear_system_state();
1967
1968     if (EOF == input_stats(cpi, &this_frame))
1969         return;
1970
1971     this_frame_error = this_frame.ssim_weighted_pred_err;
1972     this_frame_intra_error = this_frame.intra_error;
1973     this_frame_coded_error = this_frame.coded_error;
1974
1975     start_pos = cpi->twopass.stats_in;
1976
1977     // keyframe and section processing !
1978     if (cpi->twopass.frames_to_key == 0)
1979     {
1980         // Define next KF group and assign bits to it
1981         vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
1982         find_next_key_frame(cpi, &this_frame_copy);
1983
1984         // 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
1985         // outlandish behaviour if someone does set it when using two pass. It effectively disables GF groups.
1986         // This is temporary code till we decide what should really happen in this case.
1987         if (cpi->oxcf.error_resilient_mode)
1988         {
1989             cpi->twopass.gf_group_bits = cpi->twopass.kf_group_bits;
1990             cpi->twopass.gf_group_error_left = cpi->twopass.kf_group_error_left;
1991             cpi->baseline_gf_interval = cpi->twopass.frames_to_key;
1992             cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
1993             cpi->source_alt_ref_pending = FALSE;
1994         }
1995
1996     }
1997
1998     // Is this a GF / ARF (Note that a KF is always also a GF)
1999     if (cpi->frames_till_gf_update_due == 0)
2000     {
2001         // Define next gf group and assign bits to it
2002         vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2003         define_gf_group(cpi, &this_frame_copy);
2004
2005         // If we are going to code an altref frame at the end of the group and the current frame is not a key frame....
2006         // If the previous group used an arf this frame has already benefited from that arf boost and it should not be given extra bits
2007         // If the previous group was NOT coded using arf we may want to apply some boost to this GF as well
2008         if (cpi->source_alt_ref_pending && (cpi->common.frame_type != KEY_FRAME))
2009         {
2010             // Assign a standard frames worth of bits from those allocated to the GF group
2011             vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2012             assign_std_frame_bits(cpi, &this_frame_copy);
2013
2014             // 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.
2015             //if ( !cpi->source_alt_ref_active && (cpi->gfu_boost > 150) )
2016             if (FALSE)
2017             {
2018                 int extra_bits;
2019                 int pct_extra = (cpi->gfu_boost - 100) / 50;
2020
2021                 pct_extra = (pct_extra > 20) ? 20 : pct_extra;
2022
2023                 extra_bits = (cpi->twopass.gf_group_bits * pct_extra) / 100;
2024                 cpi->twopass.gf_group_bits -= extra_bits;
2025                 cpi->per_frame_bandwidth += extra_bits;
2026             }
2027         }
2028     }
2029
2030     // Otherwise this is an ordinary frame
2031     else
2032     {
2033         // 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
2034         // outlandish behaviour if someone does set it when using two pass. It effectively disables GF groups.
2035         // This is temporary code till we decide what should really happen in this case.
2036         if (cpi->oxcf.error_resilient_mode)
2037         {
2038             cpi->frames_till_gf_update_due = cpi->twopass.frames_to_key;
2039
2040             if (cpi->common.frame_type != KEY_FRAME)
2041             {
2042                 // Assign bits from those allocated to the GF group
2043                 vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2044                 assign_std_frame_bits(cpi, &this_frame_copy);
2045             }
2046         }
2047         else
2048         {
2049             // Assign bits from those allocated to the GF group
2050             vpx_memcpy(&this_frame_copy, &this_frame, sizeof(this_frame));
2051             assign_std_frame_bits(cpi, &this_frame_copy);
2052         }
2053     }
2054
2055     // Keep a globally available copy of this and the next frame's iiratio.
2056     cpi->twopass.this_iiratio = this_frame_intra_error /
2057                         DOUBLE_DIVIDE_CHECK(this_frame_coded_error);
2058     {
2059         FIRSTPASS_STATS next_frame;
2060         if ( lookup_next_frame_stats(cpi, &next_frame) != EOF )
2061         {
2062             cpi->twopass.next_iiratio = next_frame.intra_error /
2063                                 DOUBLE_DIVIDE_CHECK(next_frame.coded_error);
2064         }
2065     }
2066
2067     // Set nominal per second bandwidth for this frame
2068     cpi->target_bandwidth = cpi->per_frame_bandwidth * cpi->output_frame_rate;
2069     if (cpi->target_bandwidth < 0)
2070         cpi->target_bandwidth = 0;
2071
2072     if (cpi->common.current_video_frame == 0)
2073     {
2074         cpi->twopass.est_max_qcorrection_factor = 1.0;
2075
2076         // Experimental code to try and set a cq_level in constrained
2077         // quality mode.
2078         if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY )
2079         {
2080             int est_cq;
2081
2082             est_cq =
2083                 estimate_cq( cpi,
2084                              (cpi->twopass.total_coded_error_left / frames_left),
2085                              (int)(cpi->twopass.bits_left / frames_left));
2086
2087             cpi->cq_target_quality = cpi->oxcf.cq_level;
2088             if ( est_cq > cpi->cq_target_quality )
2089                 cpi->cq_target_quality = est_cq;
2090         }
2091
2092         // guess at maxq needed in 2nd pass
2093         cpi->twopass.maxq_max_limit = cpi->worst_quality;
2094         cpi->twopass.maxq_min_limit = cpi->best_quality;
2095         tmp_q = estimate_max_q( cpi,
2096                                 (cpi->twopass.total_coded_error_left / frames_left),
2097                                 (int)(cpi->twopass.bits_left / frames_left));
2098
2099         // Limit the maxq value returned subsequently.
2100         // This increases the risk of overspend or underspend if the initial
2101         // estimate for the clip is bad, but helps prevent excessive
2102         // variation in Q, especially near the end of a clip
2103         // where for example a small overspend may cause Q to crash
2104         cpi->twopass.maxq_max_limit = ((tmp_q + 32) < cpi->worst_quality)
2105                                   ? (tmp_q + 32) : cpi->worst_quality;
2106         cpi->twopass.maxq_min_limit = ((tmp_q - 32) > cpi->best_quality)
2107                                   ? (tmp_q - 32) : cpi->best_quality;
2108
2109         cpi->active_worst_quality         = tmp_q;
2110         cpi->ni_av_qi                     = tmp_q;
2111     }
2112
2113     // The last few frames of a clip almost always have to few or too many
2114     // bits and for the sake of over exact rate control we dont want to make
2115     // radical adjustments to the allowed quantizer range just to use up a
2116     // few surplus bits or get beneath the target rate.
2117     else if ( (cpi->common.current_video_frame <
2118                   (((unsigned int)cpi->twopass.total_stats->count * 255)>>8)) &&
2119               ((cpi->common.current_video_frame + cpi->baseline_gf_interval) <
2120                   (unsigned int)cpi->twopass.total_stats->count) )
2121     {
2122         if (frames_left < 1)
2123             frames_left = 1;
2124
2125         tmp_q = estimate_max_q(cpi, (cpi->twopass.total_coded_error_left / frames_left), (int)(cpi->twopass.bits_left / frames_left));
2126
2127         // Move active_worst_quality but in a damped way
2128         if (tmp_q > cpi->active_worst_quality)
2129             cpi->active_worst_quality ++;
2130         else if (tmp_q < cpi->active_worst_quality)
2131             cpi->active_worst_quality --;
2132
2133         cpi->active_worst_quality = ((cpi->active_worst_quality * 3) + tmp_q + 2) / 4;
2134     }
2135
2136     cpi->twopass.frames_to_key --;
2137     cpi->twopass.total_error_left      -= this_frame_error;
2138     cpi->twopass.total_intra_error_left -= this_frame_intra_error;
2139     cpi->twopass.total_coded_error_left -= this_frame_coded_error;
2140 }
2141
2142
2143 static BOOL test_candidate_kf(VP8_COMP *cpi,  FIRSTPASS_STATS *last_frame, FIRSTPASS_STATS *this_frame, FIRSTPASS_STATS *next_frame)
2144 {
2145     BOOL is_viable_kf = FALSE;
2146
2147     // Does the frame satisfy the primary criteria of a key frame
2148     //      If so, then examine how well it predicts subsequent frames
2149     if ((this_frame->pcnt_second_ref < 0.10) &&
2150         (next_frame->pcnt_second_ref < 0.10) &&
2151         ((this_frame->pcnt_inter < 0.05) ||
2152          (
2153              ((this_frame->pcnt_inter - this_frame->pcnt_neutral) < .25) &&
2154              ((this_frame->intra_error / DOUBLE_DIVIDE_CHECK(this_frame->coded_error)) < 2.5) &&
2155              ((fabs(last_frame->coded_error - this_frame->coded_error) / DOUBLE_DIVIDE_CHECK(this_frame->coded_error) > .40) ||
2156               (fabs(last_frame->intra_error - this_frame->intra_error) / DOUBLE_DIVIDE_CHECK(this_frame->intra_error) > .40) ||
2157               ((next_frame->intra_error / DOUBLE_DIVIDE_CHECK(next_frame->coded_error)) > 3.5)
2158              )
2159          )
2160         )
2161        )
2162     {
2163         int i;
2164         FIRSTPASS_STATS *start_pos;
2165
2166         FIRSTPASS_STATS local_next_frame;
2167
2168         double boost_score = 0.0;
2169         double old_boost_score = 0.0;
2170         double decay_accumulator = 1.0;
2171         double next_iiratio;
2172
2173         vpx_memcpy(&local_next_frame, next_frame, sizeof(*next_frame));
2174
2175         // Note the starting file position so we can reset to it
2176         start_pos = cpi->twopass.stats_in;
2177
2178         // Examine how well the key frame predicts subsequent frames
2179         for (i = 0 ; i < 16; i++)
2180         {
2181             next_iiratio = (IIKFACTOR1 * local_next_frame.intra_error / DOUBLE_DIVIDE_CHECK(local_next_frame.coded_error)) ;
2182
2183             if (next_iiratio > RMAX)
2184                 next_iiratio = RMAX;
2185
2186             // Cumulative effect of decay in prediction quality
2187             if (local_next_frame.pcnt_inter > 0.85)
2188                 decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2189             else
2190                 decay_accumulator = decay_accumulator * ((0.85 + local_next_frame.pcnt_inter) / 2.0);
2191
2192             //decay_accumulator = decay_accumulator * local_next_frame.pcnt_inter;
2193
2194             // Keep a running total
2195             boost_score += (decay_accumulator * next_iiratio);
2196
2197             // Test various breakout clauses
2198             if ((local_next_frame.pcnt_inter < 0.05) ||
2199                 (next_iiratio < 1.5) ||
2200                 (((local_next_frame.pcnt_inter -
2201                    local_next_frame.pcnt_neutral) < 0.20) &&
2202                  (next_iiratio < 3.0)) ||
2203                 ((boost_score - old_boost_score) < 0.5) ||
2204                 (local_next_frame.intra_error < 200)
2205                )
2206             {
2207                 break;
2208             }
2209
2210             old_boost_score = boost_score;
2211
2212             // Get the next frame details
2213             if (EOF == input_stats(cpi, &local_next_frame))
2214                 break;
2215         }
2216
2217         // If there is tolerable prediction for at least the next 3 frames then break out else discard this pottential key frame and move on
2218         if (boost_score > 5.0 && (i > 3))
2219             is_viable_kf = TRUE;
2220         else
2221         {
2222             // Reset the file position
2223             reset_fpf_position(cpi, start_pos);
2224
2225             is_viable_kf = FALSE;
2226         }
2227     }
2228
2229     return is_viable_kf;
2230 }
2231 static void find_next_key_frame(VP8_COMP *cpi, FIRSTPASS_STATS *this_frame)
2232 {
2233     int i,j;
2234     FIRSTPASS_STATS last_frame;
2235     FIRSTPASS_STATS first_frame;
2236     FIRSTPASS_STATS next_frame;
2237     FIRSTPASS_STATS *start_position;
2238
2239     double decay_accumulator = 1.0;
2240     double boost_score = 0;
2241     double old_boost_score = 0.0;
2242     double loop_decay_rate;
2243
2244     double kf_mod_err = 0.0;
2245     double kf_group_err = 0.0;
2246     double kf_group_intra_err = 0.0;
2247     double kf_group_coded_err = 0.0;
2248     double recent_loop_decay[8] = {1.0,1.0,1.0,1.0,1.0,1.0,1.0,1.0};
2249
2250     vpx_memset(&next_frame, 0, sizeof(next_frame)); // assure clean
2251
2252     vp8_clear_system_state();  //__asm emms;
2253     start_position = cpi->twopass.stats_in;
2254
2255     cpi->common.frame_type = KEY_FRAME;
2256
2257     // is this a forced key frame by interval
2258     cpi->this_key_frame_forced = cpi->next_key_frame_forced;
2259
2260     // Clear the alt ref active flag as this can never be active on a key frame
2261     cpi->source_alt_ref_active = FALSE;
2262
2263     // Kf is always a gf so clear frames till next gf counter
2264     cpi->frames_till_gf_update_due = 0;
2265
2266     cpi->twopass.frames_to_key = 1;
2267
2268     // Take a copy of the initial frame details
2269     vpx_memcpy(&first_frame, this_frame, sizeof(*this_frame));
2270
2271     cpi->twopass.kf_group_bits = 0;        // Total bits avaialable to kf group
2272     cpi->twopass.kf_group_error_left = 0;  // Group modified error score.
2273
2274     kf_mod_err = calculate_modified_err(cpi, this_frame);
2275
2276     // find the next keyframe
2277     i = 0;
2278     while (cpi->twopass.stats_in < cpi->twopass.stats_in_end)
2279     {
2280         // Accumulate kf group error
2281         kf_group_err += calculate_modified_err(cpi, this_frame);
2282
2283         // These figures keep intra and coded error counts for all frames including key frames in the group.
2284         // The effect of the key frame itself can be subtracted out using the first_frame data collected above
2285         kf_group_intra_err += this_frame->intra_error;
2286         kf_group_coded_err += this_frame->coded_error;
2287
2288         // load a the next frame's stats
2289         vpx_memcpy(&last_frame, this_frame, sizeof(*this_frame));
2290         input_stats(cpi, this_frame);
2291
2292         // Provided that we are not at the end of the file...
2293         if (cpi->oxcf.auto_key
2294             && lookup_next_frame_stats(cpi, &next_frame) != EOF)
2295         {
2296             // Normal scene cut check
2297             if (test_candidate_kf(cpi, &last_frame, this_frame, &next_frame))
2298                 break;
2299
2300             // How fast is prediction quality decaying
2301             loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2302
2303             // We want to know something about the recent past... rather than
2304             // as used elsewhere where we are concened with decay in prediction
2305             // quality since the last GF or KF.
2306             recent_loop_decay[i%8] = loop_decay_rate;
2307             decay_accumulator = 1.0;
2308             for (j = 0; j < 8; j++)
2309             {
2310                 decay_accumulator = decay_accumulator * recent_loop_decay[j];
2311             }
2312
2313             // Special check for transition or high motion followed by a
2314             // to a static scene.
2315             if ( detect_transition_to_still( cpi, i,
2316                                              (cpi->key_frame_frequency-i),
2317                                              loop_decay_rate,
2318                                              decay_accumulator ) )
2319             {
2320                 break;
2321             }
2322
2323
2324             // Step on to the next frame
2325             cpi->twopass.frames_to_key ++;
2326
2327             // If we don't have a real key frame within the next two
2328             // forcekeyframeevery intervals then break out of the loop.
2329             if (cpi->twopass.frames_to_key >= 2 *(int)cpi->key_frame_frequency)
2330                 break;
2331         } else
2332             cpi->twopass.frames_to_key ++;
2333
2334         i++;
2335     }
2336
2337     // If there is a max kf interval set by the user we must obey it.
2338     // We already breakout of the loop above at 2x max.
2339     // This code centers the extra kf if the actual natural
2340     // interval is between 1x and 2x
2341     if (cpi->oxcf.auto_key
2342         && cpi->twopass.frames_to_key > (int)cpi->key_frame_frequency )
2343     {
2344         FIRSTPASS_STATS *current_pos = cpi->twopass.stats_in;
2345         FIRSTPASS_STATS tmp_frame;
2346
2347         cpi->twopass.frames_to_key /= 2;
2348
2349         // Copy first frame details
2350         vpx_memcpy(&tmp_frame, &first_frame, sizeof(first_frame));
2351
2352         // Reset to the start of the group
2353         reset_fpf_position(cpi, start_position);
2354
2355         kf_group_err = 0;
2356         kf_group_intra_err = 0;
2357         kf_group_coded_err = 0;
2358
2359         // Rescan to get the correct error data for the forced kf group
2360         for( i = 0; i < cpi->twopass.frames_to_key; i++ )
2361         {
2362             // Accumulate kf group errors
2363             kf_group_err += calculate_modified_err(cpi, &tmp_frame);
2364             kf_group_intra_err += tmp_frame.intra_error;
2365             kf_group_coded_err += tmp_frame.coded_error;
2366
2367             // Load a the next frame's stats
2368             input_stats(cpi, &tmp_frame);
2369         }
2370
2371         // Reset to the start of the group
2372         reset_fpf_position(cpi, current_pos);
2373
2374         cpi->next_key_frame_forced = TRUE;
2375     }
2376     else
2377         cpi->next_key_frame_forced = FALSE;
2378
2379     // Special case for the last frame of the file
2380     if (cpi->twopass.stats_in >= cpi->twopass.stats_in_end)
2381     {
2382         // Accumulate kf group error
2383         kf_group_err += calculate_modified_err(cpi, this_frame);
2384
2385         // These figures keep intra and coded error counts for all frames including key frames in the group.
2386         // The effect of the key frame itself can be subtracted out using the first_frame data collected above
2387         kf_group_intra_err += this_frame->intra_error;
2388         kf_group_coded_err += this_frame->coded_error;
2389     }
2390
2391     // Calculate the number of bits that should be assigned to the kf group.
2392     if ((cpi->twopass.bits_left > 0) && (cpi->twopass.modified_error_left > 0.0))
2393     {
2394         // Max for a single normal frame (not key frame)
2395         int max_bits = frame_max_bits(cpi);
2396
2397         // Maximum bits for the kf group
2398         long long max_grp_bits;
2399
2400         // Default allocation based on bits left and relative
2401         // complexity of the section
2402         cpi->twopass.kf_group_bits = (long long)( cpi->twopass.bits_left *
2403                                           ( kf_group_err /
2404                                             cpi->twopass.modified_error_left ));
2405
2406         // Clip based on maximum per frame rate defined by the user.
2407         max_grp_bits = (long long)max_bits * (long long)cpi->twopass.frames_to_key;
2408         if (cpi->twopass.kf_group_bits > max_grp_bits)
2409             cpi->twopass.kf_group_bits = max_grp_bits;
2410
2411         // Additional special case for CBR if buffer is getting full.
2412         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2413         {
2414             int opt_buffer_lvl = cpi->oxcf.optimal_buffer_level;
2415             int buffer_lvl = cpi->buffer_level;
2416
2417             // If the buffer is near or above the optimal and this kf group is
2418             // not being allocated much then increase the allocation a bit.
2419             if (buffer_lvl >= opt_buffer_lvl)
2420             {
2421                 int high_water_mark = (opt_buffer_lvl +
2422                                        cpi->oxcf.maximum_buffer_size) >> 1;
2423
2424                 long long av_group_bits;
2425
2426                 // Av bits per frame * number of frames
2427                 av_group_bits = (long long)cpi->av_per_frame_bandwidth *
2428                                 (long long)cpi->twopass.frames_to_key;
2429
2430                 // We are at or above the maximum.
2431                 if (cpi->buffer_level >= high_water_mark)
2432                 {
2433                     long long min_group_bits;
2434
2435                     min_group_bits = av_group_bits +
2436                                      (long long)(buffer_lvl -
2437                                                  high_water_mark);
2438
2439                     if (cpi->twopass.kf_group_bits < min_group_bits)
2440                         cpi->twopass.kf_group_bits = min_group_bits;
2441                 }
2442                 // We are above optimal but below the maximum
2443                 else if (cpi->twopass.kf_group_bits < av_group_bits)
2444                 {
2445                     long long bits_below_av = av_group_bits -
2446                                               cpi->twopass.kf_group_bits;
2447
2448                     cpi->twopass.kf_group_bits +=
2449                        (long long)((double)bits_below_av *
2450                                    (double)(buffer_lvl - opt_buffer_lvl) /
2451                                    (double)(high_water_mark - opt_buffer_lvl));
2452                 }
2453             }
2454         }
2455     }
2456     else
2457         cpi->twopass.kf_group_bits = 0;
2458
2459     // Reset the first pass file position
2460     reset_fpf_position(cpi, start_position);
2461
2462     // determine how big to make this keyframe based on how well the subsequent frames use inter blocks
2463     decay_accumulator = 1.0;
2464     boost_score = 0.0;
2465     loop_decay_rate = 1.00;       // Starting decay rate
2466
2467     for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
2468     {
2469         double r;
2470
2471         if (EOF == input_stats(cpi, &next_frame))
2472             break;
2473
2474         if (next_frame.intra_error > cpi->twopass.kf_intra_err_min)
2475             r = (IIKFACTOR2 * next_frame.intra_error /
2476                      DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2477         else
2478             r = (IIKFACTOR2 * cpi->twopass.kf_intra_err_min /
2479                      DOUBLE_DIVIDE_CHECK(next_frame.coded_error));
2480
2481         if (r > RMAX)
2482             r = RMAX;
2483
2484         // How fast is prediction quality decaying
2485         loop_decay_rate = get_prediction_decay_rate(cpi, &next_frame);
2486
2487         decay_accumulator = decay_accumulator * loop_decay_rate;
2488         decay_accumulator = decay_accumulator < 0.1 ? 0.1 : decay_accumulator;
2489
2490         boost_score += (decay_accumulator * r);
2491
2492         if ((i > MIN_GF_INTERVAL) &&
2493             ((boost_score - old_boost_score) < 1.0))
2494         {
2495             break;
2496         }
2497
2498         old_boost_score = boost_score;
2499     }
2500
2501     if (1)
2502     {
2503         FIRSTPASS_STATS sectionstats;
2504         double Ratio;
2505
2506         zero_stats(&sectionstats);
2507         reset_fpf_position(cpi, start_position);
2508
2509         for (i = 0 ; i < cpi->twopass.frames_to_key ; i++)
2510         {
2511             input_stats(cpi, &next_frame);
2512             accumulate_stats(&sectionstats, &next_frame);
2513         }
2514
2515         avg_stats(&sectionstats);
2516
2517         cpi->twopass.section_intra_rating =
2518             sectionstats.intra_error
2519             / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2520
2521         Ratio = sectionstats.intra_error / DOUBLE_DIVIDE_CHECK(sectionstats.coded_error);
2522         // if( (Ratio > 11) ) //&& (sectionstats.pcnt_second_ref < .20) )
2523         //{
2524         cpi->twopass.section_max_qfactor = 1.0 - ((Ratio - 10.0) * 0.025);
2525
2526         if (cpi->twopass.section_max_qfactor < 0.80)
2527             cpi->twopass.section_max_qfactor = 0.80;
2528
2529         //}
2530         //else
2531         //    cpi->twopass.section_max_qfactor = 1.0;
2532     }
2533
2534     // When using CBR apply additional buffer fullness related upper limits
2535     if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2536     {
2537         double max_boost;
2538
2539         if (cpi->drop_frames_allowed)
2540         {
2541             int df_buffer_level = cpi->oxcf.drop_frames_water_mark * (cpi->oxcf.optimal_buffer_level / 100);
2542
2543             if (cpi->buffer_level > df_buffer_level)
2544                 max_boost = ((double)((cpi->buffer_level - df_buffer_level) * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2545             else
2546                 max_boost = 0.0;
2547         }
2548         else if (cpi->buffer_level > 0)
2549         {
2550             max_boost = ((double)(cpi->buffer_level * 2 / 3) * 16.0) / DOUBLE_DIVIDE_CHECK((double)cpi->av_per_frame_bandwidth);
2551         }
2552         else
2553         {
2554             max_boost = 0.0;
2555         }
2556
2557         if (boost_score > max_boost)
2558             boost_score = max_boost;
2559     }
2560
2561     // Reset the first pass file position
2562     reset_fpf_position(cpi, start_position);
2563
2564     // Work out how many bits to allocate for the key frame itself
2565     if (1)
2566     {
2567         int kf_boost = boost_score;
2568         int allocation_chunks;
2569         int Counter = cpi->twopass.frames_to_key;
2570         int alt_kf_bits;
2571         YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2572         // Min boost based on kf interval
2573 #if 0
2574
2575         while ((kf_boost < 48) && (Counter > 0))
2576         {
2577             Counter -= 2;
2578             kf_boost ++;
2579         }
2580
2581 #endif
2582
2583         if (kf_boost < 48)
2584         {
2585             kf_boost += ((Counter + 1) >> 1);
2586
2587             if (kf_boost > 48) kf_boost = 48;
2588         }
2589
2590         // bigger frame sizes need larger kf boosts, smaller frames smaller boosts...
2591         if ((lst_yv12->y_width * lst_yv12->y_height) > (320 * 240))
2592             kf_boost += 2 * (lst_yv12->y_width * lst_yv12->y_height) / (320 * 240);
2593         else if ((lst_yv12->y_width * lst_yv12->y_height) < (320 * 240))
2594             kf_boost -= 4 * (320 * 240) / (lst_yv12->y_width * lst_yv12->y_height);
2595
2596         kf_boost = (int)((double)kf_boost * 100.0) >> 4;                          // Scale 16 to 100
2597
2598         // Adjustment to boost based on recent average q
2599         //kf_boost = kf_boost * vp8_kf_boost_qadjustment[cpi->ni_av_qi] / 100;
2600
2601         if (kf_boost < 250)                                                      // Min KF boost
2602             kf_boost = 250;
2603
2604         // We do three calculations for kf size.
2605         // The first is based on the error score for the whole kf group.
2606         // The second (optionaly) on the key frames own error if this is smaller than the average for the group.
2607         // 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
2608
2609         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
2610
2611         // Normalize Altboost and allocations chunck down to prevent overflow
2612         while (kf_boost > 1000)
2613         {
2614             kf_boost /= 2;
2615             allocation_chunks /= 2;
2616         }
2617
2618         cpi->twopass.kf_group_bits = (cpi->twopass.kf_group_bits < 0) ? 0 : cpi->twopass.kf_group_bits;
2619
2620         // Calculate the number of bits to be spent on the key frame
2621         cpi->twopass.kf_bits  = (int)((double)kf_boost * ((double)cpi->twopass.kf_group_bits / (double)allocation_chunks));
2622
2623         // Apply an additional limit for CBR
2624         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2625         {
2626             if (cpi->twopass.kf_bits > ((3 * cpi->buffer_level) >> 2))
2627                 cpi->twopass.kf_bits = (3 * cpi->buffer_level) >> 2;
2628         }
2629
2630         // If the key frame is actually easier than the average for the
2631         // kf group (which does sometimes happen... eg a blank intro frame)
2632         // Then use an alternate calculation based on the kf error score
2633         // which should give a smaller key frame.
2634         if (kf_mod_err < kf_group_err / cpi->twopass.frames_to_key)
2635         {
2636             double  alt_kf_grp_bits =
2637                         ((double)cpi->twopass.bits_left *
2638                          (kf_mod_err * (double)cpi->twopass.frames_to_key) /
2639                          DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left));
2640
2641             alt_kf_bits = (int)((double)kf_boost *
2642                                 (alt_kf_grp_bits / (double)allocation_chunks));
2643
2644             if (cpi->twopass.kf_bits > alt_kf_bits)
2645             {
2646                 cpi->twopass.kf_bits = alt_kf_bits;
2647             }
2648         }
2649         // Else if it is much harder than other frames in the group make sure
2650         // it at least receives an allocation in keeping with its relative
2651         // error score
2652         else
2653         {
2654             alt_kf_bits =
2655                 (int)((double)cpi->twopass.bits_left *
2656                       (kf_mod_err /
2657                        DOUBLE_DIVIDE_CHECK(cpi->twopass.modified_error_left)));
2658
2659             if (alt_kf_bits > cpi->twopass.kf_bits)
2660             {
2661                 cpi->twopass.kf_bits = alt_kf_bits;
2662             }
2663         }
2664
2665         cpi->twopass.kf_group_bits -= cpi->twopass.kf_bits;
2666         cpi->twopass.kf_bits += cpi->min_frame_bandwidth;                                          // Add in the minimum frame allowance
2667
2668         cpi->per_frame_bandwidth = cpi->twopass.kf_bits;                                           // Peer frame bit target for this frame
2669         cpi->target_bandwidth = cpi->twopass.kf_bits * cpi->output_frame_rate;                      // Convert to a per second bitrate
2670     }
2671
2672     // Note the total error score of the kf group minus the key frame itself
2673     cpi->twopass.kf_group_error_left = (int)(kf_group_err - kf_mod_err);
2674
2675     // Adjust the count of total modified error left.
2676     // The count of bits left is adjusted elsewhere based on real coded frame sizes
2677     cpi->twopass.modified_error_left -= kf_group_err;
2678
2679     if (cpi->oxcf.allow_spatial_resampling)
2680     {
2681         int resample_trigger = FALSE;
2682         int last_kf_resampled = FALSE;
2683         int kf_q;
2684         int scale_val = 0;
2685         int hr, hs, vr, vs;
2686         int new_width = cpi->oxcf.Width;
2687         int new_height = cpi->oxcf.Height;
2688
2689         int projected_buffer_level = cpi->buffer_level;
2690         int tmp_q;
2691
2692         double projected_bits_perframe;
2693         double group_iiratio = (kf_group_intra_err - first_frame.intra_error) / (kf_group_coded_err - first_frame.coded_error);
2694         double err_per_frame = kf_group_err / cpi->twopass.frames_to_key;
2695         double bits_per_frame;
2696         double av_bits_per_frame;
2697         double effective_size_ratio;
2698
2699         if ((cpi->common.Width != cpi->oxcf.Width) || (cpi->common.Height != cpi->oxcf.Height))
2700             last_kf_resampled = TRUE;
2701
2702         // Set back to unscaled by defaults
2703         cpi->common.horiz_scale = NORMAL;
2704         cpi->common.vert_scale = NORMAL;
2705
2706         // Calculate Average bits per frame.
2707         //av_bits_per_frame = cpi->twopass.bits_left/(double)(cpi->twopass.total_stats->count - cpi->common.current_video_frame);
2708         av_bits_per_frame = cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate);
2709         //if ( av_bits_per_frame < 0.0 )
2710         //  av_bits_per_frame = 0.0
2711
2712         // CBR... Use the clip average as the target for deciding resample
2713         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2714         {
2715             bits_per_frame = av_bits_per_frame;
2716         }
2717
2718         // In VBR we want to avoid downsampling in easy section unless we are under extreme pressure
2719         // So use the larger of target bitrate for this sectoion or average bitrate for sequence
2720         else
2721         {
2722             bits_per_frame = cpi->twopass.kf_group_bits / cpi->twopass.frames_to_key;     // This accounts for how hard the section is...
2723
2724             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
2725                 bits_per_frame = av_bits_per_frame;
2726         }
2727
2728         // bits_per_frame should comply with our minimum
2729         if (bits_per_frame < (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100))
2730             bits_per_frame = (cpi->oxcf.target_bandwidth * cpi->oxcf.two_pass_vbrmin_section / 100);
2731
2732         // Work out if spatial resampling is necessary
2733         kf_q = estimate_kf_group_q(cpi, err_per_frame, bits_per_frame, group_iiratio);
2734
2735         // 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
2736         projected_bits_perframe = bits_per_frame;
2737         tmp_q = kf_q;
2738
2739         while (tmp_q > cpi->worst_quality)
2740         {
2741             projected_bits_perframe *= 1.04;
2742             tmp_q--;
2743         }
2744
2745         // Guess at buffer level at the end of the section
2746         projected_buffer_level = cpi->buffer_level - (int)((projected_bits_perframe - av_bits_per_frame) * cpi->twopass.frames_to_key);
2747
2748         if (0)
2749         {
2750             FILE *f = fopen("Subsamle.stt", "a");
2751             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);
2752             fclose(f);
2753         }
2754
2755         // The trigger for spatial resampling depends on the various parameters such as whether we are streaming (CBR) or VBR.
2756         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
2757         {
2758             // Trigger resample if we are projected to fall below down sample level or
2759             // resampled last time and are projected to remain below the up sample level
2760             if ((projected_buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100)) ||
2761                 (last_kf_resampled && (projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))))
2762                 //( ((cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))) &&
2763                 //  ((projected_buffer_level < (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))) ))
2764                 resample_trigger = TRUE;
2765             else
2766                 resample_trigger = FALSE;
2767         }
2768         else
2769         {
2770             long long clip_bits = (long long)(cpi->twopass.total_stats->count * cpi->oxcf.target_bandwidth / DOUBLE_DIVIDE_CHECK((double)cpi->oxcf.frame_rate));
2771             long long over_spend = cpi->oxcf.starting_buffer_level - cpi->buffer_level;
2772
2773             if ((last_kf_resampled && (kf_q > cpi->worst_quality)) ||                                               // If triggered last time the threshold for triggering again is reduced
2774                 ((kf_q > cpi->worst_quality) &&                                                                  // Projected Q higher than allowed and ...
2775                  (over_spend > clip_bits / 20)))                                                               // ... Overspend > 5% of total bits
2776                 resample_trigger = TRUE;
2777             else
2778                 resample_trigger = FALSE;
2779
2780         }
2781
2782         if (resample_trigger)
2783         {
2784             while ((kf_q >= cpi->worst_quality) && (scale_val < 6))
2785             {
2786                 scale_val ++;
2787
2788                 cpi->common.vert_scale   = vscale_lookup[scale_val];
2789                 cpi->common.horiz_scale  = hscale_lookup[scale_val];
2790
2791                 Scale2Ratio(cpi->common.horiz_scale, &hr, &hs);
2792                 Scale2Ratio(cpi->common.vert_scale, &vr, &vs);
2793
2794                 new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2795                 new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2796
2797                 // Reducing the area to 1/4 does not reduce the complexity (err_per_frame) to 1/4...
2798                 // effective_sizeratio attempts to provide a crude correction for this
2799                 effective_size_ratio = (double)(new_width * new_height) / (double)(cpi->oxcf.Width * cpi->oxcf.Height);
2800                 effective_size_ratio = (1.0 + (3.0 * effective_size_ratio)) / 4.0;
2801
2802                 // Now try again and see what Q we get with the smaller image size
2803                 kf_q = estimate_kf_group_q(cpi, err_per_frame * effective_size_ratio, bits_per_frame, group_iiratio);
2804
2805                 if (0)
2806                 {
2807                     FILE *f = fopen("Subsamle.stt", "a");
2808                     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);
2809                     fclose(f);
2810                 }
2811             }
2812         }
2813
2814         if ((cpi->common.Width != new_width) || (cpi->common.Height != new_height))
2815         {
2816             cpi->common.Width = new_width;
2817             cpi->common.Height = new_height;
2818             vp8_alloc_compressor_data(cpi);
2819         }
2820     }
2821 }