vp8/encoder/onyx_if.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
  12 #include "vpx_config.h"
  13 #include "vp8/common/onyxc_int.h"
  14 #include "onyx_int.h"
  15 #include "vp8/common/systemdependent.h"
  16 #include "quantize.h"
  17 #include "vp8/common/alloccommon.h"
  18 #include "mcomp.h"
  19 #include "firstpass.h"
  20 #include "psnr.h"
  21 #include "vpx_scale/vpxscale.h"
  22 #include "vp8/common/extend.h"
  23 #include "ratectrl.h"
  24 #include "vp8/common/quant_common.h"
  25 #include "segmentation.h"
  26 #if CONFIG_POSTPROC
  27 #include "vp8/common/postproc.h"
  28 #endif
  29 #include "vpx_mem/vpx_mem.h"
  30 #include "vp8/common/swapyv12buffer.h"
  31 #include "vp8/common/threading.h"
  32 #include "vpx_ports/vpx_timer.h"
  33 #if ARCH_ARM
  34 #include "vpx_ports/arm.h"
  35 #endif
  36 #if CONFIG_MULTI_RES_ENCODING
  37 #include "mr_dissim.h"
  38 #endif
  39 #include "encodeframe.h"
  40
  41 #include <math.h>
  42 #include <stdio.h>
  43 #include <limits.h>
  44
  45 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
  46 extern int vp8_update_coef_context(VP8_COMP *cpi);
  47 extern void vp8_update_coef_probs(VP8_COMP *cpi);
  48 #endif
  49
  50 extern void vp8cx_pick_filter_level_fast(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
  51 extern void vp8cx_set_alt_lf_level(VP8_COMP *cpi, int filt_val);
  52 extern void vp8cx_pick_filter_level(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi);
  53
  54 extern void vp8_deblock_frame(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *post, int filt_lvl, int low_var_thresh, int flag);
  55 extern void print_parms(VP8_CONFIG *ocf, char *filenam);
  56 extern unsigned int vp8_get_processor_freq();
  57 extern void print_tree_update_probs();
  58 extern void vp8cx_create_encoder_threads(VP8_COMP *cpi);
  59 extern void vp8cx_remove_encoder_threads(VP8_COMP *cpi);
  60 #if HAVE_NEON
  61 extern void vp8_yv12_copy_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
  62 extern void vp8_yv12_copy_src_frame_func_neon(YV12_BUFFER_CONFIG *src_ybc, YV12_BUFFER_CONFIG *dst_ybc);
  63 #endif
  64
  65 int vp8_estimate_entropy_savings(VP8_COMP *cpi);
  66
  67 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest);
  68
  69 extern void vp8_temporal_filter_prepare_c(VP8_COMP *cpi, int distance);
  70
  71 static void set_default_lf_deltas(VP8_COMP *cpi);
  72
  73 extern const int vp8_gf_interval_table[101];
  74
  75 #if CONFIG_INTERNAL_STATS
  76 #include "math.h"
  77
  78 extern double vp8_calc_ssim
  79 (
  80     YV12_BUFFER_CONFIG *source,
  81     YV12_BUFFER_CONFIG *dest,
  82     int lumamask,
  83     double *weight
  84 );
  85
  86
  87 extern double vp8_calc_ssimg
  88 (
  89     YV12_BUFFER_CONFIG *source,
  90     YV12_BUFFER_CONFIG *dest,
  91     double *ssim_y,
  92     double *ssim_u,
  93     double *ssim_v
  94 );
  95
  96
  97 #endif
  98
  99
 100 #ifdef OUTPUT_YUV_SRC
 101 FILE *yuv_file;
 102 #endif
 103
 104 #if 0
 105 FILE *framepsnr;
 106 FILE *kf_list;
 107 FILE *keyfile;
 108 #endif
 109
 110 #if 0
 111 extern int skip_true_count;
 112 extern int skip_false_count;
 113 #endif
 114
 115
 116 #ifdef ENTROPY_STATS
 117 extern int intra_mode_stats[10][10][10];
 118 #endif
 119
 120 #ifdef SPEEDSTATS
 121 unsigned int frames_at_speed[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 122 unsigned int tot_pm = 0;
 123 unsigned int cnt_pm = 0;
 124 unsigned int tot_ef = 0;
 125 unsigned int cnt_ef = 0;
 126 #endif
 127
 128 #ifdef MODE_STATS
 129 extern unsigned __int64 Sectionbits[50];
 130 extern int y_modes[5]  ;
 131 extern int uv_modes[4] ;
 132 extern int b_modes[10]  ;
 133
 134 extern int inter_y_modes[10] ;
 135 extern int inter_uv_modes[4] ;
 136 extern unsigned int inter_b_modes[15];
 137 #endif
 138
 139 extern const int vp8_bits_per_mb[2][QINDEX_RANGE];
 140
 141 extern const int qrounding_factors[129];
 142 extern const int qzbin_factors[129];
 143 extern void vp8cx_init_quantizer(VP8_COMP *cpi);
 144 extern const int vp8cx_base_skip_false_prob[128];
 145
 146 // Tables relating active max Q to active min Q
 147 static const unsigned char kf_low_motion_minq[QINDEX_RANGE] =
 148 {
 149     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 150     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 151     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 152     0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
 153     3,3,3,3,3,3,4,4,4,5,5,5,5,5,6,6,
 154     6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
 155     11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
 156     16,16,17,17,18,18,18,18,19,20,20,21,21,22,23,23
 157 };
 158 static const unsigned char kf_high_motion_minq[QINDEX_RANGE] =
 159 {
 160     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 161     0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 162     1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,3,
 163     3,3,3,3,4,4,4,4,5,5,5,5,5,5,6,6,
 164     6,6,7,7,8,8,8,8,9,9,10,10,10,10,11,11,
 165     11,11,12,12,13,13,13,13,14,14,15,15,15,15,16,16,
 166     16,16,17,17,18,18,18,18,19,19,20,20,20,20,21,21,
 167     21,21,22,22,23,23,24,25,25,26,26,27,28,28,29,30
 168 };
 169 static const unsigned char gf_low_motion_minq[QINDEX_RANGE] =
 170 {
 171     0,0,0,0,1,1,1,1,1,1,1,1,2,2,2,2,
 172     3,3,3,3,4,4,4,4,5,5,5,5,6,6,6,6,
 173     7,7,7,7,8,8,8,8,9,9,9,9,10,10,10,10,
 174     11,11,12,12,13,13,14,14,15,15,16,16,17,17,18,18,
 175     19,19,20,20,21,21,22,22,23,23,24,24,25,25,26,26,
 176     27,27,28,28,29,29,30,30,31,31,32,32,33,33,34,34,
 177     35,35,36,36,37,37,38,38,39,39,40,40,41,41,42,42,
 178     43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
 179 };
 180 static const unsigned char gf_mid_motion_minq[QINDEX_RANGE] =
 181 {
 182     0,0,0,0,1,1,1,1,1,1,2,2,3,3,3,4,
 183     4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
 184     9,10,10,10,10,11,11,11,12,12,12,12,13,13,13,14,
 185     14,14,15,15,16,16,17,17,18,18,19,19,20,20,21,21,
 186     22,22,23,23,24,24,25,25,26,26,27,27,28,28,29,29,
 187     30,30,31,31,32,32,33,33,34,34,35,35,36,36,37,37,
 188     38,39,39,40,40,41,41,42,42,43,43,44,45,46,47,48,
 189     49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64
 190 };
 191 static const unsigned char gf_high_motion_minq[QINDEX_RANGE] =
 192 {
 193     0,0,0,0,1,1,1,1,1,2,2,2,3,3,3,4,
 194     4,4,5,5,5,6,6,6,7,7,7,8,8,8,9,9,
 195     9,10,10,10,11,11,12,12,13,13,14,14,15,15,16,16,
 196     17,17,18,18,19,19,20,20,21,21,22,22,23,23,24,24,
 197     25,25,26,26,27,27,28,28,29,29,30,30,31,31,32,32,
 198     33,33,34,34,35,35,36,36,37,37,38,38,39,39,40,40,
 199     41,41,42,42,43,44,45,46,47,48,49,50,51,52,53,54,
 200     55,56,57,58,59,60,62,64,66,68,70,72,74,76,78,80
 201 };
 202 static const unsigned char inter_minq[QINDEX_RANGE] =
 203 {
 204     0,0,1,1,2,3,3,4,4,5,6,6,7,8,8,9,
 205     9,10,11,11,12,13,13,14,15,15,16,17,17,18,19,20,
 206     20,21,22,22,23,24,24,25,26,27,27,28,29,30,30,31,
 207     32,33,33,34,35,36,36,37,38,39,39,40,41,42,42,43,
 208     44,45,46,46,47,48,49,50,50,51,52,53,54,55,55,56,
 209     57,58,59,60,60,61,62,63,64,65,66,67,67,68,69,70,
 210     71,72,73,74,75,75,76,77,78,79,80,81,82,83,84,85,
 211     86,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100
 212 };
 213
 214 #ifdef PACKET_TESTING
 215 extern FILE *vpxlogc;
 216 #endif
 217
 218 static void save_layer_context(VP8_COMP *cpi)
 219 {
 220     LAYER_CONTEXT *lc = &cpi->layer_context[cpi->current_layer];
 221
 222     // Save layer dependent coding state
 223     lc->target_bandwidth                 = cpi->target_bandwidth;
 224     //lc->target_bandwidth                 = cpi->oxcf.target_bandwidth;
 225     lc->starting_buffer_level            = cpi->oxcf.starting_buffer_level;
 226     lc->optimal_buffer_level             = cpi->oxcf.optimal_buffer_level;
 227     lc->maximum_buffer_size              = cpi->oxcf.maximum_buffer_size;
 228     lc->starting_buffer_level_in_ms      = cpi->oxcf.starting_buffer_level_in_ms;
 229     lc->optimal_buffer_level_in_ms       = cpi->oxcf.optimal_buffer_level_in_ms;
 230     lc->maximum_buffer_size_in_ms        = cpi->oxcf.maximum_buffer_size_in_ms;
 231     lc->buffer_level                     = cpi->buffer_level;
 232     lc->bits_off_target                  = cpi->bits_off_target;
 233     lc->total_actual_bits                = cpi->total_actual_bits;
 234     lc->worst_quality                    = cpi->worst_quality;
 235     lc->active_worst_quality             = cpi->active_worst_quality;
 236     lc->best_quality                     = cpi->best_quality;
 237     lc->active_best_quality              = cpi->active_best_quality;
 238     lc->ni_av_qi                         = cpi->ni_av_qi;
 239     lc->ni_tot_qi                        = cpi->ni_tot_qi;
 240     lc->ni_frames                        = cpi->ni_frames;
 241     lc->avg_frame_qindex                 = cpi->avg_frame_qindex;
 242     lc->rate_correction_factor           = cpi->rate_correction_factor;
 243     lc->key_frame_rate_correction_factor = cpi->key_frame_rate_correction_factor;
 244     lc->gf_rate_correction_factor        = cpi->gf_rate_correction_factor;
 245     lc->zbin_over_quant                  = cpi->zbin_over_quant;
 246     lc->inter_frame_target               = cpi->inter_frame_target;
 247     lc->total_byte_count                 = cpi->total_byte_count;
 248     lc->filter_level                     = cpi->common.filter_level;
 249
 250     lc->last_frame_percent_intra         = cpi->last_frame_percent_intra;
 251
 252     memcpy (lc->count_mb_ref_frame_usage,
 253             cpi->count_mb_ref_frame_usage,
 254             sizeof(cpi->count_mb_ref_frame_usage));
 255 }
 256
 257 static void restore_layer_context(VP8_COMP *cpi, const int layer)
 258 {
 259     LAYER_CONTEXT *lc = &cpi->layer_context[layer];
 260
 261     // Restore layer dependent coding state
 262     cpi->current_layer                    = layer;
 263     cpi->target_bandwidth                 = lc->target_bandwidth;
 264     cpi->oxcf.target_bandwidth            = lc->target_bandwidth;
 265     cpi->oxcf.starting_buffer_level       = lc->starting_buffer_level;
 266     cpi->oxcf.optimal_buffer_level        = lc->optimal_buffer_level;
 267     cpi->oxcf.maximum_buffer_size         = lc->maximum_buffer_size;
 268     cpi->oxcf.starting_buffer_level_in_ms = lc->starting_buffer_level_in_ms;
 269     cpi->oxcf.optimal_buffer_level_in_ms  = lc->optimal_buffer_level_in_ms;
 270     cpi->oxcf.maximum_buffer_size_in_ms   = lc->maximum_buffer_size_in_ms;
 271     cpi->buffer_level                     = lc->buffer_level;
 272     cpi->bits_off_target                  = lc->bits_off_target;
 273     cpi->total_actual_bits                = lc->total_actual_bits;
 274     //cpi->worst_quality                    = lc->worst_quality;
 275     cpi->active_worst_quality             = lc->active_worst_quality;
 276     //cpi->best_quality                     = lc->best_quality;
 277     cpi->active_best_quality              = lc->active_best_quality;
 278     cpi->ni_av_qi                         = lc->ni_av_qi;
 279     cpi->ni_tot_qi                        = lc->ni_tot_qi;
 280     cpi->ni_frames                        = lc->ni_frames;
 281     cpi->avg_frame_qindex                 = lc->avg_frame_qindex;
 282     cpi->rate_correction_factor           = lc->rate_correction_factor;
 283     cpi->key_frame_rate_correction_factor = lc->key_frame_rate_correction_factor;
 284     cpi->gf_rate_correction_factor        = lc->gf_rate_correction_factor;
 285     cpi->zbin_over_quant                  = lc->zbin_over_quant;
 286     cpi->inter_frame_target               = lc->inter_frame_target;
 287     cpi->total_byte_count                 = lc->total_byte_count;
 288     cpi->common.filter_level              = lc->filter_level;
 289
 290     cpi->last_frame_percent_intra         = lc->last_frame_percent_intra;
 291
 292     memcpy (cpi->count_mb_ref_frame_usage,
 293             lc->count_mb_ref_frame_usage,
 294             sizeof(cpi->count_mb_ref_frame_usage));
 295 }
 296
 297 static void setup_features(VP8_COMP *cpi)
 298 {
 299     // Set up default state for MB feature flags
 300     cpi->mb.e_mbd.segmentation_enabled = 0;
 301     cpi->mb.e_mbd.update_mb_segmentation_map = 0;
 302     cpi->mb.e_mbd.update_mb_segmentation_data = 0;
 303     vpx_memset(cpi->mb.e_mbd.mb_segment_tree_probs, 255, sizeof(cpi->mb.e_mbd.mb_segment_tree_probs));
 304     vpx_memset(cpi->mb.e_mbd.segment_feature_data, 0, sizeof(cpi->mb.e_mbd.segment_feature_data));
 305
 306     cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 0;
 307     cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
 308     vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
 309     vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
 310     vpx_memset(cpi->mb.e_mbd.last_ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
 311     vpx_memset(cpi->mb.e_mbd.last_mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
 312
 313     set_default_lf_deltas(cpi);
 314
 315 }
 316
 317
 318 static void dealloc_raw_frame_buffers(VP8_COMP *cpi);
 319
 320
 321 static void dealloc_compressor_data(VP8_COMP *cpi)
 322 {
 323     vpx_free(cpi->tplist);
 324     cpi->tplist = NULL;
 325
 326     // Delete last frame MV storage buffers
 327     vpx_free(cpi->lfmv);
 328     cpi->lfmv = 0;
 329
 330     vpx_free(cpi->lf_ref_frame_sign_bias);
 331     cpi->lf_ref_frame_sign_bias = 0;
 332
 333     vpx_free(cpi->lf_ref_frame);
 334     cpi->lf_ref_frame = 0;
 335
 336     // Delete sementation map
 337     vpx_free(cpi->segmentation_map);
 338     cpi->segmentation_map = 0;
 339
 340     vpx_free(cpi->active_map);
 341     cpi->active_map = 0;
 342
 343     vp8_de_alloc_frame_buffers(&cpi->common);
 344
 345     vp8_yv12_de_alloc_frame_buffer(&cpi->pick_lf_lvl_frame);
 346     vp8_yv12_de_alloc_frame_buffer(&cpi->scaled_source);
 347     dealloc_raw_frame_buffers(cpi);
 348
 349     vpx_free(cpi->tok);
 350     cpi->tok = 0;
 351
 352     // Structure used to monitor GF usage
 353     vpx_free(cpi->gf_active_flags);
 354     cpi->gf_active_flags = 0;
 355
 356     // Activity mask based per mb zbin adjustments
 357     vpx_free(cpi->mb_activity_map);
 358     cpi->mb_activity_map = 0;
 359     vpx_free(cpi->mb_norm_activity_map);
 360     cpi->mb_norm_activity_map = 0;
 361
 362     vpx_free(cpi->mb.pip);
 363     cpi->mb.pip = 0;
 364 }
 365
 366 static void enable_segmentation(VP8_COMP *cpi)
 367 {
 368     // Set the appropriate feature bit
 369     cpi->mb.e_mbd.segmentation_enabled = 1;
 370     cpi->mb.e_mbd.update_mb_segmentation_map = 1;
 371     cpi->mb.e_mbd.update_mb_segmentation_data = 1;
 372 }
 373 static void disable_segmentation(VP8_COMP *cpi)
 374 {
 375     // Clear the appropriate feature bit
 376     cpi->mb.e_mbd.segmentation_enabled = 0;
 377 }
 378
 379 // Valid values for a segment are 0 to 3
 380 // Segmentation map is arrange as [Rows][Columns]
 381 static void set_segmentation_map(VP8_COMP *cpi, unsigned char *segmentation_map)
 382 {
 383     // Copy in the new segmentation map
 384     vpx_memcpy(cpi->segmentation_map, segmentation_map, (cpi->common.mb_rows * cpi->common.mb_cols));
 385
 386     // Signal that the map should be updated.
 387     cpi->mb.e_mbd.update_mb_segmentation_map = 1;
 388     cpi->mb.e_mbd.update_mb_segmentation_data = 1;
 389 }
 390
 391 // The values given for each segment can be either deltas (from the default value chosen for the frame) or absolute values.
 392 //
 393 // Valid range for abs values is (0-127 for MB_LVL_ALT_Q) , (0-63 for SEGMENT_ALT_LF)
 394 // Valid range for delta values are (+/-127 for MB_LVL_ALT_Q) , (+/-63 for SEGMENT_ALT_LF)
 395 //
 396 // abs_delta = SEGMENT_DELTADATA (deltas) abs_delta = SEGMENT_ABSDATA (use the absolute values given).
 397 //
 398 //
 399 static void set_segment_data(VP8_COMP *cpi, signed char *feature_data, unsigned char abs_delta)
 400 {
 401     cpi->mb.e_mbd.mb_segement_abs_delta = abs_delta;
 402     vpx_memcpy(cpi->segment_feature_data, feature_data, sizeof(cpi->segment_feature_data));
 403 }
 404
 405
 406 static void segmentation_test_function(VP8_COMP *cpi)
 407 {
 408     unsigned char *seg_map;
 409     signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
 410
 411     // Create a temporary map for segmentation data.
 412     CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
 413
 414     // MB loop to set local segmentation map
 415     /*for ( i = 0; i < cpi->common.mb_rows; i++ )
 416     {
 417         for ( j = 0; j < cpi->common.mb_cols; j++ )
 418         {
 419             //seg_map[(i*cpi->common.mb_cols) + j] = (j % 2) + ((i%2)* 2);
 420             //if ( j < cpi->common.mb_cols/2 )
 421
 422             // Segment 1 around the edge else 0
 423             if ( (i == 0) || (j == 0) || (i == (cpi->common.mb_rows-1)) || (j == (cpi->common.mb_cols-1)) )
 424                 seg_map[(i*cpi->common.mb_cols) + j] = 1;
 425             //else if ( (i < 2) || (j < 2) || (i > (cpi->common.mb_rows-3)) || (j > (cpi->common.mb_cols-3)) )
 426             //  seg_map[(i*cpi->common.mb_cols) + j] = 2;
 427             //else if ( (i < 5) || (j < 5) || (i > (cpi->common.mb_rows-6)) || (j > (cpi->common.mb_cols-6)) )
 428             //  seg_map[(i*cpi->common.mb_cols) + j] = 3;
 429             else
 430                 seg_map[(i*cpi->common.mb_cols) + j] = 0;
 431         }
 432     }*/
 433
 434     // Set the segmentation Map
 435     set_segmentation_map(cpi, seg_map);
 436
 437     // Activate segmentation.
 438     enable_segmentation(cpi);
 439
 440     // Set up the quant segment data
 441     feature_data[MB_LVL_ALT_Q][0] = 0;
 442     feature_data[MB_LVL_ALT_Q][1] = 4;
 443     feature_data[MB_LVL_ALT_Q][2] = 0;
 444     feature_data[MB_LVL_ALT_Q][3] = 0;
 445     // Set up the loop segment data
 446     feature_data[MB_LVL_ALT_LF][0] = 0;
 447     feature_data[MB_LVL_ALT_LF][1] = 0;
 448     feature_data[MB_LVL_ALT_LF][2] = 0;
 449     feature_data[MB_LVL_ALT_LF][3] = 0;
 450
 451     // Initialise the feature data structure
 452     // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
 453     set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
 454
 455     // Delete sementation map
 456         vpx_free(seg_map);
 457
 458     seg_map = 0;
 459
 460 }
 461
 462 // A simple function to cyclically refresh the background at a lower Q
 463 static void cyclic_background_refresh(VP8_COMP *cpi, int Q, int lf_adjustment)
 464 {
 465     unsigned char *seg_map;
 466     signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
 467     int i;
 468     int block_count = cpi->cyclic_refresh_mode_max_mbs_perframe;
 469     int mbs_in_frame = cpi->common.mb_rows * cpi->common.mb_cols;
 470
 471     // Create a temporary map for segmentation data.
 472     CHECK_MEM_ERROR(seg_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
 473
 474     cpi->cyclic_refresh_q = Q;
 475
 476     for (i = Q; i > 0; i--)
 477     {
 478         if (vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*(Q + 128)) / 64))
 479             //if ( vp8_bits_per_mb[cpi->common.frame_type][i] >= ((vp8_bits_per_mb[cpi->common.frame_type][Q]*((2*Q)+96))/64) )
 480         {
 481             break;
 482         }
 483     }
 484
 485     cpi->cyclic_refresh_q = i;
 486
 487     // Only update for inter frames
 488     if (cpi->common.frame_type != KEY_FRAME)
 489     {
 490         // Cycle through the macro_block rows
 491         // MB loop to set local segmentation map
 492         for (i = cpi->cyclic_refresh_mode_index; i < mbs_in_frame; i++)
 493         {
 494             // If the MB is as a candidate for clean up then mark it for possible boost/refresh (segment 1)
 495             // The segment id may get reset to 0 later if the MB gets coded anything other than last frame 0,0
 496             // as only (last frame 0,0) MBs are eligable for refresh : that is to say Mbs likely to be background blocks.
 497             if (cpi->cyclic_refresh_map[i] == 0)
 498             {
 499                 seg_map[i] = 1;
 500             }
 501             else
 502             {
 503                 seg_map[i] = 0;
 504
 505                 // Skip blocks that have been refreshed recently anyway.
 506                 if (cpi->cyclic_refresh_map[i] < 0)
 507                     //cpi->cyclic_refresh_map[i] = cpi->cyclic_refresh_map[i] / 16;
 508                     cpi->cyclic_refresh_map[i]++;
 509             }
 510
 511
 512             if (block_count > 0)
 513                 block_count--;
 514             else
 515                 break;
 516
 517         }
 518
 519         // If we have gone through the frame reset to the start
 520         cpi->cyclic_refresh_mode_index = i;
 521
 522         if (cpi->cyclic_refresh_mode_index >= mbs_in_frame)
 523             cpi->cyclic_refresh_mode_index = 0;
 524     }
 525
 526     // Set the segmentation Map
 527     set_segmentation_map(cpi, seg_map);
 528
 529     // Activate segmentation.
 530     enable_segmentation(cpi);
 531
 532     // Set up the quant segment data
 533     feature_data[MB_LVL_ALT_Q][0] = 0;
 534     feature_data[MB_LVL_ALT_Q][1] = (cpi->cyclic_refresh_q - Q);
 535     feature_data[MB_LVL_ALT_Q][2] = 0;
 536     feature_data[MB_LVL_ALT_Q][3] = 0;
 537
 538     // Set up the loop segment data
 539     feature_data[MB_LVL_ALT_LF][0] = 0;
 540     feature_data[MB_LVL_ALT_LF][1] = lf_adjustment;
 541     feature_data[MB_LVL_ALT_LF][2] = 0;
 542     feature_data[MB_LVL_ALT_LF][3] = 0;
 543
 544     // Initialise the feature data structure
 545     // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
 546     set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
 547
 548     // Delete sementation map
 549     vpx_free(seg_map);
 550
 551     seg_map = 0;
 552
 553 }
 554
 555 static void set_default_lf_deltas(VP8_COMP *cpi)
 556 {
 557     cpi->mb.e_mbd.mode_ref_lf_delta_enabled = 1;
 558     cpi->mb.e_mbd.mode_ref_lf_delta_update = 1;
 559
 560     vpx_memset(cpi->mb.e_mbd.ref_lf_deltas, 0, sizeof(cpi->mb.e_mbd.ref_lf_deltas));
 561     vpx_memset(cpi->mb.e_mbd.mode_lf_deltas, 0, sizeof(cpi->mb.e_mbd.mode_lf_deltas));
 562
 563     // Test of ref frame deltas
 564     cpi->mb.e_mbd.ref_lf_deltas[INTRA_FRAME] = 2;
 565     cpi->mb.e_mbd.ref_lf_deltas[LAST_FRAME] = 0;
 566     cpi->mb.e_mbd.ref_lf_deltas[GOLDEN_FRAME] = -2;
 567     cpi->mb.e_mbd.ref_lf_deltas[ALTREF_FRAME] = -2;
 568
 569     cpi->mb.e_mbd.mode_lf_deltas[0] = 4;               // BPRED
 570     cpi->mb.e_mbd.mode_lf_deltas[1] = -2;              // Zero
 571     cpi->mb.e_mbd.mode_lf_deltas[2] = 2;               // New mv
 572     cpi->mb.e_mbd.mode_lf_deltas[3] = 4;               // Split mv
 573 }
 574
 575 /* Convenience macros for mapping speed and mode into a continuous
 576  * range
 577  */
 578 #define GOOD(x) (x+1)
 579 #define RT(x) (x+7)
 580
 581 static int speed_map(int speed, const int *map)
 582 {
 583     int res;
 584
 585     do
 586     {
 587         res = *map++;
 588     } while(speed >= *map++);
 589     return res;
 590 }
 591
 592 static const int thresh_mult_map_znn[] = {
 593     /* map common to zero, nearest, and near */
 594     0, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(2), 2000, INT_MAX
 595 };
 596
 597 static const int thresh_mult_map_vhpred[] = {
 598     1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 1000, RT(1), 2000,
 599     RT(7), INT_MAX, INT_MAX
 600 };
 601
 602 static const int thresh_mult_map_bpred[] = {
 603     2000, GOOD(0), 2500, GOOD(2), 5000, GOOD(3), 7500, RT(0), 2500, RT(1), 5000,
 604     RT(6), INT_MAX, INT_MAX
 605 };
 606
 607 static const int thresh_mult_map_tm[] = {
 608     1000, GOOD(2), 1500, GOOD(3), 2000, RT(0), 0, RT(1), 1000, RT(2), 2000,
 609     RT(7), INT_MAX, INT_MAX
 610 };
 611
 612 static const int thresh_mult_map_new1[] = {
 613     1000, GOOD(2), 2000, RT(0), 2000, INT_MAX
 614 };
 615
 616 static const int thresh_mult_map_new2[] = {
 617     1000, GOOD(2), 2000, GOOD(3), 2500, GOOD(5), 4000, RT(0), 2000, RT(2), 2500,
 618     RT(5), 4000, INT_MAX
 619 };
 620
 621 static const int thresh_mult_map_split1[] = {
 622     2500, GOOD(0), 1700, GOOD(2), 10000, GOOD(3), 25000, GOOD(4), INT_MAX,
 623     RT(0), 5000, RT(1), 10000, RT(2), 25000, RT(3), INT_MAX, INT_MAX
 624 };
 625
 626 static const int thresh_mult_map_split2[] = {
 627     5000, GOOD(0), 4500, GOOD(2), 20000, GOOD(3), 50000, GOOD(4), INT_MAX,
 628     RT(0), 10000, RT(1), 20000, RT(2), 50000, RT(3), INT_MAX, INT_MAX
 629 };
 630
 631 static const int mode_check_freq_map_zn2[] = {
 632     /* {zero,nearest}{2,3} */
 633     0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX
 634 };
 635
 636 static const int mode_check_freq_map_vhbpred[] = {
 637     0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(5), 4, INT_MAX
 638 };
 639
 640 static const int mode_check_freq_map_near2[] = {
 641     0, GOOD(5), 2, RT(0), 0, RT(3), 2, RT(10), 1<<2, RT(11), 1<<3, RT(12), 1<<4,
 642     INT_MAX
 643 };
 644
 645 static const int mode_check_freq_map_new1[] = {
 646     0, RT(10), 1<<1, RT(11), 1<<2, RT(12), 1<<3, INT_MAX
 647 };
 648
 649 static const int mode_check_freq_map_new2[] = {
 650     0, GOOD(5), 4, RT(0), 0, RT(3), 4, RT(10), 1<<3, RT(11), 1<<4, RT(12), 1<<5,
 651     INT_MAX
 652 };
 653
 654 static const int mode_check_freq_map_split1[] = {
 655     0, GOOD(2), 2, GOOD(3), 7, RT(1), 2, RT(2), 7, INT_MAX
 656 };
 657
 658 static const int mode_check_freq_map_split2[] = {
 659     0, GOOD(1), 2, GOOD(2), 4, GOOD(3), 15, RT(1), 4, RT(2), 15, INT_MAX
 660 };
 661
 662 void vp8_set_speed_features(VP8_COMP *cpi)
 663 {
 664     SPEED_FEATURES *sf = &cpi->sf;
 665     int Mode = cpi->compressor_speed;
 666     int Speed = cpi->Speed;
 667     int i;
 668     VP8_COMMON *cm = &cpi->common;
 669     int last_improved_quant = sf->improved_quant;
 670     int ref_frames;
 671
 672     // Initialise default mode frequency sampling variables
 673     for (i = 0; i < MAX_MODES; i ++)
 674     {
 675         cpi->mode_check_freq[i] = 0;
 676         cpi->mode_test_hit_counts[i] = 0;
 677         cpi->mode_chosen_counts[i] = 0;
 678     }
 679
 680     cpi->mbs_tested_so_far = 0;
 681
 682     // best quality defaults
 683     sf->RD = 1;
 684     sf->search_method = NSTEP;
 685     sf->improved_quant = 1;
 686     sf->improved_dct = 1;
 687     sf->auto_filter = 1;
 688     sf->recode_loop = 1;
 689     sf->quarter_pixel_search = 1;
 690     sf->half_pixel_search = 1;
 691     sf->iterative_sub_pixel = 1;
 692     sf->optimize_coefficients = 1;
 693     sf->use_fastquant_for_pick = 0;
 694     sf->no_skip_block4x4_search = 1;
 695
 696     sf->first_step = 0;
 697     sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
 698     sf->improved_mv_pred = 1;
 699
 700     // default thresholds to 0
 701     for (i = 0; i < MAX_MODES; i++)
 702         sf->thresh_mult[i] = 0;
 703
 704     /* Count enabled references */
 705     ref_frames = 1;
 706     if (cpi->ref_frame_flags & VP8_LAST_FLAG)
 707         ref_frames++;
 708     if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
 709         ref_frames++;
 710     if (cpi->ref_frame_flags & VP8_ALT_FLAG)
 711         ref_frames++;
 712
 713     /* Convert speed to continuous range, with clamping */
 714     if (Mode == 0)
 715         Speed = 0;
 716     else if (Mode == 2)
 717         Speed = RT(Speed);
 718     else
 719     {
 720         if (Speed > 5)
 721             Speed = 5;
 722         Speed = GOOD(Speed);
 723     }
 724
 725     sf->thresh_mult[THR_ZERO1] =
 726     sf->thresh_mult[THR_NEAREST1] =
 727     sf->thresh_mult[THR_NEAR1] =
 728     sf->thresh_mult[THR_DC] = 0; /* always */
 729
 730     sf->thresh_mult[THR_ZERO2] =
 731     sf->thresh_mult[THR_ZERO3] =
 732     sf->thresh_mult[THR_NEAREST2] =
 733     sf->thresh_mult[THR_NEAREST3] =
 734     sf->thresh_mult[THR_NEAR2]  =
 735     sf->thresh_mult[THR_NEAR3]  = speed_map(Speed, thresh_mult_map_znn);
 736
 737     sf->thresh_mult[THR_V_PRED] =
 738     sf->thresh_mult[THR_H_PRED] = speed_map(Speed, thresh_mult_map_vhpred);
 739     sf->thresh_mult[THR_B_PRED] = speed_map(Speed, thresh_mult_map_bpred);
 740     sf->thresh_mult[THR_TM]     = speed_map(Speed, thresh_mult_map_tm);
 741     sf->thresh_mult[THR_NEW1]   = speed_map(Speed, thresh_mult_map_new1);
 742     sf->thresh_mult[THR_NEW2]   =
 743     sf->thresh_mult[THR_NEW3]   = speed_map(Speed, thresh_mult_map_new2);
 744     sf->thresh_mult[THR_SPLIT1] = speed_map(Speed, thresh_mult_map_split1);
 745     sf->thresh_mult[THR_SPLIT2] =
 746     sf->thresh_mult[THR_SPLIT3] = speed_map(Speed, thresh_mult_map_split2);
 747
 748     cpi->mode_check_freq[THR_ZERO1] =
 749     cpi->mode_check_freq[THR_NEAREST1] =
 750     cpi->mode_check_freq[THR_NEAR1] =
 751     cpi->mode_check_freq[THR_TM]     =
 752     cpi->mode_check_freq[THR_DC] = 0; /* always */
 753
 754     cpi->mode_check_freq[THR_ZERO2] =
 755     cpi->mode_check_freq[THR_ZERO3] =
 756     cpi->mode_check_freq[THR_NEAREST2] =
 757     cpi->mode_check_freq[THR_NEAREST3] = speed_map(Speed,
 758                                                    mode_check_freq_map_zn2);
 759
 760     cpi->mode_check_freq[THR_NEAR2]  =
 761     cpi->mode_check_freq[THR_NEAR3]  = speed_map(Speed,
 762                                                  mode_check_freq_map_near2);
 763
 764     cpi->mode_check_freq[THR_V_PRED] =
 765     cpi->mode_check_freq[THR_H_PRED] =
 766     cpi->mode_check_freq[THR_B_PRED] = speed_map(Speed,
 767                                                  mode_check_freq_map_vhbpred);
 768     cpi->mode_check_freq[THR_NEW1]   = speed_map(Speed,
 769                                                  mode_check_freq_map_new1);
 770     cpi->mode_check_freq[THR_NEW2]   =
 771     cpi->mode_check_freq[THR_NEW3]   = speed_map(Speed,
 772                                                  mode_check_freq_map_new2);
 773     cpi->mode_check_freq[THR_SPLIT1] = speed_map(Speed,
 774                                                  mode_check_freq_map_split1);
 775     cpi->mode_check_freq[THR_SPLIT2] =
 776     cpi->mode_check_freq[THR_SPLIT3] = speed_map(Speed,
 777                                                  mode_check_freq_map_split2);
 778     Speed = cpi->Speed;
 779     switch (Mode)
 780     {
 781 #if !(CONFIG_REALTIME_ONLY)
 782     case 0: // best quality mode
 783         sf->first_step = 0;
 784         sf->max_step_search_steps = MAX_MVSEARCH_STEPS;
 785         break;
 786     case 1:
 787     case 3:
 788         if (Speed > 0)
 789         {
 790             /* Disable coefficient optimization above speed 0 */
 791             sf->optimize_coefficients = 0;
 792             sf->use_fastquant_for_pick = 1;
 793             sf->no_skip_block4x4_search = 0;
 794
 795             sf->first_step = 1;
 796         }
 797
 798         if (Speed > 2)
 799         {
 800             sf->improved_quant = 0;
 801             sf->improved_dct = 0;
 802
 803             // Only do recode loop on key frames, golden frames and
 804             // alt ref frames
 805             sf->recode_loop = 2;
 806
 807         }
 808
 809         if (Speed > 3)
 810         {
 811             sf->auto_filter = 1;
 812             sf->recode_loop = 0; // recode loop off
 813             sf->RD = 0;         // Turn rd off
 814
 815         }
 816
 817         if (Speed > 4)
 818         {
 819             sf->auto_filter = 0;                     // Faster selection of loop filter
 820         }
 821
 822         break;
 823 #endif
 824     case 2:
 825         sf->optimize_coefficients = 0;
 826         sf->recode_loop = 0;
 827         sf->auto_filter = 1;
 828         sf->iterative_sub_pixel = 1;
 829         sf->search_method = NSTEP;
 830
 831         if (Speed > 0)
 832         {
 833             sf->improved_quant = 0;
 834             sf->improved_dct = 0;
 835
 836             sf->use_fastquant_for_pick = 1;
 837             sf->no_skip_block4x4_search = 0;
 838             sf->first_step = 1;
 839         }
 840
 841         if (Speed > 2)
 842             sf->auto_filter = 0;                     // Faster selection of loop filter
 843
 844         if (Speed > 3)
 845         {
 846             sf->RD = 0;
 847             sf->auto_filter = 1;
 848         }
 849
 850         if (Speed > 4)
 851         {
 852             sf->auto_filter = 0;                     // Faster selection of loop filter
 853             sf->search_method = HEX;
 854             sf->iterative_sub_pixel = 0;
 855         }
 856
 857         if (Speed > 6)
 858         {
 859             unsigned int sum = 0;
 860             unsigned int total_mbs = cm->MBs;
 861             int i, thresh;
 862             unsigned int total_skip;
 863
 864             int min = 2000;
 865
 866             if (cpi->oxcf.encode_breakout > 2000)
 867                 min = cpi->oxcf.encode_breakout;
 868
 869             min >>= 7;
 870
 871             for (i = 0; i < min; i++)
 872             {
 873                 sum += cpi->error_bins[i];
 874             }
 875
 876             total_skip = sum;
 877             sum = 0;
 878
 879             // i starts from 2 to make sure thresh started from 2048
 880             for (; i < 1024; i++)
 881             {
 882                 sum += cpi->error_bins[i];
 883
 884                 if (10 * sum >= (unsigned int)(cpi->Speed - 6)*(total_mbs - total_skip))
 885                     break;
 886             }
 887
 888             i--;
 889             thresh = (i << 7);
 890
 891             if (thresh < 2000)
 892                 thresh = 2000;
 893
 894             if (ref_frames > 1)
 895             {
 896                 sf->thresh_mult[THR_NEW1 ] = thresh;
 897                 sf->thresh_mult[THR_NEAREST1  ] = thresh >> 1;
 898                 sf->thresh_mult[THR_NEAR1     ] = thresh >> 1;
 899             }
 900
 901             if (ref_frames > 2)
 902             {
 903                 sf->thresh_mult[THR_NEW2] = thresh << 1;
 904                 sf->thresh_mult[THR_NEAREST2 ] = thresh;
 905                 sf->thresh_mult[THR_NEAR2    ] = thresh;
 906             }
 907
 908             if (ref_frames > 3)
 909             {
 910                 sf->thresh_mult[THR_NEW3] = thresh << 1;
 911                 sf->thresh_mult[THR_NEAREST3 ] = thresh;
 912                 sf->thresh_mult[THR_NEAR3    ] = thresh;
 913             }
 914
 915             sf->improved_mv_pred = 0;
 916         }
 917
 918         if (Speed > 8)
 919             sf->quarter_pixel_search = 0;
 920
 921         if(cm->version == 0)
 922         {
 923             cm->filter_type = NORMAL_LOOPFILTER;
 924
 925             if (Speed >= 14)
 926                 cm->filter_type = SIMPLE_LOOPFILTER;
 927         }
 928         else
 929         {
 930             cm->filter_type = SIMPLE_LOOPFILTER;
 931         }
 932
 933         // This has a big hit on quality. Last resort
 934         if (Speed >= 15)
 935             sf->half_pixel_search = 0;
 936
 937         vpx_memset(cpi->error_bins, 0, sizeof(cpi->error_bins));
 938
 939     }; /* switch */
 940
 941     // Slow quant, dct and trellis not worthwhile for first pass
 942     // so make sure they are always turned off.
 943     if ( cpi->pass == 1 )
 944     {
 945         sf->improved_quant = 0;
 946         sf->optimize_coefficients = 0;
 947         sf->improved_dct = 0;
 948     }
 949
 950     if (cpi->sf.search_method == NSTEP)
 951     {
 952         vp8_init3smotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
 953     }
 954     else if (cpi->sf.search_method == DIAMOND)
 955     {
 956         vp8_init_dsmotion_compensation(&cpi->mb, cm->yv12_fb[cm->lst_fb_idx].y_stride);
 957     }
 958
 959     if (cpi->sf.improved_dct)
 960     {
 961         cpi->mb.short_fdct8x4 = vp8_short_fdct8x4;
 962         cpi->mb.short_fdct4x4 = vp8_short_fdct4x4;
 963     }
 964     else
 965     {
 966         /* No fast FDCT defined for any platform at this time. */
 967         cpi->mb.short_fdct8x4 = vp8_short_fdct8x4;
 968         cpi->mb.short_fdct4x4 = vp8_short_fdct4x4;
 969     }
 970
 971     cpi->mb.short_walsh4x4 = vp8_short_walsh4x4;
 972
 973     if (cpi->sf.improved_quant)
 974     {
 975         cpi->mb.quantize_b      = vp8_regular_quantize_b;
 976         cpi->mb.quantize_b_pair = vp8_regular_quantize_b_pair;
 977     }
 978     else
 979     {
 980         cpi->mb.quantize_b      = vp8_fast_quantize_b;
 981         cpi->mb.quantize_b_pair = vp8_fast_quantize_b_pair;
 982     }
 983     if (cpi->sf.improved_quant != last_improved_quant)
 984         vp8cx_init_quantizer(cpi);
 985
 986     if (cpi->sf.iterative_sub_pixel == 1)
 987     {
 988         cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step_iteratively;
 989     }
 990     else if (cpi->sf.quarter_pixel_search)
 991     {
 992         cpi->find_fractional_mv_step = vp8_find_best_sub_pixel_step;
 993     }
 994     else if (cpi->sf.half_pixel_search)
 995     {
 996         cpi->find_fractional_mv_step = vp8_find_best_half_pixel_step;
 997     }
 998     else
 999     {
1000         cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1001     }
1002
1003     if (cpi->sf.optimize_coefficients == 1 && cpi->pass!=1)
1004         cpi->mb.optimize = 1;
1005     else
1006         cpi->mb.optimize = 0;
1007
1008     if (cpi->common.full_pixel)
1009         cpi->find_fractional_mv_step = vp8_skip_fractional_mv_step;
1010
1011 #ifdef SPEEDSTATS
1012     frames_at_speed[cpi->Speed]++;
1013 #endif
1014 }
1015 #undef GOOD
1016 #undef RT
1017
1018 static void alloc_raw_frame_buffers(VP8_COMP *cpi)
1019 {
1020 #if VP8_TEMPORAL_ALT_REF
1021     int width = (cpi->oxcf.Width + 15) & ~15;
1022     int height = (cpi->oxcf.Height + 15) & ~15;
1023 #endif
1024
1025     cpi->lookahead = vp8_lookahead_init(cpi->oxcf.Width, cpi->oxcf.Height,
1026                                         cpi->oxcf.lag_in_frames);
1027     if(!cpi->lookahead)
1028         vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1029                            "Failed to allocate lag buffers");
1030
1031 #if VP8_TEMPORAL_ALT_REF
1032
1033     if (vp8_yv12_alloc_frame_buffer(&cpi->alt_ref_buffer,
1034                                     width, height, VP8BORDERINPIXELS))
1035         vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1036                            "Failed to allocate altref buffer");
1037
1038 #endif
1039 }
1040
1041
1042 static void dealloc_raw_frame_buffers(VP8_COMP *cpi)
1043 {
1044 #if VP8_TEMPORAL_ALT_REF
1045     vp8_yv12_de_alloc_frame_buffer(&cpi->alt_ref_buffer);
1046 #endif
1047     vp8_lookahead_destroy(cpi->lookahead);
1048 }
1049
1050
1051 static int vp8_alloc_partition_data(VP8_COMP *cpi)
1052 {
1053         vpx_free(cpi->mb.pip);
1054
1055     cpi->mb.pip = vpx_calloc((cpi->common.mb_cols + 1) *
1056                                 (cpi->common.mb_rows + 1),
1057                                 sizeof(PARTITION_INFO));
1058     if(!cpi->mb.pip)
1059         return 1;
1060
1061     cpi->mb.pi = cpi->mb.pip + cpi->common.mode_info_stride + 1;
1062
1063     return 0;
1064 }
1065
1066 void vp8_alloc_compressor_data(VP8_COMP *cpi)
1067 {
1068     VP8_COMMON *cm = & cpi->common;
1069
1070     int width = cm->Width;
1071     int height = cm->Height;
1072
1073     if (vp8_alloc_frame_buffers(cm, width, height))
1074         vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1075                            "Failed to allocate frame buffers");
1076
1077     if (vp8_alloc_partition_data(cpi))
1078         vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1079                            "Failed to allocate partition data");
1080
1081
1082     if ((width & 0xf) != 0)
1083         width += 16 - (width & 0xf);
1084
1085     if ((height & 0xf) != 0)
1086         height += 16 - (height & 0xf);
1087
1088
1089     if (vp8_yv12_alloc_frame_buffer(&cpi->pick_lf_lvl_frame,
1090                                     width, height, VP8BORDERINPIXELS))
1091         vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1092                            "Failed to allocate last frame buffer");
1093
1094     if (vp8_yv12_alloc_frame_buffer(&cpi->scaled_source,
1095                                     width, height, VP8BORDERINPIXELS))
1096         vpx_internal_error(&cpi->common.error, VPX_CODEC_MEM_ERROR,
1097                            "Failed to allocate scaled source buffer");
1098
1099     vpx_free(cpi->tok);
1100
1101     {
1102 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
1103         unsigned int tokens = 8 * 24 * 16; /* one MB for each thread */
1104 #else
1105         unsigned int tokens = cm->mb_rows * cm->mb_cols * 24 * 16;
1106 #endif
1107         CHECK_MEM_ERROR(cpi->tok, vpx_calloc(tokens, sizeof(*cpi->tok)));
1108     }
1109
1110     // Data used for real time vc mode to see if gf needs refreshing
1111     cpi->inter_zz_count = 0;
1112     cpi->gf_bad_count = 0;
1113     cpi->gf_update_recommended = 0;
1114
1115
1116     // Structures used to minitor GF usage
1117     vpx_free(cpi->gf_active_flags);
1118     CHECK_MEM_ERROR(cpi->gf_active_flags,
1119                     vpx_calloc(1, cm->mb_rows * cm->mb_cols));
1120     cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
1121
1122     vpx_free(cpi->mb_activity_map);
1123     CHECK_MEM_ERROR(cpi->mb_activity_map,
1124                     vpx_calloc(sizeof(unsigned int),
1125                     cm->mb_rows * cm->mb_cols));
1126
1127     vpx_free(cpi->mb_norm_activity_map);
1128     CHECK_MEM_ERROR(cpi->mb_norm_activity_map,
1129                     vpx_calloc(sizeof(unsigned int),
1130                     cm->mb_rows * cm->mb_cols));
1131
1132 #if CONFIG_MULTITHREAD
1133     if (width < 640)
1134         cpi->mt_sync_range = 1;
1135     else if (width <= 1280)
1136         cpi->mt_sync_range = 4;
1137     else if (width <= 2560)
1138         cpi->mt_sync_range = 8;
1139     else
1140         cpi->mt_sync_range = 16;
1141 #endif
1142
1143     vpx_free(cpi->tplist);
1144
1145     CHECK_MEM_ERROR(cpi->tplist, vpx_malloc(sizeof(TOKENLIST) * cpi->common.mb_rows));
1146 }
1147
1148
1149 // Quant MOD
1150 static const int q_trans[] =
1151 {
1152     0,   1,  2,  3,  4,  5,  7,  8,
1153     9,  10, 12, 13, 15, 17, 18, 19,
1154     20,  21, 23, 24, 25, 26, 27, 28,
1155     29,  30, 31, 33, 35, 37, 39, 41,
1156     43,  45, 47, 49, 51, 53, 55, 57,
1157     59,  61, 64, 67, 70, 73, 76, 79,
1158     82,  85, 88, 91, 94, 97, 100, 103,
1159     106, 109, 112, 115, 118, 121, 124, 127,
1160 };
1161
1162 int vp8_reverse_trans(int x)
1163 {
1164     int i;
1165
1166     for (i = 0; i < 64; i++)
1167         if (q_trans[i] >= x)
1168             return i;
1169
1170     return 63;
1171 };
1172 void vp8_new_frame_rate(VP8_COMP *cpi, double framerate)
1173 {
1174     if(framerate < .1)
1175         framerate = 30;
1176
1177     cpi->frame_rate             = framerate;
1178     cpi->output_frame_rate      = framerate;
1179     cpi->per_frame_bandwidth    = (int)(cpi->oxcf.target_bandwidth /
1180                                   cpi->output_frame_rate);
1181     cpi->av_per_frame_bandwidth = cpi->per_frame_bandwidth;
1182     cpi->min_frame_bandwidth    = (int)(cpi->av_per_frame_bandwidth *
1183                                   cpi->oxcf.two_pass_vbrmin_section / 100);
1184
1185     // Set Maximum gf/arf interval
1186     cpi->max_gf_interval = ((int)(cpi->output_frame_rate / 2.0) + 2);
1187
1188     if(cpi->max_gf_interval < 12)
1189         cpi->max_gf_interval = 12;
1190
1191     // Extended interval for genuinely static scenes
1192     cpi->twopass.static_scene_max_gf_interval = cpi->key_frame_frequency >> 1;
1193
1194      // Special conditions when altr ref frame enabled in lagged compress mode
1195     if (cpi->oxcf.play_alternate && cpi->oxcf.lag_in_frames)
1196     {
1197         if (cpi->max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1198             cpi->max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1199
1200         if (cpi->twopass.static_scene_max_gf_interval > cpi->oxcf.lag_in_frames - 1)
1201             cpi->twopass.static_scene_max_gf_interval = cpi->oxcf.lag_in_frames - 1;
1202     }
1203
1204     if ( cpi->max_gf_interval > cpi->twopass.static_scene_max_gf_interval )
1205         cpi->max_gf_interval = cpi->twopass.static_scene_max_gf_interval;
1206 }
1207
1208
1209 static int
1210 rescale(int val, int num, int denom)
1211 {
1212     int64_t llnum = num;
1213     int64_t llden = denom;
1214     int64_t llval = val;
1215
1216     return llval * llnum / llden;
1217 }
1218
1219
1220 static void init_config(VP8_COMP *cpi, VP8_CONFIG *oxcf)
1221 {
1222     VP8_COMMON *cm = &cpi->common;
1223
1224     cpi->oxcf = *oxcf;
1225
1226     cpi->auto_gold = 1;
1227     cpi->auto_adjust_gold_quantizer = 1;
1228     cpi->goldfreq = 7;
1229
1230     cm->version = oxcf->Version;
1231     vp8_setup_version(cm);
1232
1233     /* frame rate is not available on the first frame, as it's derived from
1234      * the observed timestamps. The actual value used here doesn't matter
1235      * too much, as it will adapt quickly. If the reciprocal of the timebase
1236      * seems like a reasonable framerate, then use that as a guess, otherwise
1237      * use 30.
1238      */
1239     cpi->frame_rate = (double)(oxcf->timebase.den) /
1240                       (double)(oxcf->timebase.num);
1241
1242     if (cpi->frame_rate > 180)
1243         cpi->frame_rate = 30;
1244
1245     cpi->ref_frame_rate = cpi->frame_rate;
1246
1247     // change includes all joint functionality
1248     vp8_change_config(cpi, oxcf);
1249
1250     // Initialize active best and worst q and average q values.
1251     cpi->active_worst_quality         = cpi->oxcf.worst_allowed_q;
1252     cpi->active_best_quality          = cpi->oxcf.best_allowed_q;
1253     cpi->avg_frame_qindex             = cpi->oxcf.worst_allowed_q;
1254
1255     // Initialise the starting buffer levels
1256     cpi->buffer_level                 = cpi->oxcf.starting_buffer_level;
1257     cpi->bits_off_target              = cpi->oxcf.starting_buffer_level;
1258
1259     cpi->rolling_target_bits          = cpi->av_per_frame_bandwidth;
1260     cpi->rolling_actual_bits          = cpi->av_per_frame_bandwidth;
1261     cpi->long_rolling_target_bits     = cpi->av_per_frame_bandwidth;
1262     cpi->long_rolling_actual_bits     = cpi->av_per_frame_bandwidth;
1263
1264     cpi->total_actual_bits            = 0;
1265     cpi->total_target_vs_actual       = 0;
1266
1267     // Temporal scalabilty
1268     if (cpi->oxcf.number_of_layers > 1)
1269     {
1270         unsigned int i;
1271         double prev_layer_frame_rate=0;
1272
1273         for (i=0; i<cpi->oxcf.number_of_layers; i++)
1274         {
1275             LAYER_CONTEXT *lc = &cpi->layer_context[i];
1276
1277             // Layer configuration
1278             lc->frame_rate =
1279                         cpi->output_frame_rate / cpi->oxcf.rate_decimator[i];
1280             lc->target_bandwidth = cpi->oxcf.target_bitrate[i] * 1000;
1281
1282             lc->starting_buffer_level_in_ms = oxcf->starting_buffer_level;
1283             lc->optimal_buffer_level_in_ms  = oxcf->optimal_buffer_level;
1284             lc->maximum_buffer_size_in_ms   = oxcf->maximum_buffer_size;
1285
1286             lc->starting_buffer_level =
1287               rescale(oxcf->starting_buffer_level,
1288                           lc->target_bandwidth, 1000);
1289
1290             if (oxcf->optimal_buffer_level == 0)
1291                 lc->optimal_buffer_level = lc->target_bandwidth / 8;
1292             else
1293                 lc->optimal_buffer_level =
1294                   rescale(oxcf->optimal_buffer_level,
1295                           lc->target_bandwidth, 1000);
1296
1297             if (oxcf->maximum_buffer_size == 0)
1298                 lc->maximum_buffer_size = lc->target_bandwidth / 8;
1299             else
1300                 lc->maximum_buffer_size =
1301                   rescale(oxcf->maximum_buffer_size,
1302                           lc->target_bandwidth, 1000);
1303
1304             // Work out the average size of a frame within this layer
1305             if (i > 0)
1306                 lc->avg_frame_size_for_layer = (cpi->oxcf.target_bitrate[i] -
1307                     cpi->oxcf.target_bitrate[i-1]) * 1000 /
1308                     (lc->frame_rate - prev_layer_frame_rate);
1309
1310             lc->active_worst_quality         = cpi->oxcf.worst_allowed_q;
1311             lc->active_best_quality          = cpi->oxcf.best_allowed_q;
1312             lc->avg_frame_qindex             = cpi->oxcf.worst_allowed_q;
1313
1314             lc->buffer_level                 = lc->starting_buffer_level;
1315             lc->bits_off_target              = lc->starting_buffer_level;
1316
1317             lc->total_actual_bits                 = 0;
1318             lc->ni_av_qi                          = 0;
1319             lc->ni_tot_qi                         = 0;
1320             lc->ni_frames                         = 0;
1321             lc->rate_correction_factor            = 1.0;
1322             lc->key_frame_rate_correction_factor  = 1.0;
1323             lc->gf_rate_correction_factor         = 1.0;
1324             lc->inter_frame_target                = 0.0;
1325
1326             prev_layer_frame_rate = lc->frame_rate;
1327         }
1328     }
1329
1330 #if VP8_TEMPORAL_ALT_REF
1331     {
1332         int i;
1333
1334         cpi->fixed_divide[0] = 0;
1335
1336         for (i = 1; i < 512; i++)
1337             cpi->fixed_divide[i] = 0x80000 / i;
1338     }
1339 #endif
1340 }
1341
1342 static void update_layer_contexts (VP8_COMP *cpi)
1343 {
1344     VP8_CONFIG *oxcf = &cpi->oxcf;
1345
1346     /* Update snapshots of the layer contexts to reflect new parameters */
1347     if (oxcf->number_of_layers > 1)
1348     {
1349         unsigned int i;
1350         double prev_layer_frame_rate=0;
1351
1352         for (i=0; i<oxcf->number_of_layers; i++)
1353         {
1354             LAYER_CONTEXT *lc = &cpi->layer_context[i];
1355
1356             lc->frame_rate =
1357                 cpi->ref_frame_rate / oxcf->rate_decimator[i];
1358             lc->target_bandwidth = oxcf->target_bitrate[i] * 1000;
1359
1360             lc->starting_buffer_level = rescale(
1361                           oxcf->starting_buffer_level_in_ms,
1362                           lc->target_bandwidth, 1000);
1363
1364             if (oxcf->optimal_buffer_level == 0)
1365                 lc->optimal_buffer_level = lc->target_bandwidth / 8;
1366             else
1367                 lc->optimal_buffer_level = rescale(
1368                           oxcf->optimal_buffer_level_in_ms,
1369                           lc->target_bandwidth, 1000);
1370
1371             if (oxcf->maximum_buffer_size == 0)
1372                 lc->maximum_buffer_size = lc->target_bandwidth / 8;
1373             else
1374                 lc->maximum_buffer_size = rescale(
1375                           oxcf->maximum_buffer_size_in_ms,
1376                           lc->target_bandwidth, 1000);
1377
1378             // Work out the average size of a frame within this layer
1379             if (i > 0)
1380                 lc->avg_frame_size_for_layer = (oxcf->target_bitrate[i] -
1381                     oxcf->target_bitrate[i-1]) * 1000 /
1382                     (lc->frame_rate - prev_layer_frame_rate);
1383
1384             lc->active_worst_quality         = oxcf->worst_allowed_q;
1385             lc->active_best_quality          = oxcf->best_allowed_q;
1386             lc->avg_frame_qindex             = oxcf->worst_allowed_q;
1387
1388             prev_layer_frame_rate = lc->frame_rate;
1389         }
1390     }
1391 }
1392
1393 void vp8_change_config(VP8_COMP *cpi, VP8_CONFIG *oxcf)
1394 {
1395     VP8_COMMON *cm = &cpi->common;
1396     int last_w, last_h;
1397
1398     if (!cpi)
1399         return;
1400
1401     if (!oxcf)
1402         return;
1403
1404 #if CONFIG_MULTITHREAD
1405     /*  wait for the last picture loopfilter thread done */
1406     if (cpi->b_lpf_running)
1407     {
1408         sem_wait(&cpi->h_event_end_lpf);
1409         cpi->b_lpf_running = 0;
1410     }
1411 #endif
1412
1413     if (cm->version != oxcf->Version)
1414     {
1415         cm->version = oxcf->Version;
1416         vp8_setup_version(cm);
1417     }
1418
1419     last_w = cpi->oxcf.Width;
1420     last_h = cpi->oxcf.Height;
1421
1422     cpi->oxcf = *oxcf;
1423
1424     switch (cpi->oxcf.Mode)
1425     {
1426
1427     case MODE_REALTIME:
1428         cpi->pass = 0;
1429         cpi->compressor_speed = 2;
1430
1431         if (cpi->oxcf.cpu_used < -16)
1432         {
1433             cpi->oxcf.cpu_used = -16;
1434         }
1435
1436         if (cpi->oxcf.cpu_used > 16)
1437             cpi->oxcf.cpu_used = 16;
1438
1439         break;
1440
1441     case MODE_GOODQUALITY:
1442         cpi->pass = 0;
1443         cpi->compressor_speed = 1;
1444
1445         if (cpi->oxcf.cpu_used < -5)
1446         {
1447             cpi->oxcf.cpu_used = -5;
1448         }
1449
1450         if (cpi->oxcf.cpu_used > 5)
1451             cpi->oxcf.cpu_used = 5;
1452
1453         break;
1454
1455     case MODE_BESTQUALITY:
1456         cpi->pass = 0;
1457         cpi->compressor_speed = 0;
1458         break;
1459
1460     case MODE_FIRSTPASS:
1461         cpi->pass = 1;
1462         cpi->compressor_speed = 1;
1463         break;
1464     case MODE_SECONDPASS:
1465         cpi->pass = 2;
1466         cpi->compressor_speed = 1;
1467
1468         if (cpi->oxcf.cpu_used < -5)
1469         {
1470             cpi->oxcf.cpu_used = -5;
1471         }
1472
1473         if (cpi->oxcf.cpu_used > 5)
1474             cpi->oxcf.cpu_used = 5;
1475
1476         break;
1477     case MODE_SECONDPASS_BEST:
1478         cpi->pass = 2;
1479         cpi->compressor_speed = 0;
1480         break;
1481     }
1482
1483     if (cpi->pass == 0)
1484         cpi->auto_worst_q = 1;
1485
1486     cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1487     cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1488     cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
1489
1490     if (oxcf->fixed_q >= 0)
1491     {
1492         if (oxcf->worst_allowed_q < 0)
1493             cpi->oxcf.fixed_q = q_trans[0];
1494         else
1495             cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
1496
1497         if (oxcf->alt_q < 0)
1498             cpi->oxcf.alt_q = q_trans[0];
1499         else
1500             cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
1501
1502         if (oxcf->key_q < 0)
1503             cpi->oxcf.key_q = q_trans[0];
1504         else
1505             cpi->oxcf.key_q = q_trans[oxcf->key_q];
1506
1507         if (oxcf->gold_q < 0)
1508             cpi->oxcf.gold_q = q_trans[0];
1509         else
1510             cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
1511
1512     }
1513
1514     cpi->baseline_gf_interval =
1515         cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL;
1516
1517     cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
1518
1519     //cpi->use_golden_frame_only = 0;
1520     //cpi->use_last_frame_only = 0;
1521     cm->refresh_golden_frame = 0;
1522     cm->refresh_last_frame = 1;
1523     cm->refresh_entropy_probs = 1;
1524
1525 #if (CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
1526     cpi->oxcf.token_partitions = 3;
1527 #endif
1528
1529     if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
1530         cm->multi_token_partition =
1531             (TOKEN_PARTITION) cpi->oxcf.token_partitions;
1532
1533     setup_features(cpi);
1534
1535     {
1536         int i;
1537
1538         for (i = 0; i < MAX_MB_SEGMENTS; i++)
1539             cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1540     }
1541
1542     // At the moment the first order values may not be > MAXQ
1543     if (cpi->oxcf.fixed_q > MAXQ)
1544         cpi->oxcf.fixed_q = MAXQ;
1545
1546     // local file playback mode == really big buffer
1547     if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK)
1548     {
1549         cpi->oxcf.starting_buffer_level       = 60000;
1550         cpi->oxcf.optimal_buffer_level        = 60000;
1551         cpi->oxcf.maximum_buffer_size         = 240000;
1552         cpi->oxcf.starting_buffer_level_in_ms = 60000;
1553         cpi->oxcf.optimal_buffer_level_in_ms  = 60000;
1554         cpi->oxcf.maximum_buffer_size_in_ms   = 240000;
1555     }
1556
1557     // Convert target bandwidth from Kbit/s to Bit/s
1558     cpi->oxcf.target_bandwidth       *= 1000;
1559
1560     cpi->oxcf.starting_buffer_level =
1561         rescale(cpi->oxcf.starting_buffer_level,
1562                 cpi->oxcf.target_bandwidth, 1000);
1563
1564     // Set or reset optimal and maximum buffer levels.
1565     if (cpi->oxcf.optimal_buffer_level == 0)
1566         cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1567     else
1568         cpi->oxcf.optimal_buffer_level =
1569             rescale(cpi->oxcf.optimal_buffer_level,
1570                     cpi->oxcf.target_bandwidth, 1000);
1571
1572     if (cpi->oxcf.maximum_buffer_size == 0)
1573         cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1574     else
1575         cpi->oxcf.maximum_buffer_size =
1576             rescale(cpi->oxcf.maximum_buffer_size,
1577                     cpi->oxcf.target_bandwidth, 1000);
1578
1579     // Set up frame rate and related parameters rate control values.
1580     vp8_new_frame_rate(cpi, cpi->frame_rate);
1581
1582     // Set absolute upper and lower quality limits
1583     cpi->worst_quality               = cpi->oxcf.worst_allowed_q;
1584     cpi->best_quality                = cpi->oxcf.best_allowed_q;
1585
1586     // active values should only be modified if out of new range
1587     if (cpi->active_worst_quality > cpi->oxcf.worst_allowed_q)
1588     {
1589       cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1590     }
1591     // less likely
1592     else if (cpi->active_worst_quality < cpi->oxcf.best_allowed_q)
1593     {
1594       cpi->active_worst_quality = cpi->oxcf.best_allowed_q;
1595     }
1596     if (cpi->active_best_quality < cpi->oxcf.best_allowed_q)
1597     {
1598       cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1599     }
1600     // less likely
1601     else if (cpi->active_best_quality > cpi->oxcf.worst_allowed_q)
1602     {
1603       cpi->active_best_quality = cpi->oxcf.worst_allowed_q;
1604     }
1605
1606     cpi->buffered_mode = cpi->oxcf.optimal_buffer_level > 0;
1607
1608     cpi->cq_target_quality = cpi->oxcf.cq_level;
1609
1610     // Only allow dropped frames in buffered mode
1611     cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode;
1612
1613     cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1614
1615
1616     cm->Width       = cpi->oxcf.Width;
1617     cm->Height      = cpi->oxcf.Height;
1618
1619     /* TODO(jkoleszar): if an internal spatial resampling is active,
1620      * and we downsize the input image, maybe we should clear the
1621      * internal scale immediately rather than waiting for it to
1622      * correct.
1623      */
1624
1625     // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1626     if (cpi->oxcf.Sharpness > 7)
1627         cpi->oxcf.Sharpness = 7;
1628
1629     cm->sharpness_level = cpi->oxcf.Sharpness;
1630
1631     if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL)
1632     {
1633         int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
1634         int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
1635
1636         Scale2Ratio(cm->horiz_scale, &hr, &hs);
1637         Scale2Ratio(cm->vert_scale, &vr, &vs);
1638
1639         // always go to the next whole number
1640         cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs;
1641         cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
1642     }
1643
1644     if (last_w != cpi->oxcf.Width || last_h != cpi->oxcf.Height)
1645         cpi->force_next_frame_intra = 1;
1646
1647     if (((cm->Width + 15) & 0xfffffff0) !=
1648           cm->yv12_fb[cm->lst_fb_idx].y_width ||
1649         ((cm->Height + 15) & 0xfffffff0) !=
1650           cm->yv12_fb[cm->lst_fb_idx].y_height ||
1651         cm->yv12_fb[cm->lst_fb_idx].y_width == 0)
1652     {
1653         alloc_raw_frame_buffers(cpi);
1654         vp8_alloc_compressor_data(cpi);
1655     }
1656
1657     if (cpi->oxcf.fixed_q >= 0)
1658     {
1659         cpi->last_q[0] = cpi->oxcf.fixed_q;
1660         cpi->last_q[1] = cpi->oxcf.fixed_q;
1661     }
1662
1663     cpi->Speed = cpi->oxcf.cpu_used;
1664
1665     // force to allowlag to 0 if lag_in_frames is 0;
1666     if (cpi->oxcf.lag_in_frames == 0)
1667     {
1668         cpi->oxcf.allow_lag = 0;
1669     }
1670     // Limit on lag buffers as these are not currently dynamically allocated
1671     else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
1672         cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1673
1674     // YX Temp
1675     cpi->alt_ref_source = NULL;
1676     cpi->is_src_frame_alt_ref = 0;
1677
1678 #if CONFIG_TEMPORAL_DENOISING
1679     if (cpi->oxcf.noise_sensitivity)
1680     {
1681       if (!cpi->denoiser.yv12_mc_running_avg.buffer_alloc)
1682       {
1683         int width = (cpi->oxcf.Width + 15) & ~15;
1684         int height = (cpi->oxcf.Height + 15) & ~15;
1685         vp8_denoiser_allocate(&cpi->denoiser, width, height);
1686       }
1687     }
1688 #endif
1689
1690 #if 0
1691     // Experimental RD Code
1692     cpi->frame_distortion = 0;
1693     cpi->last_frame_distortion = 0;
1694 #endif
1695
1696 }
1697
1698 #define M_LOG2_E 0.693147180559945309417
1699 #define log2f(x) (log (x) / (float) M_LOG2_E)
1700 static void cal_mvsadcosts(int *mvsadcost[2])
1701 {
1702     int i = 1;
1703
1704     mvsadcost [0] [0] = 300;
1705     mvsadcost [1] [0] = 300;
1706
1707     do
1708     {
1709         double z = 256 * (2 * (log2f(8 * i) + .6));
1710         mvsadcost [0][i] = (int) z;
1711         mvsadcost [1][i] = (int) z;
1712         mvsadcost [0][-i] = (int) z;
1713         mvsadcost [1][-i] = (int) z;
1714     }
1715     while (++i <= mvfp_max);
1716 }
1717
1718 struct VP8_COMP* vp8_create_compressor(VP8_CONFIG *oxcf)
1719 {
1720     int i;
1721
1722     VP8_COMP *cpi;
1723     VP8_COMMON *cm;
1724
1725     cpi = vpx_memalign(32, sizeof(VP8_COMP));
1726     // Check that the CPI instance is valid
1727     if (!cpi)
1728         return 0;
1729
1730     cm = &cpi->common;
1731
1732     vpx_memset(cpi, 0, sizeof(VP8_COMP));
1733
1734     if (setjmp(cm->error.jmp))
1735     {
1736         cpi->common.error.setjmp = 0;
1737         vp8_remove_compressor(&cpi);
1738         return 0;
1739     }
1740
1741     cpi->common.error.setjmp = 1;
1742
1743     CHECK_MEM_ERROR(cpi->mb.ss, vpx_calloc(sizeof(search_site), (MAX_MVSEARCH_STEPS * 8) + 1));
1744
1745     vp8_create_common(&cpi->common);
1746
1747     init_config(cpi, oxcf);
1748
1749     memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob));
1750     cpi->common.current_video_frame   = 0;
1751     cpi->kf_overspend_bits            = 0;
1752     cpi->kf_bitrate_adjustment        = 0;
1753     cpi->frames_till_gf_update_due      = 0;
1754     cpi->gf_overspend_bits            = 0;
1755     cpi->non_gf_bitrate_adjustment     = 0;
1756     cpi->prob_last_coded              = 128;
1757     cpi->prob_gf_coded                = 128;
1758     cpi->prob_intra_coded             = 63;
1759
1760     // Prime the recent reference frame usage counters.
1761     // Hereafter they will be maintained as a sort of moving average
1762     cpi->recent_ref_frame_usage[INTRA_FRAME]  = 1;
1763     cpi->recent_ref_frame_usage[LAST_FRAME]   = 1;
1764     cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
1765     cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
1766
1767     // Set reference frame sign bias for ALTREF frame to 1 (for now)
1768     cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
1769
1770     cpi->twopass.gf_decay_rate = 0;
1771     cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1772
1773     cpi->gold_is_last = 0 ;
1774     cpi->alt_is_last  = 0 ;
1775     cpi->gold_is_alt  = 0 ;
1776
1777     // allocate memory for storing last frame's MVs for MV prediction.
1778     CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int_mv)));
1779     CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1780     CHECK_MEM_ERROR(cpi->lf_ref_frame, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1781
1782     // Create the encoder segmentation map and set all entries to 0
1783     CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1784     CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1785     vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
1786     cpi->active_map_enabled = 0;
1787
1788 #if 0
1789     // Experimental code for lagged and one pass
1790     // Initialise one_pass GF frames stats
1791     // Update stats used for GF selection
1792     if (cpi->pass == 0)
1793     {
1794         cpi->one_pass_frame_index = 0;
1795
1796         for (i = 0; i < MAX_LAG_BUFFERS; i++)
1797         {
1798             cpi->one_pass_frame_stats[i].frames_so_far = 0;
1799             cpi->one_pass_frame_stats[i].frame_intra_error = 0.0;
1800             cpi->one_pass_frame_stats[i].frame_coded_error = 0.0;
1801             cpi->one_pass_frame_stats[i].frame_pcnt_inter = 0.0;
1802             cpi->one_pass_frame_stats[i].frame_pcnt_motion = 0.0;
1803             cpi->one_pass_frame_stats[i].frame_mvr = 0.0;
1804             cpi->one_pass_frame_stats[i].frame_mvr_abs = 0.0;
1805             cpi->one_pass_frame_stats[i].frame_mvc = 0.0;
1806             cpi->one_pass_frame_stats[i].frame_mvc_abs = 0.0;
1807         }
1808     }
1809 #endif
1810
1811     // Should we use the cyclic refresh method.
1812     // Currently this is tied to error resilliant mode
1813     cpi->cyclic_refresh_mode_enabled = cpi->oxcf.error_resilient_mode;
1814     cpi->cyclic_refresh_mode_max_mbs_perframe = (cpi->common.mb_rows * cpi->common.mb_cols) / 40;
1815     cpi->cyclic_refresh_mode_index = 0;
1816     cpi->cyclic_refresh_q = 32;
1817
1818     if (cpi->cyclic_refresh_mode_enabled)
1819     {
1820         CHECK_MEM_ERROR(cpi->cyclic_refresh_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
1821     }
1822     else
1823         cpi->cyclic_refresh_map = (signed char *) NULL;
1824
1825     // Test function for segmentation
1826     //segmentation_test_function( cpi);
1827
1828 #ifdef ENTROPY_STATS
1829     init_context_counters();
1830 #endif
1831
1832     /*Initialize the feed-forward activity masking.*/
1833     cpi->activity_avg = 90<<12;
1834
1835     cpi->frames_since_key = 8;        // Give a sensible default for the first frame.
1836     cpi->key_frame_frequency = cpi->oxcf.key_freq;
1837     cpi->this_key_frame_forced = 0;
1838     cpi->next_key_frame_forced = 0;
1839
1840     cpi->source_alt_ref_pending = 0;
1841     cpi->source_alt_ref_active = 0;
1842     cpi->common.refresh_alt_ref_frame = 0;
1843
1844     cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1845 #if CONFIG_INTERNAL_STATS
1846     cpi->b_calculate_ssimg = 0;
1847
1848     cpi->count = 0;
1849     cpi->bytes = 0;
1850
1851     if (cpi->b_calculate_psnr)
1852     {
1853         cpi->total_sq_error = 0.0;
1854         cpi->total_sq_error2 = 0.0;
1855         cpi->total_y = 0.0;
1856         cpi->total_u = 0.0;
1857         cpi->total_v = 0.0;
1858         cpi->total = 0.0;
1859         cpi->totalp_y = 0.0;
1860         cpi->totalp_u = 0.0;
1861         cpi->totalp_v = 0.0;
1862         cpi->totalp = 0.0;
1863         cpi->tot_recode_hits = 0;
1864         cpi->summed_quality = 0;
1865         cpi->summed_weights = 0;
1866     }
1867
1868     if (cpi->b_calculate_ssimg)
1869     {
1870         cpi->total_ssimg_y = 0;
1871         cpi->total_ssimg_u = 0;
1872         cpi->total_ssimg_v = 0;
1873         cpi->total_ssimg_all = 0;
1874     }
1875
1876 #endif
1877
1878 #ifndef LLONG_MAX
1879 #define LLONG_MAX  9223372036854775807LL
1880 #endif
1881     cpi->first_time_stamp_ever = LLONG_MAX;
1882
1883     cpi->frames_till_gf_update_due      = 0;
1884     cpi->key_frame_count              = 1;
1885
1886     cpi->ni_av_qi                     = cpi->oxcf.worst_allowed_q;
1887     cpi->ni_tot_qi                    = 0;
1888     cpi->ni_frames                   = 0;
1889     cpi->total_byte_count             = 0;
1890
1891     cpi->drop_frame                  = 0;
1892     cpi->drop_count                  = 0;
1893     cpi->max_drop_count               = 0;
1894     cpi->max_consec_dropped_frames     = 4;
1895
1896     cpi->rate_correction_factor         = 1.0;
1897     cpi->key_frame_rate_correction_factor = 1.0;
1898     cpi->gf_rate_correction_factor  = 1.0;
1899     cpi->twopass.est_max_qcorrection_factor  = 1.0;
1900
1901     for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1902     {
1903         cpi->prior_key_frame_distance[i] = (int)cpi->output_frame_rate;
1904     }
1905
1906 #ifdef OUTPUT_YUV_SRC
1907     yuv_file = fopen("bd.yuv", "ab");
1908 #endif
1909
1910 #if 0
1911     framepsnr = fopen("framepsnr.stt", "a");
1912     kf_list = fopen("kf_list.stt", "w");
1913 #endif
1914
1915     cpi->output_pkt_list = oxcf->output_pkt_list;
1916
1917 #if !(CONFIG_REALTIME_ONLY)
1918
1919     if (cpi->pass == 1)
1920     {
1921         vp8_init_first_pass(cpi);
1922     }
1923     else if (cpi->pass == 2)
1924     {
1925         size_t packet_sz = sizeof(FIRSTPASS_STATS);
1926         int packets = oxcf->two_pass_stats_in.sz / packet_sz;
1927
1928         cpi->twopass.stats_in_start = oxcf->two_pass_stats_in.buf;
1929         cpi->twopass.stats_in = cpi->twopass.stats_in_start;
1930         cpi->twopass.stats_in_end = (void*)((char *)cpi->twopass.stats_in
1931                             + (packets - 1) * packet_sz);
1932         vp8_init_second_pass(cpi);
1933     }
1934
1935 #endif
1936
1937     if (cpi->compressor_speed == 2)
1938     {
1939         cpi->cpu_freq            = 0; //vp8_get_processor_freq();
1940         cpi->avg_encode_time      = 0;
1941         cpi->avg_pick_mode_time    = 0;
1942     }
1943
1944     vp8_set_speed_features(cpi);
1945
1946     // Set starting values of RD threshold multipliers (128 = *1)
1947     for (i = 0; i < MAX_MODES; i++)
1948     {
1949         cpi->rd_thresh_mult[i] = 128;
1950     }
1951
1952 #ifdef ENTROPY_STATS
1953     init_mv_ref_counts();
1954 #endif
1955
1956 #if CONFIG_MULTITHREAD
1957     vp8cx_create_encoder_threads(cpi);
1958 #endif
1959
1960     cpi->fn_ptr[BLOCK_16X16].sdf            = vp8_sad16x16;
1961     cpi->fn_ptr[BLOCK_16X16].vf             = vp8_variance16x16;
1962     cpi->fn_ptr[BLOCK_16X16].svf            = vp8_sub_pixel_variance16x16;
1963     cpi->fn_ptr[BLOCK_16X16].svf_halfpix_h  = vp8_variance_halfpixvar16x16_h;
1964     cpi->fn_ptr[BLOCK_16X16].svf_halfpix_v  = vp8_variance_halfpixvar16x16_v;
1965     cpi->fn_ptr[BLOCK_16X16].svf_halfpix_hv = vp8_variance_halfpixvar16x16_hv;
1966     cpi->fn_ptr[BLOCK_16X16].sdx3f          = vp8_sad16x16x3;
1967     cpi->fn_ptr[BLOCK_16X16].sdx8f          = vp8_sad16x16x8;
1968     cpi->fn_ptr[BLOCK_16X16].sdx4df         = vp8_sad16x16x4d;
1969
1970     cpi->fn_ptr[BLOCK_16X8].sdf            = vp8_sad16x8;
1971     cpi->fn_ptr[BLOCK_16X8].vf             = vp8_variance16x8;
1972     cpi->fn_ptr[BLOCK_16X8].svf            = vp8_sub_pixel_variance16x8;
1973     cpi->fn_ptr[BLOCK_16X8].svf_halfpix_h  = NULL;
1974     cpi->fn_ptr[BLOCK_16X8].svf_halfpix_v  = NULL;
1975     cpi->fn_ptr[BLOCK_16X8].svf_halfpix_hv = NULL;
1976     cpi->fn_ptr[BLOCK_16X8].sdx3f          = vp8_sad16x8x3;
1977     cpi->fn_ptr[BLOCK_16X8].sdx8f          = vp8_sad16x8x8;
1978     cpi->fn_ptr[BLOCK_16X8].sdx4df         = vp8_sad16x8x4d;
1979
1980     cpi->fn_ptr[BLOCK_8X16].sdf            = vp8_sad8x16;
1981     cpi->fn_ptr[BLOCK_8X16].vf             = vp8_variance8x16;
1982     cpi->fn_ptr[BLOCK_8X16].svf            = vp8_sub_pixel_variance8x16;
1983     cpi->fn_ptr[BLOCK_8X16].svf_halfpix_h  = NULL;
1984     cpi->fn_ptr[BLOCK_8X16].svf_halfpix_v  = NULL;
1985     cpi->fn_ptr[BLOCK_8X16].svf_halfpix_hv = NULL;
1986     cpi->fn_ptr[BLOCK_8X16].sdx3f          = vp8_sad8x16x3;
1987     cpi->fn_ptr[BLOCK_8X16].sdx8f          = vp8_sad8x16x8;
1988     cpi->fn_ptr[BLOCK_8X16].sdx4df         = vp8_sad8x16x4d;
1989
1990     cpi->fn_ptr[BLOCK_8X8].sdf            = vp8_sad8x8;
1991     cpi->fn_ptr[BLOCK_8X8].vf             = vp8_variance8x8;
1992     cpi->fn_ptr[BLOCK_8X8].svf            = vp8_sub_pixel_variance8x8;
1993     cpi->fn_ptr[BLOCK_8X8].svf_halfpix_h  = NULL;
1994     cpi->fn_ptr[BLOCK_8X8].svf_halfpix_v  = NULL;
1995     cpi->fn_ptr[BLOCK_8X8].svf_halfpix_hv = NULL;
1996     cpi->fn_ptr[BLOCK_8X8].sdx3f          = vp8_sad8x8x3;
1997     cpi->fn_ptr[BLOCK_8X8].sdx8f          = vp8_sad8x8x8;
1998     cpi->fn_ptr[BLOCK_8X8].sdx4df         = vp8_sad8x8x4d;
1999
2000     cpi->fn_ptr[BLOCK_4X4].sdf            = vp8_sad4x4;
2001     cpi->fn_ptr[BLOCK_4X4].vf             = vp8_variance4x4;
2002     cpi->fn_ptr[BLOCK_4X4].svf            = vp8_sub_pixel_variance4x4;
2003     cpi->fn_ptr[BLOCK_4X4].svf_halfpix_h  = NULL;
2004     cpi->fn_ptr[BLOCK_4X4].svf_halfpix_v  = NULL;
2005     cpi->fn_ptr[BLOCK_4X4].svf_halfpix_hv = NULL;
2006     cpi->fn_ptr[BLOCK_4X4].sdx3f          = vp8_sad4x4x3;
2007     cpi->fn_ptr[BLOCK_4X4].sdx8f          = vp8_sad4x4x8;
2008     cpi->fn_ptr[BLOCK_4X4].sdx4df         = vp8_sad4x4x4d;
2009
2010 #if ARCH_X86 || ARCH_X86_64
2011     cpi->fn_ptr[BLOCK_16X16].copymem      = vp8_copy32xn;
2012     cpi->fn_ptr[BLOCK_16X8].copymem       = vp8_copy32xn;
2013     cpi->fn_ptr[BLOCK_8X16].copymem       = vp8_copy32xn;
2014     cpi->fn_ptr[BLOCK_8X8].copymem        = vp8_copy32xn;
2015     cpi->fn_ptr[BLOCK_4X4].copymem        = vp8_copy32xn;
2016 #endif
2017
2018     cpi->full_search_sad = vp8_full_search_sad;
2019     cpi->diamond_search_sad = vp8_diamond_search_sad;
2020     cpi->refining_search_sad = vp8_refining_search_sad;
2021
2022     // make sure frame 1 is okay
2023     cpi->error_bins[0] = cpi->common.MBs;
2024
2025     //vp8cx_init_quantizer() is first called here. Add check in vp8cx_frame_init_quantizer() so that vp8cx_init_quantizer is only called later
2026     //when needed. This will avoid unnecessary calls of vp8cx_init_quantizer() for every frame.
2027     vp8cx_init_quantizer(cpi);
2028
2029     vp8_loop_filter_init(cm);
2030
2031     cpi->common.error.setjmp = 0;
2032
2033 #if CONFIG_MULTI_RES_ENCODING
2034
2035     /* Calculate # of MBs in a row in lower-resolution level image. */
2036     if (cpi->oxcf.mr_encoder_id > 0)
2037         vp8_cal_low_res_mb_cols(cpi);
2038
2039 #endif
2040
2041     /* setup RD costs to MACROBLOCK struct */
2042
2043     cpi->mb.mvcost[0] = &cpi->rd_costs.mvcosts[0][mv_max+1];
2044     cpi->mb.mvcost[1] = &cpi->rd_costs.mvcosts[1][mv_max+1];
2045     cpi->mb.mvsadcost[0] = &cpi->rd_costs.mvsadcosts[0][mvfp_max+1];
2046     cpi->mb.mvsadcost[1] = &cpi->rd_costs.mvsadcosts[1][mvfp_max+1];
2047
2048     cal_mvsadcosts(cpi->mb.mvsadcost);
2049
2050     cpi->mb.mbmode_cost = cpi->rd_costs.mbmode_cost;
2051     cpi->mb.intra_uv_mode_cost = cpi->rd_costs.intra_uv_mode_cost;
2052     cpi->mb.bmode_costs = cpi->rd_costs.bmode_costs;
2053     cpi->mb.inter_bmode_costs = cpi->rd_costs.inter_bmode_costs;
2054     cpi->mb.token_costs = cpi->rd_costs.token_costs;
2055
2056     return  cpi;
2057 }
2058
2059
2060 void vp8_remove_compressor(VP8_COMP **ptr)
2061 {
2062     VP8_COMP *cpi = *ptr;
2063
2064     if (!cpi)
2065         return;
2066
2067     if (cpi && (cpi->common.current_video_frame > 0))
2068     {
2069 #if !(CONFIG_REALTIME_ONLY)
2070
2071         if (cpi->pass == 2)
2072         {
2073             vp8_end_second_pass(cpi);
2074         }
2075
2076 #endif
2077
2078 #ifdef ENTROPY_STATS
2079         print_context_counters();
2080         print_tree_update_probs();
2081         print_mode_context();
2082 #endif
2083
2084 #if CONFIG_INTERNAL_STATS
2085
2086         if (cpi->pass != 1)
2087         {
2088             FILE *f = fopen("opsnr.stt", "a");
2089             double time_encoded = (cpi->last_end_time_stamp_seen
2090                                    - cpi->first_time_stamp_ever) / 10000000.000;
2091             double total_encode_time = (cpi->time_receive_data +
2092                                             cpi->time_compress_data) / 1000.000;
2093             double dr = (double)cpi->bytes * 8.0 / 1000.0 / time_encoded;
2094
2095             if (cpi->b_calculate_psnr)
2096             {
2097                 YV12_BUFFER_CONFIG *lst_yv12 =
2098                               &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2099
2100                 if (cpi->oxcf.number_of_layers > 1)
2101                 {
2102                     int i;
2103
2104                     fprintf(f, "Layer\tBitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\t"
2105                                "GLPsnrP\tVPXSSIM\t\n");
2106                     for (i=0; i<cpi->oxcf.number_of_layers; i++)
2107                     {
2108                         double dr = (double)cpi->bytes_in_layer[i] *
2109                                               8.0 / 1000.0  / time_encoded;
2110                         double samples = 3.0 / 2 * cpi->frames_in_layer[i] *
2111                                          lst_yv12->y_width * lst_yv12->y_height;
2112                         double total_psnr = vp8_mse2psnr(samples, 255.0,
2113                                                   cpi->total_error2[i]);
2114                         double total_psnr2 = vp8_mse2psnr(samples, 255.0,
2115                                                   cpi->total_error2_p[i]);
2116                         double total_ssim = 100 * pow(cpi->sum_ssim[i] /
2117                                                       cpi->sum_weights[i], 8.0);
2118
2119                         fprintf(f, "%5d\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2120                                    "%7.3f\t%7.3f\n",
2121                                    i, dr,
2122                                    cpi->sum_psnr[i] / cpi->frames_in_layer[i],
2123                                    total_psnr,
2124                                    cpi->sum_psnr_p[i] / cpi->frames_in_layer[i],
2125                                    total_psnr2, total_ssim);
2126                     }
2127                 }
2128                 else
2129                 {
2130                     double samples = 3.0 / 2 * cpi->count *
2131                                         lst_yv12->y_width * lst_yv12->y_height;
2132                     double total_psnr = vp8_mse2psnr(samples, 255.0,
2133                                                          cpi->total_sq_error);
2134                     double total_psnr2 = vp8_mse2psnr(samples, 255.0,
2135                                                          cpi->total_sq_error2);
2136                     double total_ssim = 100 * pow(cpi->summed_quality /
2137                                                       cpi->summed_weights, 8.0);
2138
2139                     fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\t"
2140                                "GLPsnrP\tVPXSSIM\t  Time(us)\n");
2141                     fprintf(f, "%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t"
2142                                "%7.3f\t%8.0f\n",
2143                                dr, cpi->total / cpi->count, total_psnr,
2144                                cpi->totalp / cpi->count, total_psnr2,
2145                                total_ssim, total_encode_time);
2146                 }
2147             }
2148
2149             if (cpi->b_calculate_ssimg)
2150             {
2151                 if (cpi->oxcf.number_of_layers > 1)
2152                 {
2153                     int i;
2154
2155                     fprintf(f, "Layer\tBitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t"
2156                                "Time(us)\n");
2157                     for (i=0; i<cpi->oxcf.number_of_layers; i++)
2158                     {
2159                         double dr = (double)cpi->bytes_in_layer[i] *
2160                                     8.0 / 1000.0  / time_encoded;
2161                         fprintf(f, "%5d\t%7.3f\t%6.4f\t"
2162                                 "%6.4f\t%6.4f\t%6.4f\t%8.0f\n",
2163                                 i, dr,
2164                                 cpi->total_ssimg_y_in_layer[i] /
2165                                      cpi->frames_in_layer[i],
2166                                 cpi->total_ssimg_u_in_layer[i] /
2167                                      cpi->frames_in_layer[i],
2168                                 cpi->total_ssimg_v_in_layer[i] /
2169                                      cpi->frames_in_layer[i],
2170                                 cpi->total_ssimg_all_in_layer[i] /
2171                                      cpi->frames_in_layer[i],
2172                                 total_encode_time);
2173                     }
2174                 }
2175                 else
2176                 {
2177                     fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t"
2178                                "Time(us)\n");
2179                     fprintf(f, "%7.3f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
2180                             cpi->total_ssimg_y / cpi->count,
2181                             cpi->total_ssimg_u / cpi->count,
2182                             cpi->total_ssimg_v / cpi->count,
2183                             cpi->total_ssimg_all / cpi->count, total_encode_time);
2184                 }
2185             }
2186
2187             fclose(f);
2188 #if 0
2189             f = fopen("qskip.stt", "a");
2190             fprintf(f, "minq:%d -maxq:%d skiptrue:skipfalse = %d:%d\n", cpi->oxcf.best_allowed_q, cpi->oxcf.worst_allowed_q, skiptruecount, skipfalsecount);
2191             fclose(f);
2192 #endif
2193
2194         }
2195
2196 #endif
2197
2198
2199 #ifdef SPEEDSTATS
2200
2201         if (cpi->compressor_speed == 2)
2202         {
2203             int i;
2204             FILE *f = fopen("cxspeed.stt", "a");
2205             cnt_pm /= cpi->common.MBs;
2206
2207             for (i = 0; i < 16; i++)
2208                 fprintf(f, "%5d", frames_at_speed[i]);
2209
2210             fprintf(f, "\n");
2211             //fprintf(f, "%10d PM %10d %10d %10d EF %10d %10d %10d\n", cpi->Speed, cpi->avg_pick_mode_time, (tot_pm/cnt_pm), cnt_pm,  cpi->avg_encode_time, 0, 0);
2212             fclose(f);
2213         }
2214
2215 #endif
2216
2217
2218 #ifdef MODE_STATS
2219         {
2220             extern int count_mb_seg[4];
2221             FILE *f = fopen("modes.stt", "a");
2222             double dr = (double)cpi->frame_rate * (double)bytes * (double)8 / (double)count / (double)1000 ;
2223             fprintf(f, "intra_mode in Intra Frames:\n");
2224             fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d\n", y_modes[0], y_modes[1], y_modes[2], y_modes[3], y_modes[4]);
2225             fprintf(f, "UV:%8d, %8d, %8d, %8d\n", uv_modes[0], uv_modes[1], uv_modes[2], uv_modes[3]);
2226             fprintf(f, "B: ");
2227             {
2228                 int i;
2229
2230                 for (i = 0; i < 10; i++)
2231                     fprintf(f, "%8d, ", b_modes[i]);
2232
2233                 fprintf(f, "\n");
2234
2235             }
2236
2237             fprintf(f, "Modes in Inter Frames:\n");
2238             fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d\n",
2239                     inter_y_modes[0], inter_y_modes[1], inter_y_modes[2], inter_y_modes[3], inter_y_modes[4],
2240                     inter_y_modes[5], inter_y_modes[6], inter_y_modes[7], inter_y_modes[8], inter_y_modes[9]);
2241             fprintf(f, "UV:%8d, %8d, %8d, %8d\n", inter_uv_modes[0], inter_uv_modes[1], inter_uv_modes[2], inter_uv_modes[3]);
2242             fprintf(f, "B: ");
2243             {
2244                 int i;
2245
2246                 for (i = 0; i < 15; i++)
2247                     fprintf(f, "%8d, ", inter_b_modes[i]);
2248
2249                 fprintf(f, "\n");
2250
2251             }
2252             fprintf(f, "P:%8d, %8d, %8d, %8d\n", count_mb_seg[0], count_mb_seg[1], count_mb_seg[2], count_mb_seg[3]);
2253             fprintf(f, "PB:%8d, %8d, %8d, %8d\n", inter_b_modes[LEFT4X4], inter_b_modes[ABOVE4X4], inter_b_modes[ZERO4X4], inter_b_modes[NEW4X4]);
2254
2255
2256
2257             fclose(f);
2258         }
2259 #endif
2260
2261 #ifdef ENTROPY_STATS
2262         {
2263             int i, j, k;
2264             FILE *fmode = fopen("modecontext.c", "w");
2265
2266             fprintf(fmode, "\n#include \"entropymode.h\"\n\n");
2267             fprintf(fmode, "const unsigned int vp8_kf_default_bmode_counts ");
2268             fprintf(fmode, "[VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES] =\n{\n");
2269
2270             for (i = 0; i < 10; i++)
2271             {
2272
2273                 fprintf(fmode, "    { //Above Mode :  %d\n", i);
2274
2275                 for (j = 0; j < 10; j++)
2276                 {
2277
2278                     fprintf(fmode, "        {");
2279
2280                     for (k = 0; k < 10; k++)
2281                     {
2282                         if (!intra_mode_stats[i][j][k])
2283                             fprintf(fmode, " %5d, ", 1);
2284                         else
2285                             fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2286                     }
2287
2288                     fprintf(fmode, "}, // left_mode %d\n", j);
2289
2290                 }
2291
2292                 fprintf(fmode, "    },\n");
2293
2294             }
2295
2296             fprintf(fmode, "};\n");
2297             fclose(fmode);
2298         }
2299 #endif
2300
2301
2302 #if defined(SECTIONBITS_OUTPUT)
2303
2304         if (0)
2305         {
2306             int i;
2307             FILE *f = fopen("tokenbits.stt", "a");
2308
2309             for (i = 0; i < 28; i++)
2310                 fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2311
2312             fprintf(f, "\n");
2313             fclose(f);
2314         }
2315
2316 #endif
2317
2318 #if 0
2319         {
2320             printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2321             printf("\n_frames recive_data encod_mb_row compress_frame  Total\n");
2322             printf("%6d %10ld %10ld %10ld %10ld\n", cpi->common.current_video_frame, cpi->time_receive_data / 1000, cpi->time_encode_mb_row / 1000, cpi->time_compress_data / 1000, (cpi->time_receive_data + cpi->time_compress_data) / 1000);
2323         }
2324 #endif
2325
2326     }
2327
2328 #if CONFIG_MULTITHREAD
2329     vp8cx_remove_encoder_threads(cpi);
2330 #endif
2331
2332 #if CONFIG_TEMPORAL_DENOISING
2333     vp8_denoiser_free(&cpi->denoiser);
2334 #endif
2335     dealloc_compressor_data(cpi);
2336     vpx_free(cpi->mb.ss);
2337     vpx_free(cpi->tok);
2338     vpx_free(cpi->cyclic_refresh_map);
2339
2340     vp8_remove_common(&cpi->common);
2341     vpx_free(cpi);
2342     *ptr = 0;
2343
2344 #ifdef OUTPUT_YUV_SRC
2345     fclose(yuv_file);
2346 #endif
2347
2348 #if 0
2349
2350     if (keyfile)
2351         fclose(keyfile);
2352
2353     if (framepsnr)
2354         fclose(framepsnr);
2355
2356     if (kf_list)
2357         fclose(kf_list);
2358
2359 #endif
2360
2361 }
2362
2363
2364 static uint64_t calc_plane_error(unsigned char *orig, int orig_stride,
2365                                  unsigned char *recon, int recon_stride,
2366                                  unsigned int cols, unsigned int rows)
2367 {
2368     unsigned int row, col;
2369     uint64_t total_sse = 0;
2370     int diff;
2371
2372     for (row = 0; row + 16 <= rows; row += 16)
2373     {
2374         for (col = 0; col + 16 <= cols; col += 16)
2375         {
2376             unsigned int sse;
2377
2378             vp8_mse16x16(orig + col, orig_stride,
2379                                             recon + col, recon_stride,
2380                                             &sse);
2381             total_sse += sse;
2382         }
2383
2384         /* Handle odd-sized width */
2385         if (col < cols)
2386         {
2387             unsigned int   border_row, border_col;
2388             unsigned char *border_orig = orig;
2389             unsigned char *border_recon = recon;
2390
2391             for (border_row = 0; border_row < 16; border_row++)
2392             {
2393                 for (border_col = col; border_col < cols; border_col++)
2394                 {
2395                     diff = border_orig[border_col] - border_recon[border_col];
2396                     total_sse += diff * diff;
2397                 }
2398
2399                 border_orig += orig_stride;
2400                 border_recon += recon_stride;
2401             }
2402         }
2403
2404         orig += orig_stride * 16;
2405         recon += recon_stride * 16;
2406     }
2407
2408     /* Handle odd-sized height */
2409     for (; row < rows; row++)
2410     {
2411         for (col = 0; col < cols; col++)
2412         {
2413             diff = orig[col] - recon[col];
2414             total_sse += diff * diff;
2415         }
2416
2417         orig += orig_stride;
2418         recon += recon_stride;
2419     }
2420
2421     vp8_clear_system_state();
2422     return total_sse;
2423 }
2424
2425
2426 static void generate_psnr_packet(VP8_COMP *cpi)
2427 {
2428     YV12_BUFFER_CONFIG      *orig = cpi->Source;
2429     YV12_BUFFER_CONFIG      *recon = cpi->common.frame_to_show;
2430     struct vpx_codec_cx_pkt  pkt;
2431     uint64_t                 sse;
2432     int                      i;
2433     unsigned int             width = cpi->common.Width;
2434     unsigned int             height = cpi->common.Height;
2435
2436     pkt.kind = VPX_CODEC_PSNR_PKT;
2437     sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2438                            recon->y_buffer, recon->y_stride,
2439                            width, height);
2440     pkt.data.psnr.sse[0] = sse;
2441     pkt.data.psnr.sse[1] = sse;
2442     pkt.data.psnr.samples[0] = width * height;
2443     pkt.data.psnr.samples[1] = width * height;
2444
2445     width = (width + 1) / 2;
2446     height = (height + 1) / 2;
2447
2448     sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2449                            recon->u_buffer, recon->uv_stride,
2450                            width, height);
2451     pkt.data.psnr.sse[0] += sse;
2452     pkt.data.psnr.sse[2] = sse;
2453     pkt.data.psnr.samples[0] += width * height;
2454     pkt.data.psnr.samples[2] = width * height;
2455
2456     sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2457                            recon->v_buffer, recon->uv_stride,
2458                            width, height);
2459     pkt.data.psnr.sse[0] += sse;
2460     pkt.data.psnr.sse[3] = sse;
2461     pkt.data.psnr.samples[0] += width * height;
2462     pkt.data.psnr.samples[3] = width * height;
2463
2464     for (i = 0; i < 4; i++)
2465         pkt.data.psnr.psnr[i] = vp8_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2466                                              pkt.data.psnr.sse[i]);
2467
2468     vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2469 }
2470
2471
2472 int vp8_use_as_reference(VP8_COMP *cpi, int ref_frame_flags)
2473 {
2474     if (ref_frame_flags > 7)
2475         return -1 ;
2476
2477     cpi->ref_frame_flags = ref_frame_flags;
2478     return 0;
2479 }
2480 int vp8_update_reference(VP8_COMP *cpi, int ref_frame_flags)
2481 {
2482     if (ref_frame_flags > 7)
2483         return -1 ;
2484
2485     cpi->common.refresh_golden_frame = 0;
2486     cpi->common.refresh_alt_ref_frame = 0;
2487     cpi->common.refresh_last_frame   = 0;
2488
2489     if (ref_frame_flags & VP8_LAST_FLAG)
2490         cpi->common.refresh_last_frame = 1;
2491
2492     if (ref_frame_flags & VP8_GOLD_FLAG)
2493         cpi->common.refresh_golden_frame = 1;
2494
2495     if (ref_frame_flags & VP8_ALT_FLAG)
2496         cpi->common.refresh_alt_ref_frame = 1;
2497
2498     return 0;
2499 }
2500
2501 int vp8_get_reference(VP8_COMP *cpi, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2502 {
2503     VP8_COMMON *cm = &cpi->common;
2504     int ref_fb_idx;
2505
2506     if (ref_frame_flag == VP8_LAST_FLAG)
2507         ref_fb_idx = cm->lst_fb_idx;
2508     else if (ref_frame_flag == VP8_GOLD_FLAG)
2509         ref_fb_idx = cm->gld_fb_idx;
2510     else if (ref_frame_flag == VP8_ALT_FLAG)
2511         ref_fb_idx = cm->alt_fb_idx;
2512     else
2513         return -1;
2514
2515     vp8_yv12_copy_frame(&cm->yv12_fb[ref_fb_idx], sd);
2516
2517     return 0;
2518 }
2519 int vp8_set_reference(VP8_COMP *cpi, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2520 {
2521     VP8_COMMON *cm = &cpi->common;
2522
2523     int ref_fb_idx;
2524
2525     if (ref_frame_flag == VP8_LAST_FLAG)
2526         ref_fb_idx = cm->lst_fb_idx;
2527     else if (ref_frame_flag == VP8_GOLD_FLAG)
2528         ref_fb_idx = cm->gld_fb_idx;
2529     else if (ref_frame_flag == VP8_ALT_FLAG)
2530         ref_fb_idx = cm->alt_fb_idx;
2531     else
2532         return -1;
2533
2534     vp8_yv12_copy_frame(sd, &cm->yv12_fb[ref_fb_idx]);
2535
2536     return 0;
2537 }
2538 int vp8_update_entropy(VP8_COMP *cpi, int update)
2539 {
2540     VP8_COMMON *cm = &cpi->common;
2541     cm->refresh_entropy_probs = update;
2542
2543     return 0;
2544 }
2545
2546
2547 #if OUTPUT_YUV_SRC
2548 void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
2549 {
2550     FILE *yuv_file = fopen(name, "ab");
2551     unsigned char *src = s->y_buffer;
2552     int h = s->y_height;
2553
2554     do
2555     {
2556         fwrite(src, s->y_width, 1,  yuv_file);
2557         src += s->y_stride;
2558     }
2559     while (--h);
2560
2561     src = s->u_buffer;
2562     h = s->uv_height;
2563
2564     do
2565     {
2566         fwrite(src, s->uv_width, 1,  yuv_file);
2567         src += s->uv_stride;
2568     }
2569     while (--h);
2570
2571     src = s->v_buffer;
2572     h = s->uv_height;
2573
2574     do
2575     {
2576         fwrite(src, s->uv_width, 1, yuv_file);
2577         src += s->uv_stride;
2578     }
2579     while (--h);
2580
2581     fclose(yuv_file);
2582 }
2583 #endif
2584
2585
2586 static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
2587 {
2588     VP8_COMMON *cm = &cpi->common;
2589
2590     // are we resizing the image
2591     if (cm->horiz_scale != 0 || cm->vert_scale != 0)
2592     {
2593 #if CONFIG_SPATIAL_RESAMPLING
2594         int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2595         int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2596         int tmp_height;
2597
2598         if (cm->vert_scale == 3)
2599             tmp_height = 9;
2600         else
2601             tmp_height = 11;
2602
2603         Scale2Ratio(cm->horiz_scale, &hr, &hs);
2604         Scale2Ratio(cm->vert_scale, &vr, &vs);
2605
2606         vp8_scale_frame(sd, &cpi->scaled_source, cm->temp_scale_frame.y_buffer,
2607                         tmp_height, hs, hr, vs, vr, 0);
2608
2609         vp8_yv12_extend_frame_borders(&cpi->scaled_source);
2610         cpi->Source = &cpi->scaled_source;
2611 #endif
2612     }
2613     else
2614         cpi->Source = sd;
2615 }
2616
2617
2618 static void resize_key_frame(VP8_COMP *cpi)
2619 {
2620 #if CONFIG_SPATIAL_RESAMPLING
2621     VP8_COMMON *cm = &cpi->common;
2622
2623     // Do we need to apply resampling for one pass cbr.
2624     // In one pass this is more limited than in two pass cbr
2625     // The test and any change is only made one per key frame sequence
2626     if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
2627     {
2628         int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2629         int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2630         int new_width, new_height;
2631
2632         // If we are below the resample DOWN watermark then scale down a notch.
2633         if (cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2634         {
2635             cm->horiz_scale = (cm->horiz_scale < ONETWO) ? cm->horiz_scale + 1 : ONETWO;
2636             cm->vert_scale = (cm->vert_scale < ONETWO) ? cm->vert_scale + 1 : ONETWO;
2637         }
2638         // Should we now start scaling back up
2639         else if (cpi->buffer_level > (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2640         {
2641             cm->horiz_scale = (cm->horiz_scale > NORMAL) ? cm->horiz_scale - 1 : NORMAL;
2642             cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL;
2643         }
2644
2645         // Get the new hieght and width
2646         Scale2Ratio(cm->horiz_scale, &hr, &hs);
2647         Scale2Ratio(cm->vert_scale, &vr, &vs);
2648         new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2649         new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2650
2651         // If the image size has changed we need to reallocate the buffers
2652         // and resample the source image
2653         if ((cm->Width != new_width) || (cm->Height != new_height))
2654         {
2655             cm->Width = new_width;
2656             cm->Height = new_height;
2657             vp8_alloc_compressor_data(cpi);
2658             scale_and_extend_source(cpi->un_scaled_source, cpi);
2659         }
2660     }
2661
2662 #endif
2663 }
2664
2665
2666 static void update_alt_ref_frame_stats(VP8_COMP *cpi)
2667 {
2668     VP8_COMMON *cm = &cpi->common;
2669
2670     // Select an interval before next GF or altref
2671     if (!cpi->auto_gold)
2672         cpi->frames_till_gf_update_due = cpi->goldfreq;
2673
2674     if ((cpi->pass != 2) && cpi->frames_till_gf_update_due)
2675     {
2676         cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2677
2678         // Set the bits per frame that we should try and recover in subsequent inter frames
2679         // to account for the extra GF spend... note that his does not apply for GF updates
2680         // that occur coincident with a key frame as the extra cost of key frames is dealt
2681         // with elsewhere.
2682
2683         cpi->gf_overspend_bits += cpi->projected_frame_size;
2684         cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2685     }
2686
2687     // Update data structure that monitors level of reference to last GF
2688     vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2689     cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2690
2691     // this frame refreshes means next frames don't unless specified by user
2692     cpi->common.frames_since_golden = 0;
2693
2694     // Clear the alternate reference update pending flag.
2695     cpi->source_alt_ref_pending = 0;
2696
2697     // Set the alternate refernce frame active flag
2698     cpi->source_alt_ref_active = 1;
2699
2700
2701 }
2702 static void update_golden_frame_stats(VP8_COMP *cpi)
2703 {
2704     VP8_COMMON *cm = &cpi->common;
2705
2706     // Update the Golden frame usage counts.
2707     if (cm->refresh_golden_frame)
2708     {
2709         // Select an interval before next GF
2710         if (!cpi->auto_gold)
2711             cpi->frames_till_gf_update_due = cpi->goldfreq;
2712
2713         if ((cpi->pass != 2) && (cpi->frames_till_gf_update_due > 0))
2714         {
2715             cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2716
2717             // Set the bits per frame that we should try and recover in subsequent inter frames
2718             // to account for the extra GF spend... note that his does not apply for GF updates
2719             // that occur coincident with a key frame as the extra cost of key frames is dealt
2720             // with elsewhere.
2721             if ((cm->frame_type != KEY_FRAME) && !cpi->source_alt_ref_active)
2722             {
2723                 // Calcluate GF bits to be recovered
2724                 // Projected size - av frame bits available for inter frames for clip as a whole
2725                 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->inter_frame_target);
2726             }
2727
2728             cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2729
2730         }
2731
2732         // Update data structure that monitors level of reference to last GF
2733         vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2734         cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2735
2736         // this frame refreshes means next frames don't unless specified by user
2737         cm->refresh_golden_frame = 0;
2738         cpi->common.frames_since_golden = 0;
2739
2740         //if ( cm->frame_type == KEY_FRAME )
2741         //{
2742         cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
2743         cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
2744         cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
2745         cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
2746         //}
2747         //else
2748         //{
2749         //  // Carry a potrtion of count over to begining of next gf sequence
2750         //  cpi->recent_ref_frame_usage[INTRA_FRAME] >>= 5;
2751         //  cpi->recent_ref_frame_usage[LAST_FRAME] >>= 5;
2752         //  cpi->recent_ref_frame_usage[GOLDEN_FRAME] >>= 5;
2753         //  cpi->recent_ref_frame_usage[ALTREF_FRAME] >>= 5;
2754         //}
2755
2756         // ******** Fixed Q test code only ************
2757         // If we are going to use the ALT reference for the next group of frames set a flag to say so.
2758         if (cpi->oxcf.fixed_q >= 0 &&
2759             cpi->oxcf.play_alternate && !cpi->common.refresh_alt_ref_frame)
2760         {
2761             cpi->source_alt_ref_pending = 1;
2762             cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2763         }
2764
2765         if (!cpi->source_alt_ref_pending)
2766             cpi->source_alt_ref_active = 0;
2767
2768         // Decrement count down till next gf
2769         if (cpi->frames_till_gf_update_due > 0)
2770             cpi->frames_till_gf_update_due--;
2771
2772     }
2773     else if (!cpi->common.refresh_alt_ref_frame)
2774     {
2775         // Decrement count down till next gf
2776         if (cpi->frames_till_gf_update_due > 0)
2777             cpi->frames_till_gf_update_due--;
2778
2779         if (cpi->common.frames_till_alt_ref_frame)
2780             cpi->common.frames_till_alt_ref_frame --;
2781
2782         cpi->common.frames_since_golden ++;
2783
2784         if (cpi->common.frames_since_golden > 1)
2785         {
2786             cpi->recent_ref_frame_usage[INTRA_FRAME] += cpi->count_mb_ref_frame_usage[INTRA_FRAME];
2787             cpi->recent_ref_frame_usage[LAST_FRAME] += cpi->count_mb_ref_frame_usage[LAST_FRAME];
2788             cpi->recent_ref_frame_usage[GOLDEN_FRAME] += cpi->count_mb_ref_frame_usage[GOLDEN_FRAME];
2789             cpi->recent_ref_frame_usage[ALTREF_FRAME] += cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
2790         }
2791     }
2792 }
2793
2794 // This function updates the reference frame probability estimates that
2795 // will be used during mode selection
2796 static void update_rd_ref_frame_probs(VP8_COMP *cpi)
2797 {
2798     VP8_COMMON *cm = &cpi->common;
2799
2800     const int *const rfct = cpi->count_mb_ref_frame_usage;
2801     const int rf_intra = rfct[INTRA_FRAME];
2802     const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2803
2804     if (cm->frame_type == KEY_FRAME)
2805     {
2806         cpi->prob_intra_coded = 255;
2807         cpi->prob_last_coded  = 128;
2808         cpi->prob_gf_coded  = 128;
2809     }
2810     else if (!(rf_intra + rf_inter))
2811     {
2812         cpi->prob_intra_coded = 63;
2813         cpi->prob_last_coded  = 128;
2814         cpi->prob_gf_coded    = 128;
2815     }
2816
2817     // update reference frame costs since we can do better than what we got last frame.
2818     if (cpi->oxcf.number_of_layers == 1)
2819     {
2820         if (cpi->common.refresh_alt_ref_frame)
2821         {
2822             cpi->prob_intra_coded += 40;
2823             cpi->prob_last_coded = 200;
2824             cpi->prob_gf_coded = 1;
2825         }
2826         else if (cpi->common.frames_since_golden == 0)
2827         {
2828             cpi->prob_last_coded = 214;
2829         }
2830         else if (cpi->common.frames_since_golden == 1)
2831         {
2832             cpi->prob_last_coded = 192;
2833             cpi->prob_gf_coded = 220;
2834         }
2835         else if (cpi->source_alt_ref_active)
2836         {
2837             cpi->prob_gf_coded -= 20;
2838
2839             if (cpi->prob_gf_coded < 10)
2840                 cpi->prob_gf_coded = 10;
2841         }
2842         if (!cpi->source_alt_ref_active)
2843             cpi->prob_gf_coded = 255;
2844     }
2845 }
2846
2847
2848 // 1 = key, 0 = inter
2849 static int decide_key_frame(VP8_COMP *cpi)
2850 {
2851     VP8_COMMON *cm = &cpi->common;
2852
2853     int code_key_frame = 0;
2854
2855     cpi->kf_boost = 0;
2856
2857     if (cpi->Speed > 11)
2858         return 0;
2859
2860     // Clear down mmx registers
2861     vp8_clear_system_state();  //__asm emms;
2862
2863     if ((cpi->compressor_speed == 2) && (cpi->Speed >= 5) && (cpi->sf.RD == 0))
2864     {
2865         double change = 1.0 * abs((int)(cpi->intra_error - cpi->last_intra_error)) / (1 + cpi->last_intra_error);
2866         double change2 = 1.0 * abs((int)(cpi->prediction_error - cpi->last_prediction_error)) / (1 + cpi->last_prediction_error);
2867         double minerror = cm->MBs * 256;
2868
2869 #if 0
2870
2871         if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2872             && cpi->prediction_error > minerror
2873             && (change > .25 || change2 > .25))
2874         {
2875             FILE *f = fopen("intra_inter.stt", "a");
2876
2877             if (cpi->prediction_error <= 0)
2878                 cpi->prediction_error = 1;
2879
2880             fprintf(f, "%d %d %d %d %14.4f\n",
2881                     cm->current_video_frame,
2882                     (int) cpi->prediction_error,
2883                     (int) cpi->intra_error,
2884                     (int)((10 * cpi->intra_error) / cpi->prediction_error),
2885                     change);
2886
2887             fclose(f);
2888         }
2889
2890 #endif
2891
2892         cpi->last_intra_error = cpi->intra_error;
2893         cpi->last_prediction_error = cpi->prediction_error;
2894
2895         if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2896             && cpi->prediction_error > minerror
2897             && (change > .25 || change2 > .25))
2898         {
2899             /*(change > 1.4 || change < .75)&& cpi->this_frame_percent_intra > cpi->last_frame_percent_intra + 3*/
2900             return 1;
2901         }
2902
2903         return 0;
2904
2905     }
2906
2907     // If the following are true we might as well code a key frame
2908     if (((cpi->this_frame_percent_intra == 100) &&
2909          (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 2))) ||
2910         ((cpi->this_frame_percent_intra > 95) &&
2911          (cpi->this_frame_percent_intra >= (cpi->last_frame_percent_intra + 5))))
2912     {
2913         code_key_frame = 1;
2914     }
2915     // in addition if the following are true and this is not a golden frame then code a key frame
2916     // Note that on golden frames there often seems to be a pop in intra useage anyway hence this
2917     // restriction is designed to prevent spurious key frames. The Intra pop needs to be investigated.
2918     else if (((cpi->this_frame_percent_intra > 60) &&
2919               (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 2))) ||
2920              ((cpi->this_frame_percent_intra > 75) &&
2921               (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 3 / 2))) ||
2922              ((cpi->this_frame_percent_intra > 90) &&
2923               (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10))))
2924     {
2925         if (!cm->refresh_golden_frame)
2926             code_key_frame = 1;
2927     }
2928
2929     return code_key_frame;
2930
2931 }
2932
2933 #if !(CONFIG_REALTIME_ONLY)
2934 static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
2935 {
2936     (void) size;
2937     (void) dest;
2938     (void) frame_flags;
2939     vp8_set_quantizer(cpi, 26);
2940
2941     vp8_first_pass(cpi);
2942 }
2943 #endif
2944
2945 #if 0
2946 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame)
2947 {
2948
2949     // write the frame
2950     FILE *yframe;
2951     int i;
2952     char filename[255];
2953
2954     sprintf(filename, "cx\\y%04d.raw", this_frame);
2955     yframe = fopen(filename, "wb");
2956
2957     for (i = 0; i < frame->y_height; i++)
2958         fwrite(frame->y_buffer + i * frame->y_stride, frame->y_width, 1, yframe);
2959
2960     fclose(yframe);
2961     sprintf(filename, "cx\\u%04d.raw", this_frame);
2962     yframe = fopen(filename, "wb");
2963
2964     for (i = 0; i < frame->uv_height; i++)
2965         fwrite(frame->u_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
2966
2967     fclose(yframe);
2968     sprintf(filename, "cx\\v%04d.raw", this_frame);
2969     yframe = fopen(filename, "wb");
2970
2971     for (i = 0; i < frame->uv_height; i++)
2972         fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
2973
2974     fclose(yframe);
2975 }
2976 #endif
2977 // return of 0 means drop frame
2978
2979 // Function to test for conditions that indeicate we should loop
2980 // back and recode a frame.
2981 static int recode_loop_test( VP8_COMP *cpi,
2982                               int high_limit, int low_limit,
2983                               int q, int maxq, int minq )
2984 {
2985     int force_recode = 0;
2986     VP8_COMMON *cm = &cpi->common;
2987
2988     // Is frame recode allowed at all
2989     // Yes if either recode mode 1 is selected or mode two is selcted
2990     // and the frame is a key frame. golden frame or alt_ref_frame
2991     if ( (cpi->sf.recode_loop == 1) ||
2992          ( (cpi->sf.recode_loop == 2) &&
2993            ( (cm->frame_type == KEY_FRAME) ||
2994              cm->refresh_golden_frame ||
2995              cm->refresh_alt_ref_frame ) ) )
2996     {
2997         // General over and under shoot tests
2998         if ( ((cpi->projected_frame_size > high_limit) && (q < maxq)) ||
2999              ((cpi->projected_frame_size < low_limit) && (q > minq)) )
3000         {
3001             force_recode = 1;
3002         }
3003         // Special Constrained quality tests
3004         else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3005         {
3006             // Undershoot and below auto cq level
3007             if ( (q > cpi->cq_target_quality) &&
3008                  (cpi->projected_frame_size <
3009                      ((cpi->this_frame_target * 7) >> 3)))
3010             {
3011                 force_recode = 1;
3012             }
3013             // Severe undershoot and between auto and user cq level
3014             else if ( (q > cpi->oxcf.cq_level) &&
3015                       (cpi->projected_frame_size < cpi->min_frame_bandwidth) &&
3016                       (cpi->active_best_quality > cpi->oxcf.cq_level))
3017             {
3018                 force_recode = 1;
3019                 cpi->active_best_quality = cpi->oxcf.cq_level;
3020             }
3021         }
3022     }
3023
3024     return force_recode;
3025 }
3026
3027 static void update_reference_frames(VP8_COMMON *cm)
3028 {
3029     YV12_BUFFER_CONFIG *yv12_fb = cm->yv12_fb;
3030
3031     // At this point the new frame has been encoded.
3032     // If any buffer copy / swapping is signaled it should be done here.
3033
3034     if (cm->frame_type == KEY_FRAME)
3035     {
3036         yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FLAG | VP8_ALT_FLAG ;
3037
3038         yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3039         yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3040
3041         cm->alt_fb_idx = cm->gld_fb_idx = cm->new_fb_idx;
3042     }
3043     else    /* For non key frames */
3044     {
3045         if (cm->refresh_alt_ref_frame)
3046         {
3047             assert(!cm->copy_buffer_to_arf);
3048
3049             cm->yv12_fb[cm->new_fb_idx].flags |= VP8_ALT_FLAG;
3050             cm->yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3051             cm->alt_fb_idx = cm->new_fb_idx;
3052         }
3053         else if (cm->copy_buffer_to_arf)
3054         {
3055             assert(!(cm->copy_buffer_to_arf & ~0x3));
3056
3057             if (cm->copy_buffer_to_arf == 1)
3058             {
3059                 if(cm->alt_fb_idx != cm->lst_fb_idx)
3060                 {
3061                     yv12_fb[cm->lst_fb_idx].flags |= VP8_ALT_FLAG;
3062                     yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3063                     cm->alt_fb_idx = cm->lst_fb_idx;
3064                 }
3065             }
3066             else /* if (cm->copy_buffer_to_arf == 2) */
3067             {
3068                 if(cm->alt_fb_idx != cm->gld_fb_idx)
3069                 {
3070                     yv12_fb[cm->gld_fb_idx].flags |= VP8_ALT_FLAG;
3071                     yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3072                     cm->alt_fb_idx = cm->gld_fb_idx;
3073                 }
3074             }
3075         }
3076
3077         if (cm->refresh_golden_frame)
3078         {
3079             assert(!cm->copy_buffer_to_gf);
3080
3081             cm->yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FLAG;
3082             cm->yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3083             cm->gld_fb_idx = cm->new_fb_idx;
3084         }
3085         else if (cm->copy_buffer_to_gf)
3086         {
3087             assert(!(cm->copy_buffer_to_arf & ~0x3));
3088
3089             if (cm->copy_buffer_to_gf == 1)
3090             {
3091                 if(cm->gld_fb_idx != cm->lst_fb_idx)
3092                 {
3093                     yv12_fb[cm->lst_fb_idx].flags |= VP8_GOLD_FLAG;
3094                     yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3095                     cm->gld_fb_idx = cm->lst_fb_idx;
3096                 }
3097             }
3098             else /* if (cm->copy_buffer_to_gf == 2) */
3099             {
3100                 if(cm->alt_fb_idx != cm->gld_fb_idx)
3101                 {
3102                     yv12_fb[cm->alt_fb_idx].flags |= VP8_GOLD_FLAG;
3103                     yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3104                     cm->gld_fb_idx = cm->alt_fb_idx;
3105                 }
3106             }
3107         }
3108     }
3109
3110     if (cm->refresh_last_frame)
3111     {
3112         cm->yv12_fb[cm->new_fb_idx].flags |= VP8_LAST_FLAG;
3113         cm->yv12_fb[cm->lst_fb_idx].flags &= ~VP8_LAST_FLAG;
3114         cm->lst_fb_idx = cm->new_fb_idx;
3115     }
3116 }
3117
3118 void vp8_loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm)
3119 {
3120     const FRAME_TYPE frame_type = cm->frame_type;
3121
3122     if (cm->no_lpf)
3123     {
3124         cm->filter_level = 0;
3125     }
3126     else
3127     {
3128         struct vpx_usec_timer timer;
3129
3130         vp8_clear_system_state();
3131
3132         vpx_usec_timer_start(&timer);
3133         if (cpi->sf.auto_filter == 0)
3134             vp8cx_pick_filter_level_fast(cpi->Source, cpi);
3135
3136         else
3137             vp8cx_pick_filter_level(cpi->Source, cpi);
3138
3139         if (cm->filter_level > 0)
3140         {
3141             vp8cx_set_alt_lf_level(cpi, cm->filter_level);
3142         }
3143
3144         vpx_usec_timer_mark(&timer);
3145         cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3146     }
3147
3148 #if CONFIG_MULTITHREAD
3149     if (cpi->b_multi_threaded)
3150         sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */
3151 #endif
3152
3153     if (cm->filter_level > 0)
3154     {
3155         vp8_loop_filter_frame(cm, &cpi->mb.e_mbd, frame_type);
3156     }
3157
3158     vp8_yv12_extend_frame_borders(cm->frame_to_show);
3159 #if CONFIG_TEMPORAL_DENOISING
3160     if (cpi->oxcf.noise_sensitivity)
3161     {
3162       vp8_yv12_extend_frame_borders(&cpi->denoiser.yv12_running_avg);
3163     }
3164 #endif
3165 }
3166
3167 static void encode_frame_to_data_rate
3168 (
3169     VP8_COMP *cpi,
3170     unsigned long *size,
3171     unsigned char *dest,
3172     unsigned char* dest_end,
3173     unsigned int *frame_flags
3174 )
3175 {
3176     int Q;
3177     int frame_over_shoot_limit;
3178     int frame_under_shoot_limit;
3179
3180     int Loop = 0;
3181     int loop_count;
3182
3183     VP8_COMMON *cm = &cpi->common;
3184     int active_worst_qchanged = 0;
3185
3186 #if !(CONFIG_REALTIME_ONLY)
3187     int q_low;
3188     int q_high;
3189     int zbin_oq_high;
3190     int zbin_oq_low = 0;
3191     int top_index;
3192     int bottom_index;
3193     int overshoot_seen = 0;
3194     int undershoot_seen = 0;
3195 #endif
3196
3197     int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
3198     int drop_mark75 = drop_mark * 2 / 3;
3199     int drop_mark50 = drop_mark / 4;
3200     int drop_mark25 = drop_mark / 8;
3201
3202
3203     // Clear down mmx registers to allow floating point in what follows
3204     vp8_clear_system_state();
3205
3206 #if CONFIG_MULTITHREAD
3207     /*  wait for the last picture loopfilter thread done */
3208     if (cpi->b_lpf_running)
3209     {
3210         sem_wait(&cpi->h_event_end_lpf);
3211         cpi->b_lpf_running = 0;
3212     }
3213 #endif
3214
3215     // Test code for segmentation of gf/arf (0,0)
3216     //segmentation_test_function( cpi);
3217
3218     if(cpi->force_next_frame_intra)
3219     {
3220         cm->frame_type = KEY_FRAME;  /* delayed intra frame */
3221         cpi->force_next_frame_intra = 0;
3222     }
3223
3224     // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
3225 #if !(CONFIG_REALTIME_ONLY)
3226
3227     if (cpi->pass == 2)
3228     {
3229         if (cpi->common.refresh_alt_ref_frame)
3230         {
3231             cpi->per_frame_bandwidth = cpi->twopass.gf_bits;                           // Per frame bit target for the alt ref frame
3232             cpi->target_bandwidth = cpi->twopass.gf_bits * cpi->output_frame_rate;      // per second target bitrate
3233         }
3234     }
3235     else
3236 #endif
3237         cpi->per_frame_bandwidth  = (int)(cpi->target_bandwidth / cpi->output_frame_rate);
3238
3239     // Default turn off buffer to buffer copying
3240     cm->copy_buffer_to_gf = 0;
3241     cm->copy_buffer_to_arf = 0;
3242
3243     // Clear zbin over-quant value and mode boost values.
3244     cpi->zbin_over_quant = 0;
3245     cpi->zbin_mode_boost = 0;
3246
3247     // Enable or disable mode based tweaking of the zbin
3248     // For 2 Pass Only used where GF/ARF prediction quality
3249     // is above a threshold
3250     cpi->zbin_mode_boost_enabled = 1;
3251     if (cpi->pass == 2)
3252     {
3253         if ( cpi->gfu_boost <= 400 )
3254         {
3255             cpi->zbin_mode_boost_enabled = 0;
3256         }
3257     }
3258
3259     // Current default encoder behaviour for the altref sign bias
3260     if (cpi->source_alt_ref_active)
3261         cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
3262     else
3263         cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
3264
3265     // Check to see if a key frame is signalled
3266     // For two pass with auto key frame enabled cm->frame_type may already be set, but not for one pass.
3267     if ((cm->current_video_frame == 0) ||
3268         (cm->frame_flags & FRAMEFLAGS_KEY) ||
3269         (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0)))
3270     {
3271         // Key frame from VFW/auto-keyframe/first frame
3272         cm->frame_type = KEY_FRAME;
3273     }
3274
3275 #if CONFIG_MULTI_RES_ENCODING
3276     /* In multi-resolution encoding, frame_type is decided by lowest-resolution
3277      * encoder. Same frame_type is adopted while encoding at other resolution.
3278      */
3279     if (cpi->oxcf.mr_encoder_id)
3280     {
3281         cm->frame_type =
3282             ((LOWER_RES_FRAME_INFO*)cpi->oxcf.mr_low_res_mode_info)->frame_type;
3283     }
3284 #endif
3285
3286     // Set default state for segment and mode based loop filter update flags
3287     cpi->mb.e_mbd.update_mb_segmentation_map = 0;
3288     cpi->mb.e_mbd.update_mb_segmentation_data = 0;
3289     cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
3290
3291     // Set various flags etc to special state if it is a key frame
3292     if (cm->frame_type == KEY_FRAME)
3293     {
3294         int i;
3295
3296         // Reset the loop filter deltas and segmentation map
3297         setup_features(cpi);
3298
3299         // If segmentation is enabled force a map update for key frames
3300         if (cpi->mb.e_mbd.segmentation_enabled)
3301         {
3302             cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3303             cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3304         }
3305
3306         // The alternate reference frame cannot be active for a key frame
3307         cpi->source_alt_ref_active = 0;
3308
3309         // Reset the RD threshold multipliers to default of * 1 (128)
3310         for (i = 0; i < MAX_MODES; i++)
3311         {
3312             cpi->rd_thresh_mult[i] = 128;
3313         }
3314     }
3315
3316     // Test code for segmentation
3317     //if ( (cm->frame_type == KEY_FRAME) || ((cm->current_video_frame % 2) == 0))
3318     //if ( (cm->current_video_frame % 2) == 0 )
3319     //  enable_segmentation(cpi);
3320     //else
3321     //  disable_segmentation(cpi);
3322
3323 #if 0
3324     // Experimental code for lagged compress and one pass
3325     // Initialise one_pass GF frames stats
3326     // Update stats used for GF selection
3327     //if ( cpi->pass == 0 )
3328     {
3329         cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS;
3330
3331         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0;
3332         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0;
3333         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0;
3334         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0;
3335         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0;
3336         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0;
3337         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0;
3338         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0;
3339         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0;
3340     }
3341 #endif
3342
3343     update_rd_ref_frame_probs(cpi);
3344
3345     if (cpi->drop_frames_allowed)
3346     {
3347         // The reset to decimation 0 is only done here for one pass.
3348         // Once it is set two pass leaves decimation on till the next kf.
3349         if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
3350             cpi->decimation_factor --;
3351
3352         if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
3353             cpi->decimation_factor = 1;
3354
3355         else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3))
3356         {
3357             cpi->decimation_factor = 3;
3358         }
3359         else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2))
3360         {
3361             cpi->decimation_factor = 2;
3362         }
3363         else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1))
3364         {
3365             cpi->decimation_factor = 1;
3366         }
3367         //vpx_log("Encoder: Decimation Factor: %d \n",cpi->decimation_factor);
3368     }
3369
3370     // The following decimates the frame rate according to a regular pattern (i.e. to 1/2 or 2/3 frame rate)
3371     // This can be used to help prevent buffer under-run in CBR mode. Alternatively it might be desirable in
3372     // some situations to drop frame rate but throw more bits at each frame.
3373     //
3374     // Note that dropping a key frame can be problematic if spatial resampling is also active
3375     if (cpi->decimation_factor > 0)
3376     {
3377         switch (cpi->decimation_factor)
3378         {
3379         case 1:
3380             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 3 / 2;
3381             break;
3382         case 2:
3383             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 5 / 4;
3384             break;
3385         case 3:
3386             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 5 / 4;
3387             break;
3388         }
3389
3390         // Note that we should not throw out a key frame (especially when spatial resampling is enabled).
3391         if ((cm->frame_type == KEY_FRAME)) // && cpi->oxcf.allow_spatial_resampling )
3392         {
3393             cpi->decimation_count = cpi->decimation_factor;
3394         }
3395         else if (cpi->decimation_count > 0)
3396         {
3397             cpi->decimation_count --;
3398
3399             cpi->bits_off_target += cpi->av_per_frame_bandwidth;
3400             if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
3401                 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
3402
3403             cm->current_video_frame++;
3404             cpi->frames_since_key++;
3405
3406 #if CONFIG_INTERNAL_STATS
3407             cpi->count ++;
3408 #endif
3409
3410             cpi->buffer_level = cpi->bits_off_target;
3411
3412             if (cpi->oxcf.number_of_layers > 1)
3413             {
3414                 unsigned int i;
3415
3416                 // Propagate bits saved by dropping the frame to higher layers
3417                 for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
3418                 {
3419                     LAYER_CONTEXT *lc = &cpi->layer_context[i];
3420                     lc->bits_off_target += cpi->av_per_frame_bandwidth;
3421                     if (lc->bits_off_target > lc->maximum_buffer_size)
3422                         lc->bits_off_target = lc->maximum_buffer_size;
3423                     lc->buffer_level = lc->bits_off_target;
3424                 }
3425             }
3426
3427             return;
3428         }
3429         else
3430             cpi->decimation_count = cpi->decimation_factor;
3431     }
3432
3433     // Decide how big to make the frame
3434     if (!vp8_pick_frame_size(cpi))
3435     {
3436         cm->current_video_frame++;
3437         cpi->frames_since_key++;
3438         return;
3439     }
3440
3441     // Reduce active_worst_allowed_q for CBR if our buffer is getting too full.
3442     // This has a knock on effect on active best quality as well.
3443     // For CBR if the buffer reaches its maximum level then we can no longer
3444     // save up bits for later frames so we might as well use them up
3445     // on the current frame.
3446     if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
3447         (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode)
3448     {
3449         int Adjustment = cpi->active_worst_quality / 4;       // Max adjustment is 1/4
3450
3451         if (Adjustment)
3452         {
3453             int buff_lvl_step;
3454
3455             if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
3456             {
3457                 buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
3458
3459                 if (buff_lvl_step)
3460                     Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
3461                 else
3462                     Adjustment = 0;
3463             }
3464
3465             cpi->active_worst_quality -= Adjustment;
3466
3467             if(cpi->active_worst_quality < cpi->active_best_quality)
3468                 cpi->active_worst_quality = cpi->active_best_quality;
3469         }
3470     }
3471
3472     // Set an active best quality and if necessary active worst quality
3473     // There is some odd behavior for one pass here that needs attention.
3474     if ( (cpi->pass == 2) || (cpi->ni_frames > 150))
3475     {
3476         vp8_clear_system_state();
3477
3478         Q = cpi->active_worst_quality;
3479
3480         if ( cm->frame_type == KEY_FRAME )
3481         {
3482             if ( cpi->pass == 2 )
3483             {
3484                 if (cpi->gfu_boost > 600)
3485                    cpi->active_best_quality = kf_low_motion_minq[Q];
3486                 else
3487                    cpi->active_best_quality = kf_high_motion_minq[Q];
3488
3489                 // Special case for key frames forced because we have reached
3490                 // the maximum key frame interval. Here force the Q to a range
3491                 // based on the ambient Q to reduce the risk of popping
3492                 if ( cpi->this_key_frame_forced )
3493                 {
3494                     if ( cpi->active_best_quality > cpi->avg_frame_qindex * 7/8)
3495                         cpi->active_best_quality = cpi->avg_frame_qindex * 7/8;
3496                     else if ( cpi->active_best_quality < cpi->avg_frame_qindex >> 2 )
3497                         cpi->active_best_quality = cpi->avg_frame_qindex >> 2;
3498                 }
3499             }
3500             // One pass more conservative
3501             else
3502                cpi->active_best_quality = kf_high_motion_minq[Q];
3503         }
3504
3505         else if (cpi->oxcf.number_of_layers==1 &&
3506                 (cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame))
3507         {
3508             // Use the lower of cpi->active_worst_quality and recent
3509             // average Q as basis for GF/ARF Q limit unless last frame was
3510             // a key frame.
3511             if ( (cpi->frames_since_key > 1) &&
3512                (cpi->avg_frame_qindex < cpi->active_worst_quality) )
3513             {
3514                 Q = cpi->avg_frame_qindex;
3515             }
3516
3517             // For constrained quality dont allow Q less than the cq level
3518             if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3519                  (Q < cpi->cq_target_quality) )
3520             {
3521                 Q = cpi->cq_target_quality;
3522             }
3523
3524             if ( cpi->pass == 2 )
3525             {
3526                 if ( cpi->gfu_boost > 1000 )
3527                     cpi->active_best_quality = gf_low_motion_minq[Q];
3528                 else if ( cpi->gfu_boost < 400 )
3529                     cpi->active_best_quality = gf_high_motion_minq[Q];
3530                 else
3531                     cpi->active_best_quality = gf_mid_motion_minq[Q];
3532
3533                 // Constrained quality use slightly lower active best.
3534                 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY )
3535                 {
3536                     cpi->active_best_quality =
3537                         cpi->active_best_quality * 15/16;
3538                 }
3539             }
3540             // One pass more conservative
3541             else
3542                 cpi->active_best_quality = gf_high_motion_minq[Q];
3543         }
3544         else
3545         {
3546             cpi->active_best_quality = inter_minq[Q];
3547
3548             // For the constant/constrained quality mode we dont want
3549             // q to fall below the cq level.
3550             if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3551                 (cpi->active_best_quality < cpi->cq_target_quality) )
3552             {
3553                 // If we are strongly undershooting the target rate in the last
3554                 // frames then use the user passed in cq value not the auto
3555                 // cq value.
3556                 if ( cpi->rolling_actual_bits < cpi->min_frame_bandwidth )
3557                     cpi->active_best_quality = cpi->oxcf.cq_level;
3558                 else
3559                     cpi->active_best_quality = cpi->cq_target_quality;
3560             }
3561         }
3562
3563         // If CBR and the buffer is as full then it is reasonable to allow
3564         // higher quality on the frames to prevent bits just going to waste.
3565         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3566         {
3567             // Note that the use of >= here elliminates the risk of a devide
3568             // by 0 error in the else if clause
3569             if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
3570                 cpi->active_best_quality = cpi->best_quality;
3571
3572             else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
3573             {
3574                 int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
3575                 int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
3576
3577                 cpi->active_best_quality -= min_qadjustment;
3578             }
3579         }
3580     }
3581     // Make sure constrained quality mode limits are adhered to for the first
3582     // few frames of one pass encodes
3583     else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3584     {
3585         if ( (cm->frame_type == KEY_FRAME) ||
3586              cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame )
3587         {
3588              cpi->active_best_quality = cpi->best_quality;
3589         }
3590         else if (cpi->active_best_quality < cpi->cq_target_quality)
3591         {
3592             cpi->active_best_quality = cpi->cq_target_quality;
3593         }
3594     }
3595
3596     // Clip the active best and worst quality values to limits
3597     if (cpi->active_worst_quality > cpi->worst_quality)
3598         cpi->active_worst_quality = cpi->worst_quality;
3599
3600     if (cpi->active_best_quality < cpi->best_quality)
3601         cpi->active_best_quality = cpi->best_quality;
3602
3603     if ( cpi->active_worst_quality < cpi->active_best_quality )
3604         cpi->active_worst_quality = cpi->active_best_quality;
3605
3606     // Determine initial Q to try
3607     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3608
3609 #if !(CONFIG_REALTIME_ONLY)
3610
3611     // Set highest allowed value for Zbin over quant
3612     if (cm->frame_type == KEY_FRAME)
3613         zbin_oq_high = 0; //ZBIN_OQ_MAX/16
3614     else if ((cpi->oxcf.number_of_layers == 1) && ((cm->refresh_alt_ref_frame ||
3615               (cm->refresh_golden_frame && !cpi->source_alt_ref_active))))
3616     {
3617           zbin_oq_high = 16;
3618     }
3619     else
3620         zbin_oq_high = ZBIN_OQ_MAX;
3621 #endif
3622
3623     // Setup background Q adjustment for error resilient mode.
3624     // For multi-layer encodes only enable this for the base layer.
3625     if (cpi->cyclic_refresh_mode_enabled && (cpi->current_layer==0))
3626         cyclic_background_refresh(cpi, Q, 0);
3627
3628     vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3629
3630 #if !(CONFIG_REALTIME_ONLY)
3631     // Limit Q range for the adaptive loop.
3632     bottom_index = cpi->active_best_quality;
3633     top_index    = cpi->active_worst_quality;
3634     q_low  = cpi->active_best_quality;
3635     q_high = cpi->active_worst_quality;
3636 #endif
3637
3638     vp8_save_coding_context(cpi);
3639
3640     loop_count = 0;
3641
3642     scale_and_extend_source(cpi->un_scaled_source, cpi);
3643
3644 #if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC && !(CONFIG_TEMPORAL_DENOISING)
3645
3646     if (cpi->oxcf.noise_sensitivity > 0)
3647     {
3648         unsigned char *src;
3649         int l = 0;
3650
3651         switch (cpi->oxcf.noise_sensitivity)
3652         {
3653         case 1:
3654             l = 20;
3655             break;
3656         case 2:
3657             l = 40;
3658             break;
3659         case 3:
3660             l = 60;
3661             break;
3662         case 4:
3663             l = 80;
3664             break;
3665         case 5:
3666             l = 100;
3667             break;
3668         case 6:
3669             l = 150;
3670             break;
3671         }
3672
3673
3674         if (cm->frame_type == KEY_FRAME)
3675         {
3676             vp8_de_noise(cpi->Source, cpi->Source, l , 1,  0);
3677         }
3678         else
3679         {
3680             vp8_de_noise(cpi->Source, cpi->Source, l , 1,  0);
3681
3682             src = cpi->Source->y_buffer;
3683
3684             if (cpi->Source->y_stride < 0)
3685             {
3686                 src += cpi->Source->y_stride * (cpi->Source->y_height - 1);
3687             }
3688         }
3689     }
3690
3691 #endif
3692
3693 #ifdef OUTPUT_YUV_SRC
3694     vp8_write_yuv_frame(cpi->Source);
3695 #endif
3696
3697     do
3698     {
3699         vp8_clear_system_state();  //__asm emms;
3700
3701         /*
3702         if(cpi->is_src_frame_alt_ref)
3703             Q = 127;
3704             */
3705
3706         vp8_set_quantizer(cpi, Q);
3707
3708         // setup skip prob for costing in mode/mv decision
3709         if (cpi->common.mb_no_coeff_skip)
3710         {
3711             cpi->prob_skip_false = cpi->base_skip_false_prob[Q];
3712
3713             if (cm->frame_type != KEY_FRAME)
3714             {
3715                 if (cpi->common.refresh_alt_ref_frame)
3716                 {
3717                     if (cpi->last_skip_false_probs[2] != 0)
3718                         cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3719
3720                     /*
3721                                         if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 )
3722                        cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3723                                         else if (cpi->last_skip_false_probs[2]!=0)
3724                        cpi->prob_skip_false = (cpi->last_skip_false_probs[2]  + cpi->prob_skip_false ) / 2;
3725                        */
3726                 }
3727                 else if (cpi->common.refresh_golden_frame)
3728                 {
3729                     if (cpi->last_skip_false_probs[1] != 0)
3730                         cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3731
3732                     /*
3733                                         if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 )
3734                        cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3735                                         else if (cpi->last_skip_false_probs[1]!=0)
3736                        cpi->prob_skip_false = (cpi->last_skip_false_probs[1]  + cpi->prob_skip_false ) / 2;
3737                        */
3738                 }
3739                 else
3740                 {
3741                     if (cpi->last_skip_false_probs[0] != 0)
3742                         cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3743
3744                     /*
3745                     if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 )
3746                         cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3747                     else if(cpi->last_skip_false_probs[0]!=0)
3748                         cpi->prob_skip_false = (cpi->last_skip_false_probs[0]  + cpi->prob_skip_false ) / 2;
3749                         */
3750                 }
3751
3752                 //as this is for cost estimate, let's make sure it does not go extreme eitehr way
3753                 if (cpi->prob_skip_false < 5)
3754                     cpi->prob_skip_false = 5;
3755
3756                 if (cpi->prob_skip_false > 250)
3757                     cpi->prob_skip_false = 250;
3758
3759                 if (cpi->oxcf.number_of_layers == 1 && cpi->is_src_frame_alt_ref)
3760                     cpi->prob_skip_false = 1;
3761             }
3762
3763 #if 0
3764
3765             if (cpi->pass != 1)
3766             {
3767                 FILE *f = fopen("skip.stt", "a");
3768                 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false);
3769                 fclose(f);
3770             }
3771
3772 #endif
3773
3774         }
3775
3776         if (cm->frame_type == KEY_FRAME)
3777         {
3778             resize_key_frame(cpi);
3779             vp8_setup_key_frame(cpi);
3780         }
3781
3782
3783
3784 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
3785         {
3786             if(cpi->oxcf.error_resilient_mode)
3787                 cm->refresh_entropy_probs = 0;
3788
3789             if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS)
3790             {
3791                 if (cm->frame_type == KEY_FRAME)
3792                     cm->refresh_entropy_probs = 1;
3793             }
3794
3795             if (cm->refresh_entropy_probs == 0)
3796             {
3797                 // save a copy for later refresh
3798                 vpx_memcpy(&cm->lfc, &cm->fc, sizeof(cm->fc));
3799             }
3800
3801             vp8_update_coef_context(cpi);
3802
3803             vp8_update_coef_probs(cpi);
3804
3805             // transform / motion compensation build reconstruction frame
3806             // +pack coef partitions
3807             vp8_encode_frame(cpi);
3808
3809             /* cpi->projected_frame_size is not needed for RT mode */
3810         }
3811 #else
3812         // transform / motion compensation build reconstruction frame
3813         vp8_encode_frame(cpi);
3814
3815         cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi);
3816         cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0;
3817 #endif
3818         vp8_clear_system_state();  //__asm emms;
3819
3820         // Test to see if the stats generated for this frame indicate that we should have coded a key frame
3821         // (assuming that we didn't)!
3822         if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3823         {
3824             int key_frame_decision = decide_key_frame(cpi);
3825
3826             if (cpi->compressor_speed == 2)
3827             {
3828                 /* we don't do re-encoding in realtime mode
3829                  * if key frame is decided then we force it on next frame */
3830                 cpi->force_next_frame_intra = key_frame_decision;
3831             }
3832 #if !(CONFIG_REALTIME_ONLY)
3833             else if (key_frame_decision)
3834             {
3835                 // Reset all our sizing numbers and recode
3836                 cm->frame_type = KEY_FRAME;
3837
3838                 vp8_pick_frame_size(cpi);
3839
3840                 // Clear the Alt reference frame active flag when we have a key frame
3841                 cpi->source_alt_ref_active = 0;
3842
3843                 // Reset the loop filter deltas and segmentation map
3844                 setup_features(cpi);
3845
3846                 // If segmentation is enabled force a map update for key frames
3847                 if (cpi->mb.e_mbd.segmentation_enabled)
3848                 {
3849                     cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3850                     cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3851                 }
3852
3853                 vp8_restore_coding_context(cpi);
3854
3855                 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3856
3857                 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3858
3859                 // Limit Q range for the adaptive loop.
3860                 bottom_index = cpi->active_best_quality;
3861                 top_index    = cpi->active_worst_quality;
3862                 q_low  = cpi->active_best_quality;
3863                 q_high = cpi->active_worst_quality;
3864
3865                 loop_count++;
3866                 Loop = 1;
3867
3868                 continue;
3869             }
3870 #endif
3871         }
3872
3873         vp8_clear_system_state();
3874
3875         if (frame_over_shoot_limit == 0)
3876             frame_over_shoot_limit = 1;
3877
3878         // Are we are overshooting and up against the limit of active max Q.
3879         if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) &&
3880             (Q == cpi->active_worst_quality)                     &&
3881             (cpi->active_worst_quality < cpi->worst_quality)      &&
3882             (cpi->projected_frame_size > frame_over_shoot_limit))
3883         {
3884             int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit;
3885
3886             // If so is there any scope for relaxing it
3887             while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0))
3888             {
3889                 cpi->active_worst_quality++;
3890
3891                 over_size_percent = (int)(over_size_percent * 0.96);        // Assume 1 qstep = about 4% on frame size.
3892             }
3893 #if !(CONFIG_REALTIME_ONLY)
3894             top_index = cpi->active_worst_quality;
3895 #endif
3896             // If we have updated the active max Q do not call vp8_update_rate_correction_factors() this loop.
3897             active_worst_qchanged = 1;
3898         }
3899         else
3900             active_worst_qchanged = 0;
3901
3902 #if !(CONFIG_REALTIME_ONLY)
3903         // Special case handling for forced key frames
3904         if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced )
3905         {
3906             int last_q = Q;
3907             int kf_err = vp8_calc_ss_err(cpi->Source,
3908                                          &cm->yv12_fb[cm->new_fb_idx]);
3909
3910             // The key frame is not good enough
3911             if ( kf_err > ((cpi->ambient_err * 7) >> 3) )
3912             {
3913                 // Lower q_high
3914                 q_high = (Q > q_low) ? (Q - 1) : q_low;
3915
3916                 // Adjust Q
3917                 Q = (q_high + q_low) >> 1;
3918             }
3919             // The key frame is much better than the previous frame
3920             else if ( kf_err < (cpi->ambient_err >> 1) )
3921             {
3922                 // Raise q_low
3923                 q_low = (Q < q_high) ? (Q + 1) : q_high;
3924
3925                 // Adjust Q
3926                 Q = (q_high + q_low + 1) >> 1;
3927             }
3928
3929             // Clamp Q to upper and lower limits:
3930             if (Q > q_high)
3931                 Q = q_high;
3932             else if (Q < q_low)
3933                 Q = q_low;
3934
3935             Loop = Q != last_q;
3936         }
3937
3938         // Is the projected frame size out of range and are we allowed to attempt to recode.
3939         else if ( recode_loop_test( cpi,
3940                                frame_over_shoot_limit, frame_under_shoot_limit,
3941                                Q, top_index, bottom_index ) )
3942         {
3943             int last_q = Q;
3944             int Retries = 0;
3945
3946             // Frame size out of permitted range:
3947             // Update correction factor & compute new Q to try...
3948
3949             // Frame is too large
3950             if (cpi->projected_frame_size > cpi->this_frame_target)
3951             {
3952                 //if ( cpi->zbin_over_quant == 0 )
3953                 q_low = (Q < q_high) ? (Q + 1) : q_high; // Raise Qlow as to at least the current value
3954
3955                 if (cpi->zbin_over_quant > 0)            // If we are using over quant do the same for zbin_oq_low
3956                     zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3957
3958                 //if ( undershoot_seen || (Q == MAXQ) )
3959                 if (undershoot_seen)
3960                 {
3961                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3962                     if (!active_worst_qchanged)
3963                         vp8_update_rate_correction_factors(cpi, 1);
3964
3965                     Q = (q_high + q_low + 1) / 2;
3966
3967                     // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3968                     if (Q < MAXQ)
3969                         cpi->zbin_over_quant = 0;
3970                     else
3971                     {
3972                         zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3973                         cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3974                     }
3975                 }
3976                 else
3977                 {
3978                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3979                     if (!active_worst_qchanged)
3980                         vp8_update_rate_correction_factors(cpi, 0);
3981
3982                     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3983
3984                     while (((Q < q_low) || (cpi->zbin_over_quant < zbin_oq_low)) && (Retries < 10))
3985                     {
3986                         vp8_update_rate_correction_factors(cpi, 0);
3987                         Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3988                         Retries ++;
3989                     }
3990                 }
3991
3992                 overshoot_seen = 1;
3993             }
3994             // Frame is too small
3995             else
3996             {
3997                 if (cpi->zbin_over_quant == 0)
3998                     q_high = (Q > q_low) ? (Q - 1) : q_low; // Lower q_high if not using over quant
3999                 else                                    // else lower zbin_oq_high
4000                     zbin_oq_high = (cpi->zbin_over_quant > zbin_oq_low) ? (cpi->zbin_over_quant - 1) : zbin_oq_low;
4001
4002                 if (overshoot_seen)
4003                 {
4004                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
4005                     if (!active_worst_qchanged)
4006                         vp8_update_rate_correction_factors(cpi, 1);
4007
4008                     Q = (q_high + q_low) / 2;
4009
4010                     // Adjust cpi->zbin_over_quant (only allowed when Q is max)
4011                     if (Q < MAXQ)
4012                         cpi->zbin_over_quant = 0;
4013                     else
4014                         cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
4015                 }
4016                 else
4017                 {
4018                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
4019                     if (!active_worst_qchanged)
4020                         vp8_update_rate_correction_factors(cpi, 0);
4021
4022                     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4023
4024                     // Special case reset for qlow for constrained quality.
4025                     // This should only trigger where there is very substantial
4026                     // undershoot on a frame and the auto cq level is above
4027                     // the user passsed in value.
4028                     if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
4029                          (Q < q_low) )
4030                     {
4031                         q_low = Q;
4032                     }
4033
4034                     while (((Q > q_high) || (cpi->zbin_over_quant > zbin_oq_high)) && (Retries < 10))
4035                     {
4036                         vp8_update_rate_correction_factors(cpi, 0);
4037                         Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4038                         Retries ++;
4039                     }
4040                 }
4041
4042                 undershoot_seen = 1;
4043             }
4044
4045             // Clamp Q to upper and lower limits:
4046             if (Q > q_high)
4047                 Q = q_high;
4048             else if (Q < q_low)
4049                 Q = q_low;
4050
4051             // Clamp cpi->zbin_over_quant
4052             cpi->zbin_over_quant = (cpi->zbin_over_quant < zbin_oq_low) ? zbin_oq_low : (cpi->zbin_over_quant > zbin_oq_high) ? zbin_oq_high : cpi->zbin_over_quant;
4053
4054             Loop = Q != last_q;
4055         }
4056         else
4057 #endif
4058             Loop = 0;
4059
4060         if (cpi->is_src_frame_alt_ref)
4061             Loop = 0;
4062
4063         if (Loop == 1)
4064         {
4065             vp8_restore_coding_context(cpi);
4066             loop_count++;
4067 #if CONFIG_INTERNAL_STATS
4068             cpi->tot_recode_hits++;
4069 #endif
4070         }
4071     }
4072     while (Loop == 1);
4073
4074 #if 0
4075     // Experimental code for lagged and one pass
4076     // Update stats used for one pass GF selection
4077     {
4078         /*
4079             int frames_so_far;
4080             double frame_intra_error;
4081             double frame_coded_error;
4082             double frame_pcnt_inter;
4083             double frame_pcnt_motion;
4084             double frame_mvr;
4085             double frame_mvr_abs;
4086             double frame_mvc;
4087             double frame_mvc_abs;
4088         */
4089
4090         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error;
4091         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error;
4092         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0;
4093     }
4094 #endif
4095
4096     // Special case code to reduce pulsing when key frames are forced at a
4097     // fixed interval. Note the reconstruction error if it is the frame before
4098     // the force key frame
4099     if ( cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0) )
4100     {
4101         cpi->ambient_err = vp8_calc_ss_err(cpi->Source,
4102                                            &cm->yv12_fb[cm->new_fb_idx]);
4103     }
4104
4105     /* This frame's MVs are saved and will be used in next frame's MV predictor.
4106      * Last frame has one more line(add to bottom) and one more column(add to
4107      * right) than cm->mip. The edge elements are initialized to 0.
4108      */
4109 #if CONFIG_MULTI_RES_ENCODING
4110     if(!cpi->oxcf.mr_encoder_id && cm->show_frame)
4111 #else
4112     if(cm->show_frame)   /* do not save for altref frame */
4113 #endif
4114     {
4115         int mb_row;
4116         int mb_col;
4117         /* Point to beginning of allocated MODE_INFO arrays. */
4118         MODE_INFO *tmp = cm->mip;
4119
4120         if(cm->frame_type != KEY_FRAME)
4121         {
4122             for (mb_row = 0; mb_row < cm->mb_rows+1; mb_row ++)
4123             {
4124                 for (mb_col = 0; mb_col < cm->mb_cols+1; mb_col ++)
4125                 {
4126                     if(tmp->mbmi.ref_frame != INTRA_FRAME)
4127                         cpi->lfmv[mb_col + mb_row*(cm->mode_info_stride+1)].as_int = tmp->mbmi.mv.as_int;
4128
4129                     cpi->lf_ref_frame_sign_bias[mb_col + mb_row*(cm->mode_info_stride+1)] = cm->ref_frame_sign_bias[tmp->mbmi.ref_frame];
4130                     cpi->lf_ref_frame[mb_col + mb_row*(cm->mode_info_stride+1)] = tmp->mbmi.ref_frame;
4131                     tmp++;
4132                 }
4133             }
4134         }
4135     }
4136
4137 #if CONFIG_MULTI_RES_ENCODING
4138     vp8_cal_dissimilarity(cpi);
4139 #endif
4140
4141     // Update the GF useage maps.
4142     // This is done after completing the compression of a frame when all
4143     // modes etc. are finalized but before loop filter
4144     if (cpi->oxcf.number_of_layers == 1)
4145         vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
4146
4147     if (cm->frame_type == KEY_FRAME)
4148         cm->refresh_last_frame = 1;
4149
4150 #if 0
4151     {
4152         FILE *f = fopen("gfactive.stt", "a");
4153         fprintf(f, "%8d %8d %8d %8d %8d\n", cm->current_video_frame, (100 * cpi->gf_active_count) / (cpi->common.mb_rows * cpi->common.mb_cols), cpi->this_iiratio, cpi->next_iiratio, cm->refresh_golden_frame);
4154         fclose(f);
4155     }
4156 #endif
4157
4158     // For inter frames the current default behavior is that when
4159     // cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
4160     // This is purely an encoder decision at present.
4161     if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
4162         cm->copy_buffer_to_arf  = 2;
4163     else
4164         cm->copy_buffer_to_arf  = 0;
4165
4166     cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
4167
4168 #if CONFIG_MULTITHREAD
4169     if (cpi->b_multi_threaded)
4170     {
4171         sem_post(&cpi->h_event_start_lpf); /* start loopfilter in separate thread */
4172         cpi->b_lpf_running = 1;
4173     }
4174     else
4175 #endif
4176     {
4177         vp8_loopfilter_frame(cpi, cm);
4178     }
4179
4180     update_reference_frames(cm);
4181
4182 #if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
4183     if (cpi->oxcf.error_resilient_mode)
4184     {
4185         cm->refresh_entropy_probs = 0;
4186     }
4187 #endif
4188
4189 #if CONFIG_MULTITHREAD
4190     /* wait that filter_level is picked so that we can continue with stream packing */
4191     if (cpi->b_multi_threaded)
4192         sem_wait(&cpi->h_event_end_lpf);
4193 #endif
4194
4195     // build the bitstream
4196     vp8_pack_bitstream(cpi, dest, dest_end, size);
4197
4198 #if CONFIG_MULTITHREAD
4199     /* if PSNR packets are generated we have to wait for the lpf */
4200     if (cpi->b_lpf_running && cpi->b_calculate_psnr)
4201     {
4202         sem_wait(&cpi->h_event_end_lpf);
4203         cpi->b_lpf_running = 0;
4204     }
4205 #endif
4206
4207     /* Move storing frame_type out of the above loop since it is also
4208      * needed in motion search besides loopfilter */
4209     cm->last_frame_type = cm->frame_type;
4210
4211     // Update rate control heuristics
4212     cpi->total_byte_count += (*size);
4213     cpi->projected_frame_size = (*size) << 3;
4214
4215     if (cpi->oxcf.number_of_layers > 1)
4216     {
4217         unsigned int i;
4218         for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
4219           cpi->layer_context[i].total_byte_count += (*size);
4220     }
4221
4222     if (!active_worst_qchanged)
4223         vp8_update_rate_correction_factors(cpi, 2);
4224
4225     cpi->last_q[cm->frame_type] = cm->base_qindex;
4226
4227     if (cm->frame_type == KEY_FRAME)
4228     {
4229         vp8_adjust_key_frame_context(cpi);
4230     }
4231
4232     // Keep a record of ambient average Q.
4233     if (cm->frame_type != KEY_FRAME)
4234         cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
4235
4236     // Keep a record from which we can calculate the average Q excluding GF updates and key frames
4237     if ((cm->frame_type != KEY_FRAME) && ((cpi->oxcf.number_of_layers > 1) ||
4238         (!cm->refresh_golden_frame && !cm->refresh_alt_ref_frame)))
4239     {
4240         cpi->ni_frames++;
4241
4242         // Calculate the average Q for normal inter frames (not key or GFU
4243         // frames).
4244         if ( cpi->pass == 2 )
4245         {
4246             cpi->ni_tot_qi += Q;
4247             cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4248         }
4249         else
4250         {
4251             // Damp value for first few frames
4252             if (cpi->ni_frames > 150 )
4253             {
4254                 cpi->ni_tot_qi += Q;
4255                 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4256             }
4257             // For one pass, early in the clip ... average the current frame Q
4258             // value with the worstq entered by the user as a dampening measure
4259             else
4260             {
4261                 cpi->ni_tot_qi += Q;
4262                 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2;
4263             }
4264
4265             // If the average Q is higher than what was used in the last frame
4266             // (after going through the recode loop to keep the frame size within range)
4267             // then use the last frame value - 1.
4268             // The -1 is designed to stop Q and hence the data rate, from progressively
4269             // falling away during difficult sections, but at the same time reduce the number of
4270             // itterations around the recode loop.
4271             if (Q > cpi->ni_av_qi)
4272                 cpi->ni_av_qi = Q - 1;
4273         }
4274     }
4275
4276 #if 0
4277
4278     // If the frame was massively oversize and we are below optimal buffer level drop next frame
4279     if ((cpi->drop_frames_allowed) &&
4280         (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
4281         (cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
4282         (cpi->projected_frame_size > (4 * cpi->this_frame_target)))
4283     {
4284         cpi->drop_frame = 1;
4285     }
4286
4287 #endif
4288
4289     // Set the count for maximum consecutive dropped frames based upon the ratio of
4290     // this frame size to the target average per frame bandwidth.
4291     // (cpi->av_per_frame_bandwidth > 0) is just a sanity check to prevent / 0.
4292     if (cpi->drop_frames_allowed && (cpi->av_per_frame_bandwidth > 0))
4293     {
4294         cpi->max_drop_count = cpi->projected_frame_size / cpi->av_per_frame_bandwidth;
4295
4296         if (cpi->max_drop_count > cpi->max_consec_dropped_frames)
4297             cpi->max_drop_count = cpi->max_consec_dropped_frames;
4298     }
4299
4300     // Update the buffer level variable.
4301     // Non-viewable frames are a special case and are treated as pure overhead.
4302     if ( !cm->show_frame )
4303         cpi->bits_off_target -= cpi->projected_frame_size;
4304     else
4305         cpi->bits_off_target += cpi->av_per_frame_bandwidth - cpi->projected_frame_size;
4306
4307     // Clip the buffer level to the maximum specified buffer size
4308     if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
4309         cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
4310
4311     // Rolling monitors of whether we are over or underspending used to help regulate min and Max Q in two pass.
4312     cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
4313     cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
4314     cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
4315     cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32;
4316
4317     // Actual bits spent
4318     cpi->total_actual_bits += cpi->projected_frame_size;
4319
4320     // Debug stats
4321     cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size);
4322
4323     cpi->buffer_level = cpi->bits_off_target;
4324
4325     // Propagate values to higher temporal layers
4326     if (cpi->oxcf.number_of_layers > 1)
4327     {
4328         unsigned int i;
4329
4330         for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
4331         {
4332             LAYER_CONTEXT *lc = &cpi->layer_context[i];
4333             int bits_off_for_this_layer = lc->target_bandwidth / lc->frame_rate
4334                                                 - cpi->projected_frame_size;
4335
4336             lc->bits_off_target += bits_off_for_this_layer;
4337
4338             // Clip buffer level to maximum buffer size for the layer
4339             if (lc->bits_off_target > lc->maximum_buffer_size)
4340                 lc->bits_off_target = lc->maximum_buffer_size;
4341
4342             lc->total_actual_bits += cpi->projected_frame_size;
4343             lc->total_target_vs_actual += bits_off_for_this_layer;
4344             lc->buffer_level = lc->bits_off_target;
4345         }
4346     }
4347
4348     // Update bits left to the kf and gf groups to account for overshoot or undershoot on these frames
4349     if (cm->frame_type == KEY_FRAME)
4350     {
4351         cpi->twopass.kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4352
4353         if (cpi->twopass.kf_group_bits < 0)
4354             cpi->twopass.kf_group_bits = 0 ;
4355     }
4356     else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4357     {
4358         cpi->twopass.gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4359
4360         if (cpi->twopass.gf_group_bits < 0)
4361             cpi->twopass.gf_group_bits = 0 ;
4362     }
4363
4364     if (cm->frame_type != KEY_FRAME)
4365     {
4366         if (cpi->common.refresh_alt_ref_frame)
4367         {
4368             cpi->last_skip_false_probs[2] = cpi->prob_skip_false;
4369             cpi->last_skip_probs_q[2] = cm->base_qindex;
4370         }
4371         else if (cpi->common.refresh_golden_frame)
4372         {
4373             cpi->last_skip_false_probs[1] = cpi->prob_skip_false;
4374             cpi->last_skip_probs_q[1] = cm->base_qindex;
4375         }
4376         else
4377         {
4378             cpi->last_skip_false_probs[0] = cpi->prob_skip_false;
4379             cpi->last_skip_probs_q[0] = cm->base_qindex;
4380
4381             //update the baseline
4382             cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false;
4383
4384         }
4385     }
4386
4387 #if 0 && CONFIG_INTERNAL_STATS
4388     {
4389         FILE *f = fopen("tmp.stt", "a");
4390
4391         vp8_clear_system_state();  //__asm emms;
4392
4393         if (cpi->twopass.total_left_stats.coded_error != 0.0)
4394             fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4395                        "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4396                        "%10.3f %8d\n",
4397                        cpi->common.current_video_frame, cpi->this_frame_target,
4398                        cpi->projected_frame_size,
4399                        (cpi->projected_frame_size - cpi->this_frame_target),
4400                        (int)cpi->total_target_vs_actual,
4401                        cpi->buffer_level,
4402                        (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4403                        (int)cpi->total_actual_bits, cm->base_qindex,
4404                        cpi->active_best_quality, cpi->active_worst_quality,
4405                        cpi->ni_av_qi, cpi->cq_target_quality,
4406                        cpi->zbin_over_quant,
4407                        //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4408                        cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4409                        cm->frame_type, cpi->gfu_boost,
4410                        cpi->twopass.est_max_qcorrection_factor,
4411                        (int)cpi->twopass.bits_left,
4412                        cpi->twopass.total_left_stats.coded_error,
4413                        (double)cpi->twopass.bits_left /
4414                            cpi->twopass.total_left_stats.coded_error,
4415                        cpi->tot_recode_hits);
4416         else
4417             fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4418                        "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4419                        "%8d\n",
4420                        cpi->common.current_video_frame,
4421                        cpi->this_frame_target, cpi->projected_frame_size,
4422                        (cpi->projected_frame_size - cpi->this_frame_target),
4423                        (int)cpi->total_target_vs_actual,
4424                        cpi->buffer_level,
4425                        (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4426                        (int)cpi->total_actual_bits, cm->base_qindex,
4427                        cpi->active_best_quality, cpi->active_worst_quality,
4428                        cpi->ni_av_qi, cpi->cq_target_quality,
4429                        cpi->zbin_over_quant,
4430                        //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4431                        cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4432                        cm->frame_type, cpi->gfu_boost,
4433                        cpi->twopass.est_max_qcorrection_factor,
4434                        (int)cpi->twopass.bits_left,
4435                        cpi->twopass.total_left_stats.coded_error,
4436                        cpi->tot_recode_hits);
4437
4438         fclose(f);
4439
4440         {
4441             FILE *fmodes = fopen("Modes.stt", "a");
4442             int i;
4443
4444             fprintf(fmodes, "%6d:%1d:%1d:%1d ",
4445                         cpi->common.current_video_frame,
4446                         cm->frame_type, cm->refresh_golden_frame,
4447                         cm->refresh_alt_ref_frame);
4448
4449             for (i = 0; i < MAX_MODES; i++)
4450                 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
4451
4452             fprintf(fmodes, "\n");
4453
4454             fclose(fmodes);
4455         }
4456     }
4457
4458 #endif
4459
4460     // If this was a kf or Gf note the Q
4461     if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4462         cm->last_kf_gf_q = cm->base_qindex;
4463
4464     if (cm->refresh_golden_frame == 1)
4465         cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
4466     else
4467         cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
4468
4469     if (cm->refresh_alt_ref_frame == 1)
4470         cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
4471     else
4472         cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
4473
4474
4475     if (cm->refresh_last_frame & cm->refresh_golden_frame) // both refreshed
4476         cpi->gold_is_last = 1;
4477     else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4478         cpi->gold_is_last = 0;
4479
4480     if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) // both refreshed
4481         cpi->alt_is_last = 1;
4482     else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) // 1 refreshed but not the other
4483         cpi->alt_is_last = 0;
4484
4485     if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) // both refreshed
4486         cpi->gold_is_alt = 1;
4487     else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4488         cpi->gold_is_alt = 0;
4489
4490     cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
4491
4492     if (cpi->gold_is_last)
4493         cpi->ref_frame_flags &= ~VP8_GOLD_FLAG;
4494
4495     if (cpi->alt_is_last)
4496         cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4497
4498     if (cpi->gold_is_alt)
4499         cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4500
4501
4502     if (!cpi->oxcf.error_resilient_mode)
4503     {
4504         if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame && (cm->frame_type != KEY_FRAME))
4505             // Update the alternate reference frame stats as appropriate.
4506             update_alt_ref_frame_stats(cpi);
4507         else
4508             // Update the Golden frame stats as appropriate.
4509             update_golden_frame_stats(cpi);
4510     }
4511
4512     if (cm->frame_type == KEY_FRAME)
4513     {
4514         // Tell the caller that the frame was coded as a key frame
4515         *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
4516
4517         // As this frame is a key frame  the next defaults to an inter frame.
4518         cm->frame_type = INTER_FRAME;
4519
4520         cpi->last_frame_percent_intra = 100;
4521     }
4522     else
4523     {
4524         *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
4525
4526         cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
4527     }
4528
4529     // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
4530     cpi->mb.e_mbd.update_mb_segmentation_map = 0;
4531     cpi->mb.e_mbd.update_mb_segmentation_data = 0;
4532     cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
4533
4534
4535     // Dont increment frame counters if this was an altref buffer update not a real frame
4536     if (cm->show_frame)
4537     {
4538         cm->current_video_frame++;
4539         cpi->frames_since_key++;
4540     }
4541
4542     // reset to normal state now that we are done.
4543
4544
4545
4546 #if 0
4547     {
4548         char filename[512];
4549         FILE *recon_file;
4550         sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
4551         recon_file = fopen(filename, "wb");
4552         fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc,
4553                cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
4554         fclose(recon_file);
4555     }
4556 #endif
4557
4558     // DEBUG
4559     //vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
4560
4561
4562 }
4563
4564
4565 static void check_gf_quality(VP8_COMP *cpi)
4566 {
4567     VP8_COMMON *cm = &cpi->common;
4568     int gf_active_pct = (100 * cpi->gf_active_count) / (cm->mb_rows * cm->mb_cols);
4569     int gf_ref_usage_pct = (cpi->count_mb_ref_frame_usage[GOLDEN_FRAME] * 100) / (cm->mb_rows * cm->mb_cols);
4570     int last_ref_zz_useage = (cpi->inter_zz_count * 100) / (cm->mb_rows * cm->mb_cols);
4571
4572     // Gf refresh is not currently being signalled
4573     if (cpi->gf_update_recommended == 0)
4574     {
4575         if (cpi->common.frames_since_golden > 7)
4576         {
4577             // Low use of gf
4578             if ((gf_active_pct < 10) || ((gf_active_pct + gf_ref_usage_pct) < 15))
4579             {
4580                 // ...but last frame zero zero usage is reasonbable so a new gf might be appropriate
4581                 if (last_ref_zz_useage >= 25)
4582                 {
4583                     cpi->gf_bad_count ++;
4584
4585                     if (cpi->gf_bad_count >= 8)   // Check that the condition is stable
4586                     {
4587                         cpi->gf_update_recommended = 1;
4588                         cpi->gf_bad_count = 0;
4589                     }
4590                 }
4591                 else
4592                     cpi->gf_bad_count = 0;        // Restart count as the background is not stable enough
4593             }
4594             else
4595                 cpi->gf_bad_count = 0;            // Gf useage has picked up so reset count
4596         }
4597     }
4598     // If the signal is set but has not been read should we cancel it.
4599     else if (last_ref_zz_useage < 15)
4600     {
4601         cpi->gf_update_recommended = 0;
4602         cpi->gf_bad_count = 0;
4603     }
4604
4605 #if 0
4606     {
4607         FILE *f = fopen("gfneeded.stt", "a");
4608         fprintf(f, "%10d %10d %10d %10d %10ld \n",
4609                 cm->current_video_frame,
4610                 cpi->common.frames_since_golden,
4611                 gf_active_pct, gf_ref_usage_pct,
4612                 cpi->gf_update_recommended);
4613         fclose(f);
4614     }
4615
4616 #endif
4617 }
4618
4619 #if !(CONFIG_REALTIME_ONLY)
4620 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned char * dest_end, unsigned int *frame_flags)
4621 {
4622
4623     if (!cpi->common.refresh_alt_ref_frame)
4624         vp8_second_pass(cpi);
4625
4626     encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags);
4627     cpi->twopass.bits_left -= 8 * *size;
4628
4629     if (!cpi->common.refresh_alt_ref_frame)
4630     {
4631         double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
4632             *cpi->oxcf.two_pass_vbrmin_section / 100);
4633         cpi->twopass.bits_left += (int64_t)(two_pass_min_rate / cpi->frame_rate);
4634     }
4635 }
4636 #endif
4637
4638 //For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.
4639 #if HAVE_NEON
4640 extern void vp8_push_neon(int64_t *store);
4641 extern void vp8_pop_neon(int64_t *store);
4642 #endif
4643
4644
4645 int vp8_receive_raw_frame(VP8_COMP *cpi, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time)
4646 {
4647 #if HAVE_NEON
4648     int64_t store_reg[8];
4649 #endif
4650     VP8_COMMON            *cm = &cpi->common;
4651     struct vpx_usec_timer  timer;
4652     int                    res = 0;
4653
4654 #if HAVE_NEON
4655 #if CONFIG_RUNTIME_CPU_DETECT
4656     if (cm->cpu_caps & HAS_NEON)
4657 #endif
4658     {
4659         vp8_push_neon(store_reg);
4660     }
4661 #endif
4662
4663     vpx_usec_timer_start(&timer);
4664
4665     /* Reinit the lookahead buffer if the frame size changes */
4666     if (sd->y_width != cpi->oxcf.Width || sd->y_height != cpi->oxcf.Height)
4667     {
4668         assert(cpi->oxcf.lag_in_frames < 2);
4669         dealloc_raw_frame_buffers(cpi);
4670         alloc_raw_frame_buffers(cpi);
4671     }
4672
4673     if(vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
4674                           frame_flags, cpi->active_map_enabled ? cpi->active_map : NULL))
4675         res = -1;
4676     cm->clr_type = sd->clrtype;
4677     vpx_usec_timer_mark(&timer);
4678     cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
4679
4680 #if HAVE_NEON
4681 #if CONFIG_RUNTIME_CPU_DETECT
4682     if (cm->cpu_caps & HAS_NEON)
4683 #endif
4684     {
4685         vp8_pop_neon(store_reg);
4686     }
4687 #endif
4688
4689     return res;
4690 }
4691
4692
4693 static int frame_is_reference(const VP8_COMP *cpi)
4694 {
4695     const VP8_COMMON *cm = &cpi->common;
4696     const MACROBLOCKD *xd = &cpi->mb.e_mbd;
4697
4698     return cm->frame_type == KEY_FRAME || cm->refresh_last_frame
4699            || cm->refresh_golden_frame || cm->refresh_alt_ref_frame
4700            || cm->copy_buffer_to_gf || cm->copy_buffer_to_arf
4701            || cm->refresh_entropy_probs
4702            || xd->mode_ref_lf_delta_update
4703            || xd->update_mb_segmentation_map || xd->update_mb_segmentation_data;
4704 }
4705
4706
4707 int vp8_get_compressed_data(VP8_COMP *cpi, unsigned int *frame_flags, unsigned long *size, unsigned char *dest, unsigned char *dest_end, int64_t *time_stamp, int64_t *time_end, int flush)
4708 {
4709 #if HAVE_NEON
4710     int64_t store_reg[8];
4711 #endif
4712     VP8_COMMON *cm;
4713     struct vpx_usec_timer  tsctimer;
4714     struct vpx_usec_timer  ticktimer;
4715     struct vpx_usec_timer  cmptimer;
4716     YV12_BUFFER_CONFIG    *force_src_buffer = NULL;
4717
4718     if (!cpi)
4719         return -1;
4720
4721     cm = &cpi->common;
4722
4723     if (setjmp(cpi->common.error.jmp))
4724     {
4725         cpi->common.error.setjmp = 0;
4726         return VPX_CODEC_CORRUPT_FRAME;
4727     }
4728
4729     cpi->common.error.setjmp = 1;
4730
4731 #if HAVE_NEON
4732 #if CONFIG_RUNTIME_CPU_DETECT
4733     if (cm->cpu_caps & HAS_NEON)
4734 #endif
4735     {
4736         vp8_push_neon(store_reg);
4737     }
4738 #endif
4739
4740     vpx_usec_timer_start(&cmptimer);
4741
4742     cpi->source = NULL;
4743
4744 #if !(CONFIG_REALTIME_ONLY)
4745     // Should we code an alternate reference frame
4746     if (cpi->oxcf.error_resilient_mode == 0 &&
4747         cpi->oxcf.play_alternate &&
4748         cpi->source_alt_ref_pending)
4749     {
4750         if ((cpi->source = vp8_lookahead_peek(cpi->lookahead,
4751                                               cpi->frames_till_gf_update_due,
4752                                               PEEK_FORWARD)))
4753         {
4754             cpi->alt_ref_source = cpi->source;
4755             if (cpi->oxcf.arnr_max_frames > 0)
4756             {
4757                 vp8_temporal_filter_prepare_c(cpi,
4758                                               cpi->frames_till_gf_update_due);
4759                 force_src_buffer = &cpi->alt_ref_buffer;
4760             }
4761             cm->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due;
4762             cm->refresh_alt_ref_frame = 1;
4763             cm->refresh_golden_frame = 0;
4764             cm->refresh_last_frame = 0;
4765             cm->show_frame = 0;
4766             cpi->source_alt_ref_pending = 0;  // Clear Pending alt Ref flag.
4767             cpi->is_src_frame_alt_ref = 0;
4768         }
4769     }
4770 #endif
4771
4772     if (!cpi->source)
4773     {
4774         /* Read last frame source if we are encoding first pass. */
4775         if (cpi->pass == 1 && cm->current_video_frame > 0)
4776         {
4777             if((cpi->last_source = vp8_lookahead_peek(cpi->lookahead, 1,
4778                                                       PEEK_BACKWARD)) == NULL)
4779               return -1;
4780         }
4781
4782
4783         if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush)))
4784         {
4785             cm->show_frame = 1;
4786
4787             cpi->is_src_frame_alt_ref = cpi->alt_ref_source
4788                                         && (cpi->source == cpi->alt_ref_source);
4789
4790             if(cpi->is_src_frame_alt_ref)
4791                 cpi->alt_ref_source = NULL;
4792         }
4793     }
4794
4795     if (cpi->source)
4796     {
4797         cpi->Source = force_src_buffer ? force_src_buffer : &cpi->source->img;
4798         cpi->un_scaled_source = cpi->Source;
4799         *time_stamp = cpi->source->ts_start;
4800         *time_end = cpi->source->ts_end;
4801         *frame_flags = cpi->source->flags;
4802
4803         if (cpi->pass == 1 && cm->current_video_frame > 0)
4804         {
4805             cpi->last_frame_unscaled_source = &cpi->last_source->img;
4806         }
4807     }
4808     else
4809     {
4810         *size = 0;
4811 #if !(CONFIG_REALTIME_ONLY)
4812
4813         if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done)
4814         {
4815             vp8_end_first_pass(cpi);    /* get last stats packet */
4816             cpi->twopass.first_pass_done = 1;
4817         }
4818
4819 #endif
4820
4821 #if HAVE_NEON
4822 #if CONFIG_RUNTIME_CPU_DETECT
4823         if (cm->cpu_caps & HAS_NEON)
4824 #endif
4825         {
4826             vp8_pop_neon(store_reg);
4827         }
4828 #endif
4829         return -1;
4830     }
4831
4832     if (cpi->source->ts_start < cpi->first_time_stamp_ever)
4833     {
4834         cpi->first_time_stamp_ever = cpi->source->ts_start;
4835         cpi->last_end_time_stamp_seen = cpi->source->ts_start;
4836     }
4837
4838     // adjust frame rates based on timestamps given
4839     if (cm->show_frame)
4840     {
4841         int64_t this_duration;
4842         int step = 0;
4843
4844         if (cpi->source->ts_start == cpi->first_time_stamp_ever)
4845         {
4846             this_duration = cpi->source->ts_end - cpi->source->ts_start;
4847             step = 1;
4848         }
4849         else
4850         {
4851             int64_t last_duration;
4852
4853             this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
4854             last_duration = cpi->last_end_time_stamp_seen
4855                             - cpi->last_time_stamp_seen;
4856             // do a step update if the duration changes by 10%
4857             if (last_duration)
4858                 step = ((this_duration - last_duration) * 10 / last_duration);
4859         }
4860
4861         if (this_duration)
4862         {
4863             if (step)
4864                 cpi->ref_frame_rate = 10000000.0 / this_duration;
4865             else
4866             {
4867                 double avg_duration, interval;
4868
4869                 /* Average this frame's rate into the last second's average
4870                  * frame rate. If we haven't seen 1 second yet, then average
4871                  * over the whole interval seen.
4872                  */
4873                 interval = cpi->source->ts_end - cpi->first_time_stamp_ever;
4874                 if(interval > 10000000.0)
4875                     interval = 10000000;
4876
4877                 avg_duration = 10000000.0 / cpi->ref_frame_rate;
4878                 avg_duration *= (interval - avg_duration + this_duration);
4879                 avg_duration /= interval;
4880
4881                 cpi->ref_frame_rate = 10000000.0 / avg_duration;
4882             }
4883
4884             if (cpi->oxcf.number_of_layers > 1)
4885             {
4886                 unsigned int i;
4887
4888                 // Update frame rates for each layer
4889                 for (i=0; i<cpi->oxcf.number_of_layers; i++)
4890                 {
4891                     LAYER_CONTEXT *lc = &cpi->layer_context[i];
4892                     lc->frame_rate = cpi->ref_frame_rate /
4893                                   cpi->oxcf.rate_decimator[i];
4894                 }
4895             }
4896             else
4897                 vp8_new_frame_rate(cpi, cpi->ref_frame_rate);
4898         }
4899
4900         cpi->last_time_stamp_seen = cpi->source->ts_start;
4901         cpi->last_end_time_stamp_seen = cpi->source->ts_end;
4902     }
4903
4904     if (cpi->oxcf.number_of_layers > 1)
4905     {
4906         int layer;
4907
4908         update_layer_contexts (cpi);
4909
4910         // Restore layer specific context & set frame rate
4911         layer = cpi->oxcf.layer_id[
4912                             cm->current_video_frame % cpi->oxcf.periodicity];
4913         restore_layer_context (cpi, layer);
4914         vp8_new_frame_rate (cpi, cpi->layer_context[layer].frame_rate);
4915     }
4916
4917     if (cpi->compressor_speed == 2)
4918     {
4919         if (cpi->oxcf.number_of_layers == 1)
4920             check_gf_quality(cpi);
4921         vpx_usec_timer_start(&tsctimer);
4922         vpx_usec_timer_start(&ticktimer);
4923     }
4924
4925 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
4926     {
4927         int i;
4928         const int num_part = (1 << cm->multi_token_partition);
4929         /* the available bytes in dest */
4930         const unsigned long dest_size = dest_end - dest;
4931         const int tok_part_buff_size = (dest_size * 9) / (10 * num_part);
4932
4933         unsigned char *dp = dest;
4934
4935         cpi->partition_d[0] = dp;
4936         dp += dest_size/10;         /* reserve 1/10 for control partition */
4937         cpi->partition_d_end[0] = dp;
4938
4939         for(i = 0; i < num_part; i++)
4940         {
4941             cpi->partition_d[i + 1] = dp;
4942             dp += tok_part_buff_size;
4943             cpi->partition_d_end[i + 1] = dp;
4944         }
4945     }
4946 #endif
4947
4948     // start with a 0 size frame
4949     *size = 0;
4950
4951     // Clear down mmx registers
4952     vp8_clear_system_state();  //__asm emms;
4953
4954     cm->frame_type = INTER_FRAME;
4955     cm->frame_flags = *frame_flags;
4956
4957 #if 0
4958
4959     if (cm->refresh_alt_ref_frame)
4960     {
4961         //cm->refresh_golden_frame = 1;
4962         cm->refresh_golden_frame = 0;
4963         cm->refresh_last_frame = 0;
4964     }
4965     else
4966     {
4967         cm->refresh_golden_frame = 0;
4968         cm->refresh_last_frame = 1;
4969     }
4970
4971 #endif
4972     /* find a free buffer for the new frame */
4973     {
4974         int i = 0;
4975         for(; i < NUM_YV12_BUFFERS; i++)
4976         {
4977             if(!cm->yv12_fb[i].flags)
4978             {
4979                 cm->new_fb_idx = i;
4980                 break;
4981             }
4982         }
4983
4984         assert(i < NUM_YV12_BUFFERS );
4985     }
4986 #if !(CONFIG_REALTIME_ONLY)
4987
4988     if (cpi->pass == 1)
4989     {
4990         Pass1Encode(cpi, size, dest, frame_flags);
4991     }
4992     else if (cpi->pass == 2)
4993     {
4994         Pass2Encode(cpi, size, dest, dest_end, frame_flags);
4995     }
4996     else
4997 #endif
4998         encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags);
4999
5000     if (cpi->compressor_speed == 2)
5001     {
5002         unsigned int duration, duration2;
5003         vpx_usec_timer_mark(&tsctimer);
5004         vpx_usec_timer_mark(&ticktimer);
5005
5006         duration = vpx_usec_timer_elapsed(&ticktimer);
5007         duration2 = (unsigned int)((double)duration / 2);
5008
5009         if (cm->frame_type != KEY_FRAME)
5010         {
5011             if (cpi->avg_encode_time == 0)
5012                 cpi->avg_encode_time = duration;
5013             else
5014                 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
5015         }
5016
5017         if (duration2)
5018         {
5019             //if(*frame_flags!=1)
5020             {
5021
5022                 if (cpi->avg_pick_mode_time == 0)
5023                     cpi->avg_pick_mode_time = duration2;
5024                 else
5025                     cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3;
5026             }
5027         }
5028
5029     }
5030
5031     if (cm->refresh_entropy_probs == 0)
5032     {
5033         vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc));
5034     }
5035
5036     // Save the contexts separately for alt ref, gold and last.
5037     // (TODO jbb -> Optimize this with pointers to avoid extra copies. )
5038     if(cm->refresh_alt_ref_frame)
5039         vpx_memcpy(&cpi->lfc_a, &cm->fc, sizeof(cm->fc));
5040
5041     if(cm->refresh_golden_frame)
5042         vpx_memcpy(&cpi->lfc_g, &cm->fc, sizeof(cm->fc));
5043
5044     if(cm->refresh_last_frame)
5045         vpx_memcpy(&cpi->lfc_n, &cm->fc, sizeof(cm->fc));
5046
5047     // if its a dropped frame honor the requests on subsequent frames
5048     if (*size > 0)
5049     {
5050         cpi->droppable = !frame_is_reference(cpi);
5051
5052         // return to normal state
5053         cm->refresh_entropy_probs = 1;
5054         cm->refresh_alt_ref_frame = 0;
5055         cm->refresh_golden_frame = 0;
5056         cm->refresh_last_frame = 1;
5057         cm->frame_type = INTER_FRAME;
5058
5059     }
5060
5061     // Save layer specific state
5062     if (cpi->oxcf.number_of_layers > 1)
5063         save_layer_context (cpi);
5064
5065     vpx_usec_timer_mark(&cmptimer);
5066     cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
5067
5068     if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
5069     {
5070         generate_psnr_packet(cpi);
5071     }
5072
5073 #if CONFIG_INTERNAL_STATS
5074
5075     if (cpi->pass != 1)
5076     {
5077         cpi->bytes += *size;
5078
5079         if (cm->show_frame)
5080         {
5081
5082             cpi->count ++;
5083
5084             if (cpi->b_calculate_psnr)
5085             {
5086                 double ye,ue,ve;
5087                 double frame_psnr;
5088                 YV12_BUFFER_CONFIG      *orig = cpi->Source;
5089                 YV12_BUFFER_CONFIG      *recon = cpi->common.frame_to_show;
5090                 int y_samples = orig->y_height * orig->y_width ;
5091                 int uv_samples = orig->uv_height * orig->uv_width ;
5092                 int t_samples = y_samples + 2 * uv_samples;
5093                 int64_t sq_error, sq_error2;
5094
5095                 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
5096                   recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height);
5097
5098                 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
5099                   recon->u_buffer, recon->uv_stride, orig->uv_width, orig->uv_height);
5100
5101                 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
5102                   recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height);
5103
5104                 sq_error = ye + ue + ve;
5105
5106                 frame_psnr = vp8_mse2psnr(t_samples, 255.0, sq_error);
5107
5108                 cpi->total_y += vp8_mse2psnr(y_samples, 255.0, ye);
5109                 cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, ue);
5110                 cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, ve);
5111                 cpi->total_sq_error += sq_error;
5112                 cpi->total  += frame_psnr;
5113 #if CONFIG_POSTPROC
5114                 {
5115                     YV12_BUFFER_CONFIG      *pp = &cm->post_proc_buffer;
5116                     double frame_psnr2, frame_ssim2 = 0;
5117                     double weight = 0;
5118
5119                     vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0);
5120                     vp8_clear_system_state();
5121
5122                     ye = calc_plane_error(orig->y_buffer, orig->y_stride,
5123                       pp->y_buffer, pp->y_stride, orig->y_width, orig->y_height);
5124
5125                     ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
5126                       pp->u_buffer, pp->uv_stride, orig->uv_width, orig->uv_height);
5127
5128                     ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
5129                       pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height);
5130
5131                     sq_error2 = ye + ue + ve;
5132
5133                     frame_psnr2 = vp8_mse2psnr(t_samples, 255.0, sq_error2);
5134
5135                     cpi->totalp_y += vp8_mse2psnr(y_samples, 255.0, ye);
5136                     cpi->totalp_u += vp8_mse2psnr(uv_samples, 255.0, ue);
5137                     cpi->totalp_v += vp8_mse2psnr(uv_samples, 255.0, ve);
5138                     cpi->total_sq_error2 += sq_error2;
5139                     cpi->totalp  += frame_psnr2;
5140
5141                     frame_ssim2 = vp8_calc_ssim(cpi->Source,
5142                       &cm->post_proc_buffer, 1, &weight);
5143
5144                     cpi->summed_quality += frame_ssim2 * weight;
5145                     cpi->summed_weights += weight;
5146
5147                     if (cpi->oxcf.number_of_layers > 1)
5148                     {
5149                          int i;
5150
5151                          for (i=cpi->current_layer;
5152                                        i<cpi->oxcf.number_of_layers; i++)
5153                          {
5154                              cpi->frames_in_layer[i]++;
5155
5156                              cpi->bytes_in_layer[i] += *size;
5157                              cpi->sum_psnr[i]       += frame_psnr;
5158                              cpi->sum_psnr_p[i]     += frame_psnr2;
5159                              cpi->total_error2[i]   += sq_error;
5160                              cpi->total_error2_p[i] += sq_error2;
5161                              cpi->sum_ssim[i]       += frame_ssim2 * weight;
5162                              cpi->sum_weights[i]    += weight;
5163                          }
5164                     }
5165                 }
5166 #endif
5167             }
5168
5169             if (cpi->b_calculate_ssimg)
5170             {
5171                 double y, u, v, frame_all;
5172                 frame_all =  vp8_calc_ssimg(cpi->Source, cm->frame_to_show,
5173                     &y, &u, &v);
5174
5175                 if (cpi->oxcf.number_of_layers > 1)
5176                 {
5177                     int i;
5178
5179                     for (i=cpi->current_layer;
5180                          i<cpi->oxcf.number_of_layers; i++)
5181                     {
5182                         if (!cpi->b_calculate_psnr)
5183                             cpi->frames_in_layer[i]++;
5184
5185                         cpi->total_ssimg_y_in_layer[i] += y;
5186                         cpi->total_ssimg_u_in_layer[i] += u;
5187                         cpi->total_ssimg_v_in_layer[i] += v;
5188                         cpi->total_ssimg_all_in_layer[i] += frame_all;
5189                     }
5190                 }
5191                 else
5192                 {
5193                     cpi->total_ssimg_y += y;
5194                     cpi->total_ssimg_u += u;
5195                     cpi->total_ssimg_v += v;
5196                     cpi->total_ssimg_all += frame_all;
5197                 }
5198             }
5199
5200         }
5201     }
5202
5203 #if 0
5204
5205     if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q)
5206     {
5207         skiptruecount += cpi->skip_true_count;
5208         skipfalsecount += cpi->skip_false_count;
5209     }
5210
5211 #endif
5212 #if 0
5213
5214     if (cpi->pass != 1)
5215     {
5216         FILE *f = fopen("skip.stt", "a");
5217         fprintf(f, "frame:%4d flags:%4x Q:%4d P:%4d Size:%5d\n", cpi->common.current_video_frame, *frame_flags, cpi->common.base_qindex, cpi->prob_skip_false, *size);
5218
5219         if (cpi->is_src_frame_alt_ref == 1)
5220             fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size);
5221
5222         fclose(f);
5223     }
5224
5225 #endif
5226 #endif
5227
5228 #if HAVE_NEON
5229 #if CONFIG_RUNTIME_CPU_DETECT
5230     if (cm->cpu_caps & HAS_NEON)
5231 #endif
5232     {
5233         vp8_pop_neon(store_reg);
5234     }
5235 #endif
5236
5237     cpi->common.error.setjmp = 0;
5238
5239     return 0;
5240 }
5241
5242 int vp8_get_preview_raw_frame(VP8_COMP *cpi, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags)
5243 {
5244     if (cpi->common.refresh_alt_ref_frame)
5245         return -1;
5246     else
5247     {
5248         int ret;
5249
5250 #if CONFIG_MULTITHREAD
5251         if(cpi->b_lpf_running)
5252         {
5253             sem_wait(&cpi->h_event_end_lpf);
5254             cpi->b_lpf_running = 0;
5255         }
5256 #endif
5257
5258 #if CONFIG_POSTPROC
5259         ret = vp8_post_proc_frame(&cpi->common, dest, flags);
5260 #else
5261
5262         if (cpi->common.frame_to_show)
5263         {
5264             *dest = *cpi->common.frame_to_show;
5265             dest->y_width = cpi->common.Width;
5266             dest->y_height = cpi->common.Height;
5267             dest->uv_height = cpi->common.Height / 2;
5268             ret = 0;
5269         }
5270         else
5271         {
5272             ret = -1;
5273         }
5274
5275 #endif //!CONFIG_POSTPROC
5276         vp8_clear_system_state();
5277         return ret;
5278     }
5279 }
5280
5281 int vp8_set_roimap(VP8_COMP *cpi, unsigned char *map, unsigned int rows, unsigned int cols, int delta_q[4], int delta_lf[4], unsigned int threshold[4])
5282 {
5283     signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
5284
5285     if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
5286         return -1;
5287
5288     if (!map)
5289     {
5290         disable_segmentation(cpi);
5291         return 0;
5292     }
5293
5294     // Set the segmentation Map
5295     set_segmentation_map(cpi, map);
5296
5297     // Activate segmentation.
5298     enable_segmentation(cpi);
5299
5300     // Set up the quant segment data
5301     feature_data[MB_LVL_ALT_Q][0] = delta_q[0];
5302     feature_data[MB_LVL_ALT_Q][1] = delta_q[1];
5303     feature_data[MB_LVL_ALT_Q][2] = delta_q[2];
5304     feature_data[MB_LVL_ALT_Q][3] = delta_q[3];
5305
5306     // Set up the loop segment data s
5307     feature_data[MB_LVL_ALT_LF][0] = delta_lf[0];
5308     feature_data[MB_LVL_ALT_LF][1] = delta_lf[1];
5309     feature_data[MB_LVL_ALT_LF][2] = delta_lf[2];
5310     feature_data[MB_LVL_ALT_LF][3] = delta_lf[3];
5311
5312     cpi->segment_encode_breakout[0] = threshold[0];
5313     cpi->segment_encode_breakout[1] = threshold[1];
5314     cpi->segment_encode_breakout[2] = threshold[2];
5315     cpi->segment_encode_breakout[3] = threshold[3];
5316
5317     // Initialise the feature data structure
5318     // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
5319     set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
5320
5321     return 0;
5322 }
5323
5324 int vp8_set_active_map(VP8_COMP *cpi, unsigned char *map, unsigned int rows, unsigned int cols)
5325 {
5326     if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols)
5327     {
5328         if (map)
5329         {
5330             vpx_memcpy(cpi->active_map, map, rows * cols);
5331             cpi->active_map_enabled = 1;
5332         }
5333         else
5334             cpi->active_map_enabled = 0;
5335
5336         return 0;
5337     }
5338     else
5339     {
5340         //cpi->active_map_enabled = 0;
5341         return -1 ;
5342     }
5343 }
5344
5345 int vp8_set_internal_size(VP8_COMP *cpi, VPX_SCALING horiz_mode, VPX_SCALING vert_mode)
5346 {
5347     if (horiz_mode <= ONETWO)
5348         cpi->common.horiz_scale = horiz_mode;
5349     else
5350         return -1;
5351
5352     if (vert_mode <= ONETWO)
5353         cpi->common.vert_scale  = vert_mode;
5354     else
5355         return -1;
5356
5357     return 0;
5358 }
5359
5360
5361
5362 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest)
5363 {
5364     int i, j;
5365     int Total = 0;
5366
5367     unsigned char *src = source->y_buffer;
5368     unsigned char *dst = dest->y_buffer;
5369
5370     // Loop through the Y plane raw and reconstruction data summing (square differences)
5371     for (i = 0; i < source->y_height; i += 16)
5372     {
5373         for (j = 0; j < source->y_width; j += 16)
5374         {
5375             unsigned int sse;
5376             Total += vp8_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5377         }
5378
5379         src += 16 * source->y_stride;
5380         dst += 16 * dest->y_stride;
5381     }
5382
5383     return Total;
5384 }
5385
5386
5387 int vp8_get_quantizer(VP8_COMP *cpi)
5388 {
5389     return cpi->common.base_qindex;
5390 }