granicus.if.org Git - libvpx/blob - vp8/encoder/rdopt.c

   1 /*
   2  *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11
  12 #include <stdio.h>
  13 #include <math.h>
  14 #include <limits.h>
  15 #include <assert.h>
  16 #include "pragmas.h"
  17
  18 #include "tokenize.h"
  19 #include "treewriter.h"
  20 #include "onyx_int.h"
  21 #include "modecosts.h"
  22 #include "encodeintra.h"
  23 #include "entropymode.h"
  24 #include "reconinter.h"
  25 #include "reconintra.h"
  26 #include "reconintra4x4.h"
  27 #include "findnearmv.h"
  28 #include "encodemb.h"
  29 #include "quantize.h"
  30 #include "idct.h"
  31 #include "g_common.h"
  32 #include "variance.h"
  33 #include "mcomp.h"
  34
  35 #include "vpx_mem/vpx_mem.h"
  36 #include "dct.h"
  37 #include "systemdependent.h"
  38
  39 #if CONFIG_RUNTIME_CPU_DETECT
  40 #define IF_RTCD(x)  (x)
  41 #else
  42 #define IF_RTCD(x)  NULL
  43 #endif
  44
  45
  46 extern void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x);
  47 extern void vp8_update_zbin_extra(VP8_COMP *cpi, MACROBLOCK *x);
  48
  49
  50 #define RDCOST(RM,DM,R,D) ( ((128+(R)*(RM)) >> 8) + (DM)*(D) )
  51
  52 #define MAXF(a,b)            (((a) > (b)) ? (a) : (b))
  53
  54
  55
  56 const int vp8_auto_speed_thresh[17] =
  57 {
  58     1000,
  59     200,
  60     150,
  61     130,
  62     150,
  63     125,
  64     120,
  65     115,
  66     115,
  67     115,
  68     115,
  69     115,
  70     115,
  71     115,
  72     115,
  73     115,
  74     105
  75 };
  76
  77 const MB_PREDICTION_MODE vp8_mode_order[MAX_MODES] =
  78 {
  79     ZEROMV,
  80     DC_PRED,
  81
  82     NEARESTMV,
  83     NEARMV,
  84
  85     ZEROMV,
  86     NEARESTMV,
  87
  88     ZEROMV,
  89     NEARESTMV,
  90
  91     NEARMV,
  92     NEARMV,
  93
  94     V_PRED,
  95     H_PRED,
  96     TM_PRED,
  97
  98     NEWMV,
  99     NEWMV,
 100     NEWMV,
 101
 102     SPLITMV,
 103     SPLITMV,
 104     SPLITMV,
 105
 106     B_PRED,
 107 };
 108
 109 const MV_REFERENCE_FRAME vp8_ref_frame_order[MAX_MODES] =
 110 {
 111     LAST_FRAME,
 112     INTRA_FRAME,
 113
 114     LAST_FRAME,
 115     LAST_FRAME,
 116
 117     GOLDEN_FRAME,
 118     GOLDEN_FRAME,
 119
 120     ALTREF_FRAME,
 121     ALTREF_FRAME,
 122
 123     GOLDEN_FRAME,
 124     ALTREF_FRAME,
 125
 126     INTRA_FRAME,
 127     INTRA_FRAME,
 128     INTRA_FRAME,
 129
 130     LAST_FRAME,
 131     GOLDEN_FRAME,
 132     ALTREF_FRAME,
 133
 134     LAST_FRAME,
 135     GOLDEN_FRAME,
 136     ALTREF_FRAME,
 137
 138     INTRA_FRAME,
 139 };
 140
 141 static void fill_token_costs(
 142     unsigned int c      [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [vp8_coef_tokens],
 143     const vp8_prob p    [BLOCK_TYPES] [COEF_BANDS] [PREV_COEF_CONTEXTS] [vp8_coef_tokens-1]
 144 )
 145 {
 146     int i, j, k;
 147
 148
 149     for (i = 0; i < BLOCK_TYPES; i++)
 150         for (j = 0; j < COEF_BANDS; j++)
 151             for (k = 0; k < PREV_COEF_CONTEXTS; k++)
 152
 153                 vp8_cost_tokens((int *)(c [i][j][k]), p [i][j][k], vp8_coef_tree);
 154
 155 }
 156
 157 static int rd_iifactor [ 32 ] =  {    4,   4,   3,   2,   1,   0,   0,   0,
 158                                       0,   0,   0,   0,   0,   0,   0,   0,
 159                                       0,   0,   0,   0,   0,   0,   0,   0,
 160                                       0,   0,   0,   0,   0,   0,   0,   0,
 161                                  };
 162
 163
 164 /* values are now correlated to quantizer */
 165 static int sad_per_bit16lut[QINDEX_RANGE] =
 166 {
 167     5,  5,  5,  5,  5,  5,  6,  6,
 168     6,  6,  6,  6,  6,  7,  7,  7,
 169     7,  7,  7,  7,  8,  8,  8,  8,
 170     8,  8,  8,  8,  8,  8,  9,  9,
 171     9,  9,  9,  9, 10, 10, 10, 10,
 172     10, 10, 11, 11, 11, 11, 11, 11,
 173     12, 12, 12, 12, 12, 12, 12, 13,
 174     13, 13, 13, 13, 13, 14, 14, 14,
 175     14, 14, 15, 15, 15, 15, 15, 15,
 176     16, 16, 16, 16, 16, 16, 17, 17,
 177     17, 17, 17, 17, 17, 18, 18, 18,
 178     18, 18, 19, 19, 19, 19, 19, 19,
 179     20, 20, 20, 21, 21, 21, 21, 22,
 180     22, 22, 23, 23, 23, 24, 24, 24,
 181     25, 25, 26, 26, 27, 27, 27, 28,
 182     28, 28, 29, 29, 30, 30, 31, 31
 183 };
 184 static int sad_per_bit4lut[QINDEX_RANGE] =
 185 {
 186     5,  5,  5,  5,  5,  5,  7,  7,
 187     7,  7,  7,  7,  7,  8,  8,  8,
 188     8,  8,  8,  8,  10, 10, 10, 10,
 189     10, 10, 10, 10, 10, 10, 11, 11,
 190     11, 11, 11, 11, 13, 13, 13, 13,
 191     13, 13, 14, 14, 14, 14, 14, 14,
 192     16, 16, 16, 16, 16, 16, 16, 17,
 193     17, 17, 17, 17, 17, 19, 19, 19,
 194     19, 19, 20, 20, 20, 20, 20, 20,
 195     22, 22, 22, 22, 22, 22, 23, 23,
 196     23, 23, 23, 23, 23, 25, 25, 25,
 197     25, 25, 26, 26, 26, 26, 26, 26,
 198     28, 28, 28, 29, 29, 29, 29, 31,
 199     31, 31, 32, 32, 32, 34, 34, 34,
 200     35, 35, 37, 37, 38, 38, 38, 40,
 201     40, 40, 41, 41, 43, 43, 44, 44,
 202 };
 203
 204 void vp8cx_initialize_me_consts(VP8_COMP *cpi, int QIndex)
 205 {
 206     cpi->mb.sadperbit16 =  sad_per_bit16lut[QIndex];
 207     cpi->mb.sadperbit4  =  sad_per_bit4lut[QIndex];
 208 }
 209
 210 void vp8_initialize_rd_consts(VP8_COMP *cpi, int Qvalue)
 211 {
 212     int q;
 213     int i;
 214     double capped_q = (Qvalue < 160) ? (double)Qvalue : 160.0;
 215     double rdconst = 3.00;
 216
 217     vp8_clear_system_state();  //__asm emms;
 218
 219     // Further tests required to see if optimum is different
 220     // for key frames, golden frames and arf frames.
 221     // if (cpi->common.refresh_golden_frame ||
 222     //     cpi->common.refresh_alt_ref_frame)
 223     cpi->RDMULT = (int)(rdconst * (capped_q * capped_q));
 224
 225     // Extend rate multiplier along side quantizer zbin increases
 226     if (cpi->zbin_over_quant  > 0)
 227     {
 228         double oq_factor;
 229         double modq;
 230
 231         // Experimental code using the same basic equation as used for Q above
 232         // The units of cpi->zbin_over_quant are 1/128 of Q bin size
 233         oq_factor = 1.0 + ((double)0.0015625 * cpi->zbin_over_quant);
 234         modq = (int)((double)capped_q * oq_factor);
 235         cpi->RDMULT = (int)(rdconst * (modq * modq));
 236     }
 237
 238     if (cpi->pass == 2 && (cpi->common.frame_type != KEY_FRAME))
 239     {
 240         if (cpi->next_iiratio > 31)
 241             cpi->RDMULT += (cpi->RDMULT * rd_iifactor[31]) >> 4;
 242         else
 243             cpi->RDMULT += (cpi->RDMULT * rd_iifactor[cpi->next_iiratio]) >> 4;
 244     }
 245
 246     cpi->mb.errorperbit = (cpi->RDMULT / 100);
 247     cpi->mb.errorperbit += (cpi->mb.errorperbit==0);
 248
 249     vp8_set_speed_features(cpi);
 250
 251     if (cpi->common.simpler_lpf)
 252         cpi->common.filter_type = SIMPLE_LOOPFILTER;
 253
 254     q = (int)pow(Qvalue, 1.25);
 255
 256     if (q < 8)
 257         q = 8;
 258
 259     if (cpi->RDMULT > 1000)
 260     {
 261         cpi->RDDIV = 1;
 262         cpi->RDMULT /= 100;
 263
 264         for (i = 0; i < MAX_MODES; i++)
 265         {
 266             if (cpi->sf.thresh_mult[i] < INT_MAX)
 267             {
 268                 cpi->rd_threshes[i] = cpi->sf.thresh_mult[i] * q / 100;
 269             }
 270             else
 271             {
 272                 cpi->rd_threshes[i] = INT_MAX;
 273             }
 274
 275             cpi->rd_baseline_thresh[i] = cpi->rd_threshes[i];
 276         }
 277     }
 278     else
 279     {
 280         cpi->RDDIV = 100;
 281
 282         for (i = 0; i < MAX_MODES; i++)
 283         {
 284             if (cpi->sf.thresh_mult[i] < (INT_MAX / q))
 285             {
 286                 cpi->rd_threshes[i] = cpi->sf.thresh_mult[i] * q;
 287             }
 288             else
 289             {
 290                 cpi->rd_threshes[i] = INT_MAX;
 291             }
 292
 293             cpi->rd_baseline_thresh[i] = cpi->rd_threshes[i];
 294         }
 295     }
 296
 297     fill_token_costs(
 298         cpi->mb.token_costs,
 299         (const vp8_prob( *)[8][3][11]) cpi->common.fc.coef_probs
 300     );
 301
 302     vp8_init_mode_costs(cpi);
 303
 304 }
 305
 306 void vp8_auto_select_speed(VP8_COMP *cpi)
 307 {
 308     int used = cpi->oxcf.cpu_used;
 309
 310     int milliseconds_for_compress = (int)(1000000 / cpi->oxcf.frame_rate);
 311
 312     milliseconds_for_compress = milliseconds_for_compress * (16 - cpi->oxcf.cpu_used) / 16;
 313
 314 #if 0
 315
 316     if (0)
 317     {
 318         FILE *f;
 319
 320         f = fopen("speed.stt", "a");
 321         fprintf(f, " %8ld %10ld %10ld %10ld\n",
 322                 cpi->common.current_video_frame, cpi->Speed, milliseconds_for_compress, cpi->avg_pick_mode_time);
 323         fclose(f);
 324     }
 325
 326 #endif
 327
 328     /*
 329     // this is done during parameter valid check
 330     if( used > 16)
 331         used = 16;
 332     if( used < -16)
 333         used = -16;
 334     */
 335
 336     if (cpi->avg_pick_mode_time < milliseconds_for_compress && (cpi->avg_encode_time - cpi->avg_pick_mode_time) < milliseconds_for_compress)
 337     {
 338         if (cpi->avg_pick_mode_time == 0)
 339         {
 340             cpi->Speed = 4;
 341         }
 342         else
 343         {
 344             if (milliseconds_for_compress * 100 < cpi->avg_encode_time * 95)
 345             {
 346                 cpi->Speed          += 2;
 347                 cpi->avg_pick_mode_time = 0;
 348                 cpi->avg_encode_time = 0;
 349
 350                 if (cpi->Speed > 16)
 351                 {
 352                     cpi->Speed = 16;
 353                 }
 354             }
 355
 356             if (milliseconds_for_compress * 100 > cpi->avg_encode_time * vp8_auto_speed_thresh[cpi->Speed])
 357             {
 358                 cpi->Speed          -= 1;
 359                 cpi->avg_pick_mode_time = 0;
 360                 cpi->avg_encode_time = 0;
 361
 362                 // In real-time mode, cpi->speed is in [4, 16].
 363                 if (cpi->Speed < 4)        //if ( cpi->Speed < 0 )
 364                 {
 365                     cpi->Speed = 4;        //cpi->Speed = 0;
 366                 }
 367             }
 368         }
 369     }
 370     else
 371     {
 372         cpi->Speed += 4;
 373
 374         if (cpi->Speed > 16)
 375             cpi->Speed = 16;
 376
 377
 378         cpi->avg_pick_mode_time = 0;
 379         cpi->avg_encode_time = 0;
 380     }
 381 }
 382
 383 int vp8_block_error_c(short *coeff, short *dqcoeff)
 384 {
 385     int i;
 386     int error = 0;
 387
 388     for (i = 0; i < 16; i++)
 389     {
 390         int this_diff = coeff[i] - dqcoeff[i];
 391         error += this_diff * this_diff;
 392     }
 393
 394     return error;
 395 }
 396
 397 int vp8_mbblock_error_c(MACROBLOCK *mb, int dc)
 398 {
 399     BLOCK  *be;
 400     BLOCKD *bd;
 401     int i, j;
 402     int berror, error = 0;
 403
 404     for (i = 0; i < 16; i++)
 405     {
 406         be = &mb->block[i];
 407         bd = &mb->e_mbd.block[i];
 408
 409         berror = 0;
 410
 411         for (j = dc; j < 16; j++)
 412         {
 413             int this_diff = be->coeff[j] - bd->dqcoeff[j];
 414             berror += this_diff * this_diff;
 415         }
 416
 417         error += berror;
 418     }
 419
 420     return error;
 421 }
 422
 423 int vp8_mbuverror_c(MACROBLOCK *mb)
 424 {
 425
 426     BLOCK  *be;
 427     BLOCKD *bd;
 428
 429
 430     int i;
 431     int error = 0;
 432
 433     for (i = 16; i < 24; i++)
 434     {
 435         be = &mb->block[i];
 436         bd = &mb->e_mbd.block[i];
 437
 438         error += vp8_block_error_c(be->coeff, bd->dqcoeff);
 439     }
 440
 441     return error;
 442 }
 443
 444 int VP8_UVSSE(MACROBLOCK *x, const vp8_variance_rtcd_vtable_t *rtcd)
 445 {
 446     unsigned char *uptr, *vptr;
 447     unsigned char *upred_ptr = (*(x->block[16].base_src) + x->block[16].src);
 448     unsigned char *vpred_ptr = (*(x->block[20].base_src) + x->block[20].src);
 449     int uv_stride = x->block[16].src_stride;
 450
 451     unsigned int sse1 = 0;
 452     unsigned int sse2 = 0;
 453     int mv_row;
 454     int mv_col;
 455     int offset;
 456     int pre_stride = x->e_mbd.block[16].pre_stride;
 457
 458     vp8_build_uvmvs(&x->e_mbd, 0);
 459     mv_row = x->e_mbd.block[16].bmi.mv.as_mv.row;
 460     mv_col = x->e_mbd.block[16].bmi.mv.as_mv.col;
 461
 462     offset = (mv_row >> 3) * pre_stride + (mv_col >> 3);
 463     uptr = x->e_mbd.pre.u_buffer + offset;
 464     vptr = x->e_mbd.pre.v_buffer + offset;
 465
 466     if ((mv_row | mv_col) & 7)
 467     {
 468         VARIANCE_INVOKE(rtcd, subpixvar8x8)(uptr, pre_stride, mv_col & 7, mv_row & 7, upred_ptr, uv_stride, &sse2);
 469         VARIANCE_INVOKE(rtcd, subpixvar8x8)(vptr, pre_stride, mv_col & 7, mv_row & 7, vpred_ptr, uv_stride, &sse1);
 470         sse2 += sse1;
 471     }
 472     else
 473     {
 474         VARIANCE_INVOKE(rtcd, subpixvar8x8)(uptr, pre_stride, mv_col & 7, mv_row & 7, upred_ptr, uv_stride, &sse2);
 475         VARIANCE_INVOKE(rtcd, subpixvar8x8)(vptr, pre_stride, mv_col & 7, mv_row & 7, vpred_ptr, uv_stride, &sse1);
 476         sse2 += sse1;
 477     }
 478
 479     return sse2;
 480
 481 }
 482
 483 #if !(CONFIG_REALTIME_ONLY)
 484 static int cost_coeffs(MACROBLOCK *mb, BLOCKD *b, int type, ENTROPY_CONTEXT *a, ENTROPY_CONTEXT *l)
 485 {
 486     int c = !type;              /* start at coef 0, unless Y with Y2 */
 487     int eob = b->eob;
 488     int pt ;    /* surrounding block/prev coef predictor */
 489     int cost = 0;
 490     short *qcoeff_ptr = b->qcoeff;
 491
 492     VP8_COMBINEENTROPYCONTEXTS(pt, *a, *l);
 493
 494 # define QC( I)  ( qcoeff_ptr [vp8_default_zig_zag1d[I]] )
 495
 496     for (; c < eob; c++)
 497     {
 498         int v = QC(c);
 499         int t = vp8_dct_value_tokens_ptr[v].Token;
 500         cost += mb->token_costs [type] [vp8_coef_bands[c]] [pt] [t];
 501         cost += vp8_dct_value_cost_ptr[v];
 502         pt = vp8_prev_token_class[t];
 503     }
 504
 505 # undef QC
 506
 507     if (c < 16)
 508         cost += mb->token_costs [type] [vp8_coef_bands[c]] [pt] [DCT_EOB_TOKEN];
 509
 510     pt = (c != !type); // is eob first coefficient;
 511     *a = *l = pt;
 512
 513     return cost;
 514 }
 515
 516 static int vp8_rdcost_mby(MACROBLOCK *mb)
 517 {
 518     int cost = 0;
 519     int b;
 520     MACROBLOCKD *x = &mb->e_mbd;
 521     ENTROPY_CONTEXT_PLANES t_above, t_left;
 522     ENTROPY_CONTEXT *ta;
 523     ENTROPY_CONTEXT *tl;
 524
 525     vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
 526     vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
 527
 528     ta = (ENTROPY_CONTEXT *)&t_above;
 529     tl = (ENTROPY_CONTEXT *)&t_left;
 530
 531     for (b = 0; b < 16; b++)
 532         cost += cost_coeffs(mb, x->block + b, 0,
 533                     ta + vp8_block2above[b], tl + vp8_block2left[b]);
 534
 535     cost += cost_coeffs(mb, x->block + 24, 1,
 536                 ta + vp8_block2above[24], tl + vp8_block2left[24]);
 537
 538     return cost;
 539 }
 540
 541 static void macro_block_yrd( MACROBLOCK *mb,
 542                              int *Rate,
 543                              int *Distortion,
 544                              const vp8_encodemb_rtcd_vtable_t *rtcd)
 545 {
 546     int b;
 547     MACROBLOCKD *const x = &mb->e_mbd;
 548     BLOCK   *const mb_y2 = mb->block + 24;
 549     BLOCKD *const x_y2  = x->block + 24;
 550     short *Y2DCPtr = mb_y2->src_diff;
 551     BLOCK *beptr;
 552     int d;
 553
 554     ENCODEMB_INVOKE(rtcd, submby)( mb->src_diff, mb->src.y_buffer,
 555                                    mb->e_mbd.predictor, mb->src.y_stride );
 556
 557     // Fdct and building the 2nd order block
 558     for (beptr = mb->block; beptr < mb->block + 16; beptr += 2)
 559     {
 560         mb->vp8_short_fdct8x4(beptr->src_diff, beptr->coeff, 32);
 561         *Y2DCPtr++ = beptr->coeff[0];
 562         *Y2DCPtr++ = beptr->coeff[16];
 563     }
 564
 565     // 2nd order fdct
 566     mb->short_walsh4x4(mb_y2->src_diff, mb_y2->coeff, 8);
 567
 568     // Quantization
 569     for (b = 0; b < 16; b++)
 570     {
 571         mb->quantize_b(&mb->block[b], &mb->e_mbd.block[b]);
 572     }
 573
 574     // DC predication and Quantization of 2nd Order block
 575     mb->quantize_b(mb_y2, x_y2);
 576
 577     // Distortion
 578     d = ENCODEMB_INVOKE(rtcd, mberr)(mb, 1) << 2;
 579     d += ENCODEMB_INVOKE(rtcd, berr)(mb_y2->coeff, x_y2->dqcoeff);
 580
 581     *Distortion = (d >> 4);
 582
 583     // rate
 584     *Rate = vp8_rdcost_mby(mb);
 585 }
 586
 587 static void rd_pick_intra4x4block(
 588     VP8_COMP *cpi,
 589     MACROBLOCK *x,
 590     BLOCK *be,
 591     BLOCKD *b,
 592     B_PREDICTION_MODE *best_mode,
 593     B_PREDICTION_MODE above,
 594     B_PREDICTION_MODE left,
 595     ENTROPY_CONTEXT *a,
 596     ENTROPY_CONTEXT *l,
 597
 598     int *bestrate,
 599     int *bestratey,
 600     int *bestdistortion)
 601 {
 602     B_PREDICTION_MODE mode;
 603     int best_rd = INT_MAX;       // 1<<30
 604     int rate = 0;
 605     int distortion;
 606     unsigned int *mode_costs;
 607
 608     ENTROPY_CONTEXT ta = *a, tempa = *a;
 609     ENTROPY_CONTEXT tl = *l, templ = *l;
 610
 611
 612     if (x->e_mbd.frame_type == KEY_FRAME)
 613     {
 614         mode_costs  = x->bmode_costs[above][left];
 615     }
 616     else
 617     {
 618         mode_costs = x->inter_bmode_costs;
 619     }
 620
 621     for (mode = B_DC_PRED; mode <= B_HU_PRED; mode++)
 622     {
 623         int this_rd;
 624         int ratey;
 625
 626         rate = mode_costs[mode];
 627         vp8_encode_intra4x4block_rd(IF_RTCD(&cpi->rtcd), x, be, b, mode);
 628
 629         tempa = ta;
 630         templ = tl;
 631
 632         ratey = cost_coeffs(x, b, 3, &tempa, &templ);
 633         rate += ratey;
 634         distortion = ENCODEMB_INVOKE(IF_RTCD(&cpi->rtcd.encodemb), berr)(be->coeff, b->dqcoeff) >> 2;
 635
 636         this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
 637
 638         if (this_rd < best_rd)
 639         {
 640             *bestrate = rate;
 641             *bestratey = ratey;
 642             *bestdistortion = distortion;
 643             best_rd = this_rd;
 644             *best_mode = mode;
 645             *a = tempa;
 646             *l = templ;
 647         }
 648     }
 649
 650     b->bmi.mode = (B_PREDICTION_MODE)(*best_mode);
 651     vp8_encode_intra4x4block_rd(IF_RTCD(&cpi->rtcd), x, be, b, b->bmi.mode);
 652
 653 }
 654
 655
 656 int vp8_rd_pick_intra4x4mby_modes(VP8_COMP *cpi, MACROBLOCK *mb, int *Rate, int *rate_y, int *Distortion)
 657 {
 658     MACROBLOCKD *const xd = &mb->e_mbd;
 659     int i;
 660     int cost = mb->mbmode_cost [xd->frame_type] [B_PRED];
 661     int distortion = 0;
 662     int tot_rate_y = 0;
 663     ENTROPY_CONTEXT_PLANES t_above, t_left;
 664     ENTROPY_CONTEXT *ta;
 665     ENTROPY_CONTEXT *tl;
 666
 667     vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
 668     vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
 669
 670     ta = (ENTROPY_CONTEXT *)&t_above;
 671     tl = (ENTROPY_CONTEXT *)&t_left;
 672
 673     vp8_intra_prediction_down_copy(xd);
 674
 675     for (i = 0; i < 16; i++)
 676     {
 677         MODE_INFO *const mic = xd->mode_info_context;
 678         const int mis = xd->mode_info_stride;
 679         const B_PREDICTION_MODE A = vp8_above_bmi(mic, i, mis)->mode;
 680         const B_PREDICTION_MODE L = vp8_left_bmi(mic, i)->mode;
 681         B_PREDICTION_MODE UNINITIALIZED_IS_SAFE(best_mode);
 682         int UNINITIALIZED_IS_SAFE(r), UNINITIALIZED_IS_SAFE(ry), UNINITIALIZED_IS_SAFE(d);
 683
 684         rd_pick_intra4x4block(
 685             cpi, mb, mb->block + i, xd->block + i, &best_mode, A, L,
 686             ta + vp8_block2above[i],
 687             tl + vp8_block2left[i], &r, &ry, &d);
 688
 689         cost += r;
 690         distortion += d;
 691         tot_rate_y += ry;
 692         mic->bmi[i].mode = xd->block[i].bmi.mode = best_mode;
 693     }
 694
 695     *Rate = cost;
 696     *rate_y += tot_rate_y;
 697     *Distortion = distortion;
 698
 699     return RDCOST(mb->rdmult, mb->rddiv, cost, distortion);
 700 }
 701
 702 int vp8_rd_pick_intra16x16mby_mode(VP8_COMP *cpi,
 703                                    MACROBLOCK *x,
 704                                    int *Rate,
 705                                    int *rate_y,
 706                                    int *Distortion)
 707 {
 708     MB_PREDICTION_MODE mode;
 709     MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
 710     int rate, ratey;
 711     int distortion;
 712     int best_rd = INT_MAX;
 713     int this_rd;
 714     int i;
 715
 716     //Y Search for 16x16 intra prediction mode
 717     for (mode = DC_PRED; mode <= TM_PRED; mode++)
 718     {
 719         for (i = 0; i < 16; i++)
 720         {
 721             vpx_memset(&x->e_mbd.block[i].bmi, 0, sizeof(B_MODE_INFO));
 722         }
 723
 724         x->e_mbd.mode_info_context->mbmi.mode = mode;
 725
 726         vp8_build_intra_predictors_mby_ptr(&x->e_mbd);
 727
 728         macro_block_yrd(x, &ratey, &distortion, IF_RTCD(&cpi->rtcd.encodemb));
 729         rate = ratey + x->mbmode_cost[x->e_mbd.frame_type]
 730                                      [x->e_mbd.mode_info_context->mbmi.mode];
 731
 732         this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
 733
 734         if (this_rd < best_rd)
 735         {
 736             mode_selected = mode;
 737             best_rd = this_rd;
 738             *Rate = rate;
 739             *rate_y = ratey;
 740             *Distortion = distortion;
 741         }
 742     }
 743
 744     x->e_mbd.mode_info_context->mbmi.mode = mode_selected;
 745     return best_rd;
 746 }
 747
 748 static int rd_cost_mbuv(MACROBLOCK *mb)
 749 {
 750     int b;
 751     int cost = 0;
 752     MACROBLOCKD *x = &mb->e_mbd;
 753     ENTROPY_CONTEXT_PLANES t_above, t_left;
 754     ENTROPY_CONTEXT *ta;
 755     ENTROPY_CONTEXT *tl;
 756
 757     vpx_memcpy(&t_above, mb->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
 758     vpx_memcpy(&t_left, mb->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
 759
 760     ta = (ENTROPY_CONTEXT *)&t_above;
 761     tl = (ENTROPY_CONTEXT *)&t_left;
 762
 763     for (b = 16; b < 20; b++)
 764         cost += cost_coeffs(mb, x->block + b, vp8_block2type[b],
 765                     ta + vp8_block2above[b], tl + vp8_block2left[b]);
 766
 767     for (b = 20; b < 24; b++)
 768         cost += cost_coeffs(mb, x->block + b, vp8_block2type[b],
 769                     ta + vp8_block2above[b], tl + vp8_block2left[b]);
 770
 771     return cost;
 772 }
 773
 774
 775 unsigned int vp8_get_mbuvrecon_error(const vp8_variance_rtcd_vtable_t *rtcd, const MACROBLOCK *x) // sum of squares
 776 {
 777     unsigned int sse0, sse1;
 778     int sum0, sum1;
 779     VARIANCE_INVOKE(rtcd, get8x8var)(x->src.u_buffer, x->src.uv_stride, x->e_mbd.dst.u_buffer, x->e_mbd.dst.uv_stride, &sse0, &sum0);
 780     VARIANCE_INVOKE(rtcd, get8x8var)(x->src.v_buffer, x->src.uv_stride, x->e_mbd.dst.v_buffer, x->e_mbd.dst.uv_stride, &sse1, &sum1);
 781     return (sse0 + sse1);
 782 }
 783
 784 static int vp8_rd_inter_uv(VP8_COMP *cpi, MACROBLOCK *x, int *rate, int *distortion, int fullpixel)
 785 {
 786     vp8_build_uvmvs(&x->e_mbd, fullpixel);
 787     vp8_encode_inter16x16uvrd(IF_RTCD(&cpi->rtcd), x);
 788
 789
 790     *rate       = rd_cost_mbuv(x);
 791     *distortion = ENCODEMB_INVOKE(&cpi->rtcd.encodemb, mbuverr)(x) / 4;
 792
 793     return RDCOST(x->rdmult, x->rddiv, *rate, *distortion);
 794 }
 795
 796 int vp8_rd_pick_intra_mbuv_mode(VP8_COMP *cpi, MACROBLOCK *x, int *rate, int *rate_tokenonly, int *distortion)
 797 {
 798     MB_PREDICTION_MODE mode;
 799     MB_PREDICTION_MODE UNINITIALIZED_IS_SAFE(mode_selected);
 800     int best_rd = INT_MAX;
 801     int UNINITIALIZED_IS_SAFE(d), UNINITIALIZED_IS_SAFE(r);
 802     int rate_to;
 803
 804     for (mode = DC_PRED; mode <= TM_PRED; mode++)
 805     {
 806         int rate;
 807         int distortion;
 808         int this_rd;
 809
 810         x->e_mbd.mode_info_context->mbmi.uv_mode = mode;
 811         vp8_encode_intra16x16mbuvrd(IF_RTCD(&cpi->rtcd), x);
 812
 813         rate_to = rd_cost_mbuv(x);
 814         rate = rate_to + x->intra_uv_mode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.uv_mode];
 815
 816         distortion = ENCODEMB_INVOKE(&cpi->rtcd.encodemb, mbuverr)(x) / 4;
 817
 818         this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
 819
 820         if (this_rd < best_rd)
 821         {
 822             best_rd = this_rd;
 823             d = distortion;
 824             r = rate;
 825             *rate_tokenonly = rate_to;
 826             mode_selected = mode;
 827         }
 828     }
 829
 830     *rate = r;
 831     *distortion = d;
 832
 833     x->e_mbd.mode_info_context->mbmi.uv_mode = mode_selected;
 834     return best_rd;
 835 }
 836 #endif
 837
 838 int vp8_cost_mv_ref(MB_PREDICTION_MODE m, const int near_mv_ref_ct[4])
 839 {
 840     vp8_prob p [VP8_MVREFS-1];
 841     assert(NEARESTMV <= m  &&  m <= SPLITMV);
 842     vp8_mv_ref_probs(p, near_mv_ref_ct);
 843     return vp8_cost_token(vp8_mv_ref_tree, p,
 844                           vp8_mv_ref_encoding_array - NEARESTMV + m);
 845 }
 846
 847 void vp8_set_mbmode_and_mvs(MACROBLOCK *x, MB_PREDICTION_MODE mb, MV *mv)
 848 {
 849     int i;
 850
 851     x->e_mbd.mode_info_context->mbmi.mode = mb;
 852     x->e_mbd.mode_info_context->mbmi.mv.as_mv.row = mv->row;
 853     x->e_mbd.mode_info_context->mbmi.mv.as_mv.col = mv->col;
 854
 855     for (i = 0; i < 16; i++)
 856     {
 857         B_MODE_INFO *bmi = &x->e_mbd.block[i].bmi;
 858         bmi->mode = (B_PREDICTION_MODE) mb;
 859         bmi->mv.as_mv.row = mv->row;
 860         bmi->mv.as_mv.col = mv->col;
 861     }
 862 }
 863
 864 #if !(CONFIG_REALTIME_ONLY)
 865 static int labels2mode(
 866     MACROBLOCK *x,
 867     int const *labelings, int which_label,
 868     B_PREDICTION_MODE this_mode,
 869     MV *this_mv, MV *best_ref_mv,
 870     int *mvcost[2]
 871 )
 872 {
 873     MACROBLOCKD *const xd = & x->e_mbd;
 874     MODE_INFO *const mic = xd->mode_info_context;
 875     const int mis = xd->mode_info_stride;
 876
 877     int cost = 0;
 878     int thismvcost = 0;
 879
 880     /* We have to be careful retrieving previously-encoded motion vectors.
 881        Ones from this macroblock have to be pulled from the BLOCKD array
 882        as they have not yet made it to the bmi array in our MB_MODE_INFO. */
 883
 884     int i = 0;
 885
 886     do
 887     {
 888         BLOCKD *const d = xd->block + i;
 889         const int row = i >> 2,  col = i & 3;
 890
 891         B_PREDICTION_MODE m;
 892
 893         if (labelings[i] != which_label)
 894             continue;
 895
 896         if (col  &&  labelings[i] == labelings[i-1])
 897             m = LEFT4X4;
 898         else if (row  &&  labelings[i] == labelings[i-4])
 899             m = ABOVE4X4;
 900         else
 901         {
 902             // the only time we should do costing for new motion vector or mode
 903             // is when we are on a new label  (jbb May 08, 2007)
 904             switch (m = this_mode)
 905             {
 906             case NEW4X4 :
 907                 thismvcost  = vp8_mv_bit_cost(this_mv, best_ref_mv, mvcost, 102);
 908                 break;
 909             case LEFT4X4:
 910                 *this_mv = col ? d[-1].bmi.mv.as_mv : vp8_left_bmi(mic, i)->mv.as_mv;
 911                 break;
 912             case ABOVE4X4:
 913                 *this_mv = row ? d[-4].bmi.mv.as_mv : vp8_above_bmi(mic, i, mis)->mv.as_mv;
 914                 break;
 915             case ZERO4X4:
 916                 this_mv->row = this_mv->col = 0;
 917                 break;
 918             default:
 919                 break;
 920             }
 921
 922             if (m == ABOVE4X4)  // replace above with left if same
 923             {
 924                 const MV mv = col ? d[-1].bmi.mv.as_mv : vp8_left_bmi(mic, i)->mv.as_mv;
 925
 926                 if (mv.row == this_mv->row  &&  mv.col == this_mv->col)
 927                     m = LEFT4X4;
 928             }
 929
 930             cost = x->inter_bmode_costs[ m];
 931         }
 932
 933         d->bmi.mode = m;
 934         d->bmi.mv.as_mv = *this_mv;
 935
 936     }
 937     while (++i < 16);
 938
 939     cost += thismvcost ;
 940     return cost;
 941 }
 942
 943 static int rdcost_mbsegment_y(MACROBLOCK *mb, const int *labels,
 944                               int which_label, ENTROPY_CONTEXT *ta,
 945                               ENTROPY_CONTEXT *tl)
 946 {
 947     int cost = 0;
 948     int b;
 949     MACROBLOCKD *x = &mb->e_mbd;
 950
 951     for (b = 0; b < 16; b++)
 952         if (labels[ b] == which_label)
 953             cost += cost_coeffs(mb, x->block + b, 3,
 954                                 ta + vp8_block2above[b],
 955                                 tl + vp8_block2left[b]);
 956
 957     return cost;
 958
 959 }
 960 static unsigned int vp8_encode_inter_mb_segment(MACROBLOCK *x, int const *labels, int which_label, const vp8_encodemb_rtcd_vtable_t *rtcd)
 961 {
 962     int i;
 963     unsigned int distortion = 0;
 964
 965     for (i = 0; i < 16; i++)
 966     {
 967         if (labels[i] == which_label)
 968         {
 969             BLOCKD *bd = &x->e_mbd.block[i];
 970             BLOCK *be = &x->block[i];
 971
 972
 973             vp8_build_inter_predictors_b(bd, 16, x->e_mbd.subpixel_predict);
 974             ENCODEMB_INVOKE(rtcd, subb)(be, bd, 16);
 975             x->vp8_short_fdct4x4(be->src_diff, be->coeff, 32);
 976
 977             // set to 0 no way to account for 2nd order DC so discount
 978             //be->coeff[0] = 0;
 979             x->quantize_b(be, bd);
 980
 981             distortion += ENCODEMB_INVOKE(rtcd, berr)(be->coeff, bd->dqcoeff);
 982         }
 983     }
 984
 985     return distortion;
 986 }
 987
 988 unsigned char vp8_mbsplit_offset2[4][16] = {
 989     { 0,  8,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0},
 990     { 0,  2,  0,  0,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0},
 991     { 0,  2,  8, 10,  0,  0,  0,  0,  0,  0,   0,  0,  0,  0,  0,  0},
 992     { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15}
 993 };
 994
 995
 996 static const unsigned int segmentation_to_sseshift[4] = {3, 3, 2, 0};
 997
 998
 999 typedef struct
1000 {
1001   MV *ref_mv;
1002   MV *mvp;
1003
1004   int segment_rd;
1005   int segment_num;
1006   int r;
1007   int d;
1008   int segment_yrate;
1009   B_PREDICTION_MODE modes[16];
1010   int_mv mvs[16];
1011   unsigned char eobs[16];
1012
1013   int mvthresh;
1014   int *mdcounts;
1015
1016   MV sv_mvp[4];     // save 4 mvp from 8x8
1017   int sv_istep[2];  // save 2 initial step_param for 16x8/8x16
1018
1019 } BEST_SEG_INFO;
1020
1021
1022 void vp8_rd_check_segment(VP8_COMP *cpi, MACROBLOCK *x, BEST_SEG_INFO *bsi,
1023                          unsigned int segmentation)
1024 {
1025     int i;
1026     int const *labels;
1027     int br = 0;
1028     int bd = 0;
1029     B_PREDICTION_MODE this_mode;
1030
1031
1032     int label_count;
1033     int this_segment_rd = 0;
1034     int label_mv_thresh;
1035     int rate = 0;
1036     int sbr = 0;
1037     int sbd = 0;
1038     int segmentyrate = 0;
1039
1040     vp8_variance_fn_ptr_t *v_fn_ptr;
1041
1042     ENTROPY_CONTEXT_PLANES t_above, t_left;
1043     ENTROPY_CONTEXT *ta;
1044     ENTROPY_CONTEXT *tl;
1045     ENTROPY_CONTEXT_PLANES t_above_b, t_left_b;
1046     ENTROPY_CONTEXT *ta_b;
1047     ENTROPY_CONTEXT *tl_b;
1048
1049     vpx_memcpy(&t_above, x->e_mbd.above_context, sizeof(ENTROPY_CONTEXT_PLANES));
1050     vpx_memcpy(&t_left, x->e_mbd.left_context, sizeof(ENTROPY_CONTEXT_PLANES));
1051
1052     ta = (ENTROPY_CONTEXT *)&t_above;
1053     tl = (ENTROPY_CONTEXT *)&t_left;
1054     ta_b = (ENTROPY_CONTEXT *)&t_above_b;
1055     tl_b = (ENTROPY_CONTEXT *)&t_left_b;
1056
1057     br = 0;
1058     bd = 0;
1059
1060     v_fn_ptr = &cpi->fn_ptr[segmentation];
1061     labels = vp8_mbsplits[segmentation];
1062     label_count = vp8_mbsplit_count[segmentation];
1063
1064     // 64 makes this threshold really big effectively
1065     // making it so that we very rarely check mvs on
1066     // segments.   setting this to 1 would make mv thresh
1067     // roughly equal to what it is for macroblocks
1068     label_mv_thresh = 1 * bsi->mvthresh / label_count ;
1069
1070     // Segmentation method overheads
1071     rate = vp8_cost_token(vp8_mbsplit_tree, vp8_mbsplit_probs, vp8_mbsplit_encodings + segmentation);
1072     rate += vp8_cost_mv_ref(SPLITMV, bsi->mdcounts);
1073     this_segment_rd += RDCOST(x->rdmult, x->rddiv, rate, 0);
1074     br += rate;
1075
1076     for (i = 0; i < label_count; i++)
1077     {
1078         MV mode_mv[B_MODE_COUNT];
1079         int best_label_rd = INT_MAX;
1080         B_PREDICTION_MODE mode_selected = ZERO4X4;
1081         int bestlabelyrate = 0;
1082
1083         // search for the best motion vector on this segment
1084         for (this_mode = LEFT4X4; this_mode <= NEW4X4 ; this_mode ++)
1085         {
1086             int this_rd;
1087             int distortion;
1088             int labelyrate;
1089             ENTROPY_CONTEXT_PLANES t_above_s, t_left_s;
1090             ENTROPY_CONTEXT *ta_s;
1091             ENTROPY_CONTEXT *tl_s;
1092
1093             vpx_memcpy(&t_above_s, &t_above, sizeof(ENTROPY_CONTEXT_PLANES));
1094             vpx_memcpy(&t_left_s, &t_left, sizeof(ENTROPY_CONTEXT_PLANES));
1095
1096             ta_s = (ENTROPY_CONTEXT *)&t_above_s;
1097             tl_s = (ENTROPY_CONTEXT *)&t_left_s;
1098
1099             if (this_mode == NEW4X4)
1100             {
1101                 int sseshift;
1102                 int num00;
1103                 int step_param = 0;
1104                 int further_steps;
1105                 int n;
1106                 int thissme;
1107                 int bestsme = INT_MAX;
1108                 MV  temp_mv;
1109                 BLOCK *c;
1110                 BLOCKD *e;
1111
1112                 // Is the best so far sufficiently good that we cant justify doing and new motion search.
1113                 if (best_label_rd < label_mv_thresh)
1114                     break;
1115
1116                 if(cpi->compressor_speed)
1117                 {
1118                     if (segmentation == BLOCK_8X16 || segmentation == BLOCK_16X8)
1119                     {
1120                         bsi->mvp = &bsi->sv_mvp[i];
1121                         if (i==1 && segmentation == BLOCK_16X8) bsi->mvp = &bsi->sv_mvp[2];
1122
1123                         step_param = bsi->sv_istep[i];
1124                     }
1125
1126                     // use previous block's result as next block's MV predictor.
1127                     if (segmentation == BLOCK_4X4 && i>0)
1128                     {
1129                         bsi->mvp = &(x->e_mbd.block[i-1].bmi.mv.as_mv);
1130                         if (i==4 || i==8 || i==12) bsi->mvp = &(x->e_mbd.block[i-4].bmi.mv.as_mv);
1131                         step_param = 2;
1132                     }
1133                 }
1134
1135                 further_steps = (MAX_MVSEARCH_STEPS - 1) - step_param;
1136
1137                 {
1138                     int sadpb = x->sadperbit4;
1139
1140                     // find first label
1141                     n = vp8_mbsplit_offset2[segmentation][i];
1142
1143                     c = &x->block[n];
1144                     e = &x->e_mbd.block[n];
1145
1146                     if (cpi->sf.search_method == HEX)
1147                         bestsme = vp8_hex_search(x, c, e, bsi->ref_mv,
1148                                                  &mode_mv[NEW4X4], step_param, sadpb, &num00, v_fn_ptr, x->mvsadcost, x->mvcost);
1149
1150                     else
1151                     {
1152                         bestsme = cpi->diamond_search_sad(x, c, e, bsi->mvp,
1153                                                           &mode_mv[NEW4X4], step_param,
1154                                                           sadpb / 2, &num00, v_fn_ptr, x->mvsadcost, x->mvcost, bsi->ref_mv);
1155
1156                         n = num00;
1157                         num00 = 0;
1158
1159                         while (n < further_steps)
1160                         {
1161                             n++;
1162
1163                             if (num00)
1164                                 num00--;
1165                             else
1166                             {
1167                                 thissme = cpi->diamond_search_sad(x, c, e, bsi->mvp,
1168                                                                   &temp_mv, step_param + n,
1169                                                                   sadpb / 2, &num00, v_fn_ptr, x->mvsadcost, x->mvcost, bsi->ref_mv);
1170
1171                                 if (thissme < bestsme)
1172                                 {
1173                                     bestsme = thissme;
1174                                     mode_mv[NEW4X4].row = temp_mv.row;
1175                                     mode_mv[NEW4X4].col = temp_mv.col;
1176                                 }
1177                             }
1178                         }
1179                     }
1180
1181                     sseshift = segmentation_to_sseshift[segmentation];
1182
1183                     // Should we do a full search (best quality only)
1184                     if ((cpi->compressor_speed == 0) && (bestsme >> sseshift) > 4000)
1185                     {
1186                         thissme = cpi->full_search_sad(x, c, e, bsi->mvp,
1187                                                        sadpb / 4, 16, v_fn_ptr, x->mvcost, x->mvsadcost,bsi->ref_mv);
1188
1189                         if (thissme < bestsme)
1190                         {
1191                             bestsme = thissme;
1192                             mode_mv[NEW4X4] = e->bmi.mv.as_mv;
1193                         }
1194                         else
1195                         {
1196                             // The full search result is actually worse so re-instate the previous best vector
1197                             e->bmi.mv.as_mv = mode_mv[NEW4X4];
1198                         }
1199                     }
1200                 }
1201
1202                 if (bestsme < INT_MAX)
1203                 {
1204                     if (!cpi->common.full_pixel)
1205                         cpi->find_fractional_mv_step(x, c, e, &mode_mv[NEW4X4],
1206                                                      bsi->ref_mv, x->errorperbit / 2, v_fn_ptr, x->mvcost);
1207                     else
1208                         vp8_skip_fractional_mv_step(x, c, e, &mode_mv[NEW4X4],
1209                                                     bsi->ref_mv, x->errorperbit, v_fn_ptr, x->mvcost);
1210                 }
1211             } /* NEW4X4 */
1212
1213             rate = labels2mode(x, labels, i, this_mode, &mode_mv[this_mode],
1214                                bsi->ref_mv, x->mvcost);
1215
1216             // Trap vectors that reach beyond the UMV borders
1217             if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].row >> 3) > x->mv_row_max) ||
1218                 ((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_max))
1219             {
1220                 continue;
1221             }
1222
1223             distortion = vp8_encode_inter_mb_segment(x, labels, i, IF_RTCD(&cpi->rtcd.encodemb)) / 4;
1224
1225             labelyrate = rdcost_mbsegment_y(x, labels, i, ta_s, tl_s);
1226             rate += labelyrate;
1227
1228             this_rd = RDCOST(x->rdmult, x->rddiv, rate, distortion);
1229
1230             if (this_rd < best_label_rd)
1231             {
1232                 sbr = rate;
1233                 sbd = distortion;
1234                 bestlabelyrate = labelyrate;
1235                 mode_selected = this_mode;
1236                 best_label_rd = this_rd;
1237
1238                 vpx_memcpy(ta_b, ta_s, sizeof(ENTROPY_CONTEXT_PLANES));
1239                 vpx_memcpy(tl_b, tl_s, sizeof(ENTROPY_CONTEXT_PLANES));
1240
1241             }
1242         } /*for each 4x4 mode*/
1243
1244         vpx_memcpy(ta, ta_b, sizeof(ENTROPY_CONTEXT_PLANES));
1245         vpx_memcpy(tl, tl_b, sizeof(ENTROPY_CONTEXT_PLANES));
1246
1247         labels2mode(x, labels, i, mode_selected, &mode_mv[mode_selected],
1248                     bsi->ref_mv, x->mvcost);
1249
1250         br += sbr;
1251         bd += sbd;
1252         segmentyrate += bestlabelyrate;
1253         this_segment_rd += best_label_rd;
1254
1255         if (this_segment_rd >= bsi->segment_rd)
1256             break;
1257
1258     } /* for each label */
1259
1260     if (this_segment_rd < bsi->segment_rd)
1261     {
1262         bsi->r = br;
1263         bsi->d = bd;
1264         bsi->segment_yrate = segmentyrate;
1265         bsi->segment_rd = this_segment_rd;
1266         bsi->segment_num = segmentation;
1267
1268         // store everything needed to come back to this!!
1269         for (i = 0; i < 16; i++)
1270         {
1271             BLOCKD *bd = &x->e_mbd.block[i];
1272
1273             bsi->mvs[i].as_mv = bd->bmi.mv.as_mv;
1274             bsi->modes[i] = bd->bmi.mode;
1275             bsi->eobs[i] = bd->eob;
1276         }
1277     }
1278 }
1279
1280 static __inline
1281 void vp8_cal_step_param(int sr, int *sp)
1282 {
1283     int step = 0;
1284
1285     if (sr > MAX_FIRST_STEP) sr = MAX_FIRST_STEP;
1286     else if (sr < 1) sr = 1;
1287
1288     while (sr>>=1)
1289         step++;
1290
1291     *sp = MAX_MVSEARCH_STEPS - 1 - step;
1292 }
1293
1294 static int vp8_rd_pick_best_mbsegmentation(VP8_COMP *cpi, MACROBLOCK *x,
1295                                            MV *best_ref_mv, int best_rd,
1296                                            int *mdcounts, int *returntotrate,
1297                                            int *returnyrate, int *returndistortion,
1298                                            int mvthresh)
1299 {
1300     int i;
1301     BEST_SEG_INFO bsi;
1302
1303     vpx_memset(&bsi, 0, sizeof(bsi));
1304
1305     bsi.segment_rd = best_rd;
1306     bsi.ref_mv = best_ref_mv;
1307     bsi.mvp = best_ref_mv;
1308     bsi.mvthresh = mvthresh;
1309     bsi.mdcounts = mdcounts;
1310
1311     for(i = 0; i < 16; i++)
1312     {
1313         bsi.modes[i] = ZERO4X4;
1314     }
1315
1316     if(cpi->compressor_speed == 0)
1317     {
1318         /* for now, we will keep the original segmentation order
1319            when in best quality mode */
1320         vp8_rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
1321         vp8_rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
1322         vp8_rd_check_segment(cpi, x, &bsi, BLOCK_8X8);
1323         vp8_rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
1324     }
1325     else
1326     {
1327         int sr;
1328
1329         vp8_rd_check_segment(cpi, x, &bsi, BLOCK_8X8);
1330
1331         if (bsi.segment_rd < best_rd)
1332         {
1333             int col_min = (best_ref_mv->col - MAX_FULL_PEL_VAL) >>3;
1334             int col_max = (best_ref_mv->col + MAX_FULL_PEL_VAL) >>3;
1335             int row_min = (best_ref_mv->row - MAX_FULL_PEL_VAL) >>3;
1336             int row_max = (best_ref_mv->row + MAX_FULL_PEL_VAL) >>3;
1337
1338             int tmp_col_min = x->mv_col_min;
1339             int tmp_col_max = x->mv_col_max;
1340             int tmp_row_min = x->mv_row_min;
1341             int tmp_row_max = x->mv_row_max;
1342
1343             /* Get intersection of UMV window and valid MV window to reduce # of checks in diamond search. */
1344             if (x->mv_col_min < col_min )
1345                 x->mv_col_min = col_min;
1346             if (x->mv_col_max > col_max )
1347                 x->mv_col_max = col_max;
1348             if (x->mv_row_min < row_min )
1349                 x->mv_row_min = row_min;
1350             if (x->mv_row_max > row_max )
1351                 x->mv_row_max = row_max;
1352
1353             /* Get 8x8 result */
1354             bsi.sv_mvp[0] = bsi.mvs[0].as_mv;
1355             bsi.sv_mvp[1] = bsi.mvs[2].as_mv;
1356             bsi.sv_mvp[2] = bsi.mvs[8].as_mv;
1357             bsi.sv_mvp[3] = bsi.mvs[10].as_mv;
1358
1359             /* Use 8x8 result as 16x8/8x16's predictor MV. Adjust search range according to the closeness of 2 MV. */
1360             /* block 8X16 */
1361             {
1362                 sr = MAXF((abs(bsi.sv_mvp[0].row - bsi.sv_mvp[2].row))>>3, (abs(bsi.sv_mvp[0].col - bsi.sv_mvp[2].col))>>3);
1363                 vp8_cal_step_param(sr, &bsi.sv_istep[0]);
1364
1365                 sr = MAXF((abs(bsi.sv_mvp[1].row - bsi.sv_mvp[3].row))>>3, (abs(bsi.sv_mvp[1].col - bsi.sv_mvp[3].col))>>3);
1366                 vp8_cal_step_param(sr, &bsi.sv_istep[1]);
1367
1368                 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_8X16);
1369             }
1370
1371             /* block 16X8 */
1372             {
1373                 sr = MAXF((abs(bsi.sv_mvp[0].row - bsi.sv_mvp[1].row))>>3, (abs(bsi.sv_mvp[0].col - bsi.sv_mvp[1].col))>>3);
1374                 vp8_cal_step_param(sr, &bsi.sv_istep[0]);
1375
1376                 sr = MAXF((abs(bsi.sv_mvp[2].row - bsi.sv_mvp[3].row))>>3, (abs(bsi.sv_mvp[2].col - bsi.sv_mvp[3].col))>>3);
1377                 vp8_cal_step_param(sr, &bsi.sv_istep[1]);
1378
1379                 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_16X8);
1380             }
1381
1382             /* If 8x8 is better than 16x8/8x16, then do 4x4 search */
1383             /* Not skip 4x4 if speed=0 (good quality) */
1384             if (cpi->sf.no_skip_block4x4_search || bsi.segment_num == BLOCK_8X8)  /* || (sv_segment_rd8x8-bsi.segment_rd) < sv_segment_rd8x8>>5) */
1385             {
1386                 bsi.mvp = &bsi.sv_mvp[0];
1387                 vp8_rd_check_segment(cpi, x, &bsi, BLOCK_4X4);
1388             }
1389
1390             /* restore UMV window */
1391             x->mv_col_min = tmp_col_min;
1392             x->mv_col_max = tmp_col_max;
1393             x->mv_row_min = tmp_row_min;
1394             x->mv_row_max = tmp_row_max;
1395         }
1396     }
1397
1398     /* set it to the best */
1399     for (i = 0; i < 16; i++)
1400     {
1401         BLOCKD *bd = &x->e_mbd.block[i];
1402
1403         bd->bmi.mv.as_mv = bsi.mvs[i].as_mv;
1404         bd->bmi.mode = bsi.modes[i];
1405         bd->eob = bsi.eobs[i];
1406     }
1407
1408     *returntotrate = bsi.r;
1409     *returndistortion = bsi.d;
1410     *returnyrate = bsi.segment_yrate;
1411
1412     /* save partitions */
1413     x->e_mbd.mode_info_context->mbmi.partitioning = bsi.segment_num;
1414     x->partition_info->count = vp8_mbsplit_count[bsi.segment_num];
1415
1416     for (i = 0; i < x->partition_info->count; i++)
1417     {
1418         int j;
1419
1420         j = vp8_mbsplit_offset2[bsi.segment_num][i];
1421
1422         x->partition_info->bmi[i].mode = x->e_mbd.block[j].bmi.mode;
1423         x->partition_info->bmi[i].mv.as_mv = x->e_mbd.block[j].bmi.mv.as_mv;
1424     }
1425
1426     return bsi.segment_rd;
1427 }
1428
1429 static void swap(int *x,int *y)
1430 {
1431    int tmp;
1432
1433    tmp = *x;
1434    *x = *y;
1435    *y = tmp;
1436 }
1437
1438 static void quicksortmv(int arr[],int left, int right)
1439 {
1440    int lidx,ridx,pivot;
1441
1442    lidx = left;
1443    ridx = right;
1444
1445    if( left < right)
1446    {
1447       pivot = (left + right)/2;
1448
1449       while(lidx <=pivot && ridx >=pivot)
1450       {
1451           while(arr[lidx] < arr[pivot] && lidx <= pivot)
1452               lidx++;
1453           while(arr[ridx] > arr[pivot] && ridx >= pivot)
1454               ridx--;
1455           swap(&arr[lidx], &arr[ridx]);
1456           lidx++;
1457           ridx--;
1458           if(lidx-1 == pivot)
1459           {
1460               ridx++;
1461               pivot = ridx;
1462           }
1463           else if(ridx+1 == pivot)
1464           {
1465               lidx--;
1466               pivot = lidx;
1467           }
1468       }
1469       quicksortmv(arr, left, pivot - 1);
1470       quicksortmv(arr, pivot + 1, right);
1471    }
1472 }
1473
1474 static void quicksortsad(int arr[],int idx[], int left, int right)
1475 {
1476    int lidx,ridx,pivot;
1477
1478    lidx = left;
1479    ridx = right;
1480
1481    if( left < right)
1482    {
1483       pivot = (left + right)/2;
1484
1485       while(lidx <=pivot && ridx >=pivot)
1486       {
1487           while(arr[lidx] < arr[pivot] && lidx <= pivot)
1488               lidx++;
1489           while(arr[ridx] > arr[pivot] && ridx >= pivot)
1490               ridx--;
1491           swap(&arr[lidx], &arr[ridx]);
1492           swap(&idx[lidx], &idx[ridx]);
1493           lidx++;
1494           ridx--;
1495           if(lidx-1 == pivot)
1496           {
1497               ridx++;
1498               pivot = ridx;
1499           }
1500           else if(ridx+1 == pivot)
1501           {
1502               lidx--;
1503               pivot = lidx;
1504           }
1505       }
1506       quicksortsad(arr, idx, left, pivot - 1);
1507       quicksortsad(arr, idx, pivot + 1, right);
1508    }
1509 }
1510
1511 //The improved MV prediction
1512 void vp8_mv_pred
1513 (
1514     VP8_COMP *cpi,
1515     MACROBLOCKD *xd,
1516     const MODE_INFO *here,
1517     MV *mvp,
1518     int refframe,
1519     int *ref_frame_sign_bias,
1520     int *sr,
1521     int near_sadidx[]
1522 )
1523 {
1524     const MODE_INFO *above = here - xd->mode_info_stride;
1525     const MODE_INFO *left = here - 1;
1526     const MODE_INFO *aboveleft = above - 1;
1527     int_mv           near_mvs[8];
1528     int              near_ref[8];
1529     int_mv           mv;
1530     int              vcnt=0;
1531     int              find=0;
1532     int              mb_offset;
1533
1534     int              mvx[8];
1535     int              mvy[8];
1536     int              i;
1537
1538     mv.as_int = 0;
1539
1540     if(here->mbmi.ref_frame != INTRA_FRAME)
1541     {
1542         near_mvs[0].as_int = near_mvs[1].as_int = near_mvs[2].as_int = near_mvs[3].as_int = near_mvs[4].as_int = near_mvs[5].as_int = near_mvs[6].as_int = near_mvs[7].as_int = 0;
1543         near_ref[0] = near_ref[1] = near_ref[2] = near_ref[3] = near_ref[4] = near_ref[5] = near_ref[6] = near_ref[7] = 0;
1544
1545         // read in 3 nearby block's MVs from current frame as prediction candidates.
1546         if (above->mbmi.ref_frame != INTRA_FRAME)
1547         {
1548             near_mvs[vcnt].as_int = above->mbmi.mv.as_int;
1549             mv_bias(ref_frame_sign_bias[above->mbmi.ref_frame], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1550             near_ref[vcnt] =  above->mbmi.ref_frame;
1551         }
1552         vcnt++;
1553         if (left->mbmi.ref_frame != INTRA_FRAME)
1554         {
1555             near_mvs[vcnt].as_int = left->mbmi.mv.as_int;
1556             mv_bias(ref_frame_sign_bias[left->mbmi.ref_frame], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1557             near_ref[vcnt] =  left->mbmi.ref_frame;
1558         }
1559         vcnt++;
1560         if (aboveleft->mbmi.ref_frame != INTRA_FRAME)
1561         {
1562             near_mvs[vcnt].as_int = aboveleft->mbmi.mv.as_int;
1563             mv_bias(ref_frame_sign_bias[aboveleft->mbmi.ref_frame], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1564             near_ref[vcnt] =  aboveleft->mbmi.ref_frame;
1565         }
1566         vcnt++;
1567
1568         // read in 5 nearby block's MVs from last frame.
1569         if(cpi->common.last_frame_type != KEY_FRAME)
1570         {
1571             mb_offset = (-xd->mb_to_top_edge/128 + 1) * (xd->mode_info_stride +1) + (-xd->mb_to_left_edge/128 +1) ;
1572
1573             // current in last frame
1574             if (cpi->lf_ref_frame[mb_offset] != INTRA_FRAME)
1575             {
1576                 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset].as_int;
1577                 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1578                 near_ref[vcnt] =  cpi->lf_ref_frame[mb_offset];
1579             }
1580             vcnt++;
1581
1582             // above in last frame
1583             if (cpi->lf_ref_frame[mb_offset - xd->mode_info_stride-1] != INTRA_FRAME)
1584             {
1585                 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset - xd->mode_info_stride-1].as_int;
1586                 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset - xd->mode_info_stride-1], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1587                 near_ref[vcnt] =  cpi->lf_ref_frame[mb_offset - xd->mode_info_stride-1];
1588             }
1589             vcnt++;
1590
1591             // left in last frame
1592             if (cpi->lf_ref_frame[mb_offset-1] != INTRA_FRAME)
1593             {
1594                 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset -1].as_int;
1595                 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset -1], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1596                 near_ref[vcnt] =  cpi->lf_ref_frame[mb_offset - 1];
1597             }
1598             vcnt++;
1599
1600             // right in last frame
1601             if (cpi->lf_ref_frame[mb_offset +1] != INTRA_FRAME)
1602             {
1603                 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset +1].as_int;
1604                 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset +1], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1605                 near_ref[vcnt] =  cpi->lf_ref_frame[mb_offset +1];
1606             }
1607             vcnt++;
1608
1609             // below in last frame
1610             if (cpi->lf_ref_frame[mb_offset + xd->mode_info_stride +1] != INTRA_FRAME)
1611             {
1612                 near_mvs[vcnt].as_int = cpi->lfmv[mb_offset + xd->mode_info_stride +1].as_int;
1613                 mv_bias(cpi->lf_ref_frame_sign_bias[mb_offset + xd->mode_info_stride +1], refframe, &near_mvs[vcnt], ref_frame_sign_bias);
1614                 near_ref[vcnt] =  cpi->lf_ref_frame[mb_offset + xd->mode_info_stride +1];
1615             }
1616             vcnt++;
1617         }
1618
1619         for(i=0; i< vcnt; i++)
1620         {
1621             if(near_ref[near_sadidx[i]] != INTRA_FRAME)
1622             {
1623                 if(here->mbmi.ref_frame == near_ref[near_sadidx[i]])
1624                 {
1625                     mv.as_int = near_mvs[near_sadidx[i]].as_int;
1626                     find = 1;
1627                     if (i < 3)
1628                         *sr = 3;
1629                     else
1630                         *sr = 2;
1631                     break;
1632                 }
1633             }
1634         }
1635
1636         if(!find)
1637         {
1638             for(i=0; i<vcnt; i++)
1639             {
1640                 mvx[i] = near_mvs[i].as_mv.row;
1641                 mvy[i] = near_mvs[i].as_mv.col;
1642             }
1643
1644             quicksortmv (mvx, 0, vcnt-1);
1645             quicksortmv (mvy, 0, vcnt-1);
1646             mv.as_mv.row = mvx[vcnt/2];
1647             mv.as_mv.col = mvy[vcnt/2];
1648
1649             find = 1;
1650             //sr is set to 0 to allow calling function to decide the search range.
1651             *sr = 0;
1652         }
1653     }
1654
1655     /* Set up return values */
1656     *mvp = mv.as_mv;
1657     vp8_clamp_mv(mvp, xd);
1658 }
1659
1660 int vp8_rd_pick_inter_mode(VP8_COMP *cpi, MACROBLOCK *x, int recon_yoffset, int recon_uvoffset, int *returnrate, int *returndistortion, int *returnintra)
1661 {
1662     BLOCK *b = &x->block[0];
1663     BLOCKD *d = &x->e_mbd.block[0];
1664     MACROBLOCKD *xd = &x->e_mbd;
1665     B_MODE_INFO best_bmodes[16];
1666     MB_MODE_INFO best_mbmode;
1667     PARTITION_INFO best_partition;
1668     MV best_ref_mv;
1669     MV mode_mv[MB_MODE_COUNT];
1670     MB_PREDICTION_MODE this_mode;
1671     int num00;
1672     int best_mode_index = 0;
1673
1674     int i;
1675     int mode_index;
1676     int mdcounts[4];
1677     int rate;
1678     int distortion;
1679     int best_rd = INT_MAX; // 1 << 30;
1680     int ref_frame_cost[MAX_REF_FRAMES];
1681     int rate2, distortion2;
1682     int uv_intra_rate, uv_intra_distortion, uv_intra_rate_tokenonly;
1683     int rate_y, UNINITIALIZED_IS_SAFE(rate_uv);
1684     int distortion_uv;
1685     int best_yrd = INT_MAX;
1686
1687     //int all_rds[MAX_MODES];        // Experimental debug code.
1688     //int all_rates[MAX_MODES];
1689     //int all_dist[MAX_MODES];
1690     //int intermodecost[MAX_MODES];
1691
1692     MB_PREDICTION_MODE uv_intra_mode;
1693
1694     int force_no_skip = 0;
1695
1696     MV mvp;
1697     int near_sad[8] = {0}; // 0-cf above, 1-cf left, 2-cf aboveleft, 3-lf current, 4-lf above, 5-lf left, 6-lf right, 7-lf below
1698     int near_sadidx[8] = {0, 1, 2, 3, 4, 5, 6, 7};
1699     int saddone=0;
1700     int sr=0;    //search range got from mv_pred(). It uses step_param levels. (0-7)
1701
1702     MV frame_nearest_mv[4];
1703     MV frame_near_mv[4];
1704     MV frame_best_ref_mv[4];
1705     int frame_mdcounts[4][4];
1706     int frame_lf_or_gf[4];
1707     unsigned char *y_buffer[4];
1708     unsigned char *u_buffer[4];
1709     unsigned char *v_buffer[4];
1710
1711     vpx_memset(&best_mbmode, 0, sizeof(best_mbmode));
1712
1713     if (cpi->ref_frame_flags & VP8_LAST_FLAG)
1714     {
1715         YV12_BUFFER_CONFIG *lst_yv12 = &cpi->common.yv12_fb[cpi->common.lst_fb_idx];
1716
1717         vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[LAST_FRAME], &frame_near_mv[LAST_FRAME],
1718                           &frame_best_ref_mv[LAST_FRAME], frame_mdcounts[LAST_FRAME], LAST_FRAME, cpi->common.ref_frame_sign_bias);
1719
1720         y_buffer[LAST_FRAME] = lst_yv12->y_buffer + recon_yoffset;
1721         u_buffer[LAST_FRAME] = lst_yv12->u_buffer + recon_uvoffset;
1722         v_buffer[LAST_FRAME] = lst_yv12->v_buffer + recon_uvoffset;
1723
1724         frame_lf_or_gf[LAST_FRAME] = 0;
1725     }
1726
1727     if (cpi->ref_frame_flags & VP8_GOLD_FLAG)
1728     {
1729         YV12_BUFFER_CONFIG *gld_yv12 = &cpi->common.yv12_fb[cpi->common.gld_fb_idx];
1730
1731         vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[GOLDEN_FRAME], &frame_near_mv[GOLDEN_FRAME],
1732                           &frame_best_ref_mv[GOLDEN_FRAME], frame_mdcounts[GOLDEN_FRAME], GOLDEN_FRAME, cpi->common.ref_frame_sign_bias);
1733
1734         y_buffer[GOLDEN_FRAME] = gld_yv12->y_buffer + recon_yoffset;
1735         u_buffer[GOLDEN_FRAME] = gld_yv12->u_buffer + recon_uvoffset;
1736         v_buffer[GOLDEN_FRAME] = gld_yv12->v_buffer + recon_uvoffset;
1737
1738         frame_lf_or_gf[GOLDEN_FRAME] = 1;
1739     }
1740
1741     if (cpi->ref_frame_flags & VP8_ALT_FLAG)
1742     {
1743         YV12_BUFFER_CONFIG *alt_yv12 = &cpi->common.yv12_fb[cpi->common.alt_fb_idx];
1744
1745         vp8_find_near_mvs(&x->e_mbd, x->e_mbd.mode_info_context, &frame_nearest_mv[ALTREF_FRAME], &frame_near_mv[ALTREF_FRAME],
1746                           &frame_best_ref_mv[ALTREF_FRAME], frame_mdcounts[ALTREF_FRAME], ALTREF_FRAME, cpi->common.ref_frame_sign_bias);
1747
1748         y_buffer[ALTREF_FRAME] = alt_yv12->y_buffer + recon_yoffset;
1749         u_buffer[ALTREF_FRAME] = alt_yv12->u_buffer + recon_uvoffset;
1750         v_buffer[ALTREF_FRAME] = alt_yv12->v_buffer + recon_uvoffset;
1751
1752         frame_lf_or_gf[ALTREF_FRAME] = 1;
1753     }
1754
1755     *returnintra = INT_MAX;
1756     cpi->mbs_tested_so_far++;          // Count of the number of MBs tested so far this frame
1757
1758     x->skip = 0;
1759
1760     ref_frame_cost[INTRA_FRAME]   = vp8_cost_zero(cpi->prob_intra_coded);
1761
1762     // Special case treatment when GF and ARF are not sensible options for reference
1763     if (cpi->ref_frame_flags == VP8_LAST_FLAG)
1764     {
1765         ref_frame_cost[LAST_FRAME]    = vp8_cost_one(cpi->prob_intra_coded)
1766                                         + vp8_cost_zero(255);
1767         ref_frame_cost[GOLDEN_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
1768                                         + vp8_cost_one(255)
1769                                         + vp8_cost_zero(128);
1770         ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
1771                                         + vp8_cost_one(255)
1772                                         + vp8_cost_one(128);
1773     }
1774     else
1775     {
1776         ref_frame_cost[LAST_FRAME]    = vp8_cost_one(cpi->prob_intra_coded)
1777                                         + vp8_cost_zero(cpi->prob_last_coded);
1778         ref_frame_cost[GOLDEN_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
1779                                         + vp8_cost_one(cpi->prob_last_coded)
1780                                         + vp8_cost_zero(cpi->prob_gf_coded);
1781         ref_frame_cost[ALTREF_FRAME]  = vp8_cost_one(cpi->prob_intra_coded)
1782                                         + vp8_cost_one(cpi->prob_last_coded)
1783                                         + vp8_cost_one(cpi->prob_gf_coded);
1784     }
1785
1786     vpx_memset(mode_mv, 0, sizeof(mode_mv));
1787
1788     x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
1789     vp8_rd_pick_intra_mbuv_mode(cpi, x, &uv_intra_rate, &uv_intra_rate_tokenonly, &uv_intra_distortion);
1790     uv_intra_mode = x->e_mbd.mode_info_context->mbmi.uv_mode;
1791
1792     for (mode_index = 0; mode_index < MAX_MODES; mode_index++)
1793     {
1794         int this_rd = INT_MAX;
1795         int lf_or_gf = 0;           // Lat Frame (01) or gf/arf (1)
1796         int disable_skip = 0;
1797         int other_cost = 0;
1798
1799         force_no_skip = 0;
1800
1801         // Experimental debug code.
1802         // Record of rd values recorded for this MB. -1 indicates not measured
1803         //all_rds[mode_index] = -1;
1804         //all_rates[mode_index] = -1;
1805         //all_dist[mode_index] = -1;
1806         //intermodecost[mode_index] = -1;
1807
1808         // Test best rd so far against threshold for trying this mode.
1809         if (best_rd <= cpi->rd_threshes[mode_index])
1810             continue;
1811
1812         // These variables hold are rolling total cost and distortion for this mode
1813         rate2 = 0;
1814         distortion2 = 0;
1815
1816         this_mode = vp8_mode_order[mode_index];
1817
1818         x->e_mbd.mode_info_context->mbmi.mode = this_mode;
1819         x->e_mbd.mode_info_context->mbmi.uv_mode = DC_PRED;
1820         x->e_mbd.mode_info_context->mbmi.ref_frame = vp8_ref_frame_order[mode_index];
1821
1822         // Only consider ZEROMV/ALTREF_FRAME for alt ref frame,
1823         // unless ARNR filtering is enabled in which case we want
1824         // an unfiltered alternative
1825         if (cpi->is_src_frame_alt_ref && (cpi->oxcf.arnr_max_frames == 0))
1826         {
1827             if (this_mode != ZEROMV || x->e_mbd.mode_info_context->mbmi.ref_frame != ALTREF_FRAME)
1828                 continue;
1829         }
1830
1831         /* everything but intra */
1832         if (x->e_mbd.mode_info_context->mbmi.ref_frame)
1833         {
1834             x->e_mbd.pre.y_buffer = y_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1835             x->e_mbd.pre.u_buffer = u_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1836             x->e_mbd.pre.v_buffer = v_buffer[x->e_mbd.mode_info_context->mbmi.ref_frame];
1837             mode_mv[NEARESTMV] = frame_nearest_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1838             mode_mv[NEARMV] = frame_near_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1839             best_ref_mv = frame_best_ref_mv[x->e_mbd.mode_info_context->mbmi.ref_frame];
1840             vpx_memcpy(mdcounts, frame_mdcounts[x->e_mbd.mode_info_context->mbmi.ref_frame], sizeof(mdcounts));
1841             lf_or_gf = frame_lf_or_gf[x->e_mbd.mode_info_context->mbmi.ref_frame];
1842         }
1843
1844
1845         if(x->e_mbd.mode_info_context->mbmi.mode == NEWMV)
1846         {
1847             if(!saddone)
1848             {
1849                 //calculate sad for current frame 3 nearby MBs.
1850                 if( xd->mb_to_top_edge==0 && xd->mb_to_left_edge ==0)
1851                 {
1852                     near_sad[0] = near_sad[1] = near_sad[2] = INT_MAX;
1853                 }else if(xd->mb_to_top_edge==0)
1854                 {   //only has left MB for sad calculation.
1855                     near_sad[0] = near_sad[2] = INT_MAX;
1856                     near_sad[1] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - 16,xd->dst.y_stride, 0x7fffffff);
1857                 }else if(xd->mb_to_left_edge ==0)
1858                 {   //only has left MB for sad calculation.
1859                     near_sad[1] = near_sad[2] = INT_MAX;
1860                     near_sad[0] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - xd->dst.y_stride *16,xd->dst.y_stride, 0x7fffffff);
1861                 }else
1862                 {
1863                     near_sad[0] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - xd->dst.y_stride *16,xd->dst.y_stride, 0x7fffffff);
1864                     near_sad[1] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - 16,xd->dst.y_stride, 0x7fffffff);
1865                     near_sad[2] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, xd->dst.y_buffer - xd->dst.y_stride *16 -16,xd->dst.y_stride, 0x7fffffff);
1866                 }
1867
1868                 if(cpi->common.last_frame_type != KEY_FRAME)
1869                 {
1870                     //calculate sad for last frame 5 nearby MBs.
1871                     unsigned char *pre_y_buffer = cpi->common.yv12_fb[cpi->common.lst_fb_idx].y_buffer + recon_yoffset;
1872                     int pre_y_stride = cpi->common.yv12_fb[cpi->common.lst_fb_idx].y_stride;
1873
1874                     if(xd->mb_to_top_edge==0) near_sad[4] = INT_MAX;
1875                     if(xd->mb_to_left_edge ==0) near_sad[5] = INT_MAX;
1876                     if(xd->mb_to_right_edge ==0) near_sad[6] = INT_MAX;
1877                     if(xd->mb_to_bottom_edge==0) near_sad[7] = INT_MAX;
1878
1879                     if(near_sad[4] != INT_MAX)
1880                         near_sad[4] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer - pre_y_stride *16, pre_y_stride, 0x7fffffff);
1881                     if(near_sad[5] != INT_MAX)
1882                         near_sad[5] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer - 16, pre_y_stride, 0x7fffffff);
1883                     near_sad[3] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer, pre_y_stride, 0x7fffffff);
1884                     if(near_sad[6] != INT_MAX)
1885                         near_sad[6] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer + 16, pre_y_stride, 0x7fffffff);
1886                     if(near_sad[7] != INT_MAX)
1887                         near_sad[7] = cpi->fn_ptr[BLOCK_16X16].sdf(x->src.y_buffer, x->src.y_stride, pre_y_buffer + pre_y_stride *16, pre_y_stride, 0x7fffffff);
1888                 }
1889
1890                 if(cpi->common.last_frame_type != KEY_FRAME)
1891                 {
1892                     quicksortsad(near_sad, near_sadidx, 0, 7);
1893                 }else
1894                 {
1895                     quicksortsad(near_sad, near_sadidx, 0, 2);
1896                 }
1897
1898                 saddone = 1;
1899             }
1900
1901             vp8_mv_pred(cpi, &x->e_mbd, x->e_mbd.mode_info_context, &mvp,
1902                         x->e_mbd.mode_info_context->mbmi.ref_frame, cpi->common.ref_frame_sign_bias, &sr, &near_sadidx[0]);
1903
1904             /* adjust mvp to make sure it is within MV range */
1905             if(mvp.row > best_ref_mv.row + MAX_FULL_PEL_VAL)
1906                 mvp.row = best_ref_mv.row + MAX_FULL_PEL_VAL;
1907             else if(mvp.row < best_ref_mv.row - MAX_FULL_PEL_VAL)
1908                 mvp.row = best_ref_mv.row - MAX_FULL_PEL_VAL;
1909             if(mvp.col > best_ref_mv.col + MAX_FULL_PEL_VAL)
1910                 mvp.col = best_ref_mv.col + MAX_FULL_PEL_VAL;
1911             else if(mvp.col < best_ref_mv.col - MAX_FULL_PEL_VAL)
1912                 mvp.col = best_ref_mv.col - MAX_FULL_PEL_VAL;
1913         }
1914
1915         // Check to see if the testing frequency for this mode is at its max
1916         // If so then prevent it from being tested and increase the threshold for its testing
1917         if (cpi->mode_test_hit_counts[mode_index] && (cpi->mode_check_freq[mode_index] > 1))
1918         {
1919             if (cpi->mbs_tested_so_far  <= cpi->mode_check_freq[mode_index] * cpi->mode_test_hit_counts[mode_index])
1920             {
1921                 // Increase the threshold for coding this mode to make it less likely to be chosen
1922                 cpi->rd_thresh_mult[mode_index] += 4;
1923
1924                 if (cpi->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
1925                     cpi->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
1926
1927                 cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
1928
1929                 continue;
1930             }
1931         }
1932
1933         // We have now reached the point where we are going to test the current mode so increment the counter for the number of times it has been tested
1934         cpi->mode_test_hit_counts[mode_index] ++;
1935
1936         // Experimental code. Special case for gf and arf zeromv modes. Increase zbin size to supress noise
1937         if (cpi->zbin_mode_boost_enabled)
1938         {
1939             if ( vp8_ref_frame_order[mode_index] == INTRA_FRAME )
1940                 cpi->zbin_mode_boost = 0;
1941             else
1942             {
1943                 if (vp8_mode_order[mode_index] == ZEROMV)
1944                 {
1945                     if (vp8_ref_frame_order[mode_index] != LAST_FRAME)
1946                         cpi->zbin_mode_boost = GF_ZEROMV_ZBIN_BOOST;
1947                     else
1948                         cpi->zbin_mode_boost = LF_ZEROMV_ZBIN_BOOST;
1949                 }
1950                 else if (vp8_ref_frame_order[mode_index] == SPLITMV)
1951                     cpi->zbin_mode_boost = 0;
1952                 else
1953                     cpi->zbin_mode_boost = MV_ZBIN_BOOST;
1954             }
1955
1956             vp8_update_zbin_extra(cpi, x);
1957         }
1958
1959         switch (this_mode)
1960         {
1961         case B_PRED:
1962
1963             for (i = 0; i < 16; i++)
1964             {
1965                 vpx_memset(&x->e_mbd.block[i].bmi, 0, sizeof(B_MODE_INFO));
1966             }
1967             // Note the rate value returned here includes the cost of coding the BPRED mode : x->mbmode_cost[x->e_mbd.frame_type][BPRED];
1968             vp8_rd_pick_intra4x4mby_modes(cpi, x, &rate, &rate_y, &distortion);
1969             rate2 += rate;
1970
1971             distortion2 += distortion;
1972             rate2 += uv_intra_rate;
1973             rate_uv = uv_intra_rate_tokenonly;
1974             distortion2 += uv_intra_distortion;
1975             distortion_uv = uv_intra_distortion;
1976             break;
1977
1978         case SPLITMV:
1979         {
1980             int tmp_rd;
1981             int this_rd_thresh;
1982
1983             this_rd_thresh = (x->e_mbd.mode_info_context->mbmi.ref_frame == LAST_FRAME) ? cpi->rd_threshes[THR_NEWMV] : cpi->rd_threshes[THR_NEWA];
1984             this_rd_thresh = (x->e_mbd.mode_info_context->mbmi.ref_frame == GOLDEN_FRAME) ? cpi->rd_threshes[THR_NEWG]: this_rd_thresh;
1985
1986             tmp_rd = vp8_rd_pick_best_mbsegmentation(cpi, x, &best_ref_mv,
1987                                                      best_yrd, mdcounts,
1988                                                      &rate, &rate_y, &distortion, this_rd_thresh) ;
1989
1990             rate2 += rate;
1991             distortion2 += distortion;
1992
1993             // If even the 'Y' rd value of split is higher than best so far then dont bother looking at UV
1994             if (tmp_rd < best_yrd)
1995             {
1996                 // Now work out UV cost and add it in
1997                 vp8_rd_inter_uv(cpi, x, &rate_uv, &distortion_uv, cpi->common.full_pixel);
1998                 rate2 += rate_uv;
1999                 distortion2 += distortion_uv;
2000             }
2001             else
2002             {
2003                 this_rd = INT_MAX;
2004                 disable_skip = 1;
2005             }
2006         }
2007         break;
2008         case DC_PRED:
2009         case V_PRED:
2010         case H_PRED:
2011         case TM_PRED:
2012             for (i = 0; i < 16; i++)
2013             {
2014                 vpx_memset(&x->e_mbd.block[i].bmi, 0, sizeof(B_MODE_INFO));
2015             }
2016             x->e_mbd.mode_info_context->mbmi.ref_frame = INTRA_FRAME;
2017             vp8_build_intra_predictors_mby_ptr(&x->e_mbd);
2018             {
2019                 macro_block_yrd(x, &rate_y, &distortion, IF_RTCD(&cpi->rtcd.encodemb)) ;
2020                 rate2 += rate_y;
2021                 distortion2 += distortion;
2022                 rate2 += x->mbmode_cost[x->e_mbd.frame_type][x->e_mbd.mode_info_context->mbmi.mode];
2023                 rate2 += uv_intra_rate;
2024                 rate_uv = uv_intra_rate_tokenonly;
2025                 distortion2 += uv_intra_distortion;
2026                 distortion_uv = uv_intra_distortion;
2027             }
2028             break;
2029
2030         case NEWMV:
2031
2032             // Decrement full search counter
2033             if (cpi->check_freq[lf_or_gf] > 0)
2034                 cpi->check_freq[lf_or_gf] --;
2035
2036             {
2037                 int thissme;
2038                 int bestsme = INT_MAX;
2039                 int step_param = cpi->sf.first_step;
2040                 int search_range;
2041                 int further_steps;
2042                 int n;
2043
2044                 int col_min = (best_ref_mv.col - MAX_FULL_PEL_VAL) >>3;
2045                 int col_max = (best_ref_mv.col + MAX_FULL_PEL_VAL) >>3;
2046                 int row_min = (best_ref_mv.row - MAX_FULL_PEL_VAL) >>3;
2047                 int row_max = (best_ref_mv.row + MAX_FULL_PEL_VAL) >>3;
2048
2049                 int tmp_col_min = x->mv_col_min;
2050                 int tmp_col_max = x->mv_col_max;
2051                 int tmp_row_min = x->mv_row_min;
2052                 int tmp_row_max = x->mv_row_max;
2053
2054                 // Get intersection of UMV window and valid MV window to reduce # of checks in diamond search.
2055                 if (x->mv_col_min < col_min )
2056                     x->mv_col_min = col_min;
2057                 if (x->mv_col_max > col_max )
2058                     x->mv_col_max = col_max;
2059                 if (x->mv_row_min < row_min )
2060                     x->mv_row_min = row_min;
2061                 if (x->mv_row_max > row_max )
2062                     x->mv_row_max = row_max;
2063
2064                 //adjust search range according to sr from mv prediction
2065                 if(sr > step_param)
2066                     step_param = sr;
2067
2068                 // Work out how long a search we should do
2069                 search_range = MAXF(abs(best_ref_mv.col), abs(best_ref_mv.row)) >> 3;
2070
2071                 if (search_range >= x->vector_range)
2072                     x->vector_range = search_range;
2073                 else if (x->vector_range > cpi->sf.min_fs_radius)
2074                     x->vector_range--;
2075
2076                 // Initial step/diamond search
2077                 {
2078                     int sadpb = x->sadperbit16;
2079
2080                     if (cpi->sf.search_method == HEX)
2081                     {
2082                         bestsme = vp8_hex_search(x, b, d, &best_ref_mv, &d->bmi.mv.as_mv, step_param, sadpb/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvsadcost, x->mvcost);
2083                         mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2084                         mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2085                     }
2086                     else
2087                     {
2088                         bestsme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv.as_mv, step_param, sadpb / 2/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvsadcost, x->mvcost, &best_ref_mv); //sadpb < 9
2089                         mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2090                         mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2091
2092                         // Further step/diamond searches as necessary
2093                         n = 0;
2094                         further_steps = (cpi->sf.max_step_search_steps - 1) - step_param;
2095
2096                         n = num00;
2097                         num00 = 0;
2098
2099                         while (n < further_steps)
2100                         {
2101                             n++;
2102
2103                             if (num00)
2104                                 num00--;
2105                             else
2106                             {
2107                                 thissme = cpi->diamond_search_sad(x, b, d, &mvp, &d->bmi.mv.as_mv, step_param + n, sadpb / 4/*x->errorperbit*/, &num00, &cpi->fn_ptr[BLOCK_16X16], x->mvsadcost, x->mvcost, &best_ref_mv); //sadpb = 9
2108
2109                                 if (thissme < bestsme)
2110                                 {
2111                                     bestsme = thissme;
2112                                     mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2113                                     mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2114                                 }
2115                                 else
2116                                 {
2117                                     d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
2118                                     d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
2119                                 }
2120                             }
2121                         }
2122                     }
2123
2124                 }
2125
2126                 // Should we do a full search
2127                 if (!cpi->check_freq[lf_or_gf] || cpi->do_full[lf_or_gf])
2128                 {
2129                     int thissme;
2130                     int full_flag_thresh = 0;
2131                     MV full_mvp;
2132
2133                     full_mvp.row = d->bmi.mv.as_mv.row <<3;    // use diamond search result as full search staring point
2134                     full_mvp.col = d->bmi.mv.as_mv.col <<3;
2135
2136                     // Update x->vector_range based on best vector found in step search
2137                     search_range = MAXF(abs((mvp.row>>3) - d->bmi.mv.as_mv.row), abs((mvp.col>>3) - d->bmi.mv.as_mv.col));
2138                     //search_range *= 1.4;  //didn't improve PSNR
2139
2140                     if (search_range > x->vector_range)
2141                         x->vector_range = search_range;
2142                     else
2143                         search_range = x->vector_range;
2144
2145                     // Apply limits
2146                     search_range = (search_range > cpi->sf.max_fs_radius) ? cpi->sf.max_fs_radius : search_range;
2147
2148                     //add this to reduce full search range.
2149                     if(sr<=3 && search_range > 8) search_range = 8;
2150
2151                     {
2152                         int sadpb = x->sadperbit16 >> 2;
2153                         thissme = cpi->full_search_sad(x, b, d, &full_mvp, sadpb, search_range, &cpi->fn_ptr[BLOCK_16X16], x->mvcost, x->mvsadcost,&best_ref_mv);
2154                     }
2155
2156                     // Barrier threshold to initiating full search
2157                     // full_flag_thresh = 10 + (thissme >> 7);
2158                     if ((thissme + full_flag_thresh) < bestsme)
2159                     {
2160                         cpi->do_full[lf_or_gf] ++;
2161                         bestsme = thissme;
2162                     }
2163                     else if (thissme < bestsme)
2164                         bestsme = thissme;
2165                     else
2166                     {
2167                         cpi->do_full[lf_or_gf] = cpi->do_full[lf_or_gf] >> 1;
2168                         cpi->check_freq[lf_or_gf] = cpi->sf.full_freq[lf_or_gf];
2169
2170                         // The full search result is actually worse so re-instate the previous best vector
2171                         d->bmi.mv.as_mv.row = mode_mv[NEWMV].row;
2172                         d->bmi.mv.as_mv.col = mode_mv[NEWMV].col;
2173                     }
2174                 }
2175
2176                 x->mv_col_min = tmp_col_min;
2177                 x->mv_col_max = tmp_col_max;
2178                 x->mv_row_min = tmp_row_min;
2179                 x->mv_row_max = tmp_row_max;
2180
2181                 if (bestsme < INT_MAX)
2182                     // cpi->find_fractional_mv_step(x,b,d,&d->bmi.mv.as_mv,&best_ref_mv,x->errorperbit/2,cpi->fn_ptr.svf,cpi->fn_ptr.vf,x->mvcost);  // normal mvc=11
2183                     cpi->find_fractional_mv_step(x, b, d, &d->bmi.mv.as_mv, &best_ref_mv, x->errorperbit / 4, &cpi->fn_ptr[BLOCK_16X16], x->mvcost);
2184
2185                 mode_mv[NEWMV].row = d->bmi.mv.as_mv.row;
2186                 mode_mv[NEWMV].col = d->bmi.mv.as_mv.col;
2187
2188                 // Add the new motion vector cost to our rolling cost variable
2189                 rate2 += vp8_mv_bit_cost(&mode_mv[NEWMV], &best_ref_mv, x->mvcost, 96);
2190
2191             }
2192
2193         case NEARESTMV:
2194         case NEARMV:
2195
2196             // Clip "next_nearest" so that it does not extend to far out of image
2197             if (mode_mv[this_mode].col < (xd->mb_to_left_edge - LEFT_TOP_MARGIN))
2198                 mode_mv[this_mode].col = xd->mb_to_left_edge - LEFT_TOP_MARGIN;
2199             else if (mode_mv[this_mode].col > xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN)
2200                 mode_mv[this_mode].col = xd->mb_to_right_edge + RIGHT_BOTTOM_MARGIN;
2201
2202             if (mode_mv[this_mode].row < (xd->mb_to_top_edge - LEFT_TOP_MARGIN))
2203                 mode_mv[this_mode].row = xd->mb_to_top_edge - LEFT_TOP_MARGIN;
2204             else if (mode_mv[this_mode].row > xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN)
2205                 mode_mv[this_mode].row = xd->mb_to_bottom_edge + RIGHT_BOTTOM_MARGIN;
2206
2207             // Do not bother proceeding if the vector (from newmv,nearest or near) is 0,0 as this should then be coded using the zeromv mode.
2208             if (((this_mode == NEARMV) || (this_mode == NEARESTMV)) &&
2209                 ((mode_mv[this_mode].row == 0) && (mode_mv[this_mode].col == 0)))
2210                 continue;
2211
2212         case ZEROMV:
2213
2214         mv_selected:
2215
2216             // Trap vectors that reach beyond the UMV borders
2217             // Note that ALL New MV, Nearest MV Near MV and Zero MV code drops through to this point
2218             // because of the lack of break statements in the previous two cases.
2219             if (((mode_mv[this_mode].row >> 3) < x->mv_row_min) || ((mode_mv[this_mode].row >> 3) > x->mv_row_max) ||
2220                 ((mode_mv[this_mode].col >> 3) < x->mv_col_min) || ((mode_mv[this_mode].col >> 3) > x->mv_col_max))
2221                 continue;
2222
2223             vp8_set_mbmode_and_mvs(x, this_mode, &mode_mv[this_mode]);
2224             vp8_build_inter_predictors_mby(&x->e_mbd);
2225
2226             if (cpi->active_map_enabled && x->active_ptr[0] == 0) {
2227                 x->skip = 1;
2228             }
2229             else if (x->encode_breakout)
2230             {
2231                 int sum, sse;
2232
2233                 VARIANCE_INVOKE(&cpi->rtcd.variance, get16x16var)
2234                     (x->src.y_buffer, x->src.y_stride,
2235                      x->e_mbd.predictor, 16, (unsigned int *)(&sse), &sum);
2236
2237                 if (sse < x->encode_breakout)
2238                 {
2239                     // Check u and v to make sure skip is ok
2240                     int sse2 = 0;
2241
2242                     // add dc check
2243                     if (abs(sum) < (cpi->common.Y2dequant[0][0] << 2))
2244                     {
2245                         sse2 = VP8_UVSSE(x, IF_RTCD(&cpi->rtcd.variance));
2246
2247                         if (sse2 * 2 < x->encode_breakout)
2248                         {
2249                             x->skip = 1;
2250                             distortion2 = sse + sse2;
2251                             rate2 = 500;
2252
2253                             /* for best_yrd calculation */
2254                             rate_uv = 0;
2255                             distortion_uv = sse2;
2256
2257                             disable_skip = 1;
2258                             this_rd = RDCOST(x->rdmult, x->rddiv, rate2,
2259                                              distortion2);
2260
2261                             break;
2262                         }
2263                     }
2264                 }
2265             }
2266
2267
2268             //intermodecost[mode_index] = vp8_cost_mv_ref(this_mode, mdcounts);   // Experimental debug code
2269
2270             // Add in the Mv/mode cost
2271             rate2 += vp8_cost_mv_ref(this_mode, mdcounts);
2272
2273             // Y cost and distortion
2274             macro_block_yrd(x, &rate_y, &distortion, IF_RTCD(&cpi->rtcd.encodemb));
2275             rate2 += rate_y;
2276             distortion2 += distortion;
2277
2278             // UV cost and distortion
2279             vp8_rd_inter_uv(cpi, x, &rate_uv, &distortion_uv, cpi->common.full_pixel);
2280             rate2 += rate_uv;
2281             distortion2 += distortion_uv;
2282             break;
2283
2284         default:
2285             break;
2286         }
2287
2288         // Where skip is allowable add in the default per mb cost for the no skip case.
2289         // where we then decide to skip we have to delete this and replace it with the
2290         // cost of signallying a skip
2291         if (cpi->common.mb_no_coeff_skip)
2292         {
2293             other_cost += vp8_cost_bit(cpi->prob_skip_false, 0);
2294             rate2 += other_cost;
2295         }
2296
2297         // Estimate the reference frame signaling cost and add it to the rolling cost variable.
2298         rate2 += ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
2299
2300         if (!disable_skip)
2301         {
2302             // Test for the condition where skip block will be activated because there are no non zero coefficients and make any necessary adjustment for rate
2303             if (cpi->common.mb_no_coeff_skip)
2304             {
2305                 int tteob;
2306
2307                 tteob = 0;
2308
2309                 for (i = 0; i <= 24; i++)
2310                 {
2311                     tteob += x->e_mbd.block[i].eob;
2312                 }
2313
2314                 if (tteob == 0)
2315                 {
2316                     rate2 -= (rate_y + rate_uv);
2317                     //for best_yrd calculation
2318                     rate_uv = 0;
2319
2320                     // Back out no skip flag costing and add in skip flag costing
2321                     if (cpi->prob_skip_false)
2322                     {
2323                         int prob_skip_cost;
2324
2325                         prob_skip_cost = vp8_cost_bit(cpi->prob_skip_false, 1);
2326                         prob_skip_cost -= vp8_cost_bit(cpi->prob_skip_false, 0);
2327                         rate2 += prob_skip_cost;
2328                         other_cost += prob_skip_cost;
2329                     }
2330                 }
2331             }
2332             // Calculate the final RD estimate for this mode
2333             this_rd = RDCOST(x->rdmult, x->rddiv, rate2, distortion2);
2334         }
2335
2336         // Experimental debug code.
2337         //all_rds[mode_index] = this_rd;
2338         //all_rates[mode_index] = rate2;
2339         //all_dist[mode_index] = distortion2;
2340
2341         if ((x->e_mbd.mode_info_context->mbmi.ref_frame == INTRA_FRAME)  && (this_rd < *returnintra))
2342         {
2343             *returnintra = this_rd ;
2344         }
2345
2346         // Did this mode help.. i.i is it the new best mode
2347         if (this_rd < best_rd || x->skip)
2348         {
2349             // Note index of best mode so far
2350             best_mode_index = mode_index;
2351             x->e_mbd.mode_info_context->mbmi.force_no_skip = force_no_skip;
2352
2353             if (this_mode <= B_PRED)
2354             {
2355                 x->e_mbd.mode_info_context->mbmi.uv_mode = uv_intra_mode;
2356             }
2357
2358             other_cost += ref_frame_cost[x->e_mbd.mode_info_context->mbmi.ref_frame];
2359
2360             /* Calculate the final y RD estimate for this mode */
2361             best_yrd = RDCOST(x->rdmult, x->rddiv, (rate2-rate_uv-other_cost),
2362                               (distortion2-distortion_uv));
2363
2364             *returnrate = rate2;
2365             *returndistortion = distortion2;
2366             best_rd = this_rd;
2367             vpx_memcpy(&best_mbmode, &x->e_mbd.mode_info_context->mbmi, sizeof(MB_MODE_INFO));
2368             vpx_memcpy(&best_partition, x->partition_info, sizeof(PARTITION_INFO));
2369
2370             for (i = 0; i < 16; i++)
2371             {
2372                 vpx_memcpy(&best_bmodes[i], &x->e_mbd.block[i].bmi, sizeof(B_MODE_INFO));
2373             }
2374
2375             // Testing this mode gave rise to an improvement in best error score. Lower threshold a bit for next time
2376             cpi->rd_thresh_mult[mode_index] = (cpi->rd_thresh_mult[mode_index] >= (MIN_THRESHMULT + 2)) ? cpi->rd_thresh_mult[mode_index] - 2 : MIN_THRESHMULT;
2377             cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
2378         }
2379
2380         // If the mode did not help improve the best error case then raise the threshold for testing that mode next time around.
2381         else
2382         {
2383             cpi->rd_thresh_mult[mode_index] += 4;
2384
2385             if (cpi->rd_thresh_mult[mode_index] > MAX_THRESHMULT)
2386                 cpi->rd_thresh_mult[mode_index] = MAX_THRESHMULT;
2387
2388             cpi->rd_threshes[mode_index] = (cpi->rd_baseline_thresh[mode_index] >> 7) * cpi->rd_thresh_mult[mode_index];
2389         }
2390
2391         if (x->skip)
2392             break;
2393     }
2394
2395     // Reduce the activation RD thresholds for the best choice mode
2396     if ((cpi->rd_baseline_thresh[best_mode_index] > 0) && (cpi->rd_baseline_thresh[best_mode_index] < (INT_MAX >> 2)))
2397     {
2398         int best_adjustment = (cpi->rd_thresh_mult[best_mode_index] >> 2);
2399
2400         cpi->rd_thresh_mult[best_mode_index] = (cpi->rd_thresh_mult[best_mode_index] >= (MIN_THRESHMULT + best_adjustment)) ? cpi->rd_thresh_mult[best_mode_index] - best_adjustment : MIN_THRESHMULT;
2401         cpi->rd_threshes[best_mode_index] = (cpi->rd_baseline_thresh[best_mode_index] >> 7) * cpi->rd_thresh_mult[best_mode_index];
2402
2403         // If we chose a split mode then reset the new MV thresholds as well
2404         /*if ( vp8_mode_order[best_mode_index] == SPLITMV )
2405         {
2406             best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWMV] >> 4);
2407             cpi->rd_thresh_mult[THR_NEWMV] = (cpi->rd_thresh_mult[THR_NEWMV] >= (MIN_THRESHMULT+best_adjustment)) ? cpi->rd_thresh_mult[THR_NEWMV]-best_adjustment: MIN_THRESHMULT;
2408             cpi->rd_threshes[THR_NEWMV] = (cpi->rd_baseline_thresh[THR_NEWMV] >> 7) * cpi->rd_thresh_mult[THR_NEWMV];
2409
2410             best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWG] >> 4);
2411             cpi->rd_thresh_mult[THR_NEWG] = (cpi->rd_thresh_mult[THR_NEWG] >= (MIN_THRESHMULT+best_adjustment)) ? cpi->rd_thresh_mult[THR_NEWG]-best_adjustment: MIN_THRESHMULT;
2412             cpi->rd_threshes[THR_NEWG] = (cpi->rd_baseline_thresh[THR_NEWG] >> 7) * cpi->rd_thresh_mult[THR_NEWG];
2413
2414             best_adjustment = 4; //(cpi->rd_thresh_mult[THR_NEWA] >> 4);
2415             cpi->rd_thresh_mult[THR_NEWA] = (cpi->rd_thresh_mult[THR_NEWA] >= (MIN_THRESHMULT+best_adjustment)) ? cpi->rd_thresh_mult[THR_NEWA]-best_adjustment: MIN_THRESHMULT;
2416             cpi->rd_threshes[THR_NEWA] = (cpi->rd_baseline_thresh[THR_NEWA] >> 7) * cpi->rd_thresh_mult[THR_NEWA];
2417         }*/
2418
2419     }
2420
2421     // If we have chosen new mv or split then decay the full search check count more quickly.
2422     if ((vp8_mode_order[best_mode_index] == NEWMV) || (vp8_mode_order[best_mode_index] == SPLITMV))
2423     {
2424         int lf_or_gf = (vp8_ref_frame_order[best_mode_index] == LAST_FRAME) ? 0 : 1;
2425
2426         if (cpi->check_freq[lf_or_gf] && !cpi->do_full[lf_or_gf])
2427         {
2428             cpi->check_freq[lf_or_gf] --;
2429         }
2430     }
2431
2432     // Keep a record of best mode index that we chose
2433     cpi->last_best_mode_index = best_mode_index;
2434
2435     // Note how often each mode chosen as best
2436     cpi->mode_chosen_counts[best_mode_index] ++;
2437
2438
2439     if (cpi->is_src_frame_alt_ref && (best_mbmode.mode != ZEROMV || best_mbmode.ref_frame != ALTREF_FRAME))
2440     {
2441         best_mbmode.mode = ZEROMV;
2442         best_mbmode.ref_frame = ALTREF_FRAME;
2443         best_mbmode.mv.as_int = 0;
2444         best_mbmode.uv_mode = 0;
2445         best_mbmode.mb_skip_coeff = (cpi->common.mb_no_coeff_skip) ? 1 : 0;
2446         best_mbmode.partitioning = 0;
2447         best_mbmode.dc_diff = 0;
2448
2449         vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode, sizeof(MB_MODE_INFO));
2450         vpx_memcpy(x->partition_info, &best_partition, sizeof(PARTITION_INFO));
2451
2452         for (i = 0; i < 16; i++)
2453         {
2454             vpx_memset(&x->e_mbd.block[i].bmi, 0, sizeof(B_MODE_INFO));
2455         }
2456
2457         x->e_mbd.mode_info_context->mbmi.mv.as_int = 0;
2458
2459         return best_rd;
2460     }
2461
2462
2463     // macroblock modes
2464     vpx_memcpy(&x->e_mbd.mode_info_context->mbmi, &best_mbmode, sizeof(MB_MODE_INFO));
2465     vpx_memcpy(x->partition_info, &best_partition, sizeof(PARTITION_INFO));
2466
2467     for (i = 0; i < 16; i++)
2468     {
2469         vpx_memcpy(&x->e_mbd.block[i].bmi, &best_bmodes[i], sizeof(B_MODE_INFO));
2470     }
2471
2472     x->e_mbd.mode_info_context->mbmi.mv.as_mv = x->e_mbd.block[15].bmi.mv.as_mv;
2473
2474     return best_rd;
2475 }
2476 #endif