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