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