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