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     cpi->buffered_av_per_frame_bandwidth = cpi->av_per_frame_bandwidth;
1481
1482     cpi->total_actual_bits            = 0;
1483     cpi->total_target_vs_actual       = 0;
1484
1485 #if VP8_TEMPORAL_ALT_REF
1486     {
1487         int i;
1488
1489         cpi->fixed_divide[0] = 0;
1490
1491         for (i = 1; i < 512; i++)
1492             cpi->fixed_divide[i] = 0x80000 / i;
1493     }
1494 #endif
1495 }
1496
1497
1498 void vp8_change_config(VP8_PTR ptr, VP8_CONFIG *oxcf)
1499 {
1500     VP8_COMP *cpi = (VP8_COMP *)(ptr);
1501     VP8_COMMON *cm = &cpi->common;
1502
1503     if (!cpi)
1504         return;
1505
1506     if (!oxcf)
1507         return;
1508
1509     if (cm->version != oxcf->Version)
1510     {
1511         cm->version = oxcf->Version;
1512         vp8_setup_version(cm);
1513     }
1514
1515     cpi->oxcf = *oxcf;
1516
1517     switch (cpi->oxcf.Mode)
1518     {
1519
1520     case MODE_REALTIME:
1521         cpi->pass = 0;
1522         cpi->compressor_speed = 2;
1523
1524         if (cpi->oxcf.cpu_used < -16)
1525         {
1526             cpi->oxcf.cpu_used = -16;
1527         }
1528
1529         if (cpi->oxcf.cpu_used > 16)
1530             cpi->oxcf.cpu_used = 16;
1531
1532         break;
1533
1534     case MODE_GOODQUALITY:
1535         cpi->pass = 0;
1536         cpi->compressor_speed = 1;
1537
1538         if (cpi->oxcf.cpu_used < -5)
1539         {
1540             cpi->oxcf.cpu_used = -5;
1541         }
1542
1543         if (cpi->oxcf.cpu_used > 5)
1544             cpi->oxcf.cpu_used = 5;
1545
1546         break;
1547
1548     case MODE_BESTQUALITY:
1549         cpi->pass = 0;
1550         cpi->compressor_speed = 0;
1551         break;
1552
1553     case MODE_FIRSTPASS:
1554         cpi->pass = 1;
1555         cpi->compressor_speed = 1;
1556         break;
1557     case MODE_SECONDPASS:
1558         cpi->pass = 2;
1559         cpi->compressor_speed = 1;
1560
1561         if (cpi->oxcf.cpu_used < -5)
1562         {
1563             cpi->oxcf.cpu_used = -5;
1564         }
1565
1566         if (cpi->oxcf.cpu_used > 5)
1567             cpi->oxcf.cpu_used = 5;
1568
1569         break;
1570     case MODE_SECONDPASS_BEST:
1571         cpi->pass = 2;
1572         cpi->compressor_speed = 0;
1573         break;
1574     }
1575
1576     if (cpi->pass == 0 && cpi->oxcf.end_usage != USAGE_STREAM_FROM_SERVER)
1577         cpi->auto_worst_q = 1;
1578
1579     cpi->oxcf.worst_allowed_q = q_trans[oxcf->worst_allowed_q];
1580     cpi->oxcf.best_allowed_q = q_trans[oxcf->best_allowed_q];
1581     cpi->oxcf.cq_level = q_trans[cpi->oxcf.cq_level];
1582
1583     if (oxcf->fixed_q >= 0)
1584     {
1585         if (oxcf->worst_allowed_q < 0)
1586             cpi->oxcf.fixed_q = q_trans[0];
1587         else
1588             cpi->oxcf.fixed_q = q_trans[oxcf->worst_allowed_q];
1589
1590         if (oxcf->alt_q < 0)
1591             cpi->oxcf.alt_q = q_trans[0];
1592         else
1593             cpi->oxcf.alt_q = q_trans[oxcf->alt_q];
1594
1595         if (oxcf->key_q < 0)
1596             cpi->oxcf.key_q = q_trans[0];
1597         else
1598             cpi->oxcf.key_q = q_trans[oxcf->key_q];
1599
1600         if (oxcf->gold_q < 0)
1601             cpi->oxcf.gold_q = q_trans[0];
1602         else
1603             cpi->oxcf.gold_q = q_trans[oxcf->gold_q];
1604
1605     }
1606
1607     cpi->baseline_gf_interval =
1608         cpi->oxcf.alt_freq ? cpi->oxcf.alt_freq : DEFAULT_GF_INTERVAL;
1609
1610     cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
1611
1612     //cpi->use_golden_frame_only = 0;
1613     //cpi->use_last_frame_only = 0;
1614     cm->refresh_golden_frame = 0;
1615     cm->refresh_last_frame = 1;
1616     cm->refresh_entropy_probs = 1;
1617
1618     if (cpi->oxcf.token_partitions >= 0 && cpi->oxcf.token_partitions <= 3)
1619         cm->multi_token_partition =
1620             (TOKEN_PARTITION) cpi->oxcf.token_partitions;
1621
1622     setup_features(cpi);
1623
1624     {
1625         int i;
1626
1627         for (i = 0; i < MAX_MB_SEGMENTS; i++)
1628             cpi->segment_encode_breakout[i] = cpi->oxcf.encode_breakout;
1629     }
1630
1631     // At the moment the first order values may not be > MAXQ
1632     if (cpi->oxcf.fixed_q > MAXQ)
1633         cpi->oxcf.fixed_q = MAXQ;
1634
1635     // local file playback mode == really big buffer
1636     if (cpi->oxcf.end_usage == USAGE_LOCAL_FILE_PLAYBACK)
1637     {
1638         cpi->oxcf.starting_buffer_level   = 60000;
1639         cpi->oxcf.optimal_buffer_level    = 60000;
1640         cpi->oxcf.maximum_buffer_size     = 240000;
1641     }
1642
1643     // Convert target bandwidth from Kbit/s to Bit/s
1644     cpi->oxcf.target_bandwidth       *= 1000;
1645
1646     cpi->oxcf.starting_buffer_level =
1647         rescale(cpi->oxcf.starting_buffer_level,
1648                 cpi->oxcf.target_bandwidth, 1000);
1649
1650     // Set or reset optimal and maximum buffer levels.
1651     if (cpi->oxcf.optimal_buffer_level == 0)
1652         cpi->oxcf.optimal_buffer_level = cpi->oxcf.target_bandwidth / 8;
1653     else
1654         cpi->oxcf.optimal_buffer_level =
1655             rescale(cpi->oxcf.optimal_buffer_level,
1656                     cpi->oxcf.target_bandwidth, 1000);
1657
1658     if (cpi->oxcf.maximum_buffer_size == 0)
1659         cpi->oxcf.maximum_buffer_size = cpi->oxcf.target_bandwidth / 8;
1660     else
1661         cpi->oxcf.maximum_buffer_size =
1662             rescale(cpi->oxcf.maximum_buffer_size,
1663                     cpi->oxcf.target_bandwidth, 1000);
1664
1665     // Set up frame rate and related parameters rate control values.
1666     vp8_new_frame_rate(cpi, cpi->oxcf.frame_rate);
1667
1668     // Set absolute upper and lower quality limits
1669     cpi->worst_quality               = cpi->oxcf.worst_allowed_q;
1670     cpi->best_quality                = cpi->oxcf.best_allowed_q;
1671
1672     // active values should only be modified if out of new range
1673     if (cpi->active_worst_quality > cpi->oxcf.worst_allowed_q)
1674     {
1675       cpi->active_worst_quality = cpi->oxcf.worst_allowed_q;
1676     }
1677     // less likely
1678     else if (cpi->active_worst_quality < cpi->oxcf.best_allowed_q)
1679     {
1680       cpi->active_worst_quality = cpi->oxcf.best_allowed_q;
1681     }
1682     if (cpi->active_best_quality < cpi->oxcf.best_allowed_q)
1683     {
1684       cpi->active_best_quality = cpi->oxcf.best_allowed_q;
1685     }
1686     // less likely
1687     else if (cpi->active_best_quality > cpi->oxcf.worst_allowed_q)
1688     {
1689       cpi->active_best_quality = cpi->oxcf.worst_allowed_q;
1690     }
1691
1692     cpi->buffered_mode = (cpi->oxcf.optimal_buffer_level > 0) ? TRUE : FALSE;
1693
1694     cpi->cq_target_quality = cpi->oxcf.cq_level;
1695
1696     // Only allow dropped frames in buffered mode
1697     cpi->drop_frames_allowed = cpi->oxcf.allow_df && cpi->buffered_mode;
1698
1699     if (!cm->use_bilinear_mc_filter)
1700         cm->mcomp_filter_type = SIXTAP;
1701     else
1702         cm->mcomp_filter_type = BILINEAR;
1703
1704     cpi->target_bandwidth = cpi->oxcf.target_bandwidth;
1705
1706     cm->Width       = cpi->oxcf.Width     ;
1707     cm->Height      = cpi->oxcf.Height    ;
1708
1709     cm->horiz_scale  = cpi->horiz_scale;
1710     cm->vert_scale   = cpi->vert_scale ;
1711
1712     // VP8 sharpness level mapping 0-7 (vs 0-10 in general VPx dialogs)
1713     if (cpi->oxcf.Sharpness > 7)
1714         cpi->oxcf.Sharpness = 7;
1715
1716     cm->sharpness_level = cpi->oxcf.Sharpness;
1717
1718     if (cm->horiz_scale != NORMAL || cm->vert_scale != NORMAL)
1719     {
1720         int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
1721         int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
1722
1723         Scale2Ratio(cm->horiz_scale, &hr, &hs);
1724         Scale2Ratio(cm->vert_scale, &vr, &vs);
1725
1726         // always go to the next whole number
1727         cm->Width = (hs - 1 + cpi->oxcf.Width * hr) / hs;
1728         cm->Height = (vs - 1 + cpi->oxcf.Height * vr) / vs;
1729     }
1730
1731     if (((cm->Width + 15) & 0xfffffff0) !=
1732           cm->yv12_fb[cm->lst_fb_idx].y_width ||
1733         ((cm->Height + 15) & 0xfffffff0) !=
1734           cm->yv12_fb[cm->lst_fb_idx].y_height ||
1735         cm->yv12_fb[cm->lst_fb_idx].y_width == 0)
1736     {
1737         alloc_raw_frame_buffers(cpi);
1738         vp8_alloc_compressor_data(cpi);
1739     }
1740
1741     if (cpi->oxcf.fixed_q >= 0)
1742     {
1743         cpi->last_q[0] = cpi->oxcf.fixed_q;
1744         cpi->last_q[1] = cpi->oxcf.fixed_q;
1745     }
1746
1747     cpi->Speed = cpi->oxcf.cpu_used;
1748
1749     // force to allowlag to 0 if lag_in_frames is 0;
1750     if (cpi->oxcf.lag_in_frames == 0)
1751     {
1752         cpi->oxcf.allow_lag = 0;
1753     }
1754     // Limit on lag buffers as these are not currently dynamically allocated
1755     else if (cpi->oxcf.lag_in_frames > MAX_LAG_BUFFERS)
1756         cpi->oxcf.lag_in_frames = MAX_LAG_BUFFERS;
1757
1758     // YX Temp
1759     cpi->alt_ref_source = NULL;
1760     cpi->is_src_frame_alt_ref = 0;
1761
1762
1763 #if 0
1764     // Experimental RD Code
1765     cpi->frame_distortion = 0;
1766     cpi->last_frame_distortion = 0;
1767 #endif
1768
1769 }
1770
1771 #define M_LOG2_E 0.693147180559945309417
1772 #define log2f(x) (log (x) / (float) M_LOG2_E)
1773 static void cal_mvsadcosts(int *mvsadcost[2])
1774 {
1775     int i = 1;
1776
1777     mvsadcost [0] [0] = 300;
1778     mvsadcost [1] [0] = 300;
1779
1780     do
1781     {
1782         double z = 256 * (2 * (log2f(8 * i) + .6));
1783         mvsadcost [0][i] = (int) z;
1784         mvsadcost [1][i] = (int) z;
1785         mvsadcost [0][-i] = (int) z;
1786         mvsadcost [1][-i] = (int) z;
1787     }
1788     while (++i <= mvfp_max);
1789 }
1790
1791 VP8_PTR vp8_create_compressor(VP8_CONFIG *oxcf)
1792 {
1793     int i;
1794     volatile union
1795     {
1796         VP8_COMP *cpi;
1797         VP8_PTR   ptr;
1798     } ctx;
1799
1800     VP8_COMP *cpi;
1801     VP8_COMMON *cm;
1802
1803     cpi = ctx.cpi = vpx_memalign(32, sizeof(VP8_COMP));
1804     // Check that the CPI instance is valid
1805     if (!cpi)
1806         return 0;
1807
1808     cm = &cpi->common;
1809
1810     vpx_memset(cpi, 0, sizeof(VP8_COMP));
1811
1812     if (setjmp(cm->error.jmp))
1813     {
1814         VP8_PTR ptr = ctx.ptr;
1815
1816         ctx.cpi->common.error.setjmp = 0;
1817         vp8_remove_compressor(&ptr);
1818         return 0;
1819     }
1820
1821     cpi->common.error.setjmp = 1;
1822
1823     CHECK_MEM_ERROR(cpi->mb.ss, vpx_calloc(sizeof(search_site), (MAX_MVSEARCH_STEPS * 8) + 1));
1824
1825     vp8_create_common(&cpi->common);
1826     vp8_cmachine_specific_config(cpi);
1827
1828     init_config((VP8_PTR)cpi, oxcf);
1829
1830     memcpy(cpi->base_skip_false_prob, vp8cx_base_skip_false_prob, sizeof(vp8cx_base_skip_false_prob));
1831     cpi->common.current_video_frame   = 0;
1832     cpi->kf_overspend_bits            = 0;
1833     cpi->kf_bitrate_adjustment        = 0;
1834     cpi->frames_till_gf_update_due      = 0;
1835     cpi->gf_overspend_bits            = 0;
1836     cpi->non_gf_bitrate_adjustment     = 0;
1837     cpi->prob_last_coded              = 128;
1838     cpi->prob_gf_coded                = 128;
1839     cpi->prob_intra_coded             = 63;
1840
1841     // Prime the recent reference frame useage counters.
1842     // Hereafter they will be maintained as a sort of moving average
1843     cpi->recent_ref_frame_usage[INTRA_FRAME]  = 1;
1844     cpi->recent_ref_frame_usage[LAST_FRAME]   = 1;
1845     cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
1846     cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
1847
1848     // Set reference frame sign bias for ALTREF frame to 1 (for now)
1849     cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
1850
1851     cpi->twopass.gf_decay_rate = 0;
1852     cpi->baseline_gf_interval = DEFAULT_GF_INTERVAL;
1853
1854     cpi->gold_is_last = 0 ;
1855     cpi->alt_is_last  = 0 ;
1856     cpi->gold_is_alt  = 0 ;
1857
1858     // allocate memory for storing last frame's MVs for MV prediction.
1859     CHECK_MEM_ERROR(cpi->lfmv, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int_mv)));
1860     CHECK_MEM_ERROR(cpi->lf_ref_frame_sign_bias, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1861     CHECK_MEM_ERROR(cpi->lf_ref_frame, vpx_calloc((cpi->common.mb_rows+2) * (cpi->common.mb_cols+2), sizeof(int)));
1862
1863     // Create the encoder segmentation map and set all entries to 0
1864     CHECK_MEM_ERROR(cpi->segmentation_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1865     CHECK_MEM_ERROR(cpi->active_map, vpx_calloc(cpi->common.mb_rows * cpi->common.mb_cols, 1));
1866     vpx_memset(cpi->active_map , 1, (cpi->common.mb_rows * cpi->common.mb_cols));
1867     cpi->active_map_enabled = 0;
1868
1869 #if 0
1870     // Experimental code for lagged and one pass
1871     // Initialise one_pass GF frames stats
1872     // Update stats used for GF selection
1873     if (cpi->pass == 0)
1874     {
1875         cpi->one_pass_frame_index = 0;
1876
1877         for (i = 0; i < MAX_LAG_BUFFERS; i++)
1878         {
1879             cpi->one_pass_frame_stats[i].frames_so_far = 0;
1880             cpi->one_pass_frame_stats[i].frame_intra_error = 0.0;
1881             cpi->one_pass_frame_stats[i].frame_coded_error = 0.0;
1882             cpi->one_pass_frame_stats[i].frame_pcnt_inter = 0.0;
1883             cpi->one_pass_frame_stats[i].frame_pcnt_motion = 0.0;
1884             cpi->one_pass_frame_stats[i].frame_mvr = 0.0;
1885             cpi->one_pass_frame_stats[i].frame_mvr_abs = 0.0;
1886             cpi->one_pass_frame_stats[i].frame_mvc = 0.0;
1887             cpi->one_pass_frame_stats[i].frame_mvc_abs = 0.0;
1888         }
1889     }
1890 #endif
1891
1892     // Should we use the cyclic refresh method.
1893     // Currently this is tied to error resilliant mode
1894     cpi->cyclic_refresh_mode_enabled = cpi->oxcf.error_resilient_mode;
1895     cpi->cyclic_refresh_mode_max_mbs_perframe = (cpi->common.mb_rows * cpi->common.mb_cols) / 40;
1896     cpi->cyclic_refresh_mode_index = 0;
1897     cpi->cyclic_refresh_q = 32;
1898
1899     if (cpi->cyclic_refresh_mode_enabled)
1900     {
1901         CHECK_MEM_ERROR(cpi->cyclic_refresh_map, vpx_calloc((cpi->common.mb_rows * cpi->common.mb_cols), 1));
1902     }
1903     else
1904         cpi->cyclic_refresh_map = (signed char *) NULL;
1905
1906     // Test function for segmentation
1907     //segmentation_test_function((VP8_PTR) cpi);
1908
1909 #ifdef ENTROPY_STATS
1910     init_context_counters();
1911 #endif
1912
1913     /*Initialize the feed-forward activity masking.*/
1914     cpi->activity_avg = 90<<12;
1915
1916     cpi->frames_since_key = 8;        // Give a sensible default for the first frame.
1917     cpi->key_frame_frequency = cpi->oxcf.key_freq;
1918     cpi->this_key_frame_forced = FALSE;
1919     cpi->next_key_frame_forced = FALSE;
1920
1921     cpi->source_alt_ref_pending = FALSE;
1922     cpi->source_alt_ref_active = FALSE;
1923     cpi->common.refresh_alt_ref_frame = 0;
1924
1925     cpi->b_calculate_psnr = CONFIG_INTERNAL_STATS;
1926 #if CONFIG_INTERNAL_STATS
1927     cpi->b_calculate_ssimg = 0;
1928
1929     cpi->count = 0;
1930     cpi->bytes = 0;
1931
1932     if (cpi->b_calculate_psnr)
1933     {
1934         cpi->total_sq_error = 0.0;
1935         cpi->total_sq_error2 = 0.0;
1936         cpi->total_y = 0.0;
1937         cpi->total_u = 0.0;
1938         cpi->total_v = 0.0;
1939         cpi->total = 0.0;
1940         cpi->totalp_y = 0.0;
1941         cpi->totalp_u = 0.0;
1942         cpi->totalp_v = 0.0;
1943         cpi->totalp = 0.0;
1944         cpi->tot_recode_hits = 0;
1945         cpi->summed_quality = 0;
1946         cpi->summed_weights = 0;
1947     }
1948
1949     if (cpi->b_calculate_ssimg)
1950     {
1951         cpi->total_ssimg_y = 0;
1952         cpi->total_ssimg_u = 0;
1953         cpi->total_ssimg_v = 0;
1954         cpi->total_ssimg_all = 0;
1955     }
1956
1957 #endif
1958
1959 #ifndef LLONG_MAX
1960 #define LLONG_MAX  9223372036854775807LL
1961 #endif
1962     cpi->first_time_stamp_ever = LLONG_MAX;
1963
1964     cpi->frames_till_gf_update_due      = 0;
1965     cpi->key_frame_count              = 1;
1966
1967     cpi->ni_av_qi                     = cpi->oxcf.worst_allowed_q;
1968     cpi->ni_tot_qi                    = 0;
1969     cpi->ni_frames                   = 0;
1970     cpi->total_byte_count             = 0;
1971
1972     cpi->drop_frame                  = 0;
1973     cpi->drop_count                  = 0;
1974     cpi->max_drop_count               = 0;
1975     cpi->max_consec_dropped_frames     = 4;
1976
1977     cpi->rate_correction_factor         = 1.0;
1978     cpi->key_frame_rate_correction_factor = 1.0;
1979     cpi->gf_rate_correction_factor  = 1.0;
1980     cpi->twopass.est_max_qcorrection_factor  = 1.0;
1981
1982     cpi->mb.mvcost[0] = &cpi->mb.mvcosts[0][mv_max+1];
1983     cpi->mb.mvcost[1] = &cpi->mb.mvcosts[1][mv_max+1];
1984     cpi->mb.mvsadcost[0] = &cpi->mb.mvsadcosts[0][mvfp_max+1];
1985     cpi->mb.mvsadcost[1] = &cpi->mb.mvsadcosts[1][mvfp_max+1];
1986
1987     cal_mvsadcosts(cpi->mb.mvsadcost);
1988
1989     for (i = 0; i < KEY_FRAME_CONTEXT; i++)
1990     {
1991         cpi->prior_key_frame_distance[i] = (int)cpi->output_frame_rate;
1992     }
1993
1994 #ifdef OUTPUT_YUV_SRC
1995     yuv_file = fopen("bd.yuv", "ab");
1996 #endif
1997
1998 #if 0
1999     framepsnr = fopen("framepsnr.stt", "a");
2000     kf_list = fopen("kf_list.stt", "w");
2001 #endif
2002
2003     cpi->output_pkt_list = oxcf->output_pkt_list;
2004
2005 #if !(CONFIG_REALTIME_ONLY)
2006
2007     if (cpi->pass == 1)
2008     {
2009         vp8_init_first_pass(cpi);
2010     }
2011     else if (cpi->pass == 2)
2012     {
2013         size_t packet_sz = sizeof(FIRSTPASS_STATS);
2014         int packets = oxcf->two_pass_stats_in.sz / packet_sz;
2015
2016         cpi->twopass.stats_in = oxcf->two_pass_stats_in.buf;
2017         cpi->twopass.stats_in_end = (void*)((char *)cpi->twopass.stats_in
2018                             + (packets - 1) * packet_sz);
2019         vp8_init_second_pass(cpi);
2020     }
2021
2022 #endif
2023
2024     if (cpi->compressor_speed == 2)
2025     {
2026         cpi->cpu_freq            = 0; //vp8_get_processor_freq();
2027         cpi->avg_encode_time      = 0;
2028         cpi->avg_pick_mode_time    = 0;
2029     }
2030
2031     vp8_set_speed_features(cpi);
2032
2033     // Set starting values of RD threshold multipliers (128 = *1)
2034     for (i = 0; i < MAX_MODES; i++)
2035     {
2036         cpi->rd_thresh_mult[i] = 128;
2037     }
2038
2039 #ifdef ENTROPY_STATS
2040     init_mv_ref_counts();
2041 #endif
2042
2043 #if CONFIG_MULTITHREAD
2044     vp8cx_create_encoder_threads(cpi);
2045 #endif
2046
2047     cpi->fn_ptr[BLOCK_16X16].sdf            = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16);
2048     cpi->fn_ptr[BLOCK_16X16].vf             = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x16);
2049     cpi->fn_ptr[BLOCK_16X16].svf            = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x16);
2050     cpi->fn_ptr[BLOCK_16X16].svf_halfpix_h  = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_h);
2051     cpi->fn_ptr[BLOCK_16X16].svf_halfpix_v  = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_v);
2052     cpi->fn_ptr[BLOCK_16X16].svf_halfpix_hv = VARIANCE_INVOKE(&cpi->rtcd.variance, halfpixvar16x16_hv);
2053     cpi->fn_ptr[BLOCK_16X16].sdx3f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x3);
2054     cpi->fn_ptr[BLOCK_16X16].sdx8f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x8);
2055     cpi->fn_ptr[BLOCK_16X16].sdx4df         = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x16x4d);
2056
2057     cpi->fn_ptr[BLOCK_16X8].sdf            = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8);
2058     cpi->fn_ptr[BLOCK_16X8].vf             = VARIANCE_INVOKE(&cpi->rtcd.variance, var16x8);
2059     cpi->fn_ptr[BLOCK_16X8].svf            = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar16x8);
2060     cpi->fn_ptr[BLOCK_16X8].svf_halfpix_h  = NULL;
2061     cpi->fn_ptr[BLOCK_16X8].svf_halfpix_v  = NULL;
2062     cpi->fn_ptr[BLOCK_16X8].svf_halfpix_hv = NULL;
2063     cpi->fn_ptr[BLOCK_16X8].sdx3f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x3);
2064     cpi->fn_ptr[BLOCK_16X8].sdx8f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x8);
2065     cpi->fn_ptr[BLOCK_16X8].sdx4df         = VARIANCE_INVOKE(&cpi->rtcd.variance, sad16x8x4d);
2066
2067     cpi->fn_ptr[BLOCK_8X16].sdf            = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16);
2068     cpi->fn_ptr[BLOCK_8X16].vf             = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x16);
2069     cpi->fn_ptr[BLOCK_8X16].svf            = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x16);
2070     cpi->fn_ptr[BLOCK_8X16].svf_halfpix_h  = NULL;
2071     cpi->fn_ptr[BLOCK_8X16].svf_halfpix_v  = NULL;
2072     cpi->fn_ptr[BLOCK_8X16].svf_halfpix_hv = NULL;
2073     cpi->fn_ptr[BLOCK_8X16].sdx3f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x3);
2074     cpi->fn_ptr[BLOCK_8X16].sdx8f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x8);
2075     cpi->fn_ptr[BLOCK_8X16].sdx4df         = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x16x4d);
2076
2077     cpi->fn_ptr[BLOCK_8X8].sdf            = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8);
2078     cpi->fn_ptr[BLOCK_8X8].vf             = VARIANCE_INVOKE(&cpi->rtcd.variance, var8x8);
2079     cpi->fn_ptr[BLOCK_8X8].svf            = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar8x8);
2080     cpi->fn_ptr[BLOCK_8X8].svf_halfpix_h  = NULL;
2081     cpi->fn_ptr[BLOCK_8X8].svf_halfpix_v  = NULL;
2082     cpi->fn_ptr[BLOCK_8X8].svf_halfpix_hv = NULL;
2083     cpi->fn_ptr[BLOCK_8X8].sdx3f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x3);
2084     cpi->fn_ptr[BLOCK_8X8].sdx8f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x8);
2085     cpi->fn_ptr[BLOCK_8X8].sdx4df         = VARIANCE_INVOKE(&cpi->rtcd.variance, sad8x8x4d);
2086
2087     cpi->fn_ptr[BLOCK_4X4].sdf            = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4);
2088     cpi->fn_ptr[BLOCK_4X4].vf             = VARIANCE_INVOKE(&cpi->rtcd.variance, var4x4);
2089     cpi->fn_ptr[BLOCK_4X4].svf            = VARIANCE_INVOKE(&cpi->rtcd.variance, subpixvar4x4);
2090     cpi->fn_ptr[BLOCK_4X4].svf_halfpix_h  = NULL;
2091     cpi->fn_ptr[BLOCK_4X4].svf_halfpix_v  = NULL;
2092     cpi->fn_ptr[BLOCK_4X4].svf_halfpix_hv = NULL;
2093     cpi->fn_ptr[BLOCK_4X4].sdx3f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x3);
2094     cpi->fn_ptr[BLOCK_4X4].sdx8f          = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x8);
2095     cpi->fn_ptr[BLOCK_4X4].sdx4df         = VARIANCE_INVOKE(&cpi->rtcd.variance, sad4x4x4d);
2096
2097     cpi->full_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, full_search);
2098     cpi->diamond_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, diamond_search);
2099     cpi->refining_search_sad = SEARCH_INVOKE(&cpi->rtcd.search, refining_search);
2100
2101     // make sure frame 1 is okay
2102     cpi->error_bins[0] = cpi->common.MBs;
2103
2104     //vp8cx_init_quantizer() is first called here. Add check in vp8cx_frame_init_quantizer() so that vp8cx_init_quantizer is only called later
2105     //when needed. This will avoid unnecessary calls of vp8cx_init_quantizer() for every frame.
2106     vp8cx_init_quantizer(cpi);
2107     {
2108         vp8_init_loop_filter(cm);
2109         cm->last_frame_type = KEY_FRAME;
2110         cm->last_filter_type = cm->filter_type;
2111         cm->last_sharpness_level = cm->sharpness_level;
2112     }
2113     cpi->common.error.setjmp = 0;
2114     return (VP8_PTR) cpi;
2115
2116 }
2117
2118
2119 void vp8_remove_compressor(VP8_PTR *ptr)
2120 {
2121     VP8_COMP *cpi = (VP8_COMP *)(*ptr);
2122
2123     if (!cpi)
2124         return;
2125
2126     if (cpi && (cpi->common.current_video_frame > 0))
2127     {
2128 #if !(CONFIG_REALTIME_ONLY)
2129
2130         if (cpi->pass == 2)
2131         {
2132             vp8_end_second_pass(cpi);
2133         }
2134
2135 #endif
2136
2137 #ifdef ENTROPY_STATS
2138         print_context_counters();
2139         print_tree_update_probs();
2140         print_mode_context();
2141 #endif
2142
2143 #if CONFIG_INTERNAL_STATS
2144
2145         if (cpi->pass != 1)
2146         {
2147             FILE *f = fopen("opsnr.stt", "a");
2148             double time_encoded = (cpi->last_end_time_stamp_seen
2149                                    - cpi->first_time_stamp_ever) / 10000000.000;
2150             double total_encode_time = (cpi->time_receive_data + cpi->time_compress_data)   / 1000.000;
2151             double dr = (double)cpi->bytes * (double) 8 / (double)1000  / time_encoded;
2152
2153             if (cpi->b_calculate_psnr)
2154             {
2155                 YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
2156                 double samples = 3.0 / 2 * cpi->count * lst_yv12->y_width * lst_yv12->y_height;
2157                 double total_psnr = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error);
2158                 double total_psnr2 = vp8_mse2psnr(samples, 255.0, cpi->total_sq_error2);
2159                 double total_ssim = 100 * pow(cpi->summed_quality / cpi->summed_weights, 8.0);
2160
2161                 fprintf(f, "Bitrate\tAVGPsnr\tGLBPsnr\tAVPsnrP\tGLPsnrP\tVPXSSIM\t  Time(us)\n");
2162                 fprintf(f, "%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%7.3f\t%8.0f\n",
2163                         dr, cpi->total / cpi->count, total_psnr, cpi->totalp / cpi->count, total_psnr2, total_ssim,
2164                         total_encode_time);
2165             }
2166
2167             if (cpi->b_calculate_ssimg)
2168             {
2169                 fprintf(f, "BitRate\tSSIM_Y\tSSIM_U\tSSIM_V\tSSIM_A\t  Time(us)\n");
2170                 fprintf(f, "%7.3f\t%6.4f\t%6.4f\t%6.4f\t%6.4f\t%8.0f\n", dr,
2171                         cpi->total_ssimg_y / cpi->count, cpi->total_ssimg_u / cpi->count,
2172                         cpi->total_ssimg_v / cpi->count, cpi->total_ssimg_all / cpi->count, total_encode_time);
2173             }
2174
2175             fclose(f);
2176 #if 0
2177             f = fopen("qskip.stt", "a");
2178             fprintf(f, "minq:%d -maxq:%d skipture:skipfalse = %d:%d\n", cpi->oxcf.best_allowed_q, cpi->oxcf.worst_allowed_q, skiptruecount, skipfalsecount);
2179             fclose(f);
2180 #endif
2181
2182         }
2183
2184 #endif
2185
2186
2187 #ifdef SPEEDSTATS
2188
2189         if (cpi->compressor_speed == 2)
2190         {
2191             int i;
2192             FILE *f = fopen("cxspeed.stt", "a");
2193             cnt_pm /= cpi->common.MBs;
2194
2195             for (i = 0; i < 16; i++)
2196                 fprintf(f, "%5d", frames_at_speed[i]);
2197
2198             fprintf(f, "\n");
2199             //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);
2200             fclose(f);
2201         }
2202
2203 #endif
2204
2205
2206 #ifdef MODE_STATS
2207         {
2208             extern int count_mb_seg[4];
2209             FILE *f = fopen("modes.stt", "a");
2210             double dr = (double)cpi->oxcf.frame_rate * (double)bytes * (double)8 / (double)count / (double)1000 ;
2211             fprintf(f, "intra_mode in Intra Frames:\n");
2212             fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d\n", y_modes[0], y_modes[1], y_modes[2], y_modes[3], y_modes[4]);
2213             fprintf(f, "UV:%8d, %8d, %8d, %8d\n", uv_modes[0], uv_modes[1], uv_modes[2], uv_modes[3]);
2214             fprintf(f, "B: ");
2215             {
2216                 int i;
2217
2218                 for (i = 0; i < 10; i++)
2219                     fprintf(f, "%8d, ", b_modes[i]);
2220
2221                 fprintf(f, "\n");
2222
2223             }
2224
2225             fprintf(f, "Modes in Inter Frames:\n");
2226             fprintf(f, "Y: %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d, %8d\n",
2227                     inter_y_modes[0], inter_y_modes[1], inter_y_modes[2], inter_y_modes[3], inter_y_modes[4],
2228                     inter_y_modes[5], inter_y_modes[6], inter_y_modes[7], inter_y_modes[8], inter_y_modes[9]);
2229             fprintf(f, "UV:%8d, %8d, %8d, %8d\n", inter_uv_modes[0], inter_uv_modes[1], inter_uv_modes[2], inter_uv_modes[3]);
2230             fprintf(f, "B: ");
2231             {
2232                 int i;
2233
2234                 for (i = 0; i < 15; i++)
2235                     fprintf(f, "%8d, ", inter_b_modes[i]);
2236
2237                 fprintf(f, "\n");
2238
2239             }
2240             fprintf(f, "P:%8d, %8d, %8d, %8d\n", count_mb_seg[0], count_mb_seg[1], count_mb_seg[2], count_mb_seg[3]);
2241             fprintf(f, "PB:%8d, %8d, %8d, %8d\n", inter_b_modes[LEFT4X4], inter_b_modes[ABOVE4X4], inter_b_modes[ZERO4X4], inter_b_modes[NEW4X4]);
2242
2243
2244
2245             fclose(f);
2246         }
2247 #endif
2248
2249 #ifdef ENTROPY_STATS
2250         {
2251             int i, j, k;
2252             FILE *fmode = fopen("modecontext.c", "w");
2253
2254             fprintf(fmode, "\n#include \"entropymode.h\"\n\n");
2255             fprintf(fmode, "const unsigned int vp8_kf_default_bmode_counts ");
2256             fprintf(fmode, "[VP8_BINTRAMODES] [VP8_BINTRAMODES] [VP8_BINTRAMODES] =\n{\n");
2257
2258             for (i = 0; i < 10; i++)
2259             {
2260
2261                 fprintf(fmode, "    { //Above Mode :  %d\n", i);
2262
2263                 for (j = 0; j < 10; j++)
2264                 {
2265
2266                     fprintf(fmode, "        {");
2267
2268                     for (k = 0; k < 10; k++)
2269                     {
2270                         if (!intra_mode_stats[i][j][k])
2271                             fprintf(fmode, " %5d, ", 1);
2272                         else
2273                             fprintf(fmode, " %5d, ", intra_mode_stats[i][j][k]);
2274                     }
2275
2276                     fprintf(fmode, "}, // left_mode %d\n", j);
2277
2278                 }
2279
2280                 fprintf(fmode, "    },\n");
2281
2282             }
2283
2284             fprintf(fmode, "};\n");
2285             fclose(fmode);
2286         }
2287 #endif
2288
2289
2290 #if defined(SECTIONBITS_OUTPUT)
2291
2292         if (0)
2293         {
2294             int i;
2295             FILE *f = fopen("tokenbits.stt", "a");
2296
2297             for (i = 0; i < 28; i++)
2298                 fprintf(f, "%8d", (int)(Sectionbits[i] / 256));
2299
2300             fprintf(f, "\n");
2301             fclose(f);
2302         }
2303
2304 #endif
2305
2306 #if 0
2307         {
2308             printf("\n_pick_loop_filter_level:%d\n", cpi->time_pick_lpf / 1000);
2309             printf("\n_frames recive_data encod_mb_row compress_frame  Total\n");
2310             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);
2311         }
2312 #endif
2313
2314     }
2315
2316 #if CONFIG_MULTITHREAD
2317     vp8cx_remove_encoder_threads(cpi);
2318 #endif
2319
2320     dealloc_compressor_data(cpi);
2321     vpx_free(cpi->mb.ss);
2322     vpx_free(cpi->tok);
2323     vpx_free(cpi->cyclic_refresh_map);
2324
2325     vp8_remove_common(&cpi->common);
2326     vpx_free(cpi);
2327     *ptr = 0;
2328
2329 #ifdef OUTPUT_YUV_SRC
2330     fclose(yuv_file);
2331 #endif
2332
2333 #if 0
2334
2335     if (keyfile)
2336         fclose(keyfile);
2337
2338     if (framepsnr)
2339         fclose(framepsnr);
2340
2341     if (kf_list)
2342         fclose(kf_list);
2343
2344 #endif
2345
2346 }
2347
2348
2349 static uint64_t calc_plane_error(unsigned char *orig, int orig_stride,
2350                                  unsigned char *recon, int recon_stride,
2351                                  unsigned int cols, unsigned int rows,
2352                                  vp8_variance_rtcd_vtable_t *rtcd)
2353 {
2354     unsigned int row, col;
2355     uint64_t total_sse = 0;
2356     int diff;
2357
2358     for (row = 0; row + 16 <= rows; row += 16)
2359     {
2360         for (col = 0; col + 16 <= cols; col += 16)
2361         {
2362             unsigned int sse;
2363
2364             VARIANCE_INVOKE(rtcd, mse16x16)(orig + col, orig_stride,
2365                                             recon + col, recon_stride,
2366                                             &sse);
2367             total_sse += sse;
2368         }
2369
2370         /* Handle odd-sized width */
2371         if (col < cols)
2372         {
2373             unsigned int   border_row, border_col;
2374             unsigned char *border_orig = orig;
2375             unsigned char *border_recon = recon;
2376
2377             for (border_row = 0; border_row < 16; border_row++)
2378             {
2379                 for (border_col = col; border_col < cols; border_col++)
2380                 {
2381                     diff = border_orig[border_col] - border_recon[border_col];
2382                     total_sse += diff * diff;
2383                 }
2384
2385                 border_orig += orig_stride;
2386                 border_recon += recon_stride;
2387             }
2388         }
2389
2390         orig += orig_stride * 16;
2391         recon += recon_stride * 16;
2392     }
2393
2394     /* Handle odd-sized height */
2395     for (; row < rows; row++)
2396     {
2397         for (col = 0; col < cols; col++)
2398         {
2399             diff = orig[col] - recon[col];
2400             total_sse += diff * diff;
2401         }
2402
2403         orig += orig_stride;
2404         recon += recon_stride;
2405     }
2406
2407     return total_sse;
2408 }
2409
2410
2411 static void generate_psnr_packet(VP8_COMP *cpi)
2412 {
2413     YV12_BUFFER_CONFIG      *orig = cpi->Source;
2414     YV12_BUFFER_CONFIG      *recon = cpi->common.frame_to_show;
2415     struct vpx_codec_cx_pkt  pkt;
2416     uint64_t                 sse;
2417     int                      i;
2418     unsigned int             width = cpi->common.Width;
2419     unsigned int             height = cpi->common.Height;
2420
2421     pkt.kind = VPX_CODEC_PSNR_PKT;
2422     sse = calc_plane_error(orig->y_buffer, orig->y_stride,
2423                            recon->y_buffer, recon->y_stride,
2424                            width, height,
2425                            IF_RTCD(&cpi->rtcd.variance));
2426     pkt.data.psnr.sse[0] = sse;
2427     pkt.data.psnr.sse[1] = sse;
2428     pkt.data.psnr.samples[0] = width * height;
2429     pkt.data.psnr.samples[1] = width * height;
2430
2431     width = (width + 1) / 2;
2432     height = (height + 1) / 2;
2433
2434     sse = calc_plane_error(orig->u_buffer, orig->uv_stride,
2435                            recon->u_buffer, recon->uv_stride,
2436                            width, height,
2437                            IF_RTCD(&cpi->rtcd.variance));
2438     pkt.data.psnr.sse[0] += sse;
2439     pkt.data.psnr.sse[2] = sse;
2440     pkt.data.psnr.samples[0] += width * height;
2441     pkt.data.psnr.samples[2] = width * height;
2442
2443     sse = calc_plane_error(orig->v_buffer, orig->uv_stride,
2444                            recon->v_buffer, recon->uv_stride,
2445                            width, height,
2446                            IF_RTCD(&cpi->rtcd.variance));
2447     pkt.data.psnr.sse[0] += sse;
2448     pkt.data.psnr.sse[3] = sse;
2449     pkt.data.psnr.samples[0] += width * height;
2450     pkt.data.psnr.samples[3] = width * height;
2451
2452     for (i = 0; i < 4; i++)
2453         pkt.data.psnr.psnr[i] = vp8_mse2psnr(pkt.data.psnr.samples[i], 255.0,
2454                                              pkt.data.psnr.sse[i]);
2455
2456     vpx_codec_pkt_list_add(cpi->output_pkt_list, &pkt);
2457 }
2458
2459
2460 int vp8_use_as_reference(VP8_PTR ptr, int ref_frame_flags)
2461 {
2462     VP8_COMP *cpi = (VP8_COMP *)(ptr);
2463
2464     if (ref_frame_flags > 7)
2465         return -1 ;
2466
2467     cpi->ref_frame_flags = ref_frame_flags;
2468     return 0;
2469 }
2470 int vp8_update_reference(VP8_PTR ptr, int ref_frame_flags)
2471 {
2472     VP8_COMP *cpi = (VP8_COMP *)(ptr);
2473
2474     if (ref_frame_flags > 7)
2475         return -1 ;
2476
2477     cpi->common.refresh_golden_frame = 0;
2478     cpi->common.refresh_alt_ref_frame = 0;
2479     cpi->common.refresh_last_frame   = 0;
2480
2481     if (ref_frame_flags & VP8_LAST_FLAG)
2482         cpi->common.refresh_last_frame = 1;
2483
2484     if (ref_frame_flags & VP8_GOLD_FLAG)
2485         cpi->common.refresh_golden_frame = 1;
2486
2487     if (ref_frame_flags & VP8_ALT_FLAG)
2488         cpi->common.refresh_alt_ref_frame = 1;
2489
2490     return 0;
2491 }
2492
2493 int vp8_get_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2494 {
2495     VP8_COMP *cpi = (VP8_COMP *)(ptr);
2496     VP8_COMMON *cm = &cpi->common;
2497     int ref_fb_idx;
2498
2499     if (ref_frame_flag == VP8_LAST_FLAG)
2500         ref_fb_idx = cm->lst_fb_idx;
2501     else if (ref_frame_flag == VP8_GOLD_FLAG)
2502         ref_fb_idx = cm->gld_fb_idx;
2503     else if (ref_frame_flag == VP8_ALT_FLAG)
2504         ref_fb_idx = cm->alt_fb_idx;
2505     else
2506         return -1;
2507
2508     vp8_yv12_copy_frame_ptr(&cm->yv12_fb[ref_fb_idx], sd);
2509
2510     return 0;
2511 }
2512 int vp8_set_reference(VP8_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd)
2513 {
2514     VP8_COMP *cpi = (VP8_COMP *)(ptr);
2515     VP8_COMMON *cm = &cpi->common;
2516
2517     int ref_fb_idx;
2518
2519     if (ref_frame_flag == VP8_LAST_FLAG)
2520         ref_fb_idx = cm->lst_fb_idx;
2521     else if (ref_frame_flag == VP8_GOLD_FLAG)
2522         ref_fb_idx = cm->gld_fb_idx;
2523     else if (ref_frame_flag == VP8_ALT_FLAG)
2524         ref_fb_idx = cm->alt_fb_idx;
2525     else
2526         return -1;
2527
2528     vp8_yv12_copy_frame_ptr(sd, &cm->yv12_fb[ref_fb_idx]);
2529
2530     return 0;
2531 }
2532 int vp8_update_entropy(VP8_PTR comp, int update)
2533 {
2534     VP8_COMP *cpi = (VP8_COMP *) comp;
2535     VP8_COMMON *cm = &cpi->common;
2536     cm->refresh_entropy_probs = update;
2537
2538     return 0;
2539 }
2540
2541
2542 #if OUTPUT_YUV_SRC
2543 void vp8_write_yuv_frame(const char *name, YV12_BUFFER_CONFIG *s)
2544 {
2545     FILE *yuv_file = fopen(name, "ab");
2546     unsigned char *src = s->y_buffer;
2547     int h = s->y_height;
2548
2549     do
2550     {
2551         fwrite(src, s->y_width, 1,  yuv_file);
2552         src += s->y_stride;
2553     }
2554     while (--h);
2555
2556     src = s->u_buffer;
2557     h = s->uv_height;
2558
2559     do
2560     {
2561         fwrite(src, s->uv_width, 1,  yuv_file);
2562         src += s->uv_stride;
2563     }
2564     while (--h);
2565
2566     src = s->v_buffer;
2567     h = s->uv_height;
2568
2569     do
2570     {
2571         fwrite(src, s->uv_width, 1, yuv_file);
2572         src += s->uv_stride;
2573     }
2574     while (--h);
2575
2576     fclose(yuv_file);
2577 }
2578 #endif
2579
2580
2581 static void scale_and_extend_source(YV12_BUFFER_CONFIG *sd, VP8_COMP *cpi)
2582 {
2583     VP8_COMMON *cm = &cpi->common;
2584
2585     // are we resizing the image
2586     if (cm->horiz_scale != 0 || cm->vert_scale != 0)
2587     {
2588 #if CONFIG_SPATIAL_RESAMPLING
2589         int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2590         int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2591         int tmp_height;
2592
2593         if (cm->vert_scale == 3)
2594             tmp_height = 9;
2595         else
2596             tmp_height = 11;
2597
2598         Scale2Ratio(cm->horiz_scale, &hr, &hs);
2599         Scale2Ratio(cm->vert_scale, &vr, &vs);
2600
2601         vp8_scale_frame(sd, &cpi->scaled_source, cm->temp_scale_frame.y_buffer,
2602                         tmp_height, hs, hr, vs, vr, 0);
2603
2604         vp8_yv12_extend_frame_borders(&cpi->scaled_source);
2605         cpi->Source = &cpi->scaled_source;
2606 #endif
2607     }
2608 }
2609
2610
2611 static void resize_key_frame(VP8_COMP *cpi)
2612 {
2613 #if CONFIG_SPATIAL_RESAMPLING
2614     VP8_COMMON *cm = &cpi->common;
2615
2616     // Do we need to apply resampling for one pass cbr.
2617     // In one pass this is more limited than in two pass cbr
2618     // The test and any change is only made one per key frame sequence
2619     if (cpi->oxcf.allow_spatial_resampling && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER))
2620     {
2621         int UNINITIALIZED_IS_SAFE(hr), UNINITIALIZED_IS_SAFE(hs);
2622         int UNINITIALIZED_IS_SAFE(vr), UNINITIALIZED_IS_SAFE(vs);
2623         int new_width, new_height;
2624
2625         // If we are below the resample DOWN watermark then scale down a notch.
2626         if (cpi->buffer_level < (cpi->oxcf.resample_down_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2627         {
2628             cm->horiz_scale = (cm->horiz_scale < ONETWO) ? cm->horiz_scale + 1 : ONETWO;
2629             cm->vert_scale = (cm->vert_scale < ONETWO) ? cm->vert_scale + 1 : ONETWO;
2630         }
2631         // Should we now start scaling back up
2632         else if (cpi->buffer_level > (cpi->oxcf.resample_up_water_mark * cpi->oxcf.optimal_buffer_level / 100))
2633         {
2634             cm->horiz_scale = (cm->horiz_scale > NORMAL) ? cm->horiz_scale - 1 : NORMAL;
2635             cm->vert_scale = (cm->vert_scale > NORMAL) ? cm->vert_scale - 1 : NORMAL;
2636         }
2637
2638         // Get the new hieght and width
2639         Scale2Ratio(cm->horiz_scale, &hr, &hs);
2640         Scale2Ratio(cm->vert_scale, &vr, &vs);
2641         new_width = ((hs - 1) + (cpi->oxcf.Width * hr)) / hs;
2642         new_height = ((vs - 1) + (cpi->oxcf.Height * vr)) / vs;
2643
2644         // If the image size has changed we need to reallocate the buffers
2645         // and resample the source image
2646         if ((cm->Width != new_width) || (cm->Height != new_height))
2647         {
2648             cm->Width = new_width;
2649             cm->Height = new_height;
2650             vp8_alloc_compressor_data(cpi);
2651             scale_and_extend_source(cpi->un_scaled_source, cpi);
2652         }
2653     }
2654
2655 #endif
2656 }
2657
2658
2659 static void update_alt_ref_frame_stats(VP8_COMP *cpi)
2660 {
2661     VP8_COMMON *cm = &cpi->common;
2662
2663     // Select an interval before next GF or altref
2664     if (!cpi->auto_gold)
2665         cpi->frames_till_gf_update_due = cpi->goldfreq;
2666
2667     if ((cpi->pass != 2) && cpi->frames_till_gf_update_due)
2668     {
2669         cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2670
2671         // Set the bits per frame that we should try and recover in subsequent inter frames
2672         // to account for the extra GF spend... note that his does not apply for GF updates
2673         // that occur coincident with a key frame as the extra cost of key frames is dealt
2674         // with elsewhere.
2675
2676         cpi->gf_overspend_bits += cpi->projected_frame_size;
2677         cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2678     }
2679
2680     // Update data structure that monitors level of reference to last GF
2681     vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2682     cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2683
2684     // this frame refreshes means next frames don't unless specified by user
2685     cpi->common.frames_since_golden = 0;
2686
2687     // Clear the alternate reference update pending flag.
2688     cpi->source_alt_ref_pending = FALSE;
2689
2690     // Set the alternate refernce frame active flag
2691     cpi->source_alt_ref_active = TRUE;
2692
2693
2694 }
2695 static void update_golden_frame_stats(VP8_COMP *cpi)
2696 {
2697     VP8_COMMON *cm = &cpi->common;
2698
2699     // Update the Golden frame usage counts.
2700     if (cm->refresh_golden_frame)
2701     {
2702         // Select an interval before next GF
2703         if (!cpi->auto_gold)
2704             cpi->frames_till_gf_update_due = cpi->goldfreq;
2705
2706         if ((cpi->pass != 2) && (cpi->frames_till_gf_update_due > 0))
2707         {
2708             cpi->current_gf_interval = cpi->frames_till_gf_update_due;
2709
2710             // Set the bits per frame that we should try and recover in subsequent inter frames
2711             // to account for the extra GF spend... note that his does not apply for GF updates
2712             // that occur coincident with a key frame as the extra cost of key frames is dealt
2713             // with elsewhere.
2714             if ((cm->frame_type != KEY_FRAME) && !cpi->source_alt_ref_active)
2715             {
2716                 // Calcluate GF bits to be recovered
2717                 // Projected size - av frame bits available for inter frames for clip as a whole
2718                 cpi->gf_overspend_bits += (cpi->projected_frame_size - cpi->inter_frame_target);
2719             }
2720
2721             cpi->non_gf_bitrate_adjustment = cpi->gf_overspend_bits / cpi->frames_till_gf_update_due;
2722
2723         }
2724
2725         // Update data structure that monitors level of reference to last GF
2726         vpx_memset(cpi->gf_active_flags, 1, (cm->mb_rows * cm->mb_cols));
2727         cpi->gf_active_count = cm->mb_rows * cm->mb_cols;
2728
2729         // this frame refreshes means next frames don't unless specified by user
2730         cm->refresh_golden_frame = 0;
2731         cpi->common.frames_since_golden = 0;
2732
2733         //if ( cm->frame_type == KEY_FRAME )
2734         //{
2735         cpi->recent_ref_frame_usage[INTRA_FRAME] = 1;
2736         cpi->recent_ref_frame_usage[LAST_FRAME] = 1;
2737         cpi->recent_ref_frame_usage[GOLDEN_FRAME] = 1;
2738         cpi->recent_ref_frame_usage[ALTREF_FRAME] = 1;
2739         //}
2740         //else
2741         //{
2742         //  // Carry a potrtion of count over to begining of next gf sequence
2743         //  cpi->recent_ref_frame_usage[INTRA_FRAME] >>= 5;
2744         //  cpi->recent_ref_frame_usage[LAST_FRAME] >>= 5;
2745         //  cpi->recent_ref_frame_usage[GOLDEN_FRAME] >>= 5;
2746         //  cpi->recent_ref_frame_usage[ALTREF_FRAME] >>= 5;
2747         //}
2748
2749         // ******** Fixed Q test code only ************
2750         // If we are going to use the ALT reference for the next group of frames set a flag to say so.
2751         if (cpi->oxcf.fixed_q >= 0 &&
2752             cpi->oxcf.play_alternate && !cpi->common.refresh_alt_ref_frame)
2753         {
2754             cpi->source_alt_ref_pending = TRUE;
2755             cpi->frames_till_gf_update_due = cpi->baseline_gf_interval;
2756         }
2757
2758         if (!cpi->source_alt_ref_pending)
2759             cpi->source_alt_ref_active = FALSE;
2760
2761         // Decrement count down till next gf
2762         if (cpi->frames_till_gf_update_due > 0)
2763             cpi->frames_till_gf_update_due--;
2764
2765     }
2766     else if (!cpi->common.refresh_alt_ref_frame)
2767     {
2768         // Decrement count down till next gf
2769         if (cpi->frames_till_gf_update_due > 0)
2770             cpi->frames_till_gf_update_due--;
2771
2772         if (cpi->common.frames_till_alt_ref_frame)
2773             cpi->common.frames_till_alt_ref_frame --;
2774
2775         cpi->common.frames_since_golden ++;
2776
2777         if (cpi->common.frames_since_golden > 1)
2778         {
2779             cpi->recent_ref_frame_usage[INTRA_FRAME] += cpi->count_mb_ref_frame_usage[INTRA_FRAME];
2780             cpi->recent_ref_frame_usage[LAST_FRAME] += cpi->count_mb_ref_frame_usage[LAST_FRAME];
2781             cpi->recent_ref_frame_usage[GOLDEN_FRAME] += cpi->count_mb_ref_frame_usage[GOLDEN_FRAME];
2782             cpi->recent_ref_frame_usage[ALTREF_FRAME] += cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
2783         }
2784     }
2785 }
2786
2787 // This function updates the reference frame probability estimates that
2788 // will be used during mode selection
2789 static void update_rd_ref_frame_probs(VP8_COMP *cpi)
2790 {
2791     VP8_COMMON *cm = &cpi->common;
2792
2793 #if 0
2794     const int *const rfct = cpi->recent_ref_frame_usage;
2795     const int rf_intra = rfct[INTRA_FRAME];
2796     const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2797
2798     if (cm->frame_type == KEY_FRAME)
2799     {
2800         cpi->prob_intra_coded = 255;
2801         cpi->prob_last_coded  = 128;
2802         cpi->prob_gf_coded  = 128;
2803     }
2804     else if (!(rf_intra + rf_inter))
2805     {
2806         // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
2807         cpi->prob_intra_coded = 63;
2808         cpi->prob_last_coded  = 128;
2809         cpi->prob_gf_coded    = 128;
2810     }
2811     else
2812     {
2813         cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
2814
2815         if (cpi->prob_intra_coded < 1)
2816             cpi->prob_intra_coded = 1;
2817
2818         if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
2819         {
2820             cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
2821
2822             if (cpi->prob_last_coded < 1)
2823                 cpi->prob_last_coded = 1;
2824
2825             cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
2826                                  ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
2827
2828             if (cpi->prob_gf_coded < 1)
2829                 cpi->prob_gf_coded = 1;
2830         }
2831     }
2832
2833 #else
2834     const int *const rfct = cpi->count_mb_ref_frame_usage;
2835     const int rf_intra = rfct[INTRA_FRAME];
2836     const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
2837
2838     if (cm->frame_type == KEY_FRAME)
2839     {
2840         cpi->prob_intra_coded = 255;
2841         cpi->prob_last_coded  = 128;
2842         cpi->prob_gf_coded  = 128;
2843     }
2844     else if (!(rf_intra + rf_inter))
2845     {
2846         // This is a trap in case this function is called with cpi->recent_ref_frame_usage[] blank.
2847         cpi->prob_intra_coded = 63;
2848         cpi->prob_last_coded  = 128;
2849         cpi->prob_gf_coded    = 128;
2850     }
2851     else
2852     {
2853         cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
2854
2855         if (cpi->prob_intra_coded < 1)
2856             cpi->prob_intra_coded = 1;
2857
2858         cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
2859
2860         if (cpi->prob_last_coded < 1)
2861             cpi->prob_last_coded = 1;
2862
2863         cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
2864                              ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
2865
2866         if (cpi->prob_gf_coded < 1)
2867             cpi->prob_gf_coded = 1;
2868     }
2869
2870     // update reference frame costs since we can do better than what we got last frame.
2871
2872     if (cpi->common.refresh_alt_ref_frame)
2873     {
2874         cpi->prob_intra_coded += 40;
2875         cpi->prob_last_coded = 200;
2876         cpi->prob_gf_coded = 1;
2877     }
2878     else if (cpi->common.frames_since_golden == 0)
2879     {
2880         cpi->prob_last_coded = 214;
2881         cpi->prob_gf_coded = 1;
2882     }
2883     else if (cpi->common.frames_since_golden == 1)
2884     {
2885         cpi->prob_last_coded = 192;
2886         cpi->prob_gf_coded = 220;
2887     }
2888     else if (cpi->source_alt_ref_active)
2889     {
2890         //int dist = cpi->common.frames_till_alt_ref_frame + cpi->common.frames_since_golden;
2891         cpi->prob_gf_coded -= 20;
2892
2893         if (cpi->prob_gf_coded < 10)
2894             cpi->prob_gf_coded = 10;
2895     }
2896
2897 #endif
2898 }
2899
2900
2901 // 1 = key, 0 = inter
2902 static int decide_key_frame(VP8_COMP *cpi)
2903 {
2904     VP8_COMMON *cm = &cpi->common;
2905
2906     int code_key_frame = FALSE;
2907
2908     cpi->kf_boost = 0;
2909
2910     if (cpi->Speed > 11)
2911         return FALSE;
2912
2913     // Clear down mmx registers
2914     vp8_clear_system_state();  //__asm emms;
2915
2916     if ((cpi->compressor_speed == 2) && (cpi->Speed >= 5) && (cpi->sf.RD == 0))
2917     {
2918         double change = 1.0 * abs((int)(cpi->intra_error - cpi->last_intra_error)) / (1 + cpi->last_intra_error);
2919         double change2 = 1.0 * abs((int)(cpi->prediction_error - cpi->last_prediction_error)) / (1 + cpi->last_prediction_error);
2920         double minerror = cm->MBs * 256;
2921
2922 #if 0
2923
2924         if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2925             && cpi->prediction_error > minerror
2926             && (change > .25 || change2 > .25))
2927         {
2928             FILE *f = fopen("intra_inter.stt", "a");
2929
2930             if (cpi->prediction_error <= 0)
2931                 cpi->prediction_error = 1;
2932
2933             fprintf(f, "%d %d %d %d %14.4f\n",
2934                     cm->current_video_frame,
2935                     (int) cpi->prediction_error,
2936                     (int) cpi->intra_error,
2937                     (int)((10 * cpi->intra_error) / cpi->prediction_error),
2938                     change);
2939
2940             fclose(f);
2941         }
2942
2943 #endif
2944
2945         cpi->last_intra_error = cpi->intra_error;
2946         cpi->last_prediction_error = cpi->prediction_error;
2947
2948         if (10 * cpi->intra_error / (1 + cpi->prediction_error) < 15
2949             && cpi->prediction_error > minerror
2950             && (change > .25 || change2 > .25))
2951         {
2952             /*(change > 1.4 || change < .75)&& cpi->this_frame_percent_intra > cpi->last_frame_percent_intra + 3*/
2953             return TRUE;
2954         }
2955
2956         return FALSE;
2957
2958     }
2959
2960     // If the following are true we might as well code a key frame
2961     if (((cpi->this_frame_percent_intra == 100) &&
2962          (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 2))) ||
2963         ((cpi->this_frame_percent_intra > 95) &&
2964          (cpi->this_frame_percent_intra >= (cpi->last_frame_percent_intra + 5))))
2965     {
2966         code_key_frame = TRUE;
2967     }
2968     // in addition if the following are true and this is not a golden frame then code a key frame
2969     // Note that on golden frames there often seems to be a pop in intra useage anyway hence this
2970     // restriction is designed to prevent spurious key frames. The Intra pop needs to be investigated.
2971     else if (((cpi->this_frame_percent_intra > 60) &&
2972               (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 2))) ||
2973              ((cpi->this_frame_percent_intra > 75) &&
2974               (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra * 3 / 2))) ||
2975              ((cpi->this_frame_percent_intra > 90) &&
2976               (cpi->this_frame_percent_intra > (cpi->last_frame_percent_intra + 10))))
2977     {
2978         if (!cm->refresh_golden_frame)
2979             code_key_frame = TRUE;
2980     }
2981
2982     return code_key_frame;
2983
2984 }
2985
2986 #if !(CONFIG_REALTIME_ONLY)
2987 static void Pass1Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
2988 {
2989     (void) size;
2990     (void) dest;
2991     (void) frame_flags;
2992     vp8_set_quantizer(cpi, 26);
2993
2994     scale_and_extend_source(cpi->un_scaled_source, cpi);
2995     vp8_first_pass(cpi);
2996 }
2997 #endif
2998
2999 #if 0
3000 void write_cx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame)
3001 {
3002
3003     // write the frame
3004     FILE *yframe;
3005     int i;
3006     char filename[255];
3007
3008     sprintf(filename, "cx\\y%04d.raw", this_frame);
3009     yframe = fopen(filename, "wb");
3010
3011     for (i = 0; i < frame->y_height; i++)
3012         fwrite(frame->y_buffer + i * frame->y_stride, frame->y_width, 1, yframe);
3013
3014     fclose(yframe);
3015     sprintf(filename, "cx\\u%04d.raw", this_frame);
3016     yframe = fopen(filename, "wb");
3017
3018     for (i = 0; i < frame->uv_height; i++)
3019         fwrite(frame->u_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3020
3021     fclose(yframe);
3022     sprintf(filename, "cx\\v%04d.raw", this_frame);
3023     yframe = fopen(filename, "wb");
3024
3025     for (i = 0; i < frame->uv_height; i++)
3026         fwrite(frame->v_buffer + i * frame->uv_stride, frame->uv_width, 1, yframe);
3027
3028     fclose(yframe);
3029 }
3030 #endif
3031 // return of 0 means drop frame
3032
3033 // Function to test for conditions that indeicate we should loop
3034 // back and recode a frame.
3035 static BOOL recode_loop_test( VP8_COMP *cpi,
3036                               int high_limit, int low_limit,
3037                               int q, int maxq, int minq )
3038 {
3039     BOOL    force_recode = FALSE;
3040     VP8_COMMON *cm = &cpi->common;
3041
3042     // Is frame recode allowed at all
3043     // Yes if either recode mode 1 is selected or mode two is selcted
3044     // and the frame is a key frame. golden frame or alt_ref_frame
3045     if ( (cpi->sf.recode_loop == 1) ||
3046          ( (cpi->sf.recode_loop == 2) &&
3047            ( (cm->frame_type == KEY_FRAME) ||
3048              cm->refresh_golden_frame ||
3049              cm->refresh_alt_ref_frame ) ) )
3050     {
3051         // General over and under shoot tests
3052         if ( ((cpi->projected_frame_size > high_limit) && (q < maxq)) ||
3053              ((cpi->projected_frame_size < low_limit) && (q > minq)) )
3054         {
3055             force_recode = TRUE;
3056         }
3057         // Special Constrained quality tests
3058         else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3059         {
3060             // Undershoot and below auto cq level
3061             if ( (q > cpi->cq_target_quality) &&
3062                  (cpi->projected_frame_size <
3063                      ((cpi->this_frame_target * 7) >> 3)))
3064             {
3065                 force_recode = TRUE;
3066             }
3067             // Severe undershoot and between auto and user cq level
3068             else if ( (q > cpi->oxcf.cq_level) &&
3069                       (cpi->projected_frame_size < cpi->min_frame_bandwidth) &&
3070                       (cpi->active_best_quality > cpi->oxcf.cq_level))
3071             {
3072                 force_recode = TRUE;
3073                 cpi->active_best_quality = cpi->oxcf.cq_level;
3074             }
3075         }
3076     }
3077
3078     return force_recode;
3079 }
3080
3081 void update_reference_frames(VP8_COMMON *cm)
3082 {
3083     YV12_BUFFER_CONFIG *yv12_fb = cm->yv12_fb;
3084
3085     // At this point the new frame has been encoded.
3086     // If any buffer copy / swapping is signaled it should be done here.
3087
3088     if (cm->frame_type == KEY_FRAME)
3089     {
3090         yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FLAG | VP8_ALT_FLAG ;
3091
3092         yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3093         yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3094
3095         cm->alt_fb_idx = cm->gld_fb_idx = cm->new_fb_idx;
3096     }
3097     else    /* For non key frames */
3098     {
3099         if (cm->refresh_alt_ref_frame)
3100         {
3101             assert(!cm->copy_buffer_to_arf);
3102
3103             cm->yv12_fb[cm->new_fb_idx].flags |= VP8_ALT_FLAG;
3104             cm->yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3105             cm->alt_fb_idx = cm->new_fb_idx;
3106         }
3107         else if (cm->copy_buffer_to_arf)
3108         {
3109             assert(!(cm->copy_buffer_to_arf & ~0x3));
3110
3111             if (cm->copy_buffer_to_arf == 1)
3112             {
3113                 if(cm->alt_fb_idx != cm->lst_fb_idx)
3114                 {
3115                     yv12_fb[cm->lst_fb_idx].flags |= VP8_ALT_FLAG;
3116                     yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3117                     cm->alt_fb_idx = cm->lst_fb_idx;
3118                 }
3119             }
3120             else /* if (cm->copy_buffer_to_arf == 2) */
3121             {
3122                 if(cm->alt_fb_idx != cm->gld_fb_idx)
3123                 {
3124                     yv12_fb[cm->gld_fb_idx].flags |= VP8_ALT_FLAG;
3125                     yv12_fb[cm->alt_fb_idx].flags &= ~VP8_ALT_FLAG;
3126                     cm->alt_fb_idx = cm->gld_fb_idx;
3127                 }
3128             }
3129         }
3130
3131         if (cm->refresh_golden_frame)
3132         {
3133             assert(!cm->copy_buffer_to_gf);
3134
3135             cm->yv12_fb[cm->new_fb_idx].flags |= VP8_GOLD_FLAG;
3136             cm->yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3137             cm->gld_fb_idx = cm->new_fb_idx;
3138         }
3139         else if (cm->copy_buffer_to_gf)
3140         {
3141             assert(!(cm->copy_buffer_to_arf & ~0x3));
3142
3143             if (cm->copy_buffer_to_gf == 1)
3144             {
3145                 if(cm->gld_fb_idx != cm->lst_fb_idx)
3146                 {
3147                     yv12_fb[cm->lst_fb_idx].flags |= VP8_GOLD_FLAG;
3148                     yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3149                     cm->gld_fb_idx = cm->lst_fb_idx;
3150                 }
3151             }
3152             else /* if (cm->copy_buffer_to_gf == 2) */
3153             {
3154                 if(cm->alt_fb_idx != cm->gld_fb_idx)
3155                 {
3156                     yv12_fb[cm->alt_fb_idx].flags |= VP8_GOLD_FLAG;
3157                     yv12_fb[cm->gld_fb_idx].flags &= ~VP8_GOLD_FLAG;
3158                     cm->gld_fb_idx = cm->alt_fb_idx;
3159                 }
3160             }
3161         }
3162     }
3163
3164     if (cm->refresh_last_frame)
3165     {
3166         cm->yv12_fb[cm->new_fb_idx].flags |= VP8_LAST_FLAG;
3167         cm->yv12_fb[cm->lst_fb_idx].flags &= ~VP8_LAST_FLAG;
3168         cm->lst_fb_idx = cm->new_fb_idx;
3169     }
3170 }
3171
3172 void loopfilter_frame(VP8_COMP *cpi, VP8_COMMON *cm)
3173 {
3174     if (cm->no_lpf)
3175     {
3176         cm->filter_level = 0;
3177     }
3178     else
3179     {
3180         struct vpx_usec_timer timer;
3181
3182         vp8_clear_system_state();
3183
3184         vpx_usec_timer_start(&timer);
3185         if (cpi->sf.auto_filter == 0)
3186             vp8cx_pick_filter_level_fast(cpi->Source, cpi);
3187
3188         else
3189             vp8cx_pick_filter_level(cpi->Source, cpi);
3190
3191         vpx_usec_timer_mark(&timer);
3192         cpi->time_pick_lpf += vpx_usec_timer_elapsed(&timer);
3193     }
3194
3195 #if CONFIG_MULTITHREAD
3196     if (cpi->b_multi_threaded)
3197         sem_post(&cpi->h_event_end_lpf); /* signal that we have set filter_level */
3198 #endif
3199
3200     if (cm->filter_level > 0)
3201     {
3202         vp8cx_set_alt_lf_level(cpi, cm->filter_level);
3203         vp8_loop_filter_frame(cm, &cpi->mb.e_mbd, cm->filter_level);
3204         cm->last_filter_type = cm->filter_type;
3205         cm->last_sharpness_level = cm->sharpness_level;
3206     }
3207
3208     vp8_yv12_extend_frame_borders_ptr(cm->frame_to_show);
3209
3210 }
3211
3212 static void encode_frame_to_data_rate
3213 (
3214     VP8_COMP *cpi,
3215     unsigned long *size,
3216     unsigned char *dest,
3217     unsigned int *frame_flags
3218 )
3219 {
3220     int Q;
3221     int frame_over_shoot_limit;
3222     int frame_under_shoot_limit;
3223
3224     int Loop = FALSE;
3225     int loop_count;
3226     int this_q;
3227     int last_zbin_oq;
3228
3229     int q_low;
3230     int q_high;
3231     int zbin_oq_high;
3232     int zbin_oq_low = 0;
3233     int top_index;
3234     int bottom_index;
3235     VP8_COMMON *cm = &cpi->common;
3236     int active_worst_qchanged = FALSE;
3237
3238     int overshoot_seen = FALSE;
3239     int undershoot_seen = FALSE;
3240     int drop_mark = cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100;
3241     int drop_mark75 = drop_mark * 2 / 3;
3242     int drop_mark50 = drop_mark / 4;
3243     int drop_mark25 = drop_mark / 8;
3244
3245
3246     // Clear down mmx registers to allow floating point in what follows
3247     vp8_clear_system_state();
3248
3249     // Test code for segmentation of gf/arf (0,0)
3250     //segmentation_test_function((VP8_PTR) cpi);
3251
3252 #if CONFIG_REALTIME_ONLY
3253     if(cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3254     {
3255         if(cpi->force_next_frame_intra)
3256         {
3257             cm->frame_type = KEY_FRAME;  /* delayed intra frame */
3258         }
3259     }
3260     cpi->force_next_frame_intra = 0;
3261 #endif
3262
3263     // For an alt ref frame in 2 pass we skip the call to the second pass function that sets the target bandwidth
3264 #if !(CONFIG_REALTIME_ONLY)
3265
3266     if (cpi->pass == 2)
3267     {
3268         if (cpi->common.refresh_alt_ref_frame)
3269         {
3270             cpi->per_frame_bandwidth = cpi->twopass.gf_bits;                           // Per frame bit target for the alt ref frame
3271             cpi->target_bandwidth = cpi->twopass.gf_bits * cpi->output_frame_rate;      // per second target bitrate
3272         }
3273     }
3274     else
3275 #endif
3276         cpi->per_frame_bandwidth  = (int)(cpi->target_bandwidth / cpi->output_frame_rate);
3277
3278     // Default turn off buffer to buffer copying
3279     cm->copy_buffer_to_gf = 0;
3280     cm->copy_buffer_to_arf = 0;
3281
3282     // Clear zbin over-quant value and mode boost values.
3283     cpi->zbin_over_quant = 0;
3284     cpi->zbin_mode_boost = 0;
3285
3286     // Enable or disable mode based tweaking of the zbin
3287     // For 2 Pass Only used where GF/ARF prediction quality
3288     // is above a threshold
3289     cpi->zbin_mode_boost = 0;
3290     cpi->zbin_mode_boost_enabled = TRUE;
3291     if (cpi->pass == 2)
3292     {
3293         if ( cpi->gfu_boost <= 400 )
3294         {
3295             cpi->zbin_mode_boost_enabled = FALSE;
3296         }
3297     }
3298
3299     // Current default encoder behaviour for the altref sign bias
3300     if (cpi->source_alt_ref_active)
3301         cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 1;
3302     else
3303         cpi->common.ref_frame_sign_bias[ALTREF_FRAME] = 0;
3304
3305     // Check to see if a key frame is signalled
3306     // For two pass with auto key frame enabled cm->frame_type may already be set, but not for one pass.
3307     if ((cm->current_video_frame == 0) ||
3308         (cm->frame_flags & FRAMEFLAGS_KEY) ||
3309         (cpi->oxcf.auto_key && (cpi->frames_since_key % cpi->key_frame_frequency == 0)))
3310     {
3311         // Key frame from VFW/auto-keyframe/first frame
3312         cm->frame_type = KEY_FRAME;
3313     }
3314
3315     // Set default state for segment and mode based loop filter update flags
3316     cpi->mb.e_mbd.update_mb_segmentation_map = 0;
3317     cpi->mb.e_mbd.update_mb_segmentation_data = 0;
3318     cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
3319
3320     // Set various flags etc to special state if it is a key frame
3321     if (cm->frame_type == KEY_FRAME)
3322     {
3323         int i;
3324
3325         // Reset the loop filter deltas and segmentation map
3326         setup_features(cpi);
3327
3328         // If segmentation is enabled force a map update for key frames
3329         if (cpi->mb.e_mbd.segmentation_enabled)
3330         {
3331             cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3332             cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3333         }
3334
3335         // The alternate reference frame cannot be active for a key frame
3336         cpi->source_alt_ref_active = FALSE;
3337
3338         // Reset the RD threshold multipliers to default of * 1 (128)
3339         for (i = 0; i < MAX_MODES; i++)
3340         {
3341             cpi->rd_thresh_mult[i] = 128;
3342         }
3343     }
3344
3345     // Test code for segmentation
3346     //if ( (cm->frame_type == KEY_FRAME) || ((cm->current_video_frame % 2) == 0))
3347     //if ( (cm->current_video_frame % 2) == 0 )
3348     //  enable_segmentation((VP8_PTR)cpi);
3349     //else
3350     //  disable_segmentation((VP8_PTR)cpi);
3351
3352 #if 0
3353     // Experimental code for lagged compress and one pass
3354     // Initialise one_pass GF frames stats
3355     // Update stats used for GF selection
3356     //if ( cpi->pass == 0 )
3357     {
3358         cpi->one_pass_frame_index = cm->current_video_frame % MAX_LAG_BUFFERS;
3359
3360         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frames_so_far = 0;
3361         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_intra_error = 0.0;
3362         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_coded_error = 0.0;
3363         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_inter = 0.0;
3364         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_pcnt_motion = 0.0;
3365         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr = 0.0;
3366         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvr_abs = 0.0;
3367         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc = 0.0;
3368         cpi->one_pass_frame_stats[cpi->one_pass_frame_index ].frame_mvc_abs = 0.0;
3369     }
3370 #endif
3371
3372     update_rd_ref_frame_probs(cpi);
3373
3374     if (cpi->drop_frames_allowed)
3375     {
3376         // The reset to decimation 0 is only done here for one pass.
3377         // Once it is set two pass leaves decimation on till the next kf.
3378         if ((cpi->buffer_level > drop_mark) && (cpi->decimation_factor > 0))
3379             cpi->decimation_factor --;
3380
3381         if (cpi->buffer_level > drop_mark75 && cpi->decimation_factor > 0)
3382             cpi->decimation_factor = 1;
3383
3384         else if (cpi->buffer_level < drop_mark25 && (cpi->decimation_factor == 2 || cpi->decimation_factor == 3))
3385         {
3386             cpi->decimation_factor = 3;
3387         }
3388         else if (cpi->buffer_level < drop_mark50 && (cpi->decimation_factor == 1 || cpi->decimation_factor == 2))
3389         {
3390             cpi->decimation_factor = 2;
3391         }
3392         else if (cpi->buffer_level < drop_mark75 && (cpi->decimation_factor == 0 || cpi->decimation_factor == 1))
3393         {
3394             cpi->decimation_factor = 1;
3395         }
3396
3397         //vpx_log("Encoder: Decimation Factor: %d \n",cpi->decimation_factor);
3398     }
3399
3400     // The following decimates the frame rate according to a regular pattern (i.e. to 1/2 or 2/3 frame rate)
3401     // This can be used to help prevent buffer under-run in CBR mode. Alternatively it might be desirable in
3402     // some situations to drop frame rate but throw more bits at each frame.
3403     //
3404     // Note that dropping a key frame can be problematic if spatial resampling is also active
3405     if (cpi->decimation_factor > 0)
3406     {
3407         switch (cpi->decimation_factor)
3408         {
3409         case 1:
3410             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 3 / 2;
3411             break;
3412         case 2:
3413             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 5 / 4;
3414             break;
3415         case 3:
3416             cpi->per_frame_bandwidth  = cpi->per_frame_bandwidth * 5 / 4;
3417             break;
3418         }
3419
3420         // Note that we should not throw out a key frame (especially when spatial resampling is enabled).
3421         if ((cm->frame_type == KEY_FRAME)) // && cpi->oxcf.allow_spatial_resampling )
3422         {
3423             cpi->decimation_count = cpi->decimation_factor;
3424         }
3425         else if (cpi->decimation_count > 0)
3426         {
3427             cpi->decimation_count --;
3428             cpi->bits_off_target += cpi->av_per_frame_bandwidth;
3429             cm->current_video_frame++;
3430             cpi->frames_since_key++;
3431
3432 #if CONFIG_INTERNAL_STATS
3433             cpi->count ++;
3434 #endif
3435
3436             cpi->buffer_level = cpi->bits_off_target;
3437
3438             return;
3439         }
3440         else
3441             cpi->decimation_count = cpi->decimation_factor;
3442     }
3443
3444     // Decide how big to make the frame
3445     if (!vp8_pick_frame_size(cpi))
3446     {
3447         cm->current_video_frame++;
3448         cpi->frames_since_key++;
3449         return;
3450     }
3451
3452     // Reduce active_worst_allowed_q for CBR if our buffer is getting too full.
3453     // This has a knock on effect on active best quality as well.
3454     // For CBR if the buffer reaches its maximum level then we can no longer
3455     // save up bits for later frames so we might as well use them up
3456     // on the current frame.
3457     if (cpi->pass == 2
3458         && (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
3459         (cpi->buffer_level >= cpi->oxcf.optimal_buffer_level) && cpi->buffered_mode)
3460     {
3461         int Adjustment = cpi->active_worst_quality / 4;       // Max adjustment is 1/4
3462
3463         if (Adjustment)
3464         {
3465             int buff_lvl_step;
3466
3467             if (cpi->buffer_level < cpi->oxcf.maximum_buffer_size)
3468             {
3469                 buff_lvl_step = (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level) / Adjustment;
3470
3471                 if (buff_lvl_step)
3472                     Adjustment = (cpi->buffer_level - cpi->oxcf.optimal_buffer_level) / buff_lvl_step;
3473                 else
3474                     Adjustment = 0;
3475             }
3476
3477             cpi->active_worst_quality -= Adjustment;
3478
3479             if(cpi->active_worst_quality < cpi->active_best_quality)
3480                 cpi->active_worst_quality = cpi->active_best_quality;
3481         }
3482     }
3483
3484     // Set an active best quality and if necessary active worst quality
3485     // There is some odd behaviour for one pass here that needs attention.
3486     if ( (cpi->pass == 2) || (cpi->ni_frames > 150))
3487     {
3488         vp8_clear_system_state();
3489
3490         Q = cpi->active_worst_quality;
3491
3492         if ( cm->frame_type == KEY_FRAME )
3493         {
3494             if ( cpi->pass == 2 )
3495             {
3496                 if (cpi->gfu_boost > 600)
3497                    cpi->active_best_quality = kf_low_motion_minq[Q];
3498                 else
3499                    cpi->active_best_quality = kf_high_motion_minq[Q];
3500
3501                 // Special case for key frames forced because we have reached
3502                 // the maximum key frame interval. Here force the Q to a range
3503                 // based on the ambient Q to reduce the risk of popping
3504                 if ( cpi->this_key_frame_forced )
3505                 {
3506                     if ( cpi->active_best_quality > cpi->avg_frame_qindex * 7/8)
3507                         cpi->active_best_quality = cpi->avg_frame_qindex * 7/8;
3508                     else if ( cpi->active_best_quality < cpi->avg_frame_qindex >> 2 )
3509                         cpi->active_best_quality = cpi->avg_frame_qindex >> 2;
3510                 }
3511             }
3512             // One pass more conservative
3513             else
3514                cpi->active_best_quality = kf_high_motion_minq[Q];
3515         }
3516
3517         else if (cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame)
3518         {
3519             // Use the lower of cpi->active_worst_quality and recent
3520             // average Q as basis for GF/ARF Q limit unless last frame was
3521             // a key frame.
3522             if ( (cpi->frames_since_key > 1) &&
3523                  (cpi->avg_frame_qindex < cpi->active_worst_quality) )
3524             {
3525                 Q = cpi->avg_frame_qindex;
3526
3527                 if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3528                      (Q < cpi->oxcf.cq_level) )
3529                 {
3530                     Q = cpi->oxcf.cq_level;
3531                 }
3532             }
3533
3534             if ( cpi->pass == 2 )
3535             {
3536                 if ( cpi->gfu_boost > 1000 )
3537                     cpi->active_best_quality = gf_low_motion_minq[Q];
3538                 else if ( cpi->gfu_boost < 400 )
3539                     cpi->active_best_quality = gf_high_motion_minq[Q];
3540                 else
3541                     cpi->active_best_quality = gf_mid_motion_minq[Q];
3542             }
3543             // One pass more conservative
3544             else
3545                 cpi->active_best_quality = gf_high_motion_minq[Q];
3546         }
3547         else
3548         {
3549             if(cpi->pass != 2)
3550                 Q = cpi->avg_frame_qindex;
3551
3552             cpi->active_best_quality = inter_minq[Q];
3553
3554             // For the constant/constrained quality mode we dont want
3555             // the quality to rise above the cq level.
3556             if ((cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3557                 (cpi->active_best_quality < cpi->cq_target_quality) )
3558             {
3559                 // If we are strongly undershooting the target rate in the last
3560                 // frames then use the user passed in cq value not the auto
3561                 // cq value.
3562                 if ( cpi->rolling_actual_bits < cpi->min_frame_bandwidth )
3563                     cpi->active_best_quality = cpi->oxcf.cq_level;
3564                 else
3565                     cpi->active_best_quality = cpi->cq_target_quality;
3566             }
3567         }
3568
3569         // If CBR and the buffer is as full then it is reasonable to allow
3570         // higher quality on the frames to prevent bits just going to waste.
3571         if (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)
3572         {
3573             // Note that the use of >= here elliminates the risk of a devide
3574             // by 0 error in the else if clause
3575             if (cpi->buffer_level >= cpi->oxcf.maximum_buffer_size)
3576                 cpi->active_best_quality = cpi->best_quality;
3577
3578             else if (cpi->buffer_level > cpi->oxcf.optimal_buffer_level)
3579             {
3580                 int Fraction = ((cpi->buffer_level - cpi->oxcf.optimal_buffer_level) * 128) / (cpi->oxcf.maximum_buffer_size - cpi->oxcf.optimal_buffer_level);
3581                 int min_qadjustment = ((cpi->active_best_quality - cpi->best_quality) * Fraction) / 128;
3582
3583                 cpi->active_best_quality -= min_qadjustment;
3584             }
3585         }
3586     }
3587     // Make sure constrained quality mode limits are adhered to for the first
3588     // few frames of one pass encodes
3589     else if (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY)
3590     {
3591         if ( (cm->frame_type == KEY_FRAME) ||
3592              cm->refresh_golden_frame || cpi->common.refresh_alt_ref_frame )
3593         {
3594              cpi->active_best_quality = cpi->best_quality;
3595         }
3596         else if (cpi->active_best_quality < cpi->cq_target_quality)
3597         {
3598             cpi->active_best_quality = cpi->cq_target_quality;
3599         }
3600     }
3601
3602     // Clip the active best and worst quality values to limits
3603     if (cpi->active_worst_quality > cpi->worst_quality)
3604         cpi->active_worst_quality = cpi->worst_quality;
3605
3606     if (cpi->active_best_quality < cpi->best_quality)
3607         cpi->active_best_quality = cpi->best_quality;
3608     else if (cpi->active_best_quality > cpi->active_worst_quality)
3609         cpi->active_best_quality = cpi->active_worst_quality;
3610
3611     // Determine initial Q to try
3612     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3613     last_zbin_oq = cpi->zbin_over_quant;
3614
3615     // Set highest allowed value for Zbin over quant
3616     if (cm->frame_type == KEY_FRAME)
3617         zbin_oq_high = 0; //ZBIN_OQ_MAX/16
3618     else if (cm->refresh_alt_ref_frame || (cm->refresh_golden_frame && !cpi->source_alt_ref_active))
3619         zbin_oq_high = 16;
3620     else
3621         zbin_oq_high = ZBIN_OQ_MAX;
3622
3623     // Setup background Q adjustment for error resilliant mode
3624     if (cpi->cyclic_refresh_mode_enabled)
3625         cyclic_background_refresh(cpi, Q, 0);
3626
3627     vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3628
3629     // Limit Q range for the adaptive loop.
3630     bottom_index = cpi->active_best_quality;
3631     top_index    = cpi->active_worst_quality;
3632     q_low  = cpi->active_best_quality;
3633     q_high = cpi->active_worst_quality;
3634
3635     vp8_save_coding_context(cpi);
3636
3637     loop_count = 0;
3638
3639
3640     scale_and_extend_source(cpi->un_scaled_source, cpi);
3641 #if !(CONFIG_REALTIME_ONLY) && CONFIG_POSTPROC
3642
3643     if (cpi->oxcf.noise_sensitivity > 0)
3644     {
3645         unsigned char *src;
3646         int l = 0;
3647
3648         switch (cpi->oxcf.noise_sensitivity)
3649         {
3650         case 1:
3651             l = 20;
3652             break;
3653         case 2:
3654             l = 40;
3655             break;
3656         case 3:
3657             l = 60;
3658             break;
3659         case 4:
3660             l = 80;
3661             break;
3662         case 5:
3663             l = 100;
3664             break;
3665         case 6:
3666             l = 150;
3667             break;
3668         }
3669
3670
3671         if (cm->frame_type == KEY_FRAME)
3672         {
3673             vp8_de_noise(cpi->Source, cpi->Source, l , 1,  0, RTCD(postproc));
3674         }
3675         else
3676         {
3677             vp8_de_noise(cpi->Source, cpi->Source, l , 1,  0, RTCD(postproc));
3678
3679             src = cpi->Source->y_buffer;
3680
3681             if (cpi->Source->y_stride < 0)
3682             {
3683                 src += cpi->Source->y_stride * (cpi->Source->y_height - 1);
3684             }
3685         }
3686     }
3687
3688 #endif
3689
3690 #ifdef OUTPUT_YUV_SRC
3691     vp8_write_yuv_frame(cpi->Source);
3692 #endif
3693
3694     do
3695     {
3696         vp8_clear_system_state();  //__asm emms;
3697
3698         /*
3699         if(cpi->is_src_frame_alt_ref)
3700             Q = 127;
3701             */
3702
3703         vp8_set_quantizer(cpi, Q);
3704         this_q = Q;
3705
3706         // setup skip prob for costing in mode/mv decision
3707         if (cpi->common.mb_no_coeff_skip)
3708         {
3709             cpi->prob_skip_false = cpi->base_skip_false_prob[Q];
3710
3711             if (cm->frame_type != KEY_FRAME)
3712             {
3713                 if (cpi->common.refresh_alt_ref_frame)
3714                 {
3715                     if (cpi->last_skip_false_probs[2] != 0)
3716                         cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3717
3718                     /*
3719                                         if(cpi->last_skip_false_probs[2]!=0 && abs(Q- cpi->last_skip_probs_q[2])<=16 )
3720                        cpi->prob_skip_false = cpi->last_skip_false_probs[2];
3721                                         else if (cpi->last_skip_false_probs[2]!=0)
3722                        cpi->prob_skip_false = (cpi->last_skip_false_probs[2]  + cpi->prob_skip_false ) / 2;
3723                        */
3724                 }
3725                 else if (cpi->common.refresh_golden_frame)
3726                 {
3727                     if (cpi->last_skip_false_probs[1] != 0)
3728                         cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3729
3730                     /*
3731                                         if(cpi->last_skip_false_probs[1]!=0 && abs(Q- cpi->last_skip_probs_q[1])<=16 )
3732                        cpi->prob_skip_false = cpi->last_skip_false_probs[1];
3733                                         else if (cpi->last_skip_false_probs[1]!=0)
3734                        cpi->prob_skip_false = (cpi->last_skip_false_probs[1]  + cpi->prob_skip_false ) / 2;
3735                        */
3736                 }
3737                 else
3738                 {
3739                     if (cpi->last_skip_false_probs[0] != 0)
3740                         cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3741
3742                     /*
3743                     if(cpi->last_skip_false_probs[0]!=0 && abs(Q- cpi->last_skip_probs_q[0])<=16 )
3744                         cpi->prob_skip_false = cpi->last_skip_false_probs[0];
3745                     else if(cpi->last_skip_false_probs[0]!=0)
3746                         cpi->prob_skip_false = (cpi->last_skip_false_probs[0]  + cpi->prob_skip_false ) / 2;
3747                         */
3748                 }
3749
3750                 //as this is for cost estimate, let's make sure it does not go extreme eitehr way
3751                 if (cpi->prob_skip_false < 5)
3752                     cpi->prob_skip_false = 5;
3753
3754                 if (cpi->prob_skip_false > 250)
3755                     cpi->prob_skip_false = 250;
3756
3757                 if (cpi->is_src_frame_alt_ref)
3758                     cpi->prob_skip_false = 1;
3759
3760
3761             }
3762
3763 #if 0
3764
3765             if (cpi->pass != 1)
3766             {
3767                 FILE *f = fopen("skip.stt", "a");
3768                 fprintf(f, "%d, %d, %4d ", cpi->common.refresh_golden_frame, cpi->common.refresh_alt_ref_frame, cpi->prob_skip_false);
3769                 fclose(f);
3770             }
3771
3772 #endif
3773
3774         }
3775
3776         if (cm->frame_type == KEY_FRAME)
3777         {
3778             resize_key_frame(cpi);
3779             vp8_setup_key_frame(cpi);
3780         }
3781
3782         // transform / motion compensation build reconstruction frame
3783         vp8_encode_frame(cpi);
3784
3785         cpi->projected_frame_size -= vp8_estimate_entropy_savings(cpi);
3786         cpi->projected_frame_size = (cpi->projected_frame_size > 0) ? cpi->projected_frame_size : 0;
3787
3788         vp8_clear_system_state();  //__asm emms;
3789
3790         // Test to see if the stats generated for this frame indicate that we should have coded a key frame
3791         // (assuming that we didn't)!
3792         if (cpi->pass != 2 && cpi->oxcf.auto_key && cm->frame_type != KEY_FRAME)
3793         {
3794
3795 #if CONFIG_REALTIME_ONLY
3796             {
3797                 /* we don't do re-encoding in realtime mode
3798                  * if key frame is decided than we force it on next frame */
3799                 cpi->force_next_frame_intra = decide_key_frame(cpi);
3800             }
3801 #else
3802             if (decide_key_frame(cpi))
3803             {
3804                 // Reset all our sizing numbers and recode
3805                 cm->frame_type = KEY_FRAME;
3806
3807                 vp8_pick_frame_size(cpi);
3808
3809                 // Clear the Alt reference frame active flag when we have a key frame
3810                 cpi->source_alt_ref_active = FALSE;
3811
3812                 // Reset the loop filter deltas and segmentation map
3813                 setup_features(cpi);
3814
3815                 // If segmentation is enabled force a map update for key frames
3816                 if (cpi->mb.e_mbd.segmentation_enabled)
3817                 {
3818                     cpi->mb.e_mbd.update_mb_segmentation_map = 1;
3819                     cpi->mb.e_mbd.update_mb_segmentation_data = 1;
3820                 }
3821
3822                 vp8_restore_coding_context(cpi);
3823
3824                 Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3825
3826                 vp8_compute_frame_size_bounds(cpi, &frame_under_shoot_limit, &frame_over_shoot_limit);
3827
3828                 // Limit Q range for the adaptive loop.
3829                 bottom_index = cpi->active_best_quality;
3830                 top_index    = cpi->active_worst_quality;
3831                 q_low  = cpi->active_best_quality;
3832                 q_high = cpi->active_worst_quality;
3833
3834                 loop_count++;
3835                 Loop = TRUE;
3836
3837                 continue;
3838             }
3839 #endif
3840         }
3841
3842         vp8_clear_system_state();
3843
3844         if (frame_over_shoot_limit == 0)
3845             frame_over_shoot_limit = 1;
3846
3847         // Are we are overshooting and up against the limit of active max Q.
3848         if (((cpi->pass != 2) || (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER)) &&
3849             (Q == cpi->active_worst_quality)                     &&
3850             (cpi->active_worst_quality < cpi->worst_quality)      &&
3851             (cpi->projected_frame_size > frame_over_shoot_limit))
3852         {
3853             /* step down active_worst_quality such that the corresponding
3854              * active_best_quality will be equal to the current
3855              * active_worst_quality + 1
3856              */
3857             int i;
3858
3859             for(i=cpi->active_worst_quality; i<cpi->worst_quality; i++)
3860                 if(inter_minq[i] >= cpi->active_worst_quality + 1)
3861                     break;
3862             cpi->active_worst_quality = i;
3863
3864             // If we have updated the active max Q do not call vp8_update_rate_correction_factors() this loop.
3865             active_worst_qchanged = TRUE;
3866         }
3867         else
3868             active_worst_qchanged = FALSE;
3869
3870 #if !(CONFIG_REALTIME_ONLY)
3871         // Special case handling for forced key frames
3872         if ( (cm->frame_type == KEY_FRAME) && cpi->this_key_frame_forced )
3873         {
3874             int last_q = Q;
3875             int kf_err = vp8_calc_ss_err(cpi->Source,
3876                                          &cm->yv12_fb[cm->new_fb_idx],
3877                                          IF_RTCD(&cpi->rtcd.variance));
3878
3879             // The key frame is not good enough
3880             if ( kf_err > ((cpi->ambient_err * 7) >> 3) )
3881             {
3882                 // Lower q_high
3883                 q_high = (Q > q_low) ? (Q - 1) : q_low;
3884
3885                 // Adjust Q
3886                 Q = (q_high + q_low) >> 1;
3887             }
3888             // The key frame is much better than the previous frame
3889             else if ( kf_err < (cpi->ambient_err >> 1) )
3890             {
3891                 // Raise q_low
3892                 q_low = (Q < q_high) ? (Q + 1) : q_high;
3893
3894                 // Adjust Q
3895                 Q = (q_high + q_low + 1) >> 1;
3896             }
3897
3898             // Clamp Q to upper and lower limits:
3899             if (Q > q_high)
3900                 Q = q_high;
3901             else if (Q < q_low)
3902                 Q = q_low;
3903
3904             Loop = ((Q != last_q)) ? TRUE : FALSE;
3905         }
3906
3907         // Is the projected frame size out of range and are we allowed to attempt to recode.
3908         else if ( recode_loop_test( cpi,
3909                                frame_over_shoot_limit, frame_under_shoot_limit,
3910                                Q, top_index, bottom_index ) )
3911         {
3912             int last_q = Q;
3913             int Retries = 0;
3914
3915             // Frame size out of permitted range:
3916             // Update correction factor & compute new Q to try...
3917
3918             // Frame is too large
3919             if (cpi->projected_frame_size > cpi->this_frame_target)
3920             {
3921                 //if ( cpi->zbin_over_quant == 0 )
3922                 q_low = (Q < q_high) ? (Q + 1) : q_high; // Raise Qlow as to at least the current value
3923
3924                 if (cpi->zbin_over_quant > 0)            // If we are using over quant do the same for zbin_oq_low
3925                     zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3926
3927                 //if ( undershoot_seen || (Q == MAXQ) )
3928                 if (undershoot_seen)
3929                 {
3930                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3931                     if (!active_worst_qchanged)
3932                         vp8_update_rate_correction_factors(cpi, 1);
3933
3934                     Q = (q_high + q_low + 1) / 2;
3935
3936                     // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3937                     if (Q < MAXQ)
3938                         cpi->zbin_over_quant = 0;
3939                     else
3940                     {
3941                         zbin_oq_low = (cpi->zbin_over_quant < zbin_oq_high) ? (cpi->zbin_over_quant + 1) : zbin_oq_high;
3942                         cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3943                     }
3944                 }
3945                 else
3946                 {
3947                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3948                     if (!active_worst_qchanged)
3949                         vp8_update_rate_correction_factors(cpi, 0);
3950
3951                     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3952
3953                     while (((Q < q_low) || (cpi->zbin_over_quant < zbin_oq_low)) && (Retries < 10))
3954                     {
3955                         vp8_update_rate_correction_factors(cpi, 0);
3956                         Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3957                         Retries ++;
3958                     }
3959                 }
3960
3961                 overshoot_seen = TRUE;
3962             }
3963             // Frame is too small
3964             else
3965             {
3966                 if (cpi->zbin_over_quant == 0)
3967                     q_high = (Q > q_low) ? (Q - 1) : q_low; // Lower q_high if not using over quant
3968                 else                                    // else lower zbin_oq_high
3969                     zbin_oq_high = (cpi->zbin_over_quant > zbin_oq_low) ? (cpi->zbin_over_quant - 1) : zbin_oq_low;
3970
3971                 if (overshoot_seen)
3972                 {
3973                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3974                     if (!active_worst_qchanged)
3975                         vp8_update_rate_correction_factors(cpi, 1);
3976
3977                     Q = (q_high + q_low) / 2;
3978
3979                     // Adjust cpi->zbin_over_quant (only allowed when Q is max)
3980                     if (Q < MAXQ)
3981                         cpi->zbin_over_quant = 0;
3982                     else
3983                         cpi->zbin_over_quant = (zbin_oq_high + zbin_oq_low) / 2;
3984                 }
3985                 else
3986                 {
3987                     // Update rate_correction_factor unless cpi->active_worst_quality has changed.
3988                     if (!active_worst_qchanged)
3989                         vp8_update_rate_correction_factors(cpi, 0);
3990
3991                     Q = vp8_regulate_q(cpi, cpi->this_frame_target);
3992
3993                     // Special case reset for qlow for constrained quality.
3994                     // This should only trigger where there is very substantial
3995                     // undershoot on a frame and the auto cq level is above
3996                     // the user passsed in value.
3997                     if ( (cpi->oxcf.end_usage == USAGE_CONSTRAINED_QUALITY) &&
3998                          (Q < q_low) )
3999                     {
4000                         q_low = Q;
4001                     }
4002
4003                     while (((Q > q_high) || (cpi->zbin_over_quant > zbin_oq_high)) && (Retries < 10))
4004                     {
4005                         vp8_update_rate_correction_factors(cpi, 0);
4006                         Q = vp8_regulate_q(cpi, cpi->this_frame_target);
4007                         Retries ++;
4008                     }
4009                 }
4010
4011                 undershoot_seen = TRUE;
4012             }
4013
4014             // Clamp Q to upper and lower limits:
4015             if (Q > q_high)
4016                 Q = q_high;
4017             else if (Q < q_low)
4018                 Q = q_low;
4019
4020             // Clamp cpi->zbin_over_quant
4021             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;
4022
4023             //Loop = ((Q != last_q) || (last_zbin_oq != cpi->zbin_over_quant)) ? TRUE : FALSE;
4024             Loop = ((Q != last_q)) ? TRUE : FALSE;
4025             last_zbin_oq = cpi->zbin_over_quant;
4026         }
4027         else
4028 #endif
4029             Loop = FALSE;
4030
4031         if (cpi->is_src_frame_alt_ref)
4032             Loop = FALSE;
4033
4034         if (Loop == TRUE)
4035         {
4036             vp8_restore_coding_context(cpi);
4037             loop_count++;
4038 #if CONFIG_INTERNAL_STATS
4039             cpi->tot_recode_hits++;
4040 #endif
4041         }
4042     }
4043     while (Loop == TRUE);
4044
4045 #if 0
4046     // Experimental code for lagged and one pass
4047     // Update stats used for one pass GF selection
4048     {
4049         /*
4050             int frames_so_far;
4051             double frame_intra_error;
4052             double frame_coded_error;
4053             double frame_pcnt_inter;
4054             double frame_pcnt_motion;
4055             double frame_mvr;
4056             double frame_mvr_abs;
4057             double frame_mvc;
4058             double frame_mvc_abs;
4059         */
4060
4061         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_coded_error = (double)cpi->prediction_error;
4062         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_intra_error = (double)cpi->intra_error;
4063         cpi->one_pass_frame_stats[cpi->one_pass_frame_index].frame_pcnt_inter = (double)(100 - cpi->this_frame_percent_intra) / 100.0;
4064     }
4065 #endif
4066
4067     // Special case code to reduce pulsing when key frames are forced at a
4068     // fixed interval. Note the reconstruction error if it is the frame before
4069     // the force key frame
4070     if ( cpi->next_key_frame_forced && (cpi->twopass.frames_to_key == 0) )
4071     {
4072         cpi->ambient_err = vp8_calc_ss_err(cpi->Source,
4073                                            &cm->yv12_fb[cm->new_fb_idx],
4074                                            IF_RTCD(&cpi->rtcd.variance));
4075     }
4076
4077     // This frame's MVs are saved and will be used in next frame's MV prediction.
4078     // 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.
4079     if(cm->show_frame)   //do not save for altref frame
4080     {
4081         int mb_row;
4082         int mb_col;
4083         MODE_INFO *tmp = cm->mip; //point to beginning of allocated MODE_INFO arrays.
4084
4085         if(cm->frame_type != KEY_FRAME)
4086         {
4087             for (mb_row = 0; mb_row < cm->mb_rows+1; mb_row ++)
4088             {
4089                 for (mb_col = 0; mb_col < cm->mb_cols+1; mb_col ++)
4090                 {
4091                     if(tmp->mbmi.ref_frame != INTRA_FRAME)
4092                         cpi->lfmv[mb_col + mb_row*(cm->mode_info_stride+1)].as_int = tmp->mbmi.mv.as_int;
4093
4094                     cpi->lf_ref_frame_sign_bias[mb_col + mb_row*(cm->mode_info_stride+1)] = cm->ref_frame_sign_bias[tmp->mbmi.ref_frame];
4095                     cpi->lf_ref_frame[mb_col + mb_row*(cm->mode_info_stride+1)] = tmp->mbmi.ref_frame;
4096                     tmp++;
4097                 }
4098             }
4099         }
4100     }
4101
4102     // Update the GF useage maps.
4103     // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4104     // This is done after completing the compression of a frame when all modes etc. are finalized but before loop filter
4105     vp8_update_gf_useage_maps(cpi, cm, &cpi->mb);
4106
4107     if (cm->frame_type == KEY_FRAME)
4108         cm->refresh_last_frame = 1;
4109
4110 #if 0
4111     {
4112         FILE *f = fopen("gfactive.stt", "a");
4113         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);
4114         fclose(f);
4115     }
4116 #endif
4117
4118     // For inter frames the current default behavior is that when
4119     // cm->refresh_golden_frame is set we copy the old GF over to the ARF buffer
4120     // This is purely an encoder decision at present.
4121     if (!cpi->oxcf.error_resilient_mode && cm->refresh_golden_frame)
4122         cm->copy_buffer_to_arf  = 2;
4123     else
4124         cm->copy_buffer_to_arf  = 0;
4125
4126     cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx];
4127
4128 #if CONFIG_MULTITHREAD
4129     if (cpi->b_multi_threaded)
4130     {
4131         sem_post(&cpi->h_event_start_lpf); /* start loopfilter in separate thread */
4132     }
4133     else
4134 #endif
4135     {
4136         loopfilter_frame(cpi, cm);
4137     }
4138
4139     update_reference_frames(cm);
4140
4141     if (cpi->oxcf.error_resilient_mode == 1)
4142     {
4143         cm->refresh_entropy_probs = 0;
4144     }
4145
4146 #if CONFIG_MULTITHREAD
4147     /* wait that filter_level is picked so that we can continue with stream packing */
4148     if (cpi->b_multi_threaded)
4149         sem_wait(&cpi->h_event_end_lpf);
4150 #endif
4151
4152     // build the bitstream
4153     vp8_pack_bitstream(cpi, dest, size);
4154
4155 #if CONFIG_MULTITHREAD
4156     /* wait for loopfilter thread done */
4157     if (cpi->b_multi_threaded)
4158     {
4159         sem_wait(&cpi->h_event_end_lpf);
4160     }
4161 #endif
4162
4163     /* Move storing frame_type out of the above loop since it is also
4164      * needed in motion search besides loopfilter */
4165     cm->last_frame_type = cm->frame_type;
4166
4167     // Update rate control heuristics
4168     cpi->total_byte_count += (*size);
4169     cpi->projected_frame_size = (*size) << 3;
4170
4171     if (!active_worst_qchanged)
4172         vp8_update_rate_correction_factors(cpi, 2);
4173
4174     cpi->last_q[cm->frame_type] = cm->base_qindex;
4175
4176     if (cm->frame_type == KEY_FRAME)
4177     {
4178         vp8_adjust_key_frame_context(cpi);
4179     }
4180
4181     // Keep a record of ambient average Q.
4182     if (cm->frame_type != KEY_FRAME)
4183         cpi->avg_frame_qindex = (2 + 3 * cpi->avg_frame_qindex + cm->base_qindex) >> 2;
4184
4185     // Keep a record from which we can calculate the average Q excluding GF updates and key frames
4186     if ((cm->frame_type != KEY_FRAME) && !cm->refresh_golden_frame && !cm->refresh_alt_ref_frame)
4187     {
4188         cpi->ni_frames++;
4189
4190         // Calculate the average Q for normal inter frames (not key or GFU
4191         // frames).
4192         if ( cpi->pass == 2 )
4193         {
4194             cpi->ni_tot_qi += Q;
4195             cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4196         }
4197         else
4198         {
4199             // Damp value for first few frames
4200             if (cpi->ni_frames > 150 )
4201             {
4202                 cpi->ni_tot_qi += Q;
4203                 cpi->ni_av_qi = (cpi->ni_tot_qi / cpi->ni_frames);
4204             }
4205             // For one pass, early in the clip ... average the current frame Q
4206             // value with the worstq entered by the user as a dampening measure
4207             else
4208             {
4209                 cpi->ni_tot_qi += Q;
4210                 cpi->ni_av_qi = ((cpi->ni_tot_qi / cpi->ni_frames) + cpi->worst_quality + 1) / 2;
4211             }
4212
4213             // If the average Q is higher than what was used in the last frame
4214             // (after going through the recode loop to keep the frame size within range)
4215             // then use the last frame value - 1.
4216             // The -1 is designed to stop Q and hence the data rate, from progressively
4217             // falling away during difficult sections, but at the same time reduce the number of
4218             // itterations around the recode loop.
4219             if (Q > cpi->ni_av_qi)
4220                 cpi->ni_av_qi = Q - 1;
4221         }
4222     }
4223
4224 #if 0
4225
4226     // If the frame was massively oversize and we are below optimal buffer level drop next frame
4227     if ((cpi->drop_frames_allowed) &&
4228         (cpi->oxcf.end_usage == USAGE_STREAM_FROM_SERVER) &&
4229         (cpi->buffer_level < cpi->oxcf.drop_frames_water_mark * cpi->oxcf.optimal_buffer_level / 100) &&
4230         (cpi->projected_frame_size > (4 * cpi->this_frame_target)))
4231     {
4232         cpi->drop_frame = TRUE;
4233     }
4234
4235 #endif
4236
4237     // Set the count for maximum consequative dropped frames based upon the ratio of
4238     // this frame size to the target average per frame bandwidth.
4239     // (cpi->av_per_frame_bandwidth > 0) is just a sanity check to prevent / 0.
4240     if (cpi->drop_frames_allowed && (cpi->av_per_frame_bandwidth > 0))
4241     {
4242         cpi->max_drop_count = cpi->projected_frame_size / cpi->av_per_frame_bandwidth;
4243
4244         if (cpi->max_drop_count > cpi->max_consec_dropped_frames)
4245             cpi->max_drop_count = cpi->max_consec_dropped_frames;
4246     }
4247
4248     // Update the buffer level variable.
4249     // Non-viewable frames are a special case and are treated as pure overhead.
4250     if ( cm->show_frame )
4251         cpi->bits_off_target += cpi->av_per_frame_bandwidth;
4252     cpi->bits_off_target -= cpi->projected_frame_size;
4253
4254     // Rolling monitors of whether we are over or underspending used to help regulate min and Max Q in two pass.
4255     cpi->rolling_target_bits = ((cpi->rolling_target_bits * 3) + cpi->this_frame_target + 2) / 4;
4256     cpi->rolling_actual_bits = ((cpi->rolling_actual_bits * 3) + cpi->projected_frame_size + 2) / 4;
4257     cpi->long_rolling_target_bits = ((cpi->long_rolling_target_bits * 31) + cpi->this_frame_target + 16) / 32;
4258     cpi->long_rolling_actual_bits = ((cpi->long_rolling_actual_bits * 31) + cpi->projected_frame_size + 16) / 32;
4259
4260     // Actual bits spent
4261     cpi->total_actual_bits    += cpi->projected_frame_size;
4262
4263     // Debug stats
4264     cpi->total_target_vs_actual += (cpi->this_frame_target - cpi->projected_frame_size);
4265
4266     // Update the buffered average bitrate
4267     {
4268         long long numerator;
4269
4270         numerator = cpi->oxcf.maximum_buffer_size
4271                     - cpi->buffered_av_per_frame_bandwidth
4272                     + cpi->projected_frame_size;
4273         numerator *= cpi->buffered_av_per_frame_bandwidth;
4274         cpi->buffered_av_per_frame_bandwidth = numerator
4275                                                / cpi->oxcf.maximum_buffer_size;
4276     }
4277
4278     {
4279         long long tmp = (long long)cpi->buffered_av_per_frame_bandwidth
4280                         * cpi->oxcf.maximum_buffer_size
4281                         / cpi->av_per_frame_bandwidth;
4282         cpi->buffer_level = cpi->oxcf.maximum_buffer_size
4283                             - tmp
4284                             + cpi->oxcf.optimal_buffer_level;
4285     }
4286
4287     // Accumulate overshoot error.
4288     cpi->accumulated_overshoot +=
4289         (cpi->projected_frame_size > cpi->av_per_frame_bandwidth)
4290         ? cpi->projected_frame_size - cpi->av_per_frame_bandwidth
4291         : 0;
4292
4293
4294     // Update bits left to the kf and gf groups to account for overshoot or undershoot on these frames
4295     if (cm->frame_type == KEY_FRAME)
4296     {
4297         cpi->twopass.kf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4298
4299         if (cpi->twopass.kf_group_bits < 0)
4300             cpi->twopass.kf_group_bits = 0 ;
4301     }
4302     else if (cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4303     {
4304         cpi->twopass.gf_group_bits += cpi->this_frame_target - cpi->projected_frame_size;
4305
4306         if (cpi->twopass.gf_group_bits < 0)
4307             cpi->twopass.gf_group_bits = 0 ;
4308     }
4309
4310     if (cm->frame_type != KEY_FRAME)
4311     {
4312         if (cpi->common.refresh_alt_ref_frame)
4313         {
4314             cpi->last_skip_false_probs[2] = cpi->prob_skip_false;
4315             cpi->last_skip_probs_q[2] = cm->base_qindex;
4316         }
4317         else if (cpi->common.refresh_golden_frame)
4318         {
4319             cpi->last_skip_false_probs[1] = cpi->prob_skip_false;
4320             cpi->last_skip_probs_q[1] = cm->base_qindex;
4321         }
4322         else
4323         {
4324             cpi->last_skip_false_probs[0] = cpi->prob_skip_false;
4325             cpi->last_skip_probs_q[0] = cm->base_qindex;
4326
4327             //update the baseline
4328             cpi->base_skip_false_prob[cm->base_qindex] = cpi->prob_skip_false;
4329
4330         }
4331     }
4332
4333 #if 0 && CONFIG_INTERNAL_STATS
4334     {
4335         FILE *f = fopen("tmp.stt", "a");
4336
4337         vp8_clear_system_state();  //__asm emms;
4338
4339         if (cpi->twopass.total_coded_error_left != 0.0)
4340             fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4341                        "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4342                        "%10.3f %8d\n",
4343                        cpi->common.current_video_frame, cpi->this_frame_target,
4344                        cpi->projected_frame_size,
4345                        (cpi->projected_frame_size - cpi->this_frame_target),
4346                        (int)cpi->total_target_vs_actual,
4347                        (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4348                        (int)cpi->total_actual_bits, cm->base_qindex,
4349                        cpi->active_best_quality, cpi->active_worst_quality,
4350                        cpi->ni_av_qi, cpi->cq_target_quality, cpi->zbin_over_quant,
4351                        //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4352                        cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4353                        cm->frame_type, cpi->gfu_boost,
4354                        cpi->twopass.est_max_qcorrection_factor, (int)cpi->twopass.bits_left,
4355                        cpi->twopass.total_coded_error_left,
4356                        (double)cpi->twopass.bits_left / cpi->twopass.total_coded_error_left,
4357                        cpi->tot_recode_hits);
4358         else
4359             fprintf(f, "%10d %10d %10d %10d %10d %10d %10d %10d %6d %6d"
4360                        "%6d %6d %6d %5d %5d %5d %8d %8.2f %10d %10.3f"
4361                        "%8d\n",
4362                        cpi->common.current_video_frame,
4363                        cpi->this_frame_target, cpi->projected_frame_size,
4364                        (cpi->projected_frame_size - cpi->this_frame_target),
4365                        (int)cpi->total_target_vs_actual,
4366                        (cpi->oxcf.starting_buffer_level-cpi->bits_off_target),
4367                        (int)cpi->total_actual_bits, cm->base_qindex,
4368                        cpi->active_best_quality, cpi->active_worst_quality,
4369                        cpi->ni_av_qi, cpi->cq_target_quality, cpi->zbin_over_quant,
4370                        //cpi->avg_frame_qindex, cpi->zbin_over_quant,
4371                        cm->refresh_golden_frame, cm->refresh_alt_ref_frame,
4372                        cm->frame_type, cpi->gfu_boost,
4373                        cpi->twopass.est_max_qcorrection_factor, (int)cpi->twopass.bits_left,
4374                        cpi->twopass.total_coded_error_left, cpi->tot_recode_hits);
4375
4376         fclose(f);
4377
4378         {
4379             FILE *fmodes = fopen("Modes.stt", "a");
4380             int i;
4381
4382             fprintf(fmodes, "%6d:%1d:%1d:%1d ",
4383                         cpi->common.current_video_frame,
4384                         cm->frame_type, cm->refresh_golden_frame,
4385                         cm->refresh_alt_ref_frame);
4386
4387             for (i = 0; i < MAX_MODES; i++)
4388                 fprintf(fmodes, "%5d ", cpi->mode_chosen_counts[i]);
4389
4390             fprintf(fmodes, "\n");
4391
4392             fclose(fmodes);
4393         }
4394     }
4395
4396 #endif
4397
4398     // If this was a kf or Gf note the Q
4399     if ((cm->frame_type == KEY_FRAME) || cm->refresh_golden_frame || cm->refresh_alt_ref_frame)
4400         cm->last_kf_gf_q = cm->base_qindex;
4401
4402     if (cm->refresh_golden_frame == 1)
4403         cm->frame_flags = cm->frame_flags | FRAMEFLAGS_GOLDEN;
4404     else
4405         cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_GOLDEN;
4406
4407     if (cm->refresh_alt_ref_frame == 1)
4408         cm->frame_flags = cm->frame_flags | FRAMEFLAGS_ALTREF;
4409     else
4410         cm->frame_flags = cm->frame_flags&~FRAMEFLAGS_ALTREF;
4411
4412
4413     if (cm->refresh_last_frame & cm->refresh_golden_frame) // both refreshed
4414         cpi->gold_is_last = 1;
4415     else if (cm->refresh_last_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4416         cpi->gold_is_last = 0;
4417
4418     if (cm->refresh_last_frame & cm->refresh_alt_ref_frame) // both refreshed
4419         cpi->alt_is_last = 1;
4420     else if (cm->refresh_last_frame ^ cm->refresh_alt_ref_frame) // 1 refreshed but not the other
4421         cpi->alt_is_last = 0;
4422
4423     if (cm->refresh_alt_ref_frame & cm->refresh_golden_frame) // both refreshed
4424         cpi->gold_is_alt = 1;
4425     else if (cm->refresh_alt_ref_frame ^ cm->refresh_golden_frame) // 1 refreshed but not the other
4426         cpi->gold_is_alt = 0;
4427
4428     cpi->ref_frame_flags = VP8_ALT_FLAG | VP8_GOLD_FLAG | VP8_LAST_FLAG;
4429
4430     if (cpi->gold_is_last)
4431         cpi->ref_frame_flags &= ~VP8_GOLD_FLAG;
4432
4433     if (cpi->alt_is_last)
4434         cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4435
4436     if (cpi->gold_is_alt)
4437         cpi->ref_frame_flags &= ~VP8_ALT_FLAG;
4438
4439
4440     if (!cpi->oxcf.error_resilient_mode)
4441     {
4442         if (cpi->oxcf.play_alternate && cm->refresh_alt_ref_frame && (cm->frame_type != KEY_FRAME))
4443             // Update the alternate reference frame stats as appropriate.
4444             update_alt_ref_frame_stats(cpi);
4445         else
4446             // Update the Golden frame stats as appropriate.
4447             update_golden_frame_stats(cpi);
4448     }
4449
4450     if (cm->frame_type == KEY_FRAME)
4451     {
4452         // Tell the caller that the frame was coded as a key frame
4453         *frame_flags = cm->frame_flags | FRAMEFLAGS_KEY;
4454
4455         // As this frame is a key frame  the next defaults to an inter frame.
4456         cm->frame_type = INTER_FRAME;
4457
4458         cpi->last_frame_percent_intra = 100;
4459     }
4460     else
4461     {
4462         *frame_flags = cm->frame_flags&~FRAMEFLAGS_KEY;
4463
4464         cpi->last_frame_percent_intra = cpi->this_frame_percent_intra;
4465     }
4466
4467     // Clear the one shot update flags for segmentation map and mode/ref loop filter deltas.
4468     cpi->mb.e_mbd.update_mb_segmentation_map = 0;
4469     cpi->mb.e_mbd.update_mb_segmentation_data = 0;
4470     cpi->mb.e_mbd.mode_ref_lf_delta_update = 0;
4471
4472
4473     // Dont increment frame counters if this was an altref buffer update not a real frame
4474     if (cm->show_frame)
4475     {
4476         cm->current_video_frame++;
4477         cpi->frames_since_key++;
4478     }
4479
4480     // reset to normal state now that we are done.
4481
4482
4483
4484 #if 0
4485     {
4486         char filename[512];
4487         FILE *recon_file;
4488         sprintf(filename, "enc%04d.yuv", (int) cm->current_video_frame);
4489         recon_file = fopen(filename, "wb");
4490         fwrite(cm->yv12_fb[cm->lst_fb_idx].buffer_alloc,
4491                cm->yv12_fb[cm->lst_fb_idx].frame_size, 1, recon_file);
4492         fclose(recon_file);
4493     }
4494 #endif
4495
4496     // DEBUG
4497     //vp8_write_yuv_frame("encoder_recon.yuv", cm->frame_to_show);
4498
4499
4500 }
4501
4502
4503 static void check_gf_quality(VP8_COMP *cpi)
4504 {
4505     VP8_COMMON *cm = &cpi->common;
4506     int gf_active_pct = (100 * cpi->gf_active_count) / (cm->mb_rows * cm->mb_cols);
4507     int gf_ref_usage_pct = (cpi->count_mb_ref_frame_usage[GOLDEN_FRAME] * 100) / (cm->mb_rows * cm->mb_cols);
4508     int last_ref_zz_useage = (cpi->inter_zz_count * 100) / (cm->mb_rows * cm->mb_cols);
4509
4510     // Gf refresh is not currently being signalled
4511     if (cpi->gf_update_recommended == 0)
4512     {
4513         if (cpi->common.frames_since_golden > 7)
4514         {
4515             // Low use of gf
4516             if ((gf_active_pct < 10) || ((gf_active_pct + gf_ref_usage_pct) < 15))
4517             {
4518                 // ...but last frame zero zero usage is reasonbable so a new gf might be appropriate
4519                 if (last_ref_zz_useage >= 25)
4520                 {
4521                     cpi->gf_bad_count ++;
4522
4523                     if (cpi->gf_bad_count >= 8)   // Check that the condition is stable
4524                     {
4525                         cpi->gf_update_recommended = 1;
4526                         cpi->gf_bad_count = 0;
4527                     }
4528                 }
4529                 else
4530                     cpi->gf_bad_count = 0;        // Restart count as the background is not stable enough
4531             }
4532             else
4533                 cpi->gf_bad_count = 0;            // Gf useage has picked up so reset count
4534         }
4535     }
4536     // If the signal is set but has not been read should we cancel it.
4537     else if (last_ref_zz_useage < 15)
4538     {
4539         cpi->gf_update_recommended = 0;
4540         cpi->gf_bad_count = 0;
4541     }
4542
4543 #if 0
4544     {
4545         FILE *f = fopen("gfneeded.stt", "a");
4546         fprintf(f, "%10d %10d %10d %10d %10ld \n",
4547                 cm->current_video_frame,
4548                 cpi->common.frames_since_golden,
4549                 gf_active_pct, gf_ref_usage_pct,
4550                 cpi->gf_update_recommended);
4551         fclose(f);
4552     }
4553
4554 #endif
4555 }
4556
4557 #if !(CONFIG_REALTIME_ONLY)
4558 static void Pass2Encode(VP8_COMP *cpi, unsigned long *size, unsigned char *dest, unsigned int *frame_flags)
4559 {
4560
4561     if (!cpi->common.refresh_alt_ref_frame)
4562         vp8_second_pass(cpi);
4563
4564     encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4565     cpi->twopass.bits_left -= 8 * *size;
4566
4567     if (!cpi->common.refresh_alt_ref_frame)
4568     {
4569         double two_pass_min_rate = (double)(cpi->oxcf.target_bandwidth
4570             *cpi->oxcf.two_pass_vbrmin_section / 100);
4571         cpi->twopass.bits_left += (long long)(two_pass_min_rate / cpi->oxcf.frame_rate);
4572     }
4573 }
4574 #endif
4575
4576 //For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.
4577 #if HAVE_ARMV7
4578 extern void vp8_push_neon(INT64 *store);
4579 extern void vp8_pop_neon(INT64 *store);
4580 #endif
4581
4582
4583 int vp8_receive_raw_frame(VP8_PTR ptr, unsigned int frame_flags, YV12_BUFFER_CONFIG *sd, INT64 time_stamp, INT64 end_time)
4584 {
4585 #if HAVE_ARMV7
4586     INT64 store_reg[8];
4587 #endif
4588     VP8_COMP              *cpi = (VP8_COMP *) ptr;
4589     VP8_COMMON            *cm = &cpi->common;
4590     struct vpx_usec_timer  timer;
4591     int                    res = 0;
4592
4593 #if HAVE_ARMV7
4594 #if CONFIG_RUNTIME_CPU_DETECT
4595     if (cm->rtcd.flags & HAS_NEON)
4596 #endif
4597     {
4598         vp8_push_neon(store_reg);
4599     }
4600 #endif
4601
4602     vpx_usec_timer_start(&timer);
4603     if(vp8_lookahead_push(cpi->lookahead, sd, time_stamp, end_time,
4604                           frame_flags))
4605         res = -1;
4606     cm->clr_type = sd->clrtype;
4607     vpx_usec_timer_mark(&timer);
4608     cpi->time_receive_data += vpx_usec_timer_elapsed(&timer);
4609
4610 #if HAVE_ARMV7
4611 #if CONFIG_RUNTIME_CPU_DETECT
4612     if (cm->rtcd.flags & HAS_NEON)
4613 #endif
4614     {
4615         vp8_pop_neon(store_reg);
4616     }
4617 #endif
4618
4619     return res;
4620 }
4621
4622
4623 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)
4624 {
4625 #if HAVE_ARMV7
4626     INT64 store_reg[8];
4627 #endif
4628     VP8_COMP *cpi = (VP8_COMP *) ptr;
4629     VP8_COMMON *cm = &cpi->common;
4630     struct vpx_usec_timer  tsctimer;
4631     struct vpx_usec_timer  ticktimer;
4632     struct vpx_usec_timer  cmptimer;
4633     YV12_BUFFER_CONFIG    *force_src_buffer = NULL;
4634
4635     if (!cpi)
4636         return -1;
4637
4638 #if HAVE_ARMV7
4639 #if CONFIG_RUNTIME_CPU_DETECT
4640     if (cm->rtcd.flags & HAS_NEON)
4641 #endif
4642     {
4643         vp8_push_neon(store_reg);
4644     }
4645 #endif
4646
4647     vpx_usec_timer_start(&cmptimer);
4648
4649     cpi->source = NULL;
4650
4651 #if !(CONFIG_REALTIME_ONLY)
4652     // Should we code an alternate reference frame
4653     if (cpi->oxcf.error_resilient_mode == 0 &&
4654         cpi->oxcf.play_alternate &&
4655         cpi->source_alt_ref_pending)
4656     {
4657         if ((cpi->source = vp8_lookahead_peek(cpi->lookahead,
4658                                               cpi->frames_till_gf_update_due)))
4659         {
4660             cpi->alt_ref_source = cpi->source;
4661             if (cpi->oxcf.arnr_max_frames > 0)
4662             {
4663                 vp8_temporal_filter_prepare_c(cpi,
4664                                               cpi->frames_till_gf_update_due);
4665                 force_src_buffer = &cpi->alt_ref_buffer;
4666             }
4667             cm->frames_till_alt_ref_frame = cpi->frames_till_gf_update_due;
4668             cm->refresh_alt_ref_frame = 1;
4669             cm->refresh_golden_frame = 0;
4670             cm->refresh_last_frame = 0;
4671             cm->show_frame = 0;
4672             cpi->source_alt_ref_pending = FALSE;   // Clear Pending altf Ref flag.
4673             cpi->is_src_frame_alt_ref = 0;
4674         }
4675     }
4676 #endif
4677
4678     if (!cpi->source)
4679     {
4680         if ((cpi->source = vp8_lookahead_pop(cpi->lookahead, flush)))
4681         {
4682             cm->show_frame = 1;
4683
4684             cpi->is_src_frame_alt_ref = cpi->alt_ref_source
4685                                         && (cpi->source == cpi->alt_ref_source);
4686
4687             if(cpi->is_src_frame_alt_ref)
4688                 cpi->alt_ref_source = NULL;
4689         }
4690     }
4691
4692     if (cpi->source)
4693     {
4694         cpi->un_scaled_source =
4695         cpi->Source = force_src_buffer ? force_src_buffer : &cpi->source->img;
4696         *time_stamp = cpi->source->ts_start;
4697         *time_end = cpi->source->ts_end;
4698         *frame_flags = cpi->source->flags;
4699     }
4700     else
4701     {
4702         *size = 0;
4703 #if !(CONFIG_REALTIME_ONLY)
4704
4705         if (flush && cpi->pass == 1 && !cpi->twopass.first_pass_done)
4706         {
4707             vp8_end_first_pass(cpi);    /* get last stats packet */
4708             cpi->twopass.first_pass_done = 1;
4709         }
4710
4711 #endif
4712
4713 #if HAVE_ARMV7
4714 #if CONFIG_RUNTIME_CPU_DETECT
4715         if (cm->rtcd.flags & HAS_NEON)
4716 #endif
4717         {
4718             vp8_pop_neon(store_reg);
4719         }
4720 #endif
4721         return -1;
4722     }
4723
4724     if (cpi->source->ts_start < cpi->first_time_stamp_ever)
4725     {
4726         cpi->first_time_stamp_ever = cpi->source->ts_start;
4727         cpi->last_end_time_stamp_seen = cpi->source->ts_start;
4728     }
4729
4730     // adjust frame rates based on timestamps given
4731     if (!cm->refresh_alt_ref_frame)
4732     {
4733         long long this_duration;
4734         int step = 0;
4735
4736         if (cpi->source->ts_start == cpi->first_time_stamp_ever)
4737         {
4738             this_duration = cpi->source->ts_end - cpi->source->ts_start;
4739             step = 1;
4740         }
4741         else
4742         {
4743             long long last_duration;
4744
4745             this_duration = cpi->source->ts_end - cpi->last_end_time_stamp_seen;
4746             last_duration = cpi->last_end_time_stamp_seen
4747                             - cpi->last_time_stamp_seen;
4748             // do a step update if the duration changes by 10%
4749             if (last_duration)
4750                 step = ((this_duration - last_duration) * 10 / last_duration);
4751         }
4752
4753         if (this_duration)
4754         {
4755             if (step)
4756                 vp8_new_frame_rate(cpi, 10000000.0 / this_duration);
4757             else
4758             {
4759                 double avg_duration, interval;
4760
4761                 /* Average this frame's rate into the last second's average
4762                  * frame rate. If we haven't seen 1 second yet, then average
4763                  * over the whole interval seen.
4764                  */
4765                 interval = cpi->source->ts_end - cpi->first_time_stamp_ever;
4766                 if(interval > 10000000.0)
4767                     interval = 10000000;
4768
4769                 avg_duration = 10000000.0 / cpi->oxcf.frame_rate;
4770                 avg_duration *= (interval - avg_duration + this_duration);
4771                 avg_duration /= interval;
4772
4773                 vp8_new_frame_rate(cpi, 10000000.0 / avg_duration);
4774             }
4775         }
4776
4777         cpi->last_time_stamp_seen = cpi->source->ts_start;
4778         cpi->last_end_time_stamp_seen = cpi->source->ts_end;
4779     }
4780
4781     if (cpi->compressor_speed == 2)
4782     {
4783         check_gf_quality(cpi);
4784         vpx_usec_timer_start(&tsctimer);
4785         vpx_usec_timer_start(&ticktimer);
4786     }
4787
4788     // start with a 0 size frame
4789     *size = 0;
4790
4791     // Clear down mmx registers
4792     vp8_clear_system_state();  //__asm emms;
4793
4794     cm->frame_type = INTER_FRAME;
4795     cm->frame_flags = *frame_flags;
4796
4797 #if 0
4798
4799     if (cm->refresh_alt_ref_frame)
4800     {
4801         //cm->refresh_golden_frame = 1;
4802         cm->refresh_golden_frame = 0;
4803         cm->refresh_last_frame = 0;
4804     }
4805     else
4806     {
4807         cm->refresh_golden_frame = 0;
4808         cm->refresh_last_frame = 1;
4809     }
4810
4811 #endif
4812     /* find a free buffer for the new frame */
4813     {
4814         int i = 0;
4815         for(; i < NUM_YV12_BUFFERS; i++)
4816         {
4817             if(!cm->yv12_fb[i].flags)
4818             {
4819                 cm->new_fb_idx = i;
4820                 break;
4821             }
4822         }
4823
4824         assert(i < NUM_YV12_BUFFERS );
4825     }
4826 #if !(CONFIG_REALTIME_ONLY)
4827
4828     if (cpi->pass == 1)
4829     {
4830         Pass1Encode(cpi, size, dest, frame_flags);
4831     }
4832     else if (cpi->pass == 2)
4833     {
4834         Pass2Encode(cpi, size, dest, frame_flags);
4835     }
4836     else
4837 #endif
4838         encode_frame_to_data_rate(cpi, size, dest, frame_flags);
4839
4840     if (cpi->compressor_speed == 2)
4841     {
4842         unsigned int duration, duration2;
4843         vpx_usec_timer_mark(&tsctimer);
4844         vpx_usec_timer_mark(&ticktimer);
4845
4846         duration = vpx_usec_timer_elapsed(&ticktimer);
4847         duration2 = (unsigned int)((double)duration / 2);
4848
4849         if (cm->frame_type != KEY_FRAME)
4850         {
4851             if (cpi->avg_encode_time == 0)
4852                 cpi->avg_encode_time = duration;
4853             else
4854                 cpi->avg_encode_time = (7 * cpi->avg_encode_time + duration) >> 3;
4855         }
4856
4857         if (duration2)
4858         {
4859             //if(*frame_flags!=1)
4860             {
4861
4862                 if (cpi->avg_pick_mode_time == 0)
4863                     cpi->avg_pick_mode_time = duration2;
4864                 else
4865                     cpi->avg_pick_mode_time = (7 * cpi->avg_pick_mode_time + duration2) >> 3;
4866             }
4867         }
4868
4869     }
4870
4871     if (cm->refresh_entropy_probs == 0)
4872     {
4873         vpx_memcpy(&cm->fc, &cm->lfc, sizeof(cm->fc));
4874     }
4875
4876     // if its a dropped frame honor the requests on subsequent frames
4877     if (*size > 0)
4878     {
4879
4880         // return to normal state
4881         cm->refresh_entropy_probs = 1;
4882         cm->refresh_alt_ref_frame = 0;
4883         cm->refresh_golden_frame = 0;
4884         cm->refresh_last_frame = 1;
4885         cm->frame_type = INTER_FRAME;
4886
4887     }
4888
4889     vpx_usec_timer_mark(&cmptimer);
4890     cpi->time_compress_data += vpx_usec_timer_elapsed(&cmptimer);
4891
4892     if (cpi->b_calculate_psnr && cpi->pass != 1 && cm->show_frame)
4893     {
4894         generate_psnr_packet(cpi);
4895     }
4896
4897 #if CONFIG_INTERNAL_STATS
4898
4899     if (cpi->pass != 1)
4900     {
4901         cpi->bytes += *size;
4902
4903         if (cm->show_frame)
4904         {
4905
4906             cpi->count ++;
4907
4908             if (cpi->b_calculate_psnr)
4909             {
4910                 double ye,ue,ve;
4911                 double frame_psnr;
4912                 YV12_BUFFER_CONFIG      *orig = cpi->Source;
4913                 YV12_BUFFER_CONFIG      *recon = cpi->common.frame_to_show;
4914                 YV12_BUFFER_CONFIG      *pp = &cm->post_proc_buffer;
4915                 int y_samples = orig->y_height * orig->y_width ;
4916                 int uv_samples = orig->uv_height * orig->uv_width ;
4917                 int t_samples = y_samples + 2 * uv_samples;
4918                 long long sq_error;
4919
4920                 ye = calc_plane_error(orig->y_buffer, orig->y_stride,
4921                   recon->y_buffer, recon->y_stride, orig->y_width, orig->y_height,
4922                   IF_RTCD(&cpi->rtcd.variance));
4923
4924                 ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
4925                   recon->u_buffer, recon->uv_stride, orig->uv_width, orig->uv_height,
4926                   IF_RTCD(&cpi->rtcd.variance));
4927
4928                 ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
4929                   recon->v_buffer, recon->uv_stride, orig->uv_width, orig->uv_height,
4930                   IF_RTCD(&cpi->rtcd.variance));
4931
4932                 sq_error = ye + ue + ve;
4933
4934                 frame_psnr = vp8_mse2psnr(t_samples, 255.0, sq_error);
4935
4936                 cpi->total_y += vp8_mse2psnr(y_samples, 255.0, ye);
4937                 cpi->total_u += vp8_mse2psnr(uv_samples, 255.0, ue);
4938                 cpi->total_v += vp8_mse2psnr(uv_samples, 255.0, ve);
4939                 cpi->total_sq_error += sq_error;
4940                 cpi->total  += frame_psnr;
4941                 {
4942                     double frame_psnr2, frame_ssim2 = 0;
4943                     double weight = 0;
4944
4945                     vp8_deblock(cm->frame_to_show, &cm->post_proc_buffer, cm->filter_level * 10 / 6, 1, 0, IF_RTCD(&cm->rtcd.postproc));
4946                     vp8_clear_system_state();
4947
4948                     ye = calc_plane_error(orig->y_buffer, orig->y_stride,
4949                       pp->y_buffer, pp->y_stride, orig->y_width, orig->y_height,
4950                       IF_RTCD(&cpi->rtcd.variance));
4951
4952                     ue = calc_plane_error(orig->u_buffer, orig->uv_stride,
4953                       pp->u_buffer, pp->uv_stride, orig->uv_width, orig->uv_height,
4954                       IF_RTCD(&cpi->rtcd.variance));
4955
4956                     ve = calc_plane_error(orig->v_buffer, orig->uv_stride,
4957                       pp->v_buffer, pp->uv_stride, orig->uv_width, orig->uv_height,
4958                       IF_RTCD(&cpi->rtcd.variance));
4959
4960                     sq_error = ye + ue + ve;
4961
4962                     frame_psnr2 = vp8_mse2psnr(t_samples, 255.0, sq_error);
4963
4964                     cpi->totalp_y += vp8_mse2psnr(y_samples, 255.0, ye);
4965                     cpi->totalp_u += vp8_mse2psnr(uv_samples, 255.0, ue);
4966                     cpi->totalp_v += vp8_mse2psnr(uv_samples, 255.0, ve);
4967                     cpi->total_sq_error2 += sq_error;
4968                     cpi->totalp  += frame_psnr2;
4969
4970                     frame_ssim2 = vp8_calc_ssim(cpi->Source,
4971                       &cm->post_proc_buffer, 1, &weight,
4972                       IF_RTCD(&cpi->rtcd.variance));
4973
4974                     cpi->summed_quality += frame_ssim2 * weight;
4975                     cpi->summed_weights += weight;
4976
4977                 }
4978             }
4979
4980             if (cpi->b_calculate_ssimg)
4981             {
4982                 double y, u, v, frame_all;
4983                 frame_all =  vp8_calc_ssimg(cpi->Source, cm->frame_to_show,
4984                     &y, &u, &v, IF_RTCD(&cpi->rtcd.variance));
4985                 cpi->total_ssimg_y += y;
4986                 cpi->total_ssimg_u += u;
4987                 cpi->total_ssimg_v += v;
4988                 cpi->total_ssimg_all += frame_all;
4989             }
4990
4991         }
4992     }
4993
4994 #if 0
4995
4996     if (cpi->common.frame_type != 0 && cpi->common.base_qindex == cpi->oxcf.worst_allowed_q)
4997     {
4998         skiptruecount += cpi->skip_true_count;
4999         skipfalsecount += cpi->skip_false_count;
5000     }
5001
5002 #endif
5003 #if 0
5004
5005     if (cpi->pass != 1)
5006     {
5007         FILE *f = fopen("skip.stt", "a");
5008         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);
5009
5010         if (cpi->is_src_frame_alt_ref == 1)
5011             fprintf(f, "skipcount: %4d framesize: %d\n", cpi->skip_true_count , *size);
5012
5013         fclose(f);
5014     }
5015
5016 #endif
5017 #endif
5018
5019 #if HAVE_ARMV7
5020 #if CONFIG_RUNTIME_CPU_DETECT
5021     if (cm->rtcd.flags & HAS_NEON)
5022 #endif
5023     {
5024         vp8_pop_neon(store_reg);
5025     }
5026 #endif
5027
5028     return 0;
5029 }
5030
5031 int vp8_get_preview_raw_frame(VP8_PTR comp, YV12_BUFFER_CONFIG *dest, vp8_ppflags_t *flags)
5032 {
5033     VP8_COMP *cpi = (VP8_COMP *) comp;
5034
5035     if (cpi->common.refresh_alt_ref_frame)
5036         return -1;
5037     else
5038     {
5039         int ret;
5040 #if CONFIG_POSTPROC
5041         ret = vp8_post_proc_frame(&cpi->common, dest, flags);
5042 #else
5043
5044         if (cpi->common.frame_to_show)
5045         {
5046             *dest = *cpi->common.frame_to_show;
5047             dest->y_width = cpi->common.Width;
5048             dest->y_height = cpi->common.Height;
5049             dest->uv_height = cpi->common.Height / 2;
5050             ret = 0;
5051         }
5052         else
5053         {
5054             ret = -1;
5055         }
5056
5057 #endif //!CONFIG_POSTPROC
5058         vp8_clear_system_state();
5059         return ret;
5060     }
5061 }
5062
5063 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])
5064 {
5065     VP8_COMP *cpi = (VP8_COMP *) comp;
5066     signed char feature_data[MB_LVL_MAX][MAX_MB_SEGMENTS];
5067
5068     if (cpi->common.mb_rows != rows || cpi->common.mb_cols != cols)
5069         return -1;
5070
5071     if (!map)
5072     {
5073         disable_segmentation((VP8_PTR)cpi);
5074         return 0;
5075     }
5076
5077     // Set the segmentation Map
5078     set_segmentation_map((VP8_PTR)cpi, map);
5079
5080     // Activate segmentation.
5081     enable_segmentation((VP8_PTR)cpi);
5082
5083     // Set up the quant segment data
5084     feature_data[MB_LVL_ALT_Q][0] = delta_q[0];
5085     feature_data[MB_LVL_ALT_Q][1] = delta_q[1];
5086     feature_data[MB_LVL_ALT_Q][2] = delta_q[2];
5087     feature_data[MB_LVL_ALT_Q][3] = delta_q[3];
5088
5089     // Set up the loop segment data s
5090     feature_data[MB_LVL_ALT_LF][0] = delta_lf[0];
5091     feature_data[MB_LVL_ALT_LF][1] = delta_lf[1];
5092     feature_data[MB_LVL_ALT_LF][2] = delta_lf[2];
5093     feature_data[MB_LVL_ALT_LF][3] = delta_lf[3];
5094
5095     cpi->segment_encode_breakout[0] = threshold[0];
5096     cpi->segment_encode_breakout[1] = threshold[1];
5097     cpi->segment_encode_breakout[2] = threshold[2];
5098     cpi->segment_encode_breakout[3] = threshold[3];
5099
5100     // Initialise the feature data structure
5101     // SEGMENT_DELTADATA    0, SEGMENT_ABSDATA      1
5102     set_segment_data((VP8_PTR)cpi, &feature_data[0][0], SEGMENT_DELTADATA);
5103
5104     return 0;
5105 }
5106
5107 int vp8_set_active_map(VP8_PTR comp, unsigned char *map, unsigned int rows, unsigned int cols)
5108 {
5109     VP8_COMP *cpi = (VP8_COMP *) comp;
5110
5111     if (rows == cpi->common.mb_rows && cols == cpi->common.mb_cols)
5112     {
5113         if (map)
5114         {
5115             vpx_memcpy(cpi->active_map, map, rows * cols);
5116             cpi->active_map_enabled = 1;
5117         }
5118         else
5119             cpi->active_map_enabled = 0;
5120
5121         return 0;
5122     }
5123     else
5124     {
5125         //cpi->active_map_enabled = 0;
5126         return -1 ;
5127     }
5128 }
5129
5130 int vp8_set_internal_size(VP8_PTR comp, VPX_SCALING horiz_mode, VPX_SCALING vert_mode)
5131 {
5132     VP8_COMP *cpi = (VP8_COMP *) comp;
5133
5134     if (horiz_mode <= ONETWO)
5135         cpi->common.horiz_scale = horiz_mode;
5136     else
5137         return -1;
5138
5139     if (vert_mode <= ONETWO)
5140         cpi->common.vert_scale  = vert_mode;
5141     else
5142         return -1;
5143
5144     return 0;
5145 }
5146
5147
5148
5149 int vp8_calc_ss_err(YV12_BUFFER_CONFIG *source, YV12_BUFFER_CONFIG *dest, const vp8_variance_rtcd_vtable_t *rtcd)
5150 {
5151     int i, j;
5152     int Total = 0;
5153
5154     unsigned char *src = source->y_buffer;
5155     unsigned char *dst = dest->y_buffer;
5156     (void)rtcd;
5157
5158     // Loop through the Y plane raw and reconstruction data summing (square differences)
5159     for (i = 0; i < source->y_height; i += 16)
5160     {
5161         for (j = 0; j < source->y_width; j += 16)
5162         {
5163             unsigned int sse;
5164             Total += VARIANCE_INVOKE(rtcd, mse16x16)(src + j, source->y_stride, dst + j, dest->y_stride, &sse);
5165         }
5166
5167         src += 16 * source->y_stride;
5168         dst += 16 * dest->y_stride;
5169     }
5170
5171     return Total;
5172 }
5173
5174
5175 int vp8_get_quantizer(VP8_PTR c)
5176 {
5177     VP8_COMP   *cpi = (VP8_COMP *) c;
5178     return cpi->common.base_qindex;
5179 }