vp8/encoder/encodeframe.c

   1 /*
   2  *  Copyright (c) 2010 The VP8 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 "vpx_ports/config.h"
  13 #include "encodemb.h"
  14 #include "encodemv.h"
  15 #include "common.h"
  16 #include "onyx_int.h"
  17 #include "extend.h"
  18 #include "entropymode.h"
  19 #include "quant_common.h"
  20 #include "segmentation_common.h"
  21 #include "setupintrarecon.h"
  22 #include "encodeintra.h"
  23 #include "reconinter.h"
  24 #include "rdopt.h"
  25 #include "pickinter.h"
  26 #include "findnearmv.h"
  27 #include "reconintra.h"
  28 #include <stdio.h>
  29 #include <limits.h>
  30 #include "subpixel.h"
  31 #include "vpx_ports/vpx_timer.h"
  32
  33 #if CONFIG_RUNTIME_CPU_DETECT
  34 #define RTCD(x)     &cpi->common.rtcd.x
  35 #define IF_RTCD(x)  (x)
  36 #else
  37 #define RTCD(x)     NULL
  38 #define IF_RTCD(x)  NULL
  39 #endif
  40 extern void vp8_stuff_mb(VP8_COMP *cpi, MACROBLOCKD *x, TOKENEXTRA **t) ;
  41
  42 extern void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex);
  43 extern void vp8_auto_select_speed(VP8_COMP *cpi);
  44 extern void vp8cx_init_mbrthread_data(VP8_COMP *cpi,
  45                                       MACROBLOCK *x,
  46                                       MB_ROW_COMP *mbr_ei,
  47                                       int mb_row,
  48                                       int count);
  49 void vp8_build_block_offsets(MACROBLOCK *x);
  50 void vp8_setup_block_ptrs(MACROBLOCK *x);
  51 int vp8cx_encode_inter_macroblock(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t, int recon_yoffset, int recon_uvoffset);
  52 int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t);
  53
  54 #ifdef MODE_STATS
  55 unsigned int inter_y_modes[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  56 unsigned int inter_uv_modes[4] = {0, 0, 0, 0};
  57 unsigned int inter_b_modes[15]  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  58 unsigned int y_modes[5]   = {0, 0, 0, 0, 0};
  59 unsigned int uv_modes[4]  = {0, 0, 0, 0};
  60 unsigned int b_modes[14]  = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
  61 #endif
  62
  63 // The first four entries are dummy values
  64 static const int qrounding_factors[129] =
  65 {
  66     56, 56, 56, 56, 56, 56, 56, 56,
  67     48, 48, 48, 48, 48, 48, 48, 48,
  68     48, 48, 48, 48, 48, 48, 48, 48,
  69     48, 48, 48, 48, 48, 48, 48, 48,
  70     48, 48, 48, 48, 48, 48, 48, 48,
  71     48, 48, 48, 48, 48, 48, 48, 48,
  72     48, 48, 48, 48, 48, 48, 48, 48,
  73     48, 48, 48, 48, 48, 48, 48, 48,
  74     48, 48, 48, 48, 48, 48, 48, 48,
  75     48, 48, 48, 48, 48, 48, 48, 48,
  76     48, 48, 48, 48, 48, 48, 48, 48,
  77     48, 48, 48, 48, 48, 48, 48, 48,
  78     48, 48, 48, 48, 48, 48, 48, 48,
  79     48, 48, 48, 48, 48, 48, 48, 48,
  80     48, 48, 48, 48, 48, 48, 48, 48,
  81     48, 48, 48, 48, 48, 48, 48, 48,
  82     48,
  83 };
  84
  85 static const int qzbin_factors[129] =
  86 {
  87     64, 64, 64, 64, 80, 80, 80, 80,
  88     80, 80, 80, 80, 80, 80, 80, 80,
  89     80, 80, 80, 80, 80, 80, 80, 80,
  90     80, 80, 80, 80, 80, 80, 80, 80,
  91     80, 80, 80, 80, 80, 80, 80, 80,
  92     80, 80, 80, 80, 80, 80, 80, 80,
  93     80, 80, 80, 80, 80, 80, 80, 80,
  94     80, 80, 80, 80, 80, 80, 80, 80,
  95     80, 80, 80, 80, 80, 80, 80, 80,
  96     80, 80, 80, 80, 80, 80, 80, 80,
  97     80, 80, 80, 80, 80, 80, 80, 80,
  98     80, 80, 80, 80, 80, 80, 80, 80,
  99     80, 80, 80, 80, 80, 80, 80, 80,
 100     80, 80, 80, 80, 80, 80, 80, 80,
 101     80, 80, 80, 80, 80, 80, 80, 80,
 102     80, 80, 80, 80, 80, 80, 80, 80,
 103     80,
 104 };
 105
 106 void vp8cx_init_quantizer(VP8_COMP *cpi)
 107 {
 108     int r, c;
 109     int i;
 110     int quant_val;
 111     int Q;
 112
 113     int zbin_boost[16] = {0, 0, 8, 10, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44, 44, 44};
 114
 115     for (Q = 0; Q < QINDEX_RANGE; Q++)
 116     {
 117         // dc values
 118         quant_val = vp8_dc_quant(Q, cpi->common.y1dc_delta_q);
 119         cpi->Y1quant[Q][0][0] = (1 << 16) / quant_val;
 120         cpi->Y1zbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
 121         cpi->Y1round[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;
 122         cpi->common.Y1dequant[Q][0][0] = quant_val;
 123         cpi->zrun_zbin_boost_y1[Q][0] = (quant_val * zbin_boost[0]) >> 7;
 124
 125         quant_val = vp8_dc2quant(Q, cpi->common.y2dc_delta_q);
 126         cpi->Y2quant[Q][0][0] = (1 << 16) / quant_val;
 127         cpi->Y2zbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
 128         cpi->Y2round[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;
 129         cpi->common.Y2dequant[Q][0][0] = quant_val;
 130         cpi->zrun_zbin_boost_y2[Q][0] = (quant_val * zbin_boost[0]) >> 7;
 131
 132         quant_val = vp8_dc_uv_quant(Q, cpi->common.uvdc_delta_q);
 133         cpi->UVquant[Q][0][0] = (1 << 16) / quant_val;
 134         cpi->UVzbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;;
 135         cpi->UVround[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;
 136         cpi->common.UVdequant[Q][0][0] = quant_val;
 137         cpi->zrun_zbin_boost_uv[Q][0] = (quant_val * zbin_boost[0]) >> 7;
 138
 139         // all the ac values = ;
 140         for (i = 1; i < 16; i++)
 141         {
 142             int rc = vp8_default_zig_zag1d[i];
 143             r = (rc >> 2);
 144             c = (rc & 3);
 145
 146             quant_val = vp8_ac_yquant(Q);
 147             cpi->Y1quant[Q][r][c] = (1 << 16) / quant_val;
 148             cpi->Y1zbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
 149             cpi->Y1round[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;
 150             cpi->common.Y1dequant[Q][r][c] = quant_val;
 151             cpi->zrun_zbin_boost_y1[Q][i] = (quant_val * zbin_boost[i]) >> 7;
 152
 153             quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q);
 154             cpi->Y2quant[Q][r][c] = (1 << 16) / quant_val;
 155             cpi->Y2zbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
 156             cpi->Y2round[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;
 157             cpi->common.Y2dequant[Q][r][c] = quant_val;
 158             cpi->zrun_zbin_boost_y2[Q][i] = (quant_val * zbin_boost[i]) >> 7;
 159
 160             quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q);
 161             cpi->UVquant[Q][r][c] = (1 << 16) / quant_val;
 162             cpi->UVzbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
 163             cpi->UVround[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;
 164             cpi->common.UVdequant[Q][r][c] = quant_val;
 165             cpi->zrun_zbin_boost_uv[Q][i] = (quant_val * zbin_boost[i]) >> 7;
 166         }
 167     }
 168 }
 169
 170 void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x)
 171 {
 172     int i;
 173     int QIndex;
 174     MACROBLOCKD *xd = &x->e_mbd;
 175     MB_MODE_INFO *mbmi = &xd->mbmi;
 176     int zbin_extra;
 177
 178     // Select the baseline MB Q index.
 179     if (xd->segmentation_enabled)
 180     {
 181         // Abs Value
 182         if (xd->mb_segement_abs_delta == SEGMENT_ABSDATA)
 183             QIndex = xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];
 184
 185         // Delta Value
 186         else
 187         {
 188             QIndex = cpi->common.base_qindex + xd->segment_feature_data[MB_LVL_ALT_Q][mbmi->segment_id];
 189             QIndex = (QIndex >= 0) ? ((QIndex <= MAXQ) ? QIndex : MAXQ) : 0;    // Clamp to valid range
 190         }
 191     }
 192     else
 193         QIndex = cpi->common.base_qindex;
 194
 195     // Y
 196     zbin_extra = (cpi->common.Y1dequant[QIndex][0][1] * (cpi->zbin_over_quant + cpi->zbin_mode_boost)) >> 7;
 197
 198     for (i = 0; i < 16; i++)
 199     {
 200         x->block[i].quant = cpi->Y1quant[QIndex];
 201         x->block[i].zbin = cpi->Y1zbin[QIndex];
 202         x->block[i].round = cpi->Y1round[QIndex];
 203         x->e_mbd.block[i].dequant = cpi->common.Y1dequant[QIndex];
 204         x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_y1[QIndex];
 205         x->block[i].zbin_extra = (short)zbin_extra;
 206     }
 207
 208     // UV
 209     zbin_extra = (cpi->common.UVdequant[QIndex][0][1] * (cpi->zbin_over_quant + cpi->zbin_mode_boost)) >> 7;
 210
 211     for (i = 16; i < 24; i++)
 212     {
 213         x->block[i].quant = cpi->UVquant[QIndex];
 214         x->block[i].zbin = cpi->UVzbin[QIndex];
 215         x->block[i].round = cpi->UVround[QIndex];
 216         x->e_mbd.block[i].dequant = cpi->common.UVdequant[QIndex];
 217         x->block[i].zrun_zbin_boost = cpi->zrun_zbin_boost_uv[QIndex];
 218         x->block[i].zbin_extra = (short)zbin_extra;
 219     }
 220
 221     // Y2
 222     zbin_extra = (cpi->common.Y2dequant[QIndex][0][1] * ((cpi->zbin_over_quant / 2) + cpi->zbin_mode_boost)) >> 7;
 223     x->block[24].quant = cpi->Y2quant[QIndex];
 224     x->block[24].zbin = cpi->Y2zbin[QIndex];
 225     x->block[24].round = cpi->Y2round[QIndex];
 226     x->e_mbd.block[24].dequant = cpi->common.Y2dequant[QIndex];
 227     x->block[24].zrun_zbin_boost = cpi->zrun_zbin_boost_y2[QIndex];
 228     x->block[24].zbin_extra = (short)zbin_extra;
 229 }
 230
 231 void vp8cx_frame_init_quantizer(VP8_COMP *cpi)
 232 {
 233     // vp8cx_init_quantizer() is first called in vp8_create_compressor(). A check is added here so that vp8cx_init_quantizer() is only called
 234     // when these values are not all zero.
 235     if (cpi->common.y1dc_delta_q | cpi->common.y2dc_delta_q | cpi->common.uvdc_delta_q | cpi->common.y2ac_delta_q | cpi->common.uvac_delta_q)
 236     {
 237         vp8cx_init_quantizer(cpi);
 238     }
 239
 240     // MB level quantizer setup
 241     vp8cx_mb_init_quantizer(cpi, &cpi->mb);
 242 }
 243
 244
 245
 246 static
 247 void encode_mb_row(VP8_COMP *cpi,
 248                    VP8_COMMON *cm,
 249                    int mb_row,
 250                    MACROBLOCK  *x,
 251                    MACROBLOCKD *xd,
 252                    TOKENEXTRA **tp,
 253                    int *segment_counts,
 254                    int *totalrate)
 255 {
 256     int i;
 257     int recon_yoffset, recon_uvoffset;
 258     int mb_col;
 259     int recon_y_stride = cm->last_frame.y_stride;
 260     int recon_uv_stride = cm->last_frame.uv_stride;
 261     int seg_map_index = (mb_row * cpi->common.mb_cols);
 262
 263
 264     // reset above block coeffs
 265     xd->above_context[Y1CONTEXT] = cm->above_context[Y1CONTEXT];
 266     xd->above_context[UCONTEXT ] = cm->above_context[UCONTEXT ];
 267     xd->above_context[VCONTEXT ] = cm->above_context[VCONTEXT ];
 268     xd->above_context[Y2CONTEXT] = cm->above_context[Y2CONTEXT];
 269
 270     xd->up_available = (mb_row != 0);
 271     recon_yoffset = (mb_row * recon_y_stride * 16);
 272     recon_uvoffset = (mb_row * recon_uv_stride * 8);
 273
 274     cpi->tplist[mb_row].start = *tp;
 275     //printf("Main mb_row = %d\n", mb_row);
 276
 277     // for each macroblock col in image
 278     for (mb_col = 0; mb_col < cm->mb_cols; mb_col++)
 279     {
 280         // Distance of Mb to the various image edges.
 281         // These specified to 8th pel as they are always compared to values that are in 1/8th pel units
 282         xd->mb_to_left_edge = -((mb_col * 16) << 3);
 283         xd->mb_to_right_edge = ((cm->mb_cols - 1 - mb_col) * 16) << 3;
 284         xd->mb_to_top_edge = -((mb_row * 16) << 3);
 285         xd->mb_to_bottom_edge = ((cm->mb_rows - 1 - mb_row) * 16) << 3;
 286
 287         // Set up limit values for motion vectors used to prevent them extending outside the UMV borders
 288         x->mv_col_min = -((mb_col * 16) + (VP8BORDERINPIXELS - 16));
 289         x->mv_col_max = ((cm->mb_cols - 1 - mb_col) * 16) + (VP8BORDERINPIXELS - 16);
 290         x->mv_row_min = -((mb_row * 16) + (VP8BORDERINPIXELS - 16));
 291         x->mv_row_max = ((cm->mb_rows - 1 - mb_row) * 16) + (VP8BORDERINPIXELS - 16);
 292
 293         xd->dst.y_buffer = cm->new_frame.y_buffer + recon_yoffset;
 294         xd->dst.u_buffer = cm->new_frame.u_buffer + recon_uvoffset;
 295         xd->dst.v_buffer = cm->new_frame.v_buffer + recon_uvoffset;
 296         xd->left_available = (mb_col != 0);
 297
 298         // Is segmentation enabled
 299         // MB level adjutment to quantizer
 300         if (xd->segmentation_enabled)
 301         {
 302             // Code to set segment id in xd->mbmi.segment_id for current MB (with range checking)
 303             if (cpi->segmentation_map[seg_map_index+mb_col] <= 3)
 304                 xd->mbmi.segment_id = cpi->segmentation_map[seg_map_index+mb_col];
 305             else
 306                 xd->mbmi.segment_id = 0;
 307
 308             vp8cx_mb_init_quantizer(cpi, x);
 309         }
 310         else
 311             xd->mbmi.segment_id = 0;         // Set to Segment 0 by default
 312
 313         x->active_ptr = cpi->active_map + seg_map_index + mb_col;
 314
 315         if (cm->frame_type == KEY_FRAME)
 316         {
 317             *totalrate += vp8cx_encode_intra_macro_block(cpi, x, tp);
 318 #ifdef MODE_STATS
 319             y_modes[xd->mbmi.mode] ++;
 320 #endif
 321         }
 322         else
 323         {
 324             *totalrate += vp8cx_encode_inter_macroblock(cpi, x, tp, recon_yoffset, recon_uvoffset);
 325
 326 #ifdef MODE_STATS
 327             inter_y_modes[xd->mbmi.mode] ++;
 328
 329             if (xd->mbmi.mode == SPLITMV)
 330             {
 331                 int b;
 332
 333                 for (b = 0; b < xd->mbmi.partition_count; b++)
 334                 {
 335                     inter_b_modes[xd->mbmi.partition_bmi[b].mode] ++;
 336                 }
 337             }
 338
 339 #endif
 340
 341             // Count of last ref frame 0,0 useage
 342             if ((xd->mbmi.mode == ZEROMV) && (xd->mbmi.ref_frame == LAST_FRAME))
 343                 cpi->inter_zz_count ++;
 344
 345             // Special case code for cyclic refresh
 346             // If cyclic update enabled then copy xd->mbmi.segment_id; (which may have been updated based on mode
 347             // during vp8cx_encode_inter_macroblock()) back into the global sgmentation map
 348             if (cpi->cyclic_refresh_mode_enabled && xd->segmentation_enabled)
 349             {
 350                 cpi->segmentation_map[seg_map_index+mb_col] = xd->mbmi.segment_id;
 351
 352                 // If the block has been refreshed mark it as clean (the magnitude of the -ve influences how long it will be before we consider another refresh):
 353                 // Else if it was coded (last frame 0,0) and has not already been refreshed then mark it as a candidate for cleanup next time (marked 0)
 354                 // else mark it as dirty (1).
 355                 if (xd->mbmi.segment_id)
 356                     cpi->cyclic_refresh_map[seg_map_index+mb_col] = -1;
 357                 else if ((xd->mbmi.mode == ZEROMV) && (xd->mbmi.ref_frame == LAST_FRAME))
 358                 {
 359                     if (cpi->cyclic_refresh_map[seg_map_index+mb_col] == 1)
 360                         cpi->cyclic_refresh_map[seg_map_index+mb_col] = 0;
 361                 }
 362                 else
 363                     cpi->cyclic_refresh_map[seg_map_index+mb_col] = 1;
 364
 365             }
 366         }
 367
 368         cpi->tplist[mb_row].stop = *tp;
 369
 370         xd->gf_active_ptr++;      // Increment pointer into gf useage flags structure for next mb
 371
 372         // store macroblock mode info into context array
 373         vpx_memcpy(&xd->mode_info_context->mbmi, &xd->mbmi, sizeof(xd->mbmi));
 374
 375         for (i = 0; i < 16; i++)
 376             vpx_memcpy(&xd->mode_info_context->bmi[i], &xd->block[i].bmi, sizeof(xd->block[i].bmi));
 377
 378         // adjust to the next column of macroblocks
 379         x->src.y_buffer += 16;
 380         x->src.u_buffer += 8;
 381         x->src.v_buffer += 8;
 382
 383         recon_yoffset += 16;
 384         recon_uvoffset += 8;
 385
 386         // Keep track of segment useage
 387         segment_counts[xd->mbmi.segment_id] ++;
 388
 389         // skip to next mb
 390         xd->mode_info_context++;
 391
 392         xd->above_context[Y1CONTEXT] += 4;
 393         xd->above_context[UCONTEXT ] += 2;
 394         xd->above_context[VCONTEXT ] += 2;
 395         xd->above_context[Y2CONTEXT] ++;
 396         cpi->current_mb_col_main = mb_col;
 397     }
 398
 399     //extend the recon for intra prediction
 400     vp8_extend_mb_row(
 401         &cm->new_frame,
 402         xd->dst.y_buffer + 16,
 403         xd->dst.u_buffer + 8,
 404         xd->dst.v_buffer + 8);
 405
 406     // this is to account for the border
 407     xd->mode_info_context++;
 408 }
 409
 410
 411
 412
 413
 414 void vp8_encode_frame(VP8_COMP *cpi)
 415 {
 416     int mb_row;
 417     MACROBLOCK *const x = & cpi->mb;
 418     VP8_COMMON *const cm = & cpi->common;
 419     MACROBLOCKD *const xd = & x->e_mbd;
 420
 421     int i;
 422     TOKENEXTRA *tp = cpi->tok;
 423     int segment_counts[MAX_MB_SEGMENTS];
 424     int totalrate;
 425
 426     if (cm->frame_type != KEY_FRAME)
 427     {
 428         if (cm->mcomp_filter_type == SIXTAP)
 429         {
 430             xd->subpixel_predict     = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, sixtap4x4);
 431             xd->subpixel_predict8x4      = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, sixtap8x4);
 432             xd->subpixel_predict8x8      = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, sixtap8x8);
 433             xd->subpixel_predict16x16    = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, sixtap16x16);
 434         }
 435         else
 436         {
 437             xd->subpixel_predict     = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, bilinear4x4);
 438             xd->subpixel_predict8x4      = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, bilinear8x4);
 439             xd->subpixel_predict8x8      = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, bilinear8x8);
 440             xd->subpixel_predict16x16    = SUBPIX_INVOKE(&cpi->common.rtcd.subpix, bilinear16x16);
 441         }
 442     }
 443
 444     //else  // Key Frame
 445     //{
 446     // For key frames make sure the intra ref frame probability value
 447     // is set to "all intra"
 448     //cpi->prob_intra_coded = 255;
 449     //}
 450
 451
 452     xd->gf_active_ptr = (signed char *)cm->gf_active_flags;     // Point to base of GF active flags data structure
 453
 454     x->vector_range = 32;
 455
 456     // Count of MBs using the alternate Q if any
 457     cpi->alt_qcount = 0;
 458
 459     // Reset frame count of inter 0,0 motion vector useage.
 460     cpi->inter_zz_count = 0;
 461
 462     vpx_memset(segment_counts, 0, sizeof(segment_counts));
 463
 464     cpi->prediction_error = 0;
 465     cpi->intra_error = 0;
 466     cpi->skip_true_count = 0;
 467     cpi->skip_false_count = 0;
 468
 469 #if 0
 470     // Experimental code
 471     cpi->frame_distortion = 0;
 472     cpi->last_mb_distortion = 0;
 473 #endif
 474
 475     totalrate = 0;
 476
 477     xd->mode_info = cm->mi - 1;
 478
 479     xd->mode_info_context = cm->mi;
 480     xd->mode_info_stride = cm->mode_info_stride;
 481
 482     xd->frame_type = cm->frame_type;
 483
 484     xd->frames_since_golden = cm->frames_since_golden;
 485     xd->frames_till_alt_ref_frame = cm->frames_till_alt_ref_frame;
 486     vp8_zero(cpi->MVcount);
 487     // vp8_zero( Contexts)
 488     vp8_zero(cpi->coef_counts);
 489
 490     // reset intra mode contexts
 491     if (cm->frame_type == KEY_FRAME)
 492         vp8_init_mbmode_probs(cm);
 493
 494
 495     vp8cx_frame_init_quantizer(cpi);
 496
 497     if (cpi->compressor_speed == 2)
 498     {
 499         if (cpi->oxcf.cpu_used < 0)
 500             cpi->Speed = -(cpi->oxcf.cpu_used);
 501         else
 502             vp8_auto_select_speed(cpi);
 503     }
 504
 505     vp8_initialize_rd_consts(cpi, vp8_dc_quant(cm->base_qindex, cm->y1dc_delta_q));
 506     //vp8_initialize_rd_consts( cpi, vp8_dc_quant(cpi->avg_frame_qindex, cm->y1dc_delta_q) );
 507     vp8cx_initialize_me_consts(cpi, cm->base_qindex);
 508     //vp8cx_initialize_me_consts( cpi, cpi->avg_frame_qindex);
 509
 510     // Copy data over into macro block data sturctures.
 511
 512     x->src = * cpi->Source;
 513     xd->pre = cm->last_frame;
 514     xd->dst = cm->new_frame;
 515
 516     // set up frame new frame for intra coded blocks
 517
 518     vp8_setup_intra_recon(&cm->new_frame);
 519
 520     vp8_build_block_offsets(x);
 521
 522     vp8_setup_block_dptrs(&x->e_mbd);
 523
 524     vp8_setup_block_ptrs(x);
 525
 526     x->rddiv = cpi->RDDIV;
 527     x->rdmult = cpi->RDMULT;
 528
 529 #if 0
 530     // Experimental rd code
 531     // 2 Pass - Possibly set Rdmult based on last frame distortion + this frame target bits or other metrics
 532     // such as cpi->rate_correction_factor that indicate relative complexity.
 533     /*if ( cpi->pass == 2 && (cpi->last_frame_distortion > 0) && (cpi->target_bits_per_mb > 0) )
 534     {
 535         //x->rdmult = ((cpi->last_frame_distortion * 256)/cpi->common.MBs)/ cpi->target_bits_per_mb;
 536         x->rdmult = (int)(cpi->RDMULT * cpi->rate_correction_factor);
 537     }
 538     else
 539         x->rdmult = cpi->RDMULT; */
 540     //x->rdmult = (int)(cpi->RDMULT * pow( (cpi->rate_correction_factor * 2.0), 0.75 ));
 541 #endif
 542
 543     xd->mbmi.mode = DC_PRED;
 544     xd->mbmi.uv_mode = DC_PRED;
 545
 546     xd->left_context = cm->left_context;
 547
 548     vp8_zero(cpi->count_mb_ref_frame_usage)
 549     vp8_zero(cpi->ymode_count)
 550     vp8_zero(cpi->uv_mode_count)
 551
 552     x->mvc = cm->fc.mvc;
 553
 554     // vp8_zero( entropy_stats)
 555     {
 556         ENTROPY_CONTEXT **p = cm->above_context;
 557         const size_t L = cm->mb_cols;
 558
 559         vp8_zero_array(p [Y1CONTEXT], L * 4)
 560         vp8_zero_array(p [ UCONTEXT], L * 2)
 561         vp8_zero_array(p [ VCONTEXT], L * 2)
 562         vp8_zero_array(p [Y2CONTEXT], L)
 563     }
 564
 565
 566     {
 567         struct vpx_usec_timer  emr_timer;
 568         vpx_usec_timer_start(&emr_timer);
 569
 570         if (!cpi->b_multi_threaded)
 571         {
 572             // for each macroblock row in image
 573             for (mb_row = 0; mb_row < cm->mb_rows; mb_row++)
 574             {
 575
 576                 vp8_zero(cm->left_context)
 577
 578                 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
 579
 580                 // adjust to the next row of mbs
 581                 x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
 582                 x->src.u_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
 583                 x->src.v_buffer += 8 * x->src.uv_stride - 8 * cm->mb_cols;
 584             }
 585
 586             cpi->tok_count = tp - cpi->tok;
 587
 588         }
 589         else
 590         {
 591 #if CONFIG_MULTITHREAD
 592             vp8cx_init_mbrthread_data(cpi, x, cpi->mb_row_ei, 1,  cpi->encoding_thread_count);
 593
 594             for (mb_row = 0; mb_row < cm->mb_rows; mb_row += (cpi->encoding_thread_count + 1))
 595             {
 596                 int i;
 597                 cpi->current_mb_col_main = -1;
 598
 599                 for (i = 0; i < cpi->encoding_thread_count; i++)
 600                 {
 601                     if ((mb_row + i + 1) >= cm->mb_rows)
 602                         break;
 603
 604                     cpi->mb_row_ei[i].mb_row = mb_row + i + 1;
 605                     cpi->mb_row_ei[i].tp  = cpi->tok + (mb_row + i + 1) * (cm->mb_cols * 16 * 24);
 606                     cpi->mb_row_ei[i].current_mb_col = -1;
 607                     //SetEvent(cpi->h_event_mbrencoding[i]);
 608                     sem_post(&cpi->h_event_mbrencoding[i]);
 609                 }
 610
 611                 vp8_zero(cm->left_context)
 612
 613                 tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);
 614
 615                 encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
 616
 617                 // adjust to the next row of mbs
 618                 x->src.y_buffer += 16 * x->src.y_stride * (cpi->encoding_thread_count + 1) - 16 * cm->mb_cols;
 619                 x->src.u_buffer +=  8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
 620                 x->src.v_buffer +=  8 * x->src.uv_stride * (cpi->encoding_thread_count + 1) - 8 * cm->mb_cols;
 621
 622                 xd->mode_info_context += xd->mode_info_stride * cpi->encoding_thread_count;
 623
 624                 if (mb_row < cm->mb_rows - 1)
 625                     //WaitForSingleObject(cpi->h_event_main, INFINITE);
 626                     sem_wait(&cpi->h_event_main);
 627             }
 628
 629             /*
 630             for( ;mb_row<cm->mb_rows; mb_row ++)
 631             {
 632             vp8_zero( cm->left_context)
 633
 634             tp = cpi->tok + mb_row * (cm->mb_cols * 16 * 24);
 635
 636             encode_mb_row(cpi, cm, mb_row, x, xd, &tp, segment_counts, &totalrate);
 637             // adjust to the next row of mbs
 638             x->src.y_buffer += 16 * x->src.y_stride - 16 * cm->mb_cols;
 639             x->src.u_buffer +=  8 * x->src.uv_stride - 8 * cm->mb_cols;
 640             x->src.v_buffer +=  8 * x->src.uv_stride - 8 * cm->mb_cols;
 641
 642             }
 643             */
 644             cpi->tok_count = 0;
 645
 646             for (mb_row = 0; mb_row < cm->mb_rows; mb_row ++)
 647             {
 648                 cpi->tok_count += cpi->tplist[mb_row].stop - cpi->tplist[mb_row].start;
 649             }
 650
 651             if (xd->segmentation_enabled)
 652             {
 653
 654                 int i, j;
 655
 656                 if (xd->segmentation_enabled)
 657                 {
 658
 659                     for (i = 0; i < cpi->encoding_thread_count; i++)
 660                     {
 661                         for (j = 0; j < 4; j++)
 662                             segment_counts[j] += cpi->mb_row_ei[i].segment_counts[j];
 663                     }
 664                 }
 665
 666             }
 667
 668             for (i = 0; i < cpi->encoding_thread_count; i++)
 669             {
 670                 totalrate += cpi->mb_row_ei[i].totalrate;
 671             }
 672
 673 #endif
 674
 675         }
 676
 677         vpx_usec_timer_mark(&emr_timer);
 678         cpi->time_encode_mb_row += vpx_usec_timer_elapsed(&emr_timer);
 679
 680     }
 681
 682
 683     // Work out the segment probabilites if segmentation is enabled
 684     if (xd->segmentation_enabled)
 685     {
 686         int tot_count;
 687         int i;
 688
 689         // Set to defaults
 690         vpx_memset(xd->mb_segment_tree_probs, 255 , sizeof(xd->mb_segment_tree_probs));
 691
 692         tot_count = segment_counts[0] + segment_counts[1] + segment_counts[2] + segment_counts[3];
 693
 694         if (tot_count)
 695         {
 696             xd->mb_segment_tree_probs[0] = ((segment_counts[0] + segment_counts[1]) * 255) / tot_count;
 697
 698             tot_count = segment_counts[0] + segment_counts[1];
 699
 700             if (tot_count > 0)
 701             {
 702                 xd->mb_segment_tree_probs[1] = (segment_counts[0] * 255) / tot_count;
 703             }
 704
 705             tot_count = segment_counts[2] + segment_counts[3];
 706
 707             if (tot_count > 0)
 708                 xd->mb_segment_tree_probs[2] = (segment_counts[2] * 255) / tot_count;
 709
 710             // Zero probabilities not allowed
 711             for (i = 0; i < MB_FEATURE_TREE_PROBS; i ++)
 712             {
 713                 if (xd->mb_segment_tree_probs[i] == 0)
 714                     xd->mb_segment_tree_probs[i] = 1;
 715             }
 716         }
 717     }
 718
 719     // 256 rate units to the bit
 720     cpi->projected_frame_size = totalrate >> 8;   // projected_frame_size in units of BYTES
 721
 722     // Make a note of the percentage MBs coded Intra.
 723     if (cm->frame_type == KEY_FRAME)
 724     {
 725         cpi->this_frame_percent_intra = 100;
 726     }
 727     else
 728     {
 729         int tot_modes;
 730
 731         tot_modes = cpi->count_mb_ref_frame_usage[INTRA_FRAME]
 732                     + cpi->count_mb_ref_frame_usage[LAST_FRAME]
 733                     + cpi->count_mb_ref_frame_usage[GOLDEN_FRAME]
 734                     + cpi->count_mb_ref_frame_usage[ALTREF_FRAME];
 735
 736         if (tot_modes)
 737             cpi->this_frame_percent_intra = cpi->count_mb_ref_frame_usage[INTRA_FRAME] * 100 / tot_modes;
 738
 739     }
 740
 741 #if 0
 742     {
 743         int cnt = 0;
 744         int flag[2] = {0, 0};
 745
 746         for (cnt = 0; cnt < MVPcount; cnt++)
 747         {
 748             if (cm->fc.pre_mvc[0][cnt] != cm->fc.mvc[0][cnt])
 749             {
 750                 flag[0] = 1;
 751                 vpx_memcpy(cm->fc.pre_mvc[0], cm->fc.mvc[0], MVPcount);
 752                 break;
 753             }
 754         }
 755
 756         for (cnt = 0; cnt < MVPcount; cnt++)
 757         {
 758             if (cm->fc.pre_mvc[1][cnt] != cm->fc.mvc[1][cnt])
 759             {
 760                 flag[1] = 1;
 761                 vpx_memcpy(cm->fc.pre_mvc[1], cm->fc.mvc[1], MVPcount);
 762                 break;
 763             }
 764         }
 765
 766         if (flag[0] || flag[1])
 767             vp8_build_component_cost_table(cpi->mb.mvcost, cpi->mb.mvsadcost, (const MV_CONTEXT *) cm->fc.mvc, flag);
 768     }
 769 #endif
 770
 771     // Adjust the projected reference frame useage probability numbers to reflect
 772     // what we have just seen. This may be usefull when we make multiple itterations
 773     // of the recode loop rather than continuing to use values from the previous frame.
 774     if ((cm->frame_type != KEY_FRAME) && !cm->refresh_alt_ref_frame && !cm->refresh_golden_frame)
 775     {
 776         const int *const rfct = cpi->count_mb_ref_frame_usage;
 777         const int rf_intra = rfct[INTRA_FRAME];
 778         const int rf_inter = rfct[LAST_FRAME] + rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME];
 779
 780         if ((rf_intra + rf_inter) > 0)
 781         {
 782             cpi->prob_intra_coded = (rf_intra * 255) / (rf_intra + rf_inter);
 783
 784             if (cpi->prob_intra_coded < 1)
 785                 cpi->prob_intra_coded = 1;
 786
 787             if ((cm->frames_since_golden > 0) || cpi->source_alt_ref_active)
 788             {
 789                 cpi->prob_last_coded = rf_inter ? (rfct[LAST_FRAME] * 255) / rf_inter : 128;
 790
 791                 if (cpi->prob_last_coded < 1)
 792                     cpi->prob_last_coded = 1;
 793
 794                 cpi->prob_gf_coded = (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME])
 795                                      ? (rfct[GOLDEN_FRAME] * 255) / (rfct[GOLDEN_FRAME] + rfct[ALTREF_FRAME]) : 128;
 796
 797                 if (cpi->prob_gf_coded < 1)
 798                     cpi->prob_gf_coded = 1;
 799             }
 800         }
 801     }
 802
 803 #if 0
 804     // Keep record of the total distortion this time around for future use
 805     cpi->last_frame_distortion = cpi->frame_distortion;
 806 #endif
 807
 808 }
 809 void vp8_setup_block_ptrs(MACROBLOCK *x)
 810 {
 811     int r, c;
 812     int i;
 813
 814     for (r = 0; r < 4; r++)
 815     {
 816         for (c = 0; c < 4; c++)
 817         {
 818             x->block[r*4+c].src_diff = x->src_diff + r * 4 * 16 + c * 4;
 819         }
 820     }
 821
 822     for (r = 0; r < 2; r++)
 823     {
 824         for (c = 0; c < 2; c++)
 825         {
 826             x->block[16 + r*2+c].src_diff = x->src_diff + 256 + r * 4 * 8 + c * 4;
 827         }
 828     }
 829
 830
 831     for (r = 0; r < 2; r++)
 832     {
 833         for (c = 0; c < 2; c++)
 834         {
 835             x->block[20 + r*2+c].src_diff = x->src_diff + 320 + r * 4 * 8 + c * 4;
 836         }
 837     }
 838
 839     x->block[24].src_diff = x->src_diff + 384;
 840
 841
 842     for (i = 0; i < 25; i++)
 843     {
 844         x->block[i].coeff = x->coeff + i * 16;
 845     }
 846 }
 847
 848 void vp8_build_block_offsets(MACROBLOCK *x)
 849 {
 850     int block = 0;
 851     int br, bc;
 852
 853     vp8_build_block_doffsets(&x->e_mbd);
 854
 855     // y blocks
 856     for (br = 0; br < 4; br++)
 857     {
 858         for (bc = 0; bc < 4; bc++)
 859         {
 860             BLOCK *this_block = &x->block[block];
 861             this_block->base_src = &x->src.y_buffer;
 862             this_block->src_stride = x->src.y_stride;
 863             this_block->src = 4 * br * this_block->src_stride + 4 * bc;
 864             ++block;
 865         }
 866     }
 867
 868     // u blocks
 869     for (br = 0; br < 2; br++)
 870     {
 871         for (bc = 0; bc < 2; bc++)
 872         {
 873             BLOCK *this_block = &x->block[block];
 874             this_block->base_src = &x->src.u_buffer;
 875             this_block->src_stride = x->src.uv_stride;
 876             this_block->src = 4 * br * this_block->src_stride + 4 * bc;
 877             ++block;
 878         }
 879     }
 880
 881     // v blocks
 882     for (br = 0; br < 2; br++)
 883     {
 884         for (bc = 0; bc < 2; bc++)
 885         {
 886             BLOCK *this_block = &x->block[block];
 887             this_block->base_src = &x->src.v_buffer;
 888             this_block->src_stride = x->src.uv_stride;
 889             this_block->src = 4 * br * this_block->src_stride + 4 * bc;
 890             ++block;
 891         }
 892     }
 893 }
 894
 895 static void sum_intra_stats(VP8_COMP *cpi, MACROBLOCK *x)
 896 {
 897     const MACROBLOCKD *xd = & x->e_mbd;
 898     const MB_PREDICTION_MODE m = xd->mbmi.mode;
 899     const MB_PREDICTION_MODE uvm = xd->mbmi.uv_mode;
 900
 901 #ifdef MODE_STATS
 902     const int is_key = cpi->common.frame_type == KEY_FRAME;
 903
 904     ++ (is_key ? uv_modes : inter_uv_modes)[uvm];
 905
 906     if (m == B_PRED)
 907     {
 908         unsigned int *const bct = is_key ? b_modes : inter_b_modes;
 909
 910         int b = 0;
 911
 912         do
 913         {
 914             ++ bct[xd->block[b].bmi.mode];
 915         }
 916         while (++b < 16);
 917     }
 918
 919 #endif
 920
 921     ++cpi->ymode_count[m];
 922     ++cpi->uv_mode_count[uvm];
 923
 924 }
 925 int vp8cx_encode_intra_macro_block(VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t)
 926 {
 927     int Error4x4, Error16x16, error_uv;
 928     B_PREDICTION_MODE intra_bmodes[16];
 929     int rate4x4, rate16x16, rateuv;
 930     int dist4x4, dist16x16, distuv;
 931     int rate = 0;
 932     int rate4x4_tokenonly = 0;
 933     int rate16x16_tokenonly = 0;
 934     int rateuv_tokenonly = 0;
 935     int i;
 936
 937     x->e_mbd.mbmi.ref_frame = INTRA_FRAME;
 938
 939 #if !(CONFIG_REALTIME_ONLY)
 940
 941     if (cpi->sf.RD || cpi->compressor_speed != 2)
 942     {
 943         Error4x4 = vp8_rd_pick_intra4x4mby_modes(cpi, x, &rate4x4, &rate4x4_tokenonly, &dist4x4);
 944
 945         //save the b modes for possible later use
 946         for (i = 0; i < 16; i++)
 947             intra_bmodes[i] = x->e_mbd.block[i].bmi.mode;
 948
 949         Error16x16 = vp8_rd_pick_intra16x16mby_mode(cpi, x, &rate16x16, &rate16x16_tokenonly, &dist16x16);
 950
 951         error_uv = vp8_rd_pick_intra_mbuv_mode(cpi, x, &rateuv, &rateuv_tokenonly, &distuv);
 952
 953         x->e_mbd.mbmi.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
 954
 955         vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
 956         rate += rateuv;
 957
 958         if (Error4x4 < Error16x16)
 959         {
 960             rate += rate4x4;
 961             x->e_mbd.mbmi.mode = B_PRED;
 962
 963             // get back the intra block modes
 964             for (i = 0; i < 16; i++)
 965                 x->e_mbd.block[i].bmi.mode = intra_bmodes[i];
 966
 967             vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
 968             cpi->prediction_error += Error4x4 ;
 969 #if 0
 970             // Experimental RD code
 971             cpi->frame_distortion += dist4x4;
 972 #endif
 973         }
 974         else
 975         {
 976             vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
 977             rate += rate16x16;
 978
 979 #if 0
 980             // Experimental RD code
 981             cpi->prediction_error += Error16x16;
 982             cpi->frame_distortion += dist16x16;
 983 #endif
 984         }
 985
 986         sum_intra_stats(cpi, x);
 987
 988         vp8_tokenize_mb(cpi, &x->e_mbd, t);
 989     }
 990     else
 991 #endif
 992     {
 993
 994         int rate2, distortion2;
 995         MB_PREDICTION_MODE mode, best_mode = DC_PRED;
 996         int this_rd;
 997         Error16x16 = INT_MAX;
 998
 999         for (mode = DC_PRED; mode <= TM_PRED; mode ++)
1000         {
1001             x->e_mbd.mbmi.mode = mode;
1002             vp8_build_intra_predictors_mby_ptr(&x->e_mbd);
1003             distortion2 = VARIANCE_INVOKE(&cpi->rtcd.variance, get16x16prederror)(x->src.y_buffer, x->src.y_stride, x->e_mbd.predictor, 16, 0x7fffffff);
1004             rate2  = x->mbmode_cost[x->e_mbd.frame_type][mode];
1005             this_rd = RD_ESTIMATE(x->rdmult, x->rddiv, rate2, distortion2);
1006
1007             if (Error16x16 > this_rd)
1008             {
1009                 Error16x16 = this_rd;
1010                 best_mode = mode;
1011             }
1012         }
1013
1014         vp8_pick_intra4x4mby_modes(IF_RTCD(&cpi->rtcd), x, &rate2, &distortion2);
1015
1016         if (distortion2 == INT_MAX)
1017             Error4x4 = INT_MAX;
1018         else
1019             Error4x4 = RD_ESTIMATE(x->rdmult, x->rddiv, rate2, distortion2);
1020
1021         x->e_mbd.mbmi.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
1022
1023         if (Error4x4 < Error16x16)
1024         {
1025             x->e_mbd.mbmi.mode = B_PRED;
1026             vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
1027             cpi->prediction_error += Error4x4;
1028         }
1029         else
1030         {
1031             x->e_mbd.mbmi.mode = best_mode;
1032             vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
1033             cpi->prediction_error += Error16x16;
1034         }
1035
1036         vp8_pick_intra_mbuv_mode(x);
1037         vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
1038         sum_intra_stats(cpi, x);
1039         vp8_tokenize_mb(cpi, &x->e_mbd, t);
1040     }
1041
1042     return rate;
1043 }
1044 #ifdef SPEEDSTATS
1045 extern int cnt_pm;
1046 #endif
1047
1048 extern void vp8_fix_contexts(VP8_COMP *cpi, MACROBLOCKD *x);
1049
1050 int vp8cx_encode_inter_macroblock
1051 (
1052     VP8_COMP *cpi, MACROBLOCK *x, TOKENEXTRA **t,
1053     int recon_yoffset, int recon_uvoffset
1054 )
1055 {
1056     MACROBLOCKD *const xd = &x->e_mbd;
1057     int inter_error;
1058     int intra_error = 0;
1059     int rate;
1060     int distortion;
1061
1062     x->skip = 0;
1063
1064     if (xd->segmentation_enabled)
1065         x->encode_breakout = cpi->segment_encode_breakout[xd->mbmi.segment_id];
1066     else
1067         x->encode_breakout = cpi->oxcf.encode_breakout;
1068
1069 #if !(CONFIG_REALTIME_ONLY)
1070
1071     if (cpi->sf.RD)
1072     {
1073         inter_error = vp8_rd_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate, &distortion, &intra_error);
1074     }
1075     else
1076 #endif
1077         inter_error = vp8_pick_inter_mode(cpi, x, recon_yoffset, recon_uvoffset, &rate, &distortion, &intra_error);
1078
1079
1080     cpi->prediction_error += inter_error;
1081     cpi->intra_error += intra_error;
1082
1083 #if 0
1084     // Experimental RD code
1085     cpi->frame_distortion += distortion;
1086     cpi->last_mb_distortion = distortion;
1087 #endif
1088
1089     // MB level adjutment to quantizer setup
1090     if (xd->segmentation_enabled || cpi->zbin_mode_boost_enabled)
1091     {
1092         // If cyclic update enabled
1093         if (cpi->cyclic_refresh_mode_enabled)
1094         {
1095             // Clear segment_id back to 0 if not coded (last frame 0,0)
1096             if ((xd->mbmi.segment_id == 1) &&
1097                 ((xd->mbmi.ref_frame != LAST_FRAME) || (xd->mbmi.mode != ZEROMV)))
1098             {
1099                 xd->mbmi.segment_id = 0;
1100             }
1101         }
1102
1103         // Experimental code. Special case for gf and arf zeromv modes. Increase zbin size to supress noise
1104         if (cpi->zbin_mode_boost_enabled)
1105         {
1106             if ((xd->mbmi.mode == ZEROMV) && (xd->mbmi.ref_frame != LAST_FRAME))
1107                 cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
1108             else
1109                 cpi->zbin_mode_boost = 0;
1110         }
1111
1112         vp8cx_mb_init_quantizer(cpi,  x);
1113     }
1114
1115     cpi->count_mb_ref_frame_usage[xd->mbmi.ref_frame] ++;
1116
1117     if (xd->mbmi.ref_frame == INTRA_FRAME)
1118     {
1119         x->e_mbd.mbmi.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
1120
1121         vp8_encode_intra16x16mbuv(IF_RTCD(&cpi->rtcd), x);
1122
1123         if (xd->mbmi.mode == B_PRED)
1124         {
1125             vp8_encode_intra4x4mby(IF_RTCD(&cpi->rtcd), x);
1126         }
1127         else
1128         {
1129             vp8_encode_intra16x16mby(IF_RTCD(&cpi->rtcd), x);
1130         }
1131
1132         sum_intra_stats(cpi, x);
1133     }
1134     else
1135     {
1136         MV best_ref_mv;
1137         MV nearest, nearby;
1138         int mdcounts[4];
1139
1140         vp8_find_near_mvs(xd, xd->mode_info_context,
1141                           &nearest, &nearby, &best_ref_mv, mdcounts, xd->mbmi.ref_frame, cpi->common.ref_frame_sign_bias);
1142
1143         vp8_build_uvmvs(xd, cpi->common.full_pixel);
1144
1145         // store motion vectors in our motion vector list
1146         if (xd->mbmi.ref_frame == LAST_FRAME)
1147         {
1148             // Set up pointers for this macro block into the previous frame recon buffer
1149             xd->pre.y_buffer = cpi->common.last_frame.y_buffer + recon_yoffset;
1150             xd->pre.u_buffer = cpi->common.last_frame.u_buffer + recon_uvoffset;
1151             xd->pre.v_buffer = cpi->common.last_frame.v_buffer + recon_uvoffset;
1152         }
1153         else if (xd->mbmi.ref_frame == GOLDEN_FRAME)
1154         {
1155             // Set up pointers for this macro block into the golden frame recon buffer
1156             xd->pre.y_buffer = cpi->common.golden_frame.y_buffer + recon_yoffset;
1157             xd->pre.u_buffer = cpi->common.golden_frame.u_buffer + recon_uvoffset;
1158             xd->pre.v_buffer = cpi->common.golden_frame.v_buffer + recon_uvoffset;
1159         }
1160         else
1161         {
1162             // Set up pointers for this macro block into the alternate reference frame recon buffer
1163             xd->pre.y_buffer = cpi->common.alt_ref_frame.y_buffer + recon_yoffset;
1164             xd->pre.u_buffer = cpi->common.alt_ref_frame.u_buffer + recon_uvoffset;
1165             xd->pre.v_buffer = cpi->common.alt_ref_frame.v_buffer + recon_uvoffset;
1166         }
1167
1168         if (xd->mbmi.mode == SPLITMV)
1169         {
1170             int i;
1171
1172             for (i = 0; i < 16; i++)
1173             {
1174                 if (xd->block[i].bmi.mode == NEW4X4)
1175                 {
1176                     cpi->MVcount[0][mv_max+((xd->block[i].bmi.mv.as_mv.row - best_ref_mv.row) >> 1)]++;
1177                     cpi->MVcount[1][mv_max+((xd->block[i].bmi.mv.as_mv.col - best_ref_mv.col) >> 1)]++;
1178                 }
1179             }
1180         }
1181         else if (xd->mbmi.mode == NEWMV)
1182         {
1183             cpi->MVcount[0][mv_max+((xd->block[0].bmi.mv.as_mv.row - best_ref_mv.row) >> 1)]++;
1184             cpi->MVcount[1][mv_max+((xd->block[0].bmi.mv.as_mv.col - best_ref_mv.col) >> 1)]++;
1185         }
1186
1187         if (!x->skip && !x->e_mbd.mbmi.force_no_skip)
1188         {
1189             vp8_encode_inter16x16(IF_RTCD(&cpi->rtcd), x);
1190
1191             // Clear mb_skip_coeff if mb_no_coeff_skip is not set
1192             if (!cpi->common.mb_no_coeff_skip)
1193                 xd->mbmi.mb_skip_coeff = 0;
1194
1195         }
1196         else
1197             vp8_stuff_inter16x16(x);
1198     }
1199
1200     if (!x->skip)
1201         vp8_tokenize_mb(cpi, xd, t);
1202     else
1203     {
1204         if (cpi->common.mb_no_coeff_skip)
1205         {
1206             if (xd->mbmi.mode != B_PRED && xd->mbmi.mode != SPLITMV)
1207                 xd->mbmi.dc_diff = 0;
1208             else
1209                 xd->mbmi.dc_diff = 1;
1210
1211             xd->mbmi.mb_skip_coeff = 1;
1212             cpi->skip_true_count ++;
1213             vp8_fix_contexts(cpi, xd);
1214         }
1215         else
1216         {
1217             vp8_stuff_mb(cpi, xd, t);
1218             xd->mbmi.mb_skip_coeff = 0;
1219             cpi->skip_false_count ++;
1220         }
1221     }
1222
1223     return rate;
1224 }