vp8/encoder/onyx_if.c

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