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     if (cm->no_lpf)
3121     {
3122         cm->filter_level = 0;
3123     }
3124     else
3125     {
3126         struct vpx_usec_timer timer;
3127
3128         vp8_clear_system_state();
3129
3130         vpx_usec_timer_start(&timer);
3131         if (cpi->sf.auto_filter == 0)
3132             vp8cx_pick_filter_level_fast(cpi->Source, cpi);
3133
3134         else
3135             vp8cx_pick_filter_level(cpi->Source, cpi);
3136
3137         vpx_usec_timer_mark(&timer);
3138         cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3139     }
3140
3141 #if CONFIG_MULTITHREAD
3142     if (cpi->b_multi_threaded)
3143         sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */
3144 #endif
3145
3146     if (cm->filter_level > 0)
3147     {
3148         vp8cx_set_alt_lf_level(cpi, cm->filter_level);
3149         vp8_loop_filter_frame(cm, &cpi->mb.e_mbd);
3150     }
3151
3152     vp8_yv12_extend_frame_borders(cm->frame_to_show);
3153 #if CONFIG_TEMPORAL_DENOISING
3154     if (cpi->oxcf.noise_sensitivity)
3155     {
3156       vp8_yv12_extend_frame_borders(&cpi->denoiser.yv12_running_avg);
3157     }
3158 #endif
3159 }
3160
3161 static void encode_frame_to_data_rate
3162 (
3163     VP8_COMP *cpi,
3164     unsigned long *size,
3165     unsigned char *dest,
3166     unsigned char* dest_end,
3167     unsigned int *frame_flags
3168 )
3169 {
3170     int Q;
3171     int frame_over_shoot_limit;
3172     int frame_under_shoot_limit;
3173
3174     int Loop = 0;
3175     int loop_count;
3176
3177     VP8_COMMON *cm = &cpi->common;
3178     int active_worst_qchanged = 0;
3179
3180 #if !(CONFIG_REALTIME_ONLY)
3181     int q_low;
3182     int q_high;
3183     int zbin_oq_high;
3184     int zbin_oq_low = 0;
3185     int top_index;
3186     int bottom_index;
3187     int overshoot_seen = 0;
3188     int undershoot_seen = 0;
3189 #endif
3190
3191     int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
3192     int drop_mark75 = drop_mark * 2 / 3;
3193     int drop_mark50 = drop_mark / 4;
3194     int drop_mark25 = drop_mark / 8;
3195
3196
3197     // Clear down mmx registers to allow floating point in what follows
3198     vp8_clear_system_state();
3199
3200 #if CONFIG_MULTITHREAD
3201     /*  wait for the last picture loopfilter thread done */
3202     if (cpi->b_lpf_running)
3203     {
3204         sem_wait(&cpi->h_event_end_lpf);
3205         cpi->b_lpf_running = 0;
3206     }
3207 #endif
3208
3209     // Test code for segmentation of gf/arf (0,0)
3210     //segmentation_test_function( cpi);
3211
3212     if(cpi->force_next_frame_intra)
3213     {
3214         cm->frame_type = KEY_FRAME;  /* delayed intra frame */
3215         cpi->force_next_frame_intra = 0;
3216     }
3217
3218     // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
3219 #if !(CONFIG_REALTIME_ONLY)
3220
3221     if (cpi->pass == 2)
3222     {
3223         if (cpi->common.refresh_alt_ref_frame)
3224         {
3225             cpi->per_frame_bandwidth = cpi->twopass.gf_bits;                           // Per frame bit target for the alt ref frame
3226             cpi->target_bandwidth = cpi->twopass.gf_bits * cpi->output_frame_rate;      // per second target bitrate
3227         }
3228     }
3229     else
3230 #endif
3231         cpi->per_frame_bandwidth  = (int)(cpi->target_bandwidth / cpi->output_frame_rate);
3232
3233     // Default turn off buffer to buffer copying
3234     cm->copy_buffer_to_gf = 0;
3235     cm->copy_buffer_to_arf = 0;
3236
3237     // Clear zbin over-quant value and mode boost values.
3238     cpi->zbin_over_quant = 0;
3239     cpi->zbin_mode_boost = 0;
3240
3241     // Enable or disable mode based tweaking of the zbin
3242     // For 2 Pass Only used where GF/ARF prediction quality
3243     // is above a threshold
3244     cpi->zbin_mode_boost_enabled = 1;
3245     if (cpi->pass == 2)
3246     {
3247         if ( cpi->gfu_boost <= 400 )
3248         {
3249             cpi->zbin_mode_boost_enabled = 0;
3250         }
3251     }
3252
3253     // Current default encoder behaviour for the altref sign bias
3254     if (cpi->source_alt_ref_active)
3255         cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
3256     else
3257         cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
3258
3259     // Check to see if a key frame is signalled
3260     // For two pass with auto key frame enabled cm->frame_type may already be set, but not for one pass.
3261     if ((cm->current_video_frame == 0) ||
3262         (cm->frame_flags & FRAMEFLAGS_KEY) ||
3263         (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0)))
3264     {
3265         // Key frame from VFW/auto-keyframe/first frame
3266         cm->frame_type = KEY_FRAME;
3267     }
3268
3269 #if CONFIG_MULTI_RES_ENCODING
3270     /* In multi-resolution encoding, frame_type is decided by lowest-resolution
3271      * encoder. Same frame_type is adopted while encoding at other resolution.
3272      */
3273     if (cpi->oxcf.mr_encoder_id)
3274     {
3275         cm->frame_type =
3276             ((LOWER_RES_FRAME_INFO*)cpi->oxcf.mr_low_res_mode_info)->frame_type;
3277     }
3278 #endif
3279
3280     // Set default state for segment and mode based loop filter update flags
3281     cpi->mb.e_mbd.update_mb_segmentation_map = 0;
3282     cpi->mb.e_mbd.update_mb_segmentation_data = 0;
3283     cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
3284
3285     // Set various flags etc to special state if it is a key frame
3286     if (cm->frame_type == KEY_FRAME)
3287     {
3288         int i;
3289
3290         // Reset the loop filter deltas and segmentation map
3291         setup_features(cpi);
3292
3293         // If segmentation is enabled force a map update for key frames
3294         if (cpi->mb.e_mbd.segmentation_enabled)
3295         {
3296             cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3297             cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3298         }
3299
3300         // The alternate reference frame cannot be active for a key frame
3301         cpi->source_alt_ref_active = 0;
3302
3303         // Reset the RD threshold multipliers to default of * 1 (128)
3304         for (i = 0; i < MAX_MODES; i++)
3305         {
3306             cpi->rd_thresh_mult[i] = 128;
3307         }
3308     }
3309
3310     // Test code for segmentation
3311     //if ( (cm->frame_type == KEY_FRAME) || ((cm->current_video_frame % 2) == 0))
3312     //if ( (cm->current_video_frame % 2) == 0 )
3313     //  enable_segmentation(cpi);
3314     //else
3315     //  disable_segmentation(cpi);
3316
3317 #if 0
3318     // Experimental code for lagged compress and one pass
3319     // Initialise one_pass GF frames stats
3320     // Update stats used for GF selection
3321     //if ( cpi->pass == 0 )
3322     {
3323         cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS;
3324
3325         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0;
3326         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0;
3327         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0;
3328         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0;
3329         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0;
3330         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0;
3331         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0;
3332         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0;
3333         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0;
3334     }
3335 #endif
3336
3337     update_rd_ref_frame_probs(cpi);
3338
3339     if (cpi->drop_frames_allowed)
3340     {
3341         // The reset to decimation 0 is only done here for one pass.
3342         // Once it is set two pass leaves decimation on till the next kf.
3343         if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
3344             cpi->decimation_factor --;
3345
3346         if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
3347             cpi->decimation_factor = 1;
3348
3349         else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3))
3350         {
3351             cpi->decimation_factor = 3;
3352         }
3353         else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2))
3354         {
3355             cpi->decimation_factor = 2;
3356         }
3357         else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1))
3358         {
3359             cpi->decimation_factor = 1;
3360         }
3361         //vpx_log("Encoder: Decimation Factor: %d \n",cpi->decimation_factor);
3362     }
3363
3364     // The following decimates the frame rate according to a regular pattern (i.e. to 1/2 or 2/3 frame rate)
3365     // This can be used to help prevent buffer under-run in CBR mode. Alternatively it might be desirable in
3366     // some situations to drop frame rate but throw more bits at each frame.
3367     //
3368     // Note that dropping a key frame can be problematic if spatial resampling is also active
3369     if (cpi->decimation_factor > 0)
3370     {
3371         switch (cpi->decimation_factor)
3372         {
3373         case 1:
3374             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 3 / 2;
3375             break;
3376         case 2:
3377             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 5 / 4;
3378             break;
3379         case 3:
3380             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 5 / 4;
3381             break;
3382         }
3383
3384         // Note that we should not throw out a key frame (especially when spatial resampling is enabled).
3385         if ((cm->frame_type == KEY_FRAME)) // && cpi->oxcf.allow_spatial_resampling )
3386         {
3387             cpi->decimation_count = cpi->decimation_factor;
3388         }
3389         else if (cpi->decimation_count > 0)
3390         {
3391             cpi->decimation_count --;
3392
3393             cpi->bits_off_target += cpi->av_per_frame_bandwidth;
3394             if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
3395                 cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
3396
3397             cm->current_video_frame++;
3398             cpi->frames_since_key++;
3399
3400 #if CONFIG_INTERNAL_STATS
3401             cpi->count ++;
3402 #endif
3403
3404             cpi->buffer_level = cpi->bits_off_target;
3405
3406             if (cpi->oxcf.number_of_layers > 1)
3407             {
3408                 unsigned int i;
3409
3410                 // Propagate bits saved by dropping the frame to higher layers
3411                 for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
3412                 {
3413                     LAYER_CONTEXT *lc = &cpi->layer_context[i];
3414                     lc->bits_off_target += cpi->av_per_frame_bandwidth;
3415                     if (lc->bits_off_target > lc->maximum_buffer_size)
3416                         lc->bits_off_target = lc->maximum_buffer_size;
3417                     lc->buffer_level = lc->bits_off_target;
3418                 }
3419             }
3420
3421             return;
3422         }
3423         else
3424             cpi->decimation_count = cpi->decimation_factor;
3425     }
3426
3427     // Decide how big to make the frame
3428     if (!vp8_pick_frame_size(cpi))
3429     {
3430         cm->current_video_frame++;
3431         cpi->frames_since_key++;
3432         return;
3433     }
3434
3435     // Reduce active_worst_allowed_q for CBR if our buffer is getting too full.
3436     // This has a knock on effect on active best quality as well.
3437     // For CBR if the buffer reaches its maximum level then we can no longer
3438     // save up bits for later frames so we might as well use them up
3439     // on the current frame.
3440     if ((cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
3441         (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode)
3442     {
3443         int Adjustment = cpi->active_worst_quality / 4;       // Max adjustment is 1/4
3444
3445         if (Adjustment)
3446         {
3447             int buff_lvl_step;
3448
3449             if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
3450             {
3451                 buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
3452
3453                 if (buff_lvl_step)
3454                     Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
3455                 else
3456                     Adjustment = 0;
3457             }
3458
3459             cpi->active_worst_quality -= Adjustment;
3460
3461             if(cpi->active_worst_quality < cpi->active_best_quality)
3462                 cpi->active_worst_quality = cpi->active_best_quality;
3463         }
3464     }
3465
3466     // Set an active best quality and if necessary active worst quality
3467     // There is some odd behavior for one pass here that needs attention.
3468     if ( (cpi->pass == 2) || (cpi->ni_frames > 150))
3469     {
3470         vp8_clear_system_state();
3471
3472         Q = cpi->active_worst_quality;
3473
3474         if ( cm->frame_type == KEY_FRAME )
3475         {
3476             if ( cpi->pass == 2 )
3477             {
3478                 if (cpi->gfu_boost > 600)
3479                    cpi->active_best_quality = kf_low_motion_minq[Q];
3480                 else
3481                    cpi->active_best_quality = kf_high_motion_minq[Q];
3482
3483                 // Special case for key frames forced because we have reached
3484                 // the maximum key frame interval. Here force the Q to a range
3485                 // based on the ambient Q to reduce the risk of popping
3486                 if ( cpi->this_key_frame_forced )
3487                 {
3488                     if ( cpi->active_best_quality > cpi->avg_frame_qindex * 7/8)
3489                         cpi->active_best_quality = cpi->avg_frame_qindex * 7/8;
3490                     else if ( cpi->active_best_quality < cpi->avg_frame_qindex >> 2 )
3491                         cpi->active_best_quality = cpi->avg_frame_qindex >> 2;
3492                 }
3493             }
3494             // One pass more conservative
3495             else
3496                cpi->active_best_quality = kf_high_motion_minq[Q];
3497         }
3498
3499         else if (cpi->oxcf.number_of_layers==1 &&
3500                 (cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame))
3501         {
3502             // Use the lower of cpi->active_worst_quality and recent
3503             // average Q as basis for GF/ARF Q limit unless last frame was
3504             // a key frame.
3505             if ( (cpi->frames_since_key > 1) &&
3506                (cpi->avg_frame_qindex < cpi->active_worst_quality) )
3507             {
3508                 Q = cpi->avg_frame_qindex;
3509             }
3510
3511             // For constrained quality dont allow Q less than the cq level
3512             if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3513                  (Q < cpi->cq_target_quality) )
3514             {
3515                 Q = cpi->cq_target_quality;
3516             }
3517
3518             if ( cpi->pass == 2 )
3519             {
3520                 if ( cpi->gfu_boost > 1000 )
3521                     cpi->active_best_quality = gf_low_motion_minq[Q];
3522                 else if ( cpi->gfu_boost < 400 )
3523                     cpi->active_best_quality = gf_high_motion_minq[Q];
3524                 else
3525                     cpi->active_best_quality = gf_mid_motion_minq[Q];
3526
3527                 // Constrained quality use slightly lower active best.
3528                 if ( cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY )
3529                 {
3530                     cpi->active_best_quality =
3531                         cpi->active_best_quality * 15/16;
3532                 }
3533             }
3534             // One pass more conservative
3535             else
3536                 cpi->active_best_quality = gf_high_motion_minq[Q];
3537         }
3538         else
3539         {
3540             cpi->active_best_quality = inter_minq[Q];
3541
3542             // For the constant/constrained quality mode we dont want
3543             // q to fall below the cq level.
3544             if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3545                 (cpi->active_best_quality < cpi->cq_target_quality) )
3546             {
3547                 // If we are strongly undershooting the target rate in the last
3548                 // frames then use the user passed in cq value not the auto
3549                 // cq value.
3550                 if ( cpi->rolling_actual_bits < cpi->min_frame_bandwidth )
3551                     cpi->active_best_quality = cpi->oxcf.cq_level;
3552                 else
3553                     cpi->active_best_quality = cpi->cq_target_quality;
3554             }
3555         }
3556
3557         // If CBR and the buffer is as full then it is reasonable to allow
3558         // higher quality on the frames to prevent bits just going to waste.
3559         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3560         {
3561             // Note that the use of >= here elliminates the risk of a devide
3562             // by 0 error in the else if clause
3563             if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
3564                 cpi->active_best_quality = cpi->best_quality;
3565
3566             else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
3567             {
3568                 int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
3569                 int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
3570
3571                 cpi->active_best_quality -= min_qadjustment;
3572             }
3573         }
3574     }
3575     // Make sure constrained quality mode limits are adhered to for the first
3576     // few frames of one pass encodes
3577     else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3578     {
3579         if ( (cm->frame_type == KEY_FRAME) ||
3580              cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame )
3581         {
3582              cpi->active_best_quality = cpi->best_quality;
3583         }
3584         else if (cpi->active_best_quality < cpi->cq_target_quality)
3585         {
3586             cpi->active_best_quality = cpi->cq_target_quality;
3587         }
3588     }
3589
3590     // Clip the active best and worst quality values to limits
3591     if (cpi->active_worst_quality > cpi->worst_quality)
3592         cpi->active_worst_quality = cpi->worst_quality;
3593
3594     if (cpi->active_best_quality < cpi->best_quality)
3595         cpi->active_best_quality = cpi->best_quality;
3596
3597     if ( cpi->active_worst_quality < cpi->active_best_quality )
3598         cpi->active_worst_quality = cpi->active_best_quality;
3599
3600     // Determine initial Q to try
3601     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3602
3603 #if !(CONFIG_REALTIME_ONLY)
3604
3605     // Set highest allowed value for Zbin over quant
3606     if (cm->frame_type == KEY_FRAME)
3607         zbin_oq_high = 0; //ZBIN_OQ_MAX/16
3608     else if ((cpi->oxcf.number_of_layers == 1) && ((cm->refresh_alt_ref_frame ||
3609               (cm->refresh_golden_frame && !cpi->source_alt_ref_active))))
3610     {
3611           zbin_oq_high = 16;
3612     }
3613     else
3614         zbin_oq_high = ZBIN_OQ_MAX;
3615 #endif
3616
3617     // Setup background Q adjustment for error resilient mode.
3618     // For multi-layer encodes only enable this for the base layer.
3619     if (cpi->cyclic_refresh_mode_enabled && (cpi->current_layer==0))
3620         cyclic_background_refresh(cpi, Q, 0);
3621
3622     vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3623
3624 #if !(CONFIG_REALTIME_ONLY)
3625     // Limit Q range for the adaptive loop.
3626     bottom_index = cpi->active_best_quality;
3627     top_index    = cpi->active_worst_quality;
3628     q_low  = cpi->active_best_quality;
3629     q_high = cpi->active_worst_quality;
3630 #endif
3631
3632     vp8_save_coding_context(cpi);
3633
3634     loop_count = 0;
3635
3636     scale_and_extend_source(cpi->un_scaled_source, cpi);
3637
3638 #if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC && !(CONFIG_TEMPORAL_DENOISING)
3639
3640     if (cpi->oxcf.noise_sensitivity > 0)
3641     {
3642         unsigned char *src;
3643         int l = 0;
3644
3645         switch (cpi->oxcf.noise_sensitivity)
3646         {
3647         case 1:
3648             l = 20;
3649             break;
3650         case 2:
3651             l = 40;
3652             break;
3653         case 3:
3654             l = 60;
3655             break;
3656         case 4:
3657             l = 80;
3658             break;
3659         case 5:
3660             l = 100;
3661             break;
3662         case 6:
3663             l = 150;
3664             break;
3665         }
3666
3667
3668         if (cm->frame_type == KEY_FRAME)
3669         {
3670             vp8_de_noise(cpi->Source, cpi->Source, l , 1,  0);
3671         }
3672         else
3673         {
3674             vp8_de_noise(cpi->Source, cpi->Source, l , 1,  0);
3675
3676             src = cpi->Source->y_buffer;
3677
3678             if (cpi->Source->y_stride < 0)
3679             {
3680                 src += cpi->Source->y_stride * (cpi->Source->y_height - 1);
3681             }
3682         }
3683     }
3684
3685 #endif
3686
3687 #ifdef OUTPUT_YUV_SRC
3688     vp8_write_yuv_frame(cpi->Source);
3689 #endif
3690
3691     do
3692     {
3693         vp8_clear_system_state();  //__asm emms;
3694
3695         /*
3696         if(cpi->is_src_frame_alt_ref)
3697             Q = 127;
3698             */
3699
3700         vp8_set_quantizer(cpi, Q);
3701
3702         // setup skip prob for costing in mode/mv decision
3703         if (cpi->common.mb_no_coeff_skip)
3704         {
3705             cpi->prob_skip_false = cpi->base_skip_false_prob[Q];
3706
3707             if (cm->frame_type != KEY_FRAME)
3708             {
3709                 if (cpi->common.refresh_alt_ref_frame)
3710                 {
3711                     if (cpi->last_skip_false_probs[2] != 0)
3712                         cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3713
3714                     /*
3715                                         if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 )
3716                        cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3717                                         else if (cpi->last_skip_false_probs[2]!=0)
3718                        cpi->prob_skip_false = (cpi->last_skip_false_probs[2]  + cpi->prob_skip_false ) / 2;
3719                        */
3720                 }
3721                 else if (cpi->common.refresh_golden_frame)
3722                 {
3723                     if (cpi->last_skip_false_probs[1] != 0)
3724                         cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3725
3726                     /*
3727                                         if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 )
3728                        cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3729                                         else if (cpi->last_skip_false_probs[1]!=0)
3730                        cpi->prob_skip_false = (cpi->last_skip_false_probs[1]  + cpi->prob_skip_false ) / 2;
3731                        */
3732                 }
3733                 else
3734                 {
3735                     if (cpi->last_skip_false_probs[0] != 0)
3736                         cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3737
3738                     /*
3739                     if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 )
3740                         cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3741                     else if(cpi->last_skip_false_probs[0]!=0)
3742                         cpi->prob_skip_false = (cpi->last_skip_false_probs[0]  + cpi->prob_skip_false ) / 2;
3743                         */
3744                 }
3745
3746                 //as this is for cost estimate, let's make sure it does not go extreme eitehr way
3747                 if (cpi->prob_skip_false < 5)
3748                     cpi->prob_skip_false = 5;
3749
3750                 if (cpi->prob_skip_false > 250)
3751                     cpi->prob_skip_false = 250;
3752
3753                 if (cpi->oxcf.number_of_layers == 1 && cpi->is_src_frame_alt_ref)
3754                     cpi->prob_skip_false = 1;
3755             }
3756
3757 #if 0
3758
3759             if (cpi->pass != 1)
3760             {
3761                 FILE *f = fopen("skip.stt", "a");
3762                 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false);
3763                 fclose(f);
3764             }
3765
3766 #endif
3767
3768         }
3769
3770         if (cm->frame_type == KEY_FRAME)
3771         {
3772             resize_key_frame(cpi);
3773             vp8_setup_key_frame(cpi);
3774         }
3775
3776
3777
3778 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
3779         {
3780             if(cpi->oxcf.error_resilient_mode)
3781                 cm->refresh_entropy_probs = 0;
3782
3783             if (cpi->oxcf.error_resilient_mode & VPX_ERROR_RESILIENT_PARTITIONS)
3784             {
3785                 if (cm->frame_type == KEY_FRAME)
3786                     cm->refresh_entropy_probs = 1;
3787             }
3788
3789             if (cm->refresh_entropy_probs == 0)
3790             {
3791                 // save a copy for later refresh
3792                 vpx_memcpy(&cm->lfc, &cm->fc, sizeof(cm->fc));
3793             }
3794
3795             vp8_update_coef_context(cpi);
3796
3797             vp8_update_coef_probs(cpi);
3798
3799             // transform / motion compensation build reconstruction frame
3800             // +pack coef partitions
3801             vp8_encode_frame(cpi);
3802
3803             /* cpi->projected_frame_size is not needed for RT mode */
3804         }
3805 #else
3806         // transform / motion compensation build reconstruction frame
3807         vp8_encode_frame(cpi);
3808
3809         cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi);
3810         cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0;
3811 #endif
3812         vp8_clear_system_state();  //__asm emms;
3813
3814         // Test to see if the stats generated for this frame indicate that we should have coded a key frame
3815         // (assuming that we didn't)!
3816         if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3817         {
3818             int key_frame_decision = decide_key_frame(cpi);
3819
3820             if (cpi->compressor_speed == 2)
3821             {
3822                 /* we don't do re-encoding in realtime mode
3823                  * if key frame is decided then we force it on next frame */
3824                 cpi->force_next_frame_intra = key_frame_decision;
3825             }
3826 #if !(CONFIG_REALTIME_ONLY)
3827             else if (key_frame_decision)
3828             {
3829                 // Reset all our sizing numbers and recode
3830                 cm->frame_type = KEY_FRAME;
3831
3832                 vp8_pick_frame_size(cpi);
3833
3834                 // Clear the Alt reference frame active flag when we have a key frame
3835                 cpi->source_alt_ref_active = 0;
3836
3837                 // Reset the loop filter deltas and segmentation map
3838                 setup_features(cpi);
3839
3840                 // If segmentation is enabled force a map update for key frames
3841                 if (cpi->mb.e_mbd.segmentation_enabled)
3842                 {
3843                     cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3844                     cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3845                 }
3846
3847                 vp8_restore_coding_context(cpi);
3848
3849                 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3850
3851                 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3852
3853                 // Limit Q range for the adaptive loop.
3854                 bottom_index = cpi->active_best_quality;
3855                 top_index    = cpi->active_worst_quality;
3856                 q_low  = cpi->active_best_quality;
3857                 q_high = cpi->active_worst_quality;
3858
3859                 loop_count++;
3860                 Loop = 1;
3861
3862                 continue;
3863             }
3864 #endif
3865         }
3866
3867         vp8_clear_system_state();
3868
3869         if (frame_over_shoot_limit == 0)
3870             frame_over_shoot_limit = 1;
3871
3872         // Are we are overshooting and up against the limit of active max Q.
3873         if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) &&
3874             (Q == cpi->active_worst_quality)                     &&
3875             (cpi->active_worst_quality < cpi->worst_quality)      &&
3876             (cpi->projected_frame_size > frame_over_shoot_limit))
3877         {
3878             int over_size_percent = ((cpi->projected_frame_size - frame_over_shoot_limit) * 100) / frame_over_shoot_limit;
3879
3880             // If so is there any scope for relaxing it
3881             while ((cpi->active_worst_quality < cpi->worst_quality) && (over_size_percent > 0))
3882             {
3883                 cpi->active_worst_quality++;
3884
3885                 over_size_percent = (int)(over_size_percent * 0.96);        // Assume 1 qstep = about 4% on frame size.
3886             }
3887 #if !(CONFIG_REALTIME_ONLY)
3888             top_index = cpi->active_worst_quality;
3889 #endif
3890             // If we have updated the active max Q do not call vp8_update_rate_correction_factors() this loop.
3891             active_worst_qchanged = 1;
3892         }
3893         else
3894             active_worst_qchanged = 0;
3895
3896 #if !(CONFIG_REALTIME_ONLY)
3897         // Special case handling for forced key frames
3898         if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced )
3899         {
3900             int last_q = Q;
3901             int kf_err = vp8_calc_ss_err(cpi->Source,
3902                                          &cm->yv12_fb[cm->new_fb_idx]);
3903
3904             // The key frame is not good enough
3905             if ( kf_err > ((cpi->ambient_err * 7) >> 3) )
3906             {
3907                 // Lower q_high
3908                 q_high = (Q > q_low) ? (Q - 1) : q_low;
3909
3910                 // Adjust Q
3911                 Q = (q_high + q_low) >> 1;
3912             }
3913             // The key frame is much better than the previous frame
3914             else if ( kf_err < (cpi->ambient_err >> 1) )
3915             {
3916                 // Raise q_low
3917                 q_low = (Q < q_high) ? (Q + 1) : q_high;
3918
3919                 // Adjust Q
3920                 Q = (q_high + q_low + 1) >> 1;
3921             }
3922
3923             // Clamp Q to upper and lower limits:
3924             if (Q > q_high)
3925                 Q = q_high;
3926             else if (Q < q_low)
3927                 Q = q_low;
3928
3929             Loop = Q != last_q;
3930         }
3931
3932         // Is the projected frame size out of range and are we allowed to attempt to recode.
3933         else if ( recode_loop_test( cpi,
3934                                frame_over_shoot_limit, frame_under_shoot_limit,
3935                                Q, top_index, bottom_index ) )
3936         {
3937             int last_q = Q;
3938             int Retries = 0;
3939
3940             // Frame size out of permitted range:
3941             // Update correction factor & compute new Q to try...
3942
3943             // Frame is too large
3944             if (cpi->projected_frame_size > cpi->this_frame_target)
3945             {
3946                 //if ( cpi->zbin_over_quant == 0 )
3947                 q_low = (Q < q_high) ? (Q + 1) : q_high; // Raise Qlow as to at least the current value
3948
3949                 if (cpi->zbin_over_quant > 0)            // If we are using over quant do the same for zbin_oq_low
3950                     zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3951
3952                 //if ( undershoot_seen || (Q == MAXQ) )
3953                 if (undershoot_seen)
3954                 {
3955                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3956                     if (!active_worst_qchanged)
3957                         vp8_update_rate_correction_factors(cpi, 1);
3958
3959                     Q = (q_high + q_low + 1) / 2;
3960
3961                     // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3962                     if (Q < MAXQ)
3963                         cpi->zbin_over_quant = 0;
3964                     else
3965                     {
3966                         zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3967                         cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3968                     }
3969                 }
3970                 else
3971                 {
3972                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3973                     if (!active_worst_qchanged)
3974                         vp8_update_rate_correction_factors(cpi, 0);
3975
3976                     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3977
3978                     while (((Q < q_low) || (cpi->zbin_over_quant < zbin_oq_low)) && (Retries < 10))
3979                     {
3980                         vp8_update_rate_correction_factors(cpi, 0);
3981                         Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3982                         Retries ++;
3983                     }
3984                 }
3985
3986                 overshoot_seen = 1;
3987             }
3988             // Frame is too small
3989             else
3990             {
3991                 if (cpi->zbin_over_quant == 0)
3992                     q_high = (Q > q_low) ? (Q - 1) : q_low; // Lower q_high if not using over quant
3993                 else                                    // else lower zbin_oq_high
3994                     zbin_oq_high = (cpi->zbin_over_quant > zbin_oq_low) ? (cpi->zbin_over_quant - 1) : zbin_oq_low;
3995
3996                 if (overshoot_seen)
3997                 {
3998                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3999                     if (!active_worst_qchanged)
4000                         vp8_update_rate_correction_factors(cpi, 1);
4001
4002                     Q = (q_high + q_low) / 2;
4003
4004                     // Adjust cpi->zbin_over_quant (only allowed when Q is max)
4005                     if (Q < MAXQ)
4006                         cpi->zbin_over_quant = 0;
4007                     else
4008                         cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
4009                 }
4010                 else
4011                 {
4012                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
4013                     if (!active_worst_qchanged)
4014                         vp8_update_rate_correction_factors(cpi, 0);
4015
4016                     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4017
4018                     // Special case reset for qlow for constrained quality.
4019                     // This should only trigger where there is very substantial
4020                     // undershoot on a frame and the auto cq level is above
4021                     // the user passsed in value.
4022                     if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
4023                          (Q < q_low) )
4024                     {
4025                         q_low = Q;
4026                     }
4027
4028                     while (((Q > q_high) || (cpi->zbin_over_quant > zbin_oq_high)) && (Retries < 10))
4029                     {
4030                         vp8_update_rate_correction_factors(cpi, 0);
4031                         Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4032                         Retries ++;
4033                     }
4034                 }
4035
4036                 undershoot_seen = 1;
4037             }
4038
4039             // Clamp Q to upper and lower limits:
4040             if (Q > q_high)
4041                 Q = q_high;
4042             else if (Q < q_low)
4043                 Q = q_low;
4044
4045             // Clamp cpi->zbin_over_quant
4046             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;
4047
4048             Loop = Q != last_q;
4049         }
4050         else
4051 #endif
4052             Loop = 0;
4053
4054         if (cpi->is_src_frame_alt_ref)
4055             Loop = 0;
4056
4057         if (Loop == 1)
4058         {
4059             vp8_restore_coding_context(cpi);
4060             loop_count++;
4061 #if CONFIG_INTERNAL_STATS
4062             cpi->tot_recode_hits++;
4063 #endif
4064         }
4065     }
4066     while (Loop == 1);
4067
4068 #if 0
4069     // Experimental code for lagged and one pass
4070     // Update stats used for one pass GF selection
4071     {
4072         /*
4073             int frames_so_far;
4074             double frame_intra_error;
4075             double frame_coded_error;
4076             double frame_pcnt_inter;
4077             double frame_pcnt_motion;
4078             double frame_mvr;
4079             double frame_mvr_abs;
4080             double frame_mvc;
4081             double frame_mvc_abs;
4082         */
4083
4084         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error;
4085         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error;
4086         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0;
4087     }
4088 #endif
4089
4090     // Special case code to reduce pulsing when key frames are forced at a
4091     // fixed interval. Note the reconstruction error if it is the frame before
4092     // the force key frame
4093     if ( cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0) )
4094     {
4095         cpi->ambient_err = vp8_calc_ss_err(cpi->Source,
4096                                            &cm->yv12_fb[cm->new_fb_idx]);
4097     }
4098
4099     /* This frame's MVs are saved and will be used in next frame's MV predictor.
4100      * Last frame has one more line(add to bottom) and one more column(add to
4101      * right) than cm->mip. The edge elements are initialized to 0.
4102      */
4103 #if CONFIG_MULTI_RES_ENCODING
4104     if(!cpi->oxcf.mr_encoder_id && cm->show_frame)
4105 #else
4106     if(cm->show_frame)   /* do not save for altref frame */
4107 #endif
4108     {
4109         int mb_row;
4110         int mb_col;
4111         /* Point to beginning of allocated MODE_INFO arrays. */
4112         MODE_INFO *tmp = cm->mip;
4113
4114         if(cm->frame_type != KEY_FRAME)
4115         {
4116             for (mb_row = 0; mb_row < cm->mb_rows+1; mb_row ++)
4117             {
4118                 for (mb_col = 0; mb_col < cm->mb_cols+1; mb_col ++)
4119                 {
4120                     if(tmp->mbmi.ref_frame != INTRA_FRAME)
4121                         cpi->lfmv[mb_col + mb_row*(cm->mode_info_stride+1)].as_int = tmp->mbmi.mv.as_int;
4122
4123                     cpi->lf_ref_frame_sign_bias[mb_col + mb_row*(cm->mode_info_stride+1)] = cm->ref_frame_sign_bias[tmp->mbmi.ref_frame];
4124                     cpi->lf_ref_frame[mb_col + mb_row*(cm->mode_info_stride+1)] = tmp->mbmi.ref_frame;
4125                     tmp++;
4126                 }
4127             }
4128         }
4129     }
4130
4131 #if CONFIG_MULTI_RES_ENCODING
4132     vp8_cal_dissimilarity(cpi);
4133 #endif
4134
4135     // Update the GF useage maps.
4136     // This is done after completing the compression of a frame when all
4137     // modes etc. are finalized but before loop filter
4138     if (cpi->oxcf.number_of_layers == 1)
4139         vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
4140
4141     if (cm->frame_type == KEY_FRAME)
4142         cm->refresh_last_frame = 1;
4143
4144 #if 0
4145     {
4146         FILE *f = fopen("gfactive.stt", "a");
4147         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);
4148         fclose(f);
4149     }
4150 #endif
4151
4152     // For inter frames the current default behavior is that when
4153     // cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
4154     // This is purely an encoder decision at present.
4155     if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
4156         cm->copy_buffer_to_arf  = 2;
4157     else
4158         cm->copy_buffer_to_arf  = 0;
4159
4160     cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
4161
4162 #if CONFIG_MULTITHREAD
4163     if (cpi->b_multi_threaded)
4164     {
4165         sem_post(&cpi->h_event_start_lpf); /* start loopfilter in separate thread */
4166         cpi->b_lpf_running = 1;
4167     }
4168     else
4169 #endif
4170     {
4171         vp8_loopfilter_frame(cpi, cm);
4172     }
4173
4174     update_reference_frames(cm);
4175
4176 #if !(CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING)
4177     if (cpi->oxcf.error_resilient_mode)
4178     {
4179         cm->refresh_entropy_probs = 0;
4180     }
4181 #endif
4182
4183 #if CONFIG_MULTITHREAD
4184     /* wait that filter_level is picked so that we can continue with stream packing */
4185     if (cpi->b_multi_threaded)
4186         sem_wait(&cpi->h_event_end_lpf);
4187 #endif
4188
4189     // build the bitstream
4190     vp8_pack_bitstream(cpi, dest, dest_end, size);
4191
4192 #if CONFIG_MULTITHREAD
4193     /* if PSNR packets are generated we have to wait for the lpf */
4194     if (cpi->b_lpf_running && cpi->b_calculate_psnr)
4195     {
4196         sem_wait(&cpi->h_event_end_lpf);
4197         cpi->b_lpf_running = 0;
4198     }
4199 #endif
4200
4201     /* Move storing frame_type out of the above loop since it is also
4202      * needed in motion search besides loopfilter */
4203     cm->last_frame_type = cm->frame_type;
4204
4205     // Update rate control heuristics
4206     cpi->total_byte_count += (*size);
4207     cpi->projected_frame_size = (*size) << 3;
4208
4209     if (cpi->oxcf.number_of_layers > 1)
4210     {
4211         unsigned int i;
4212         for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
4213           cpi->layer_context[i].total_byte_count += (*size);
4214     }
4215
4216     if (!active_worst_qchanged)
4217         vp8_update_rate_correction_factors(cpi, 2);
4218
4219     cpi->last_q[cm->frame_type] = cm->base_qindex;
4220
4221     if (cm->frame_type == KEY_FRAME)
4222     {
4223         vp8_adjust_key_frame_context(cpi);
4224     }
4225
4226     // Keep a record of ambient average Q.
4227     if (cm->frame_type != KEY_FRAME)
4228         cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
4229
4230     // Keep a record from which we can calculate the average Q excluding GF updates and key frames
4231     if ((cm->frame_type != KEY_FRAME) && ((cpi->oxcf.number_of_layers > 1) ||
4232         (!cm->refresh_golden_frame && !cm->refresh_alt_ref_frame)))
4233     {
4234         cpi->ni_frames++;
4235
4236         // Calculate the average Q for normal inter frames (not key or GFU
4237         // frames).
4238         if ( cpi->pass == 2 )
4239         {
4240             cpi->ni_tot_qi += Q;
4241             cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4242         }
4243         else
4244         {
4245             // Damp value for first few frames
4246             if (cpi->ni_frames > 150 )
4247             {
4248                 cpi->ni_tot_qi += Q;
4249                 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4250             }
4251             // For one pass, early in the clip ... average the current frame Q
4252             // value with the worstq entered by the user as a dampening measure
4253             else
4254             {
4255                 cpi->ni_tot_qi += Q;
4256                 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2;
4257             }
4258
4259             // If the average Q is higher than what was used in the last frame
4260             // (after going through the recode loop to keep the frame size within range)
4261             // then use the last frame value - 1.
4262             // The -1 is designed to stop Q and hence the data rate, from progressively
4263             // falling away during difficult sections, but at the same time reduce the number of
4264             // itterations around the recode loop.
4265             if (Q > cpi->ni_av_qi)
4266                 cpi->ni_av_qi = Q - 1;
4267         }
4268     }
4269
4270 #if 0
4271
4272     // If the frame was massively oversize and we are below optimal buffer level drop next frame
4273     if ((cpi->drop_frames_allowed) &&
4274         (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
4275         (cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
4276         (cpi->projected_frame_size > (4 * cpi->this_frame_target)))
4277     {
4278         cpi->drop_frame = 1;
4279     }
4280
4281 #endif
4282
4283     // Set the count for maximum consecutive dropped frames based upon the ratio of
4284     // this frame size to the target average per frame bandwidth.
4285     // (cpi->av_per_frame_bandwidth > 0) is just a sanity check to prevent / 0.
4286     if (cpi->drop_frames_allowed && (cpi->av_per_frame_bandwidth > 0))
4287     {
4288         cpi->max_drop_count = cpi->projected_frame_size / cpi->av_per_frame_bandwidth;
4289
4290         if (cpi->max_drop_count > cpi->max_consec_dropped_frames)
4291             cpi->max_drop_count = cpi->max_consec_dropped_frames;
4292     }
4293
4294     // Update the buffer level variable.
4295     // Non-viewable frames are a special case and are treated as pure overhead.
4296     if ( !cm->show_frame )
4297         cpi->bits_off_target -= cpi->projected_frame_size;
4298     else
4299         cpi->bits_off_target += cpi->av_per_frame_bandwidth - cpi->projected_frame_size;
4300
4301     // Clip the buffer level to the maximum specified buffer size
4302     if (cpi->bits_off_target > cpi->oxcf.maximum_buffer_size)
4303         cpi->bits_off_target = cpi->oxcf.maximum_buffer_size;
4304
4305     // Rolling monitors of whether we are over or underspending used to help regulate min and Max Q in two pass.
4306     cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
4307     cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
4308     cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
4309     cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32;
4310
4311     // Actual bits spent
4312     cpi->total_actual_bits += cpi->projected_frame_size;
4313
4314     // Debug stats
4315     cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size);
4316
4317     cpi->buffer_level = cpi->bits_off_target;
4318
4319     // Propagate values to higher temporal layers
4320     if (cpi->oxcf.number_of_layers > 1)
4321     {
4322         unsigned int i;
4323
4324         for (i=cpi->current_layer+1; i<cpi->oxcf.number_of_layers; i++)
4325         {
4326             LAYER_CONTEXT *lc = &cpi->layer_context[i];
4327             int bits_off_for_this_layer = lc->target_bandwidth / lc->frame_rate
4328                                                 - cpi->projected_frame_size;
4329
4330             lc->bits_off_target += bits_off_for_this_layer;
4331
4332             // Clip buffer level to maximum buffer size for the layer
4333             if (lc->bits_off_target > lc->maximum_buffer_size)
4334                 lc->bits_off_target = lc->maximum_buffer_size;
4335
4336             lc->total_actual_bits += cpi->projected_frame_size;
4337             lc->total_target_vs_actual += bits_off_for_this_layer;
4338             lc->buffer_level = lc->bits_off_target;
4339         }
4340     }
4341
4342     // Update bits left to the kf and gf groups to account for overshoot or undershoot on these frames
4343     if (cm->frame_type == KEY_FRAME)
4344     {
4345         cpi->twopass.kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4346
4347         if (cpi->twopass.kf_group_bits < 0)
4348             cpi->twopass.kf_group_bits = 0 ;
4349     }
4350     else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4351     {
4352         cpi->twopass.gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4353
4354         if (cpi->twopass.gf_group_bits < 0)
4355             cpi->twopass.gf_group_bits = 0 ;
4356     }
4357
4358     if (cm->frame_type != KEY_FRAME)
4359     {
4360         if (cpi->common.refresh_alt_ref_frame)
4361         {
4362             cpi->last_skip_false_probs[2] = cpi->prob_skip_false;
4363             cpi->last_skip_probs_q[2] = cm->base_qindex;
4364         }
4365         else if (cpi->common.refresh_golden_frame)
4366         {
4367             cpi->last_skip_false_probs[1] = cpi->prob_skip_false;
4368             cpi->last_skip_probs_q[1] = cm->base_qindex;
4369         }
4370         else
4371         {
4372             cpi->last_skip_false_probs[0] = cpi->prob_skip_false;
4373             cpi->last_skip_probs_q[0] = cm->base_qindex;
4374
4375             //update the baseline
4376             cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false;
4377
4378         }
4379     }
4380
4381 #if 0 && CONFIG_INTERNAL_STATS
4382     {
4383         FILE *f = fopen("tmp.stt", "a");
4384
4385         vp8_clear_system_state();  //__asm emms;
4386
4387         if (cpi->twopass.total_left_stats.coded_error != 0.0)
4388             fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4389                        "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4390                        "%10.3f %8d\n",
4391                        cpi->common.current_video_frame, cpi->this_frame_target,
4392                        cpi->projected_frame_size,
4393                        (cpi->projected_frame_size - cpi->this_frame_target),
4394                        (int)cpi->total_target_vs_actual,
4395                        cpi->buffer_level,
4396                        (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4397                        (int)cpi->total_actual_bits, cm->base_qindex,
4398                        cpi->active_best_quality, cpi->active_worst_quality,
4399                        cpi->ni_av_qi, cpi->cq_target_quality,
4400                        cpi->zbin_over_quant,
4401                        //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4402                        cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4403                        cm->frame_type, cpi->gfu_boost,
4404                        cpi->twopass.est_max_qcorrection_factor,
4405                        (int)cpi->twopass.bits_left,
4406                        cpi->twopass.total_left_stats.coded_error,
4407                        (double)cpi->twopass.bits_left /
4408                            cpi->twopass.total_left_stats.coded_error,
4409                        cpi->tot_recode_hits);
4410         else
4411             fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4412                        "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4413                        "%8d\n",
4414                        cpi->common.current_video_frame,
4415                        cpi->this_frame_target, cpi->projected_frame_size,
4416                        (cpi->projected_frame_size - cpi->this_frame_target),
4417                        (int)cpi->total_target_vs_actual,
4418                        cpi->buffer_level,
4419                        (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4420                        (int)cpi->total_actual_bits, cm->base_qindex,
4421                        cpi->active_best_quality, cpi->active_worst_quality,
4422                        cpi->ni_av_qi, cpi->cq_target_quality,
4423                        cpi->zbin_over_quant,
4424                        //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4425                        cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4426                        cm->frame_type, cpi->gfu_boost,
4427                        cpi->twopass.est_max_qcorrection_factor,
4428                        (int)cpi->twopass.bits_left,
4429                        cpi->twopass.total_left_stats.coded_error,
4430                        cpi->tot_recode_hits);
4431
4432         fclose(f);
4433
4434         {
4435             FILE *fmodes = fopen("Modes.stt", "a");
4436             int i;
4437
4438             fprintf(fmodes, "%6d:%1d:%1d:%1d ",
4439                         cpi->common.current_video_frame,
4440                         cm->frame_type, cm->refresh_golden_frame,
4441                         cm->refresh_alt_ref_frame);
4442
4443             for (i = 0; i < MAX_MODES; i++)
4444                 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
4445
4446             fprintf(fmodes, "\n");
4447
4448             fclose(fmodes);
4449         }
4450     }
4451
4452 #endif
4453
4454     // If this was a kf or Gf note the Q
4455     if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4456         cm->last_kf_gf_q = cm->base_qindex;
4457
4458     if (cm->refresh_golden_frame == 1)
4459         cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
4460     else
4461         cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
4462
4463     if (cm->refresh_alt_ref_frame == 1)
4464         cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
4465     else
4466         cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
4467
4468
4469     if (cm->refresh_last_frame & cm->refresh_golden_frame) // both refreshed
4470         cpi->gold_is_last = 1;
4471     else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4472         cpi->gold_is_last = 0;
4473
4474     if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) // both refreshed
4475         cpi->alt_is_last = 1;
4476     else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) // 1 refreshed but not the other
4477         cpi->alt_is_last = 0;
4478
4479     if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) // both refreshed
4480         cpi->gold_is_alt = 1;
4481     else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4482         cpi->gold_is_alt = 0;
4483
4484     cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
4485
4486     if (cpi->gold_is_last)
4487         cpi->ref_frame_flags &= ~VP8_GOLD_FLAG;
4488
4489     if (cpi->alt_is_last)
4490         cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4491
4492     if (cpi->gold_is_alt)
4493         cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4494
4495
4496     if (!cpi->oxcf.error_resilient_mode)
4497     {
4498         if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame && (cm->frame_type != KEY_FRAME))
4499             // Update the alternate reference frame stats as appropriate.
4500             update_alt_ref_frame_stats(cpi);
4501         else
4502             // Update the Golden frame stats as appropriate.
4503             update_golden_frame_stats(cpi);
4504     }
4505
4506     if (cm->frame_type == KEY_FRAME)
4507     {
4508         // Tell the caller that the frame was coded as a key frame
4509         *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
4510
4511         // As this frame is a key frame  the next defaults to an inter frame.
4512         cm->frame_type = INTER_FRAME;
4513
4514         cpi->last_frame_percent_intra = 100;
4515     }
4516     else
4517     {
4518         *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
4519
4520         cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
4521     }
4522
4523     // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
4524     cpi->mb.e_mbd.update_mb_segmentation_map = 0;
4525     cpi->mb.e_mbd.update_mb_segmentation_data = 0;
4526     cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
4527
4528
4529     // Dont increment frame counters if this was an altref buffer update not a real frame
4530     if (cm->show_frame)
4531     {
4532         cm->current_video_frame++;
4533         cpi->frames_since_key++;
4534     }
4535
4536     // reset to normal state now that we are done.
4537
4538
4539
4540 #if 0
4541     {
4542         char filename[512];
4543         FILE *recon_file;
4544         sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
4545         recon_file = fopen(filename, "wb");
4546         fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc,
4547                cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
4548         fclose(recon_file);
4549     }
4550 #endif
4551
4552     // DEBUG
4553     //vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
4554
4555
4556 }
4557
4558
4559 static void check_gf_quality(VP8_COMP *cpi)
4560 {
4561     VP8_COMMON *cm = &cpi->common;
4562     int gf_active_pct = (100 * cpi->gf_active_count) / (cm->mb_rows * cm->mb_cols);
4563     int gf_ref_usage_pct = (cpi->count_mb_ref_frame_usage[GOLDEN_FRAME] * 100) / (cm->mb_rows * cm->mb_cols);
4564     int last_ref_zz_useage = (cpi->inter_zz_count * 100) / (cm->mb_rows * cm->mb_cols);
4565
4566     // Gf refresh is not currently being signalled
4567     if (cpi->gf_update_recommended == 0)
4568     {
4569         if (cpi->common.frames_since_golden > 7)
4570         {
4571             // Low use of gf
4572             if ((gf_active_pct < 10) || ((gf_active_pct + gf_ref_usage_pct) < 15))
4573             {
4574                 // ...but last frame zero zero usage is reasonbable so a new gf might be appropriate
4575                 if (last_ref_zz_useage >= 25)
4576                 {
4577                     cpi->gf_bad_count ++;
4578
4579                     if (cpi->gf_bad_count >= 8)   // Check that the condition is stable
4580                     {
4581                         cpi->gf_update_recommended = 1;
4582                         cpi->gf_bad_count = 0;
4583                     }
4584                 }
4585                 else
4586                     cpi->gf_bad_count = 0;        // Restart count as the background is not stable enough
4587             }
4588             else
4589                 cpi->gf_bad_count = 0;            // Gf useage has picked up so reset count
4590         }
4591     }
4592     // If the signal is set but has not been read should we cancel it.
4593     else if (last_ref_zz_useage < 15)
4594     {
4595         cpi->gf_update_recommended = 0;
4596         cpi->gf_bad_count = 0;
4597     }
4598
4599 #if 0
4600     {
4601         FILE *f = fopen("gfneeded.stt", "a");
4602         fprintf(f, "%10d %10d %10d %10d %10ld \n",
4603                 cm->current_video_frame,
4604                 cpi->common.frames_since_golden,
4605                 gf_active_pct, gf_ref_usage_pct,
4606                 cpi->gf_update_recommended);
4607         fclose(f);
4608     }
4609
4610 #endif
4611 }
4612
4613 #if !(CONFIG_REALTIME_ONLY)
4614 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned char * dest_end, unsigned int *frame_flags)
4615 {
4616
4617     if (!cpi->common.refresh_alt_ref_frame)
4618         vp8_second_pass(cpi);
4619
4620     encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags);
4621     cpi->twopass.bits_left -= 8 * *size;
4622
4623     if (!cpi->common.refresh_alt_ref_frame)
4624     {
4625         double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
4626             *cpi->oxcf.two_pass_vbrmin_section / 100);
4627         cpi->twopass.bits_left += (int64_t)(two_pass_min_rate / cpi->frame_rate);
4628     }
4629 }
4630 #endif
4631
4632 //For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.
4633 #if HAVE_NEON
4634 extern void vp8_push_neon(int64_t *store);
4635 extern void vp8_pop_neon(int64_t *store);
4636 #endif
4637
4638
4639 int vp8_receive_raw_frame(VP8_COMP *cpi, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, int64_t time_stamp, int64_t end_time)
4640 {
4641 #if HAVE_NEON
4642     int64_t store_reg[8];
4643 #endif
4644     VP8_COMMON            *cm = &cpi->common;
4645     struct vpx_usec_timer  timer;
4646     int                    res = 0;
4647
4648 #if HAVE_NEON
4649 #if CONFIG_RUNTIME_CPU_DETECT
4650     if (cm->cpu_caps & HAS_NEON)
4651 #endif
4652     {
4653         vp8_push_neon(store_reg);
4654     }
4655 #endif
4656
4657     vpx_usec_timer_start(&timer);
4658
4659     /* Reinit the lookahead buffer if the frame size changes */
4660     if (sd->y_width != cpi->oxcf.Width || sd->y_height != cpi->oxcf.Height)
4661     {
4662         assert(cpi->oxcf.lag_in_frames < 2);
4663         dealloc_raw_frame_buffers(cpi);
4664         alloc_raw_frame_buffers(cpi);
4665     }
4666
4667     if(vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
4668                           frame_flags, cpi->active_map_enabled ? cpi->active_map : NULL))
4669         res = -1;
4670     cm->clr_type = sd->clrtype;
4671     vpx_usec_timer_mark(&timer);
4672     cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
4673
4674 #if HAVE_NEON
4675 #if CONFIG_RUNTIME_CPU_DETECT
4676     if (cm->cpu_caps & HAS_NEON)
4677 #endif
4678     {
4679         vp8_pop_neon(store_reg);
4680     }
4681 #endif
4682
4683     return res;
4684 }
4685
4686
4687 static int frame_is_reference(const VP8_COMP *cpi)
4688 {
4689     const VP8_COMMON *cm = &cpi->common;
4690     const MACROBLOCKD *xd = &cpi->mb.e_mbd;
4691
4692     return cm->frame_type == KEY_FRAME || cm->refresh_last_frame
4693            || cm->refresh_golden_frame || cm->refresh_alt_ref_frame
4694            || cm->copy_buffer_to_gf || cm->copy_buffer_to_arf
4695            || cm->refresh_entropy_probs
4696            || xd->mode_ref_lf_delta_update
4697            || xd->update_mb_segmentation_map || xd->update_mb_segmentation_data;
4698 }
4699
4700
4701 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)
4702 {
4703 #if HAVE_NEON
4704     int64_t store_reg[8];
4705 #endif
4706     VP8_COMMON *cm;
4707     struct vpx_usec_timer  tsctimer;
4708     struct vpx_usec_timer  ticktimer;
4709     struct vpx_usec_timer  cmptimer;
4710     YV12_BUFFER_CONFIG    *force_src_buffer = NULL;
4711
4712     if (!cpi)
4713         return -1;
4714
4715     cm = &cpi->common;
4716
4717     if (setjmp(cpi->common.error.jmp))
4718     {
4719         cpi->common.error.setjmp = 0;
4720         return VPX_CODEC_CORRUPT_FRAME;
4721     }
4722
4723     cpi->common.error.setjmp = 1;
4724
4725 #if HAVE_NEON
4726 #if CONFIG_RUNTIME_CPU_DETECT
4727     if (cm->cpu_caps & HAS_NEON)
4728 #endif
4729     {
4730         vp8_push_neon(store_reg);
4731     }
4732 #endif
4733
4734     vpx_usec_timer_start(&cmptimer);
4735
4736     cpi->source = NULL;
4737
4738 #if !(CONFIG_REALTIME_ONLY)
4739     // Should we code an alternate reference frame
4740     if (cpi->oxcf.error_resilient_mode == 0 &&
4741         cpi->oxcf.play_alternate &&
4742         cpi->source_alt_ref_pending)
4743     {
4744         if ((cpi->source = vp8_lookahead_peek(cpi->lookahead,
4745                                               cpi->frames_till_gf_update_due,
4746                                               PEEK_FORWARD)))
4747         {
4748             cpi->alt_ref_source = cpi->source;
4749             if (cpi->oxcf.arnr_max_frames > 0)
4750             {
4751                 vp8_temporal_filter_prepare_c(cpi,
4752                                               cpi->frames_till_gf_update_due);
4753                 force_src_buffer = &cpi->alt_ref_buffer;
4754             }
4755             cm->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due;
4756             cm->refresh_alt_ref_frame = 1;
4757             cm->refresh_golden_frame = 0;
4758             cm->refresh_last_frame = 0;
4759             cm->show_frame = 0;
4760             cpi->source_alt_ref_pending = 0;  // Clear Pending alt Ref flag.
4761             cpi->is_src_frame_alt_ref = 0;
4762         }
4763     }
4764 #endif
4765
4766     if (!cpi->source)
4767     {
4768         /* Read last frame source if we are encoding first pass. */
4769         if (cpi->pass == 1 && cm->current_video_frame > 0)
4770         {
4771             if((cpi->last_source = vp8_lookahead_peek(cpi->lookahead, 1,
4772                                                       PEEK_BACKWARD)) == NULL)
4773               return -1;
4774         }
4775
4776
4777         if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush)))
4778         {
4779             cm->show_frame = 1;
4780
4781             cpi->is_src_frame_alt_ref = cpi->alt_ref_source
4782                                         && (cpi->source == cpi->alt_ref_source);
4783
4784             if(cpi->is_src_frame_alt_ref)
4785                 cpi->alt_ref_source = NULL;
4786         }
4787     }
4788
4789     if (cpi->source)
4790     {
4791         cpi->Source = force_src_buffer ? force_src_buffer : &cpi->source->img;
4792         cpi->un_scaled_source = cpi->Source;
4793         *time_stamp = cpi->source->ts_start;
4794         *time_end = cpi->source->ts_end;
4795         *frame_flags = cpi->source->flags;
4796
4797         if (cpi->pass == 1 && cm->current_video_frame > 0)
4798         {
4799             cpi->last_frame_unscaled_source = &cpi->last_source->img;
4800         }
4801     }
4802     else
4803     {
4804         *size = 0;
4805 #if !(CONFIG_REALTIME_ONLY)
4806
4807         if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done)
4808         {
4809             vp8_end_first_pass(cpi);    /* get last stats packet */
4810             cpi->twopass.first_pass_done = 1;
4811         }
4812
4813 #endif
4814
4815 #if HAVE_NEON
4816 #if CONFIG_RUNTIME_CPU_DETECT
4817         if (cm->cpu_caps & HAS_NEON)
4818 #endif
4819         {
4820             vp8_pop_neon(store_reg);
4821         }
4822 #endif
4823         return -1;
4824     }
4825
4826     if (cpi->source->ts_start < cpi->first_time_stamp_ever)
4827     {
4828         cpi->first_time_stamp_ever = cpi->source->ts_start;
4829         cpi->last_end_time_stamp_seen = cpi->source->ts_start;
4830     }
4831
4832     // adjust frame rates based on timestamps given
4833     if (cm->show_frame)
4834     {
4835         int64_t this_duration;
4836         int step = 0;
4837
4838         if (cpi->source->ts_start == cpi->first_time_stamp_ever)
4839         {
4840             this_duration = cpi->source->ts_end - cpi->source->ts_start;
4841             step = 1;
4842         }
4843         else
4844         {
4845             int64_t last_duration;
4846
4847             this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
4848             last_duration = cpi->last_end_time_stamp_seen
4849                             - cpi->last_time_stamp_seen;
4850             // do a step update if the duration changes by 10%
4851             if (last_duration)
4852                 step = ((this_duration - last_duration) * 10 / last_duration);
4853         }
4854
4855         if (this_duration)
4856         {
4857             if (step)
4858                 cpi->ref_frame_rate = 10000000.0 / this_duration;
4859             else
4860             {
4861                 double avg_duration, interval;
4862
4863                 /* Average this frame's rate into the last second's average
4864                  * frame rate. If we haven't seen 1 second yet, then average
4865                  * over the whole interval seen.
4866                  */
4867                 interval = cpi->source->ts_end - cpi->first_time_stamp_ever;
4868                 if(interval > 10000000.0)
4869                     interval = 10000000;
4870
4871                 avg_duration = 10000000.0 / cpi->ref_frame_rate;
4872                 avg_duration *= (interval - avg_duration + this_duration);
4873                 avg_duration /= interval;
4874
4875                 cpi->ref_frame_rate = 10000000.0 / avg_duration;
4876             }
4877
4878             if (cpi->oxcf.number_of_layers > 1)
4879             {
4880                 unsigned int i;
4881
4882                 // Update frame rates for each layer
4883                 for (i=0; i<cpi->oxcf.number_of_layers; i++)
4884                 {
4885                     LAYER_CONTEXT *lc = &cpi->layer_context[i];
4886                     lc->frame_rate = cpi->ref_frame_rate /
4887                                   cpi->oxcf.rate_decimator[i];
4888                 }
4889             }
4890             else
4891                 vp8_new_frame_rate(cpi, cpi->ref_frame_rate);
4892         }
4893
4894         cpi->last_time_stamp_seen = cpi->source->ts_start;
4895         cpi->last_end_time_stamp_seen = cpi->source->ts_end;
4896     }
4897
4898     if (cpi->oxcf.number_of_layers > 1)
4899     {
4900         int layer;
4901
4902         update_layer_contexts (cpi);
4903
4904         // Restore layer specific context & set frame rate
4905         layer = cpi->oxcf.layer_id[
4906                             cm->current_video_frame % cpi->oxcf.periodicity];
4907         restore_layer_context (cpi, layer);
4908         vp8_new_frame_rate (cpi, cpi->layer_context[layer].frame_rate);
4909     }
4910
4911     if (cpi->compressor_speed == 2)
4912     {
4913         if (cpi->oxcf.number_of_layers == 1)
4914             check_gf_quality(cpi);
4915         vpx_usec_timer_start(&tsctimer);
4916         vpx_usec_timer_start(&ticktimer);
4917     }
4918
4919 #if CONFIG_REALTIME_ONLY & CONFIG_ONTHEFLY_BITPACKING
4920     {
4921         int i;
4922         const int num_part = (1 << cm->multi_token_partition);
4923         /* the available bytes in dest */
4924         const unsigned long dest_size = dest_end - dest;
4925         const int tok_part_buff_size = (dest_size * 9) / (10 * num_part);
4926
4927         unsigned char *dp = dest;
4928
4929         cpi->partition_d[0] = dp;
4930         dp += dest_size/10;         /* reserve 1/10 for control partition */
4931         cpi->partition_d_end[0] = dp;
4932
4933         for(i = 0; i < num_part; i++)
4934         {
4935             cpi->partition_d[i + 1] = dp;
4936             dp += tok_part_buff_size;
4937             cpi->partition_d_end[i + 1] = dp;
4938         }
4939     }
4940 #endif
4941
4942     // start with a 0 size frame
4943     *size = 0;
4944
4945     // Clear down mmx registers
4946     vp8_clear_system_state();  //__asm emms;
4947
4948     cm->frame_type = INTER_FRAME;
4949     cm->frame_flags = *frame_flags;
4950
4951 #if 0
4952
4953     if (cm->refresh_alt_ref_frame)
4954     {
4955         //cm->refresh_golden_frame = 1;
4956         cm->refresh_golden_frame = 0;
4957         cm->refresh_last_frame = 0;
4958     }
4959     else
4960     {
4961         cm->refresh_golden_frame = 0;
4962         cm->refresh_last_frame = 1;
4963     }
4964
4965 #endif
4966     /* find a free buffer for the new frame */
4967     {
4968         int i = 0;
4969         for(; i < NUM_YV12_BUFFERS; i++)
4970         {
4971             if(!cm->yv12_fb[i].flags)
4972             {
4973                 cm->new_fb_idx = i;
4974                 break;
4975             }
4976         }
4977
4978         assert(i < NUM_YV12_BUFFERS );
4979     }
4980 #if !(CONFIG_REALTIME_ONLY)
4981
4982     if (cpi->pass == 1)
4983     {
4984         Pass1Encode(cpi, size, dest, frame_flags);
4985     }
4986     else if (cpi->pass == 2)
4987     {
4988         Pass2Encode(cpi, size, dest, dest_end, frame_flags);
4989     }
4990     else
4991 #endif
4992         encode_frame_to_data_rate(cpi, size, dest, dest_end, frame_flags);
4993
4994     if (cpi->compressor_speed == 2)
4995     {
4996         unsigned int duration, duration2;
4997         vpx_usec_timer_mark(&tsctimer);
4998         vpx_usec_timer_mark(&ticktimer);
4999
5000         duration = vpx_usec_timer_elapsed(&ticktimer);
5001         duration2 = (unsigned int)((double)duration / 2);
5002
5003         if (cm->frame_type != KEY_FRAME)
5004         {
5005             if (cpi->avg_encode_time == 0)
5006                 cpi->avg_encode_time = duration;
5007             else
5008                 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
5009         }
5010
5011         if (duration2)
5012         {
5013             //if(*frame_flags!=1)
5014             {
5015
5016                 if (cpi->avg_pick_mode_time == 0)
5017                     cpi->avg_pick_mode_time = duration2;
5018                 else
5019                     cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3;
5020             }
5021         }
5022
5023     }
5024
5025     if (cm->refresh_entropy_probs == 0)
5026     {
5027         vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc));
5028     }
5029
5030     // Save the contexts separately for alt ref, gold and last.
5031     // (TODO jbb -> Optimize this with pointers to avoid extra copies. )
5032     if(cm->refresh_alt_ref_frame)
5033         vpx_memcpy(&cpi->lfc_a, &cm->fc, sizeof(cm->fc));
5034
5035     if(cm->refresh_golden_frame)
5036         vpx_memcpy(&cpi->lfc_g, &cm->fc, sizeof(cm->fc));
5037
5038     if(cm->refresh_last_frame)
5039         vpx_memcpy(&cpi->lfc_n, &cm->fc, sizeof(cm->fc));
5040
5041     // if its a dropped frame honor the requests on subsequent frames
5042     if (*size > 0)
5043     {
5044         cpi->droppable = !frame_is_reference(cpi);
5045
5046         // return to normal state
5047         cm->refresh_entropy_probs = 1;
5048         cm->refresh_alt_ref_frame = 0;
5049         cm->refresh_golden_frame = 0;
5050         cm->refresh_last_frame = 1;
5051         cm->frame_type = INTER_FRAME;
5052
5053     }
5054
5055     // Save layer specific state
5056     if (cpi->oxcf.number_of_layers > 1)
5057         save_layer_context (cpi);
5058
5059     vpx_usec_timer_mark(&cmptimer);
5060     cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
5061
5062     if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
5063     {
5064         generate_psnr_packet(cpi);
5065     }
5066
5067 #if CONFIG_INTERNAL_STATS
5068
5069     if (cpi->pass != 1)
5070     {
5071         cpi->bytes += *size;
5072
5073         if (cm->show_frame)
5074         {
5075
5076             cpi->count ++;
5077
5078             if (cpi->b_calculate_psnr)
5079             {
5080                 double ye,ue,ve;
5081                 double frame_psnr;
5082                 YV12_BUFFER_CONFIG      *orig = cpi->Source;
5083                 YV12_BUFFER_CONFIG      *recon = cpi->common.frame_to_show;
5084                 int y_samples = orig->y_height * orig->y_width ;
5085                 int uv_samples = orig->uv_height * orig->uv_width ;
5086                 int t_samples = y_samples + 2 * uv_samples;
5087                 int64_t sq_error, sq_error2;
5088
5089                 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
5090                   recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height);
5091
5092                 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
5093                   recon->u_buffer, recon->uv_stride, orig->uv_width, orig->uv_height);
5094
5095                 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
5096                   recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height);
5097
5098                 sq_error = ye + ue + ve;
5099
5100                 frame_psnr = vp8_mse2psnr(t_samples, 255.0, sq_error);
5101
5102                 cpi->total_y += vp8_mse2psnr(y_samples, 255.0, ye);
5103                 cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, ue);
5104                 cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, ve);
5105                 cpi->total_sq_error += sq_error;
5106                 cpi->total  += frame_psnr;
5107 #if CONFIG_POSTPROC
5108                 {
5109                     YV12_BUFFER_CONFIG      *pp = &cm->post_proc_buffer;
5110                     double frame_psnr2, frame_ssim2 = 0;
5111                     double weight = 0;
5112
5113                     vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0);
5114                     vp8_clear_system_state();
5115
5116                     ye = calc_plane_error(orig->y_buffer, orig->y_stride,
5117                       pp->y_buffer, pp->y_stride, orig->y_width, orig->y_height);
5118
5119                     ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
5120                       pp->u_buffer, pp->uv_stride, orig->uv_width, orig->uv_height);
5121
5122                     ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
5123                       pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height);
5124
5125                     sq_error2 = ye + ue + ve;
5126
5127                     frame_psnr2 = vp8_mse2psnr(t_samples, 255.0, sq_error2);
5128
5129                     cpi->totalp_y += vp8_mse2psnr(y_samples, 255.0, ye);
5130                     cpi->totalp_u += vp8_mse2psnr(uv_samples, 255.0, ue);
5131                     cpi->totalp_v += vp8_mse2psnr(uv_samples, 255.0, ve);
5132                     cpi->total_sq_error2 += sq_error2;
5133                     cpi->totalp  += frame_psnr2;
5134
5135                     frame_ssim2 = vp8_calc_ssim(cpi->Source,
5136                       &cm->post_proc_buffer, 1, &weight);
5137
5138                     cpi->summed_quality += frame_ssim2 * weight;
5139                     cpi->summed_weights += weight;
5140
5141                     if (cpi->oxcf.number_of_layers > 1)
5142                     {
5143                          int i;
5144
5145                          for (i=cpi->current_layer;
5146                                        i<cpi->oxcf.number_of_layers; i++)
5147                          {
5148                              cpi->frames_in_layer[i]++;
5149
5150                              cpi->bytes_in_layer[i] += *size;
5151                              cpi->sum_psnr[i]       += frame_psnr;
5152                              cpi->sum_psnr_p[i]     += frame_psnr2;
5153                              cpi->total_error2[i]   += sq_error;
5154                              cpi->total_error2_p[i] += sq_error2;
5155                              cpi->sum_ssim[i]       += frame_ssim2 * weight;
5156                              cpi->sum_weights[i]    += weight;
5157                          }
5158                     }
5159                 }
5160 #endif
5161             }
5162
5163             if (cpi->b_calculate_ssimg)
5164             {
5165                 double y, u, v, frame_all;
5166                 frame_all =  vp8_calc_ssimg(cpi->Source, cm->frame_to_show,
5167                     &y, &u, &v);
5168
5169                 if (cpi->oxcf.number_of_layers > 1)
5170                 {
5171                     int i;
5172
5173                     for (i=cpi->current_layer;
5174                          i<cpi->oxcf.number_of_layers; i++)
5175                     {
5176                         if (!cpi->b_calculate_psnr)
5177                             cpi->frames_in_layer[i]++;
5178
5179                         cpi->total_ssimg_y_in_layer[i] += y;
5180                         cpi->total_ssimg_u_in_layer[i] += u;
5181                         cpi->total_ssimg_v_in_layer[i] += v;
5182                         cpi->total_ssimg_all_in_layer[i] += frame_all;
5183                     }
5184                 }
5185                 else
5186                 {
5187                     cpi->total_ssimg_y += y;
5188                     cpi->total_ssimg_u += u;
5189                     cpi->total_ssimg_v += v;
5190                     cpi->total_ssimg_all += frame_all;
5191                 }
5192             }
5193
5194         }
5195     }
5196
5197 #if 0
5198
5199     if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q)
5200     {
5201         skiptruecount += cpi->skip_true_count;
5202         skipfalsecount += cpi->skip_false_count;
5203     }
5204
5205 #endif
5206 #if 0
5207
5208     if (cpi->pass != 1)
5209     {
5210         FILE *f = fopen("skip.stt", "a");
5211         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);
5212
5213         if (cpi->is_src_frame_alt_ref == 1)
5214             fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size);
5215
5216         fclose(f);
5217     }
5218
5219 #endif
5220 #endif
5221
5222 #if HAVE_NEON
5223 #if CONFIG_RUNTIME_CPU_DETECT
5224     if (cm->cpu_caps & HAS_NEON)
5225 #endif
5226     {
5227         vp8_pop_neon(store_reg);
5228     }
5229 #endif
5230
5231     cpi->common.error.setjmp = 0;
5232
5233     return 0;
5234 }
5235
5236 int vp8_get_preview_raw_frame(VP8_COMP *cpi, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags)
5237 {
5238     if (cpi->common.refresh_alt_ref_frame)
5239         return -1;
5240     else
5241     {
5242         int ret;
5243
5244 #if CONFIG_MULTITHREAD
5245         if(cpi->b_lpf_running)
5246         {
5247             sem_wait(&cpi->h_event_end_lpf);
5248             cpi->b_lpf_running = 0;
5249         }
5250 #endif
5251
5252 #if CONFIG_POSTPROC
5253         ret = vp8_post_proc_frame(&cpi->common, dest, flags);
5254 #else
5255
5256         if (cpi->common.frame_to_show)
5257         {
5258             *dest = *cpi->common.frame_to_show;
5259             dest->y_width = cpi->common.Width;
5260             dest->y_height = cpi->common.Height;
5261             dest->uv_height = cpi->common.Height / 2;
5262             ret = 0;
5263         }
5264         else
5265         {
5266             ret = -1;
5267         }
5268
5269 #endif //!CONFIG_POSTPROC
5270         vp8_clear_system_state();
5271         return ret;
5272     }
5273 }
5274
5275 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])
5276 {
5277     signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
5278
5279     if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
5280         return -1;
5281
5282     if (!map)
5283     {
5284         disable_segmentation(cpi);
5285         return 0;
5286     }
5287
5288     // Set the segmentation Map
5289     set_segmentation_map(cpi, map);
5290
5291     // Activate segmentation.
5292     enable_segmentation(cpi);
5293
5294     // Set up the quant segment data
5295     feature_data[MB_LVL_ALT_Q][0] = delta_q[0];
5296     feature_data[MB_LVL_ALT_Q][1] = delta_q[1];
5297     feature_data[MB_LVL_ALT_Q][2] = delta_q[2];
5298     feature_data[MB_LVL_ALT_Q][3] = delta_q[3];
5299
5300     // Set up the loop segment data s
5301     feature_data[MB_LVL_ALT_LF][0] = delta_lf[0];
5302     feature_data[MB_LVL_ALT_LF][1] = delta_lf[1];
5303     feature_data[MB_LVL_ALT_LF][2] = delta_lf[2];
5304     feature_data[MB_LVL_ALT_LF][3] = delta_lf[3];
5305
5306     cpi->segment_encode_breakout[0] = threshold[0];
5307     cpi->segment_encode_breakout[1] = threshold[1];
5308     cpi->segment_encode_breakout[2] = threshold[2];
5309     cpi->segment_encode_breakout[3] = threshold[3];
5310
5311     // Initialise the feature data structure
5312     // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
5313     set_segment_data(cpi, &feature_data[0][0], SEGMENT_DELTADATA);
5314
5315     return 0;
5316 }
5317
5318 int vp8_set_active_map(VP8_COMP *cpi, unsigned char *map, unsigned int rows, unsigned int cols)
5319 {
5320     if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols)
5321     {
5322         if (map)
5323         {
5324             vpx_memcpy(cpi->active_map, map, rows * cols);
5325             cpi->active_map_enabled = 1;
5326         }
5327         else
5328             cpi->active_map_enabled = 0;
5329
5330         return 0;
5331     }
5332     else
5333     {
5334         //cpi->active_map_enabled = 0;
5335         return -1 ;
5336     }
5337 }
5338
5339 int vp8_set_internal_size(VP8_COMP *cpi, VPX_SCALING horiz_mode, VPX_SCALING vert_mode)
5340 {
5341     if (horiz_mode <= ONETWO)
5342         cpi->common.horiz_scale = horiz_mode;
5343     else
5344         return -1;
5345
5346     if (vert_mode <= ONETWO)
5347         cpi->common.vert_scale  = vert_mode;
5348     else
5349         return -1;
5350
5351     return 0;
5352 }
5353
5354
5355
5356 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest)
5357 {
5358     int i, j;
5359     int Total = 0;
5360
5361     unsigned char *src = source->y_buffer;
5362     unsigned char *dst = dest->y_buffer;
5363
5364     // Loop through the Y plane raw and reconstruction data summing (square differences)
5365     for (i = 0; i < source->y_height; i += 16)
5366     {
5367         for (j = 0; j < source->y_width; j += 16)
5368         {
5369             unsigned int sse;
5370             Total += vp8_mse16x16(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5371         }
5372
5373         src += 16 * source->y_stride;
5374         dst += 16 * dest->y_stride;
5375     }
5376
5377     return Total;
5378 }
5379
5380
5381 int vp8_get_quantizer(VP8_COMP *cpi)
5382 {
5383     return cpi->common.base_qindex;
5384 }