vp8/encoder/onyx_if.c

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