src/third_party/libvpx/source/libvpx/vp8/encoder/mcomp.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 "onyx_int.h"
  13 #include "mcomp.h"
  14 #include "vpx_mem/vpx_mem.h"
  15 #include "vpx_config.h"
  16 #include <stdio.h>
  17 #include <limits.h>
  18 #include <math.h>
  19 #include "vp8/common/findnearmv.h"
  20 #include "vp8/common/common.h"
  21
  22 #ifdef VP8_ENTROPY_STATS
  23 static int mv_ref_ct [31] [4] [2];
  24 static int mv_mode_cts [4] [2];
  25 #endif
  26
  27 int vp8_mv_bit_cost(int_mv *mv, int_mv *ref, int *mvcost[2], int Weight)
  28 {
  29     /* MV costing is based on the distribution of vectors in the previous
  30      * frame and as such will tend to over state the cost of vectors. In
  31      * addition coding a new vector can have a knock on effect on the cost
  32      * of subsequent vectors and the quality of prediction from NEAR and
  33      * NEAREST for subsequent blocks. The "Weight" parameter allows, to a
  34      * limited extent, for some account to be taken of these factors.
  35      */
  36     return ((mvcost[0][(mv->as_mv.row - ref->as_mv.row) >> 1] + mvcost[1][(mv->as_mv.col - ref->as_mv.col) >> 1]) * Weight) >> 7;
  37 }
  38
  39 static int mv_err_cost(int_mv *mv, int_mv *ref, int *mvcost[2], int error_per_bit)
  40 {
  41     /* Ignore mv costing if mvcost is NULL */
  42     if (mvcost)
  43         return ((mvcost[0][(mv->as_mv.row - ref->as_mv.row) >> 1] +
  44                  mvcost[1][(mv->as_mv.col - ref->as_mv.col) >> 1])
  45                  * error_per_bit + 128) >> 8;
  46     return 0;
  47 }
  48
  49 static int mvsad_err_cost(int_mv *mv, int_mv *ref, int *mvsadcost[2], int error_per_bit)
  50 {
  51     /* Calculate sad error cost on full pixel basis. */
  52     /* Ignore mv costing if mvsadcost is NULL */
  53     if (mvsadcost)
  54         return ((mvsadcost[0][(mv->as_mv.row - ref->as_mv.row)] +
  55                  mvsadcost[1][(mv->as_mv.col - ref->as_mv.col)])
  56                 * error_per_bit + 128) >> 8;
  57     return 0;
  58 }
  59
  60 void vp8_init_dsmotion_compensation(MACROBLOCK *x, int stride)
  61 {
  62     int Len;
  63     int search_site_count = 0;
  64
  65
  66     /* Generate offsets for 4 search sites per step. */
  67     Len = MAX_FIRST_STEP;
  68     x->ss[search_site_count].mv.col = 0;
  69     x->ss[search_site_count].mv.row = 0;
  70     x->ss[search_site_count].offset = 0;
  71     search_site_count++;
  72
  73     while (Len > 0)
  74     {
  75
  76         /* Compute offsets for search sites. */
  77         x->ss[search_site_count].mv.col = 0;
  78         x->ss[search_site_count].mv.row = -Len;
  79         x->ss[search_site_count].offset = -Len * stride;
  80         search_site_count++;
  81
  82         /* Compute offsets for search sites. */
  83         x->ss[search_site_count].mv.col = 0;
  84         x->ss[search_site_count].mv.row = Len;
  85         x->ss[search_site_count].offset = Len * stride;
  86         search_site_count++;
  87
  88         /* Compute offsets for search sites. */
  89         x->ss[search_site_count].mv.col = -Len;
  90         x->ss[search_site_count].mv.row = 0;
  91         x->ss[search_site_count].offset = -Len;
  92         search_site_count++;
  93
  94         /* Compute offsets for search sites. */
  95         x->ss[search_site_count].mv.col = Len;
  96         x->ss[search_site_count].mv.row = 0;
  97         x->ss[search_site_count].offset = Len;
  98         search_site_count++;
  99
 100         /* Contract. */
 101         Len /= 2;
 102     }
 103
 104     x->ss_count = search_site_count;
 105     x->searches_per_step = 4;
 106 }
 107
 108 void vp8_init3smotion_compensation(MACROBLOCK *x, int stride)
 109 {
 110     int Len;
 111     int search_site_count = 0;
 112
 113     /* Generate offsets for 8 search sites per step. */
 114     Len = MAX_FIRST_STEP;
 115     x->ss[search_site_count].mv.col = 0;
 116     x->ss[search_site_count].mv.row = 0;
 117     x->ss[search_site_count].offset = 0;
 118     search_site_count++;
 119
 120     while (Len > 0)
 121     {
 122
 123         /* Compute offsets for search sites. */
 124         x->ss[search_site_count].mv.col = 0;
 125         x->ss[search_site_count].mv.row = -Len;
 126         x->ss[search_site_count].offset = -Len * stride;
 127         search_site_count++;
 128
 129         /* Compute offsets for search sites. */
 130         x->ss[search_site_count].mv.col = 0;
 131         x->ss[search_site_count].mv.row = Len;
 132         x->ss[search_site_count].offset = Len * stride;
 133         search_site_count++;
 134
 135         /* Compute offsets for search sites. */
 136         x->ss[search_site_count].mv.col = -Len;
 137         x->ss[search_site_count].mv.row = 0;
 138         x->ss[search_site_count].offset = -Len;
 139         search_site_count++;
 140
 141         /* Compute offsets for search sites. */
 142         x->ss[search_site_count].mv.col = Len;
 143         x->ss[search_site_count].mv.row = 0;
 144         x->ss[search_site_count].offset = Len;
 145         search_site_count++;
 146
 147         /* Compute offsets for search sites. */
 148         x->ss[search_site_count].mv.col = -Len;
 149         x->ss[search_site_count].mv.row = -Len;
 150         x->ss[search_site_count].offset = -Len * stride - Len;
 151         search_site_count++;
 152
 153         /* Compute offsets for search sites. */
 154         x->ss[search_site_count].mv.col = Len;
 155         x->ss[search_site_count].mv.row = -Len;
 156         x->ss[search_site_count].offset = -Len * stride + Len;
 157         search_site_count++;
 158
 159         /* Compute offsets for search sites. */
 160         x->ss[search_site_count].mv.col = -Len;
 161         x->ss[search_site_count].mv.row = Len;
 162         x->ss[search_site_count].offset = Len * stride - Len;
 163         search_site_count++;
 164
 165         /* Compute offsets for search sites. */
 166         x->ss[search_site_count].mv.col = Len;
 167         x->ss[search_site_count].mv.row = Len;
 168         x->ss[search_site_count].offset = Len * stride + Len;
 169         search_site_count++;
 170
 171
 172         /* Contract. */
 173         Len /= 2;
 174     }
 175
 176     x->ss_count = search_site_count;
 177     x->searches_per_step = 8;
 178 }
 179
 180 /*
 181  * To avoid the penalty for crossing cache-line read, preload the reference
 182  * area in a small buffer, which is aligned to make sure there won't be crossing
 183  * cache-line read while reading from this buffer. This reduced the cpu
 184  * cycles spent on reading ref data in sub-pixel filter functions.
 185  * TODO: Currently, since sub-pixel search range here is -3 ~ 3, copy 22 rows x
 186  * 32 cols area that is enough for 16x16 macroblock. Later, for SPLITMV, we
 187  * could reduce the area.
 188  */
 189
 190 /* estimated cost of a motion vector (r,c) */
 191 #define MVC(r,c) (mvcost ? ((mvcost[0][(r)-rr] + mvcost[1][(c) - rc]) * error_per_bit + 128 )>>8 : 0)
 192 /* pointer to predictor base of a motionvector */
 193 #define PRE(r,c) (y + (((r)>>2) * y_stride + ((c)>>2) -(offset)))
 194 /* convert motion vector component to offset for svf calc */
 195 #define SP(x) (((x)&3)<<1)
 196 /* returns subpixel variance error function. */
 197 #define DIST(r,c) vfp->svf( PRE(r,c), y_stride, SP(c),SP(r), z,b->src_stride,&sse)
 198 #define IFMVCV(r,c,s,e) if ( c >= minc && c <= maxc && r >= minr && r <= maxr) s else e;
 199 /* returns distortion + motion vector cost */
 200 #define ERR(r,c) (MVC(r,c)+DIST(r,c))
 201 /* checks if (r,c) has better score than previous best */
 202 #define CHECK_BETTER(v,r,c) IFMVCV(r,c,{thismse = DIST(r,c); if((v = (MVC(r,c)+thismse)) < besterr) { besterr = v; br=r; bc=c; *distortion = thismse; *sse1 = sse; }}, v=UINT_MAX;)
 203
 204 int vp8_find_best_sub_pixel_step_iteratively(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
 205                                              int_mv *bestmv, int_mv *ref_mv,
 206                                              int error_per_bit,
 207                                              const vp8_variance_fn_ptr_t *vfp,
 208                                              int *mvcost[2], int *distortion,
 209                                              unsigned int *sse1)
 210 {
 211     unsigned char *z = (*(b->base_src) + b->src);
 212
 213     int rr = ref_mv->as_mv.row >> 1, rc = ref_mv->as_mv.col >> 1;
 214     int br = bestmv->as_mv.row * 4, bc = bestmv->as_mv.col * 4;
 215     int tr = br, tc = bc;
 216     unsigned int besterr;
 217     unsigned int left, right, up, down, diag;
 218     unsigned int sse;
 219     unsigned int whichdir;
 220     unsigned int halfiters = 4;
 221     unsigned int quarteriters = 4;
 222     int thismse;
 223
 224     int minc = MAX(x->mv_col_min * 4,
 225                    (ref_mv->as_mv.col >> 1) - ((1 << mvlong_width) - 1));
 226     int maxc = MIN(x->mv_col_max * 4,
 227                    (ref_mv->as_mv.col >> 1) + ((1 << mvlong_width) - 1));
 228     int minr = MAX(x->mv_row_min * 4,
 229                    (ref_mv->as_mv.row >> 1) - ((1 << mvlong_width) - 1));
 230     int maxr = MIN(x->mv_row_max * 4,
 231                    (ref_mv->as_mv.row >> 1) + ((1 << mvlong_width) - 1));
 232
 233     int y_stride;
 234     int offset;
 235     int pre_stride = x->e_mbd.pre.y_stride;
 236     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
 237
 238
 239 #if ARCH_X86 || ARCH_X86_64
 240     MACROBLOCKD *xd = &x->e_mbd;
 241     unsigned char *y_0 = base_pre + d->offset + (bestmv->as_mv.row) * pre_stride + bestmv->as_mv.col;
 242     unsigned char *y;
 243     int buf_r1, buf_r2, buf_c1;
 244
 245     /* Clamping to avoid out-of-range data access */
 246     buf_r1 = ((bestmv->as_mv.row - 3) < x->mv_row_min)?(bestmv->as_mv.row - x->mv_row_min):3;
 247     buf_r2 = ((bestmv->as_mv.row + 3) > x->mv_row_max)?(x->mv_row_max - bestmv->as_mv.row):3;
 248     buf_c1 = ((bestmv->as_mv.col - 3) < x->mv_col_min)?(bestmv->as_mv.col - x->mv_col_min):3;
 249     y_stride = 32;
 250
 251     /* Copy to intermediate buffer before searching. */
 252     vfp->copymem(y_0 - buf_c1 - pre_stride*buf_r1, pre_stride, xd->y_buf, y_stride, 16+buf_r1+buf_r2);
 253     y = xd->y_buf + y_stride*buf_r1 +buf_c1;
 254 #else
 255     unsigned char *y = base_pre + d->offset + (bestmv->as_mv.row) * pre_stride + bestmv->as_mv.col;
 256     y_stride = pre_stride;
 257 #endif
 258
 259     offset = (bestmv->as_mv.row) * y_stride + bestmv->as_mv.col;
 260
 261     /* central mv */
 262     bestmv->as_mv.row *= 8;
 263     bestmv->as_mv.col *= 8;
 264
 265     /* calculate central point error */
 266     besterr = vfp->vf(y, y_stride, z, b->src_stride, sse1);
 267     *distortion = besterr;
 268     besterr += mv_err_cost(bestmv, ref_mv, mvcost, error_per_bit);
 269
 270     /* TODO: Each subsequent iteration checks at least one point in common
 271      * with the last iteration could be 2 ( if diag selected)
 272      */
 273     while (--halfiters)
 274     {
 275         /* 1/2 pel */
 276         CHECK_BETTER(left, tr, tc - 2);
 277         CHECK_BETTER(right, tr, tc + 2);
 278         CHECK_BETTER(up, tr - 2, tc);
 279         CHECK_BETTER(down, tr + 2, tc);
 280
 281         whichdir = (left < right ? 0 : 1) + (up < down ? 0 : 2);
 282
 283         switch (whichdir)
 284         {
 285         case 0:
 286             CHECK_BETTER(diag, tr - 2, tc - 2);
 287             break;
 288         case 1:
 289             CHECK_BETTER(diag, tr - 2, tc + 2);
 290             break;
 291         case 2:
 292             CHECK_BETTER(diag, tr + 2, tc - 2);
 293             break;
 294         case 3:
 295             CHECK_BETTER(diag, tr + 2, tc + 2);
 296             break;
 297         }
 298
 299         /* no reason to check the same one again. */
 300         if (tr == br && tc == bc)
 301             break;
 302
 303         tr = br;
 304         tc = bc;
 305     }
 306
 307     /* TODO: Each subsequent iteration checks at least one point in common
 308      * with the last iteration could be 2 ( if diag selected)
 309      */
 310
 311     /* 1/4 pel */
 312     while (--quarteriters)
 313     {
 314         CHECK_BETTER(left, tr, tc - 1);
 315         CHECK_BETTER(right, tr, tc + 1);
 316         CHECK_BETTER(up, tr - 1, tc);
 317         CHECK_BETTER(down, tr + 1, tc);
 318
 319         whichdir = (left < right ? 0 : 1) + (up < down ? 0 : 2);
 320
 321         switch (whichdir)
 322         {
 323         case 0:
 324             CHECK_BETTER(diag, tr - 1, tc - 1);
 325             break;
 326         case 1:
 327             CHECK_BETTER(diag, tr - 1, tc + 1);
 328             break;
 329         case 2:
 330             CHECK_BETTER(diag, tr + 1, tc - 1);
 331             break;
 332         case 3:
 333             CHECK_BETTER(diag, tr + 1, tc + 1);
 334             break;
 335         }
 336
 337         /* no reason to check the same one again. */
 338         if (tr == br && tc == bc)
 339             break;
 340
 341         tr = br;
 342         tc = bc;
 343     }
 344
 345     bestmv->as_mv.row = br * 2;
 346     bestmv->as_mv.col = bc * 2;
 347
 348     if ((abs(bestmv->as_mv.col - ref_mv->as_mv.col) > (MAX_FULL_PEL_VAL<<3)) ||
 349         (abs(bestmv->as_mv.row - ref_mv->as_mv.row) > (MAX_FULL_PEL_VAL<<3)))
 350         return INT_MAX;
 351
 352     return besterr;
 353 }
 354 #undef MVC
 355 #undef PRE
 356 #undef SP
 357 #undef DIST
 358 #undef IFMVCV
 359 #undef ERR
 360 #undef CHECK_BETTER
 361
 362 int vp8_find_best_sub_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
 363                                  int_mv *bestmv, int_mv *ref_mv,
 364                                  int error_per_bit,
 365                                  const vp8_variance_fn_ptr_t *vfp,
 366                                  int *mvcost[2], int *distortion,
 367                                  unsigned int *sse1)
 368 {
 369     int bestmse = INT_MAX;
 370     int_mv startmv;
 371     int_mv this_mv;
 372     unsigned char *z = (*(b->base_src) + b->src);
 373     int left, right, up, down, diag;
 374     unsigned int sse;
 375     int whichdir ;
 376     int thismse;
 377     int y_stride;
 378     int pre_stride = x->e_mbd.pre.y_stride;
 379     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
 380
 381 #if ARCH_X86 || ARCH_X86_64
 382     MACROBLOCKD *xd = &x->e_mbd;
 383     unsigned char *y_0 = base_pre + d->offset + (bestmv->as_mv.row) * pre_stride + bestmv->as_mv.col;
 384     unsigned char *y;
 385
 386     y_stride = 32;
 387     /* Copy 18 rows x 32 cols area to intermediate buffer before searching. */
 388      vfp->copymem(y_0 - 1 - pre_stride, pre_stride, xd->y_buf, y_stride, 18);
 389      y = xd->y_buf + y_stride + 1;
 390 #else
 391      unsigned char *y = base_pre + d->offset + (bestmv->as_mv.row) * pre_stride + bestmv->as_mv.col;
 392      y_stride = pre_stride;
 393 #endif
 394
 395     /* central mv */
 396     bestmv->as_mv.row *= 8;
 397     bestmv->as_mv.col *= 8;
 398     startmv = *bestmv;
 399
 400     /* calculate central point error */
 401     bestmse = vfp->vf(y, y_stride, z, b->src_stride, sse1);
 402     *distortion = bestmse;
 403     bestmse += mv_err_cost(bestmv, ref_mv, mvcost, error_per_bit);
 404
 405     /* go left then right and check error */
 406     this_mv.as_mv.row = startmv.as_mv.row;
 407     this_mv.as_mv.col = ((startmv.as_mv.col - 8) | 4);
 408     thismse = vfp->svf_halfpix_h(y - 1, y_stride, z, b->src_stride, &sse);
 409     left = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 410
 411     if (left < bestmse)
 412     {
 413         *bestmv = this_mv;
 414         bestmse = left;
 415         *distortion = thismse;
 416         *sse1 = sse;
 417     }
 418
 419     this_mv.as_mv.col += 8;
 420     thismse = vfp->svf_halfpix_h(y, y_stride, z, b->src_stride, &sse);
 421     right = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 422
 423     if (right < bestmse)
 424     {
 425         *bestmv = this_mv;
 426         bestmse = right;
 427         *distortion = thismse;
 428         *sse1 = sse;
 429     }
 430
 431     /* go up then down and check error */
 432     this_mv.as_mv.col = startmv.as_mv.col;
 433     this_mv.as_mv.row = ((startmv.as_mv.row - 8) | 4);
 434     thismse =  vfp->svf_halfpix_v(y - y_stride, y_stride, z, b->src_stride, &sse);
 435     up = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 436
 437     if (up < bestmse)
 438     {
 439         *bestmv = this_mv;
 440         bestmse = up;
 441         *distortion = thismse;
 442         *sse1 = sse;
 443     }
 444
 445     this_mv.as_mv.row += 8;
 446     thismse = vfp->svf_halfpix_v(y, y_stride, z, b->src_stride, &sse);
 447     down = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 448
 449     if (down < bestmse)
 450     {
 451         *bestmv = this_mv;
 452         bestmse = down;
 453         *distortion = thismse;
 454         *sse1 = sse;
 455     }
 456
 457
 458     /* now check 1 more diagonal */
 459     whichdir = (left < right ? 0 : 1) + (up < down ? 0 : 2);
 460     this_mv = startmv;
 461
 462     switch (whichdir)
 463     {
 464     case 0:
 465         this_mv.as_mv.col = (this_mv.as_mv.col - 8) | 4;
 466         this_mv.as_mv.row = (this_mv.as_mv.row - 8) | 4;
 467         thismse = vfp->svf_halfpix_hv(y - 1 - y_stride, y_stride, z, b->src_stride, &sse);
 468         break;
 469     case 1:
 470         this_mv.as_mv.col += 4;
 471         this_mv.as_mv.row = (this_mv.as_mv.row - 8) | 4;
 472         thismse = vfp->svf_halfpix_hv(y - y_stride, y_stride, z, b->src_stride, &sse);
 473         break;
 474     case 2:
 475         this_mv.as_mv.col = (this_mv.as_mv.col - 8) | 4;
 476         this_mv.as_mv.row += 4;
 477         thismse = vfp->svf_halfpix_hv(y - 1, y_stride, z, b->src_stride, &sse);
 478         break;
 479     case 3:
 480     default:
 481         this_mv.as_mv.col += 4;
 482         this_mv.as_mv.row += 4;
 483         thismse = vfp->svf_halfpix_hv(y, y_stride, z, b->src_stride, &sse);
 484         break;
 485     }
 486
 487     diag = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 488
 489     if (diag < bestmse)
 490     {
 491         *bestmv = this_mv;
 492         bestmse = diag;
 493         *distortion = thismse;
 494         *sse1 = sse;
 495     }
 496
 497
 498     /* time to check quarter pels. */
 499     if (bestmv->as_mv.row < startmv.as_mv.row)
 500         y -= y_stride;
 501
 502     if (bestmv->as_mv.col < startmv.as_mv.col)
 503         y--;
 504
 505     startmv = *bestmv;
 506
 507
 508
 509     /* go left then right and check error */
 510     this_mv.as_mv.row = startmv.as_mv.row;
 511
 512     if (startmv.as_mv.col & 7)
 513     {
 514         this_mv.as_mv.col = startmv.as_mv.col - 2;
 515         thismse = vfp->svf(y, y_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 516     }
 517     else
 518     {
 519         this_mv.as_mv.col = (startmv.as_mv.col - 8) | 6;
 520         thismse = vfp->svf(y - 1, y_stride, 6, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 521     }
 522
 523     left = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 524
 525     if (left < bestmse)
 526     {
 527         *bestmv = this_mv;
 528         bestmse = left;
 529         *distortion = thismse;
 530         *sse1 = sse;
 531     }
 532
 533     this_mv.as_mv.col += 4;
 534     thismse = vfp->svf(y, y_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 535     right = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 536
 537     if (right < bestmse)
 538     {
 539         *bestmv = this_mv;
 540         bestmse = right;
 541         *distortion = thismse;
 542         *sse1 = sse;
 543     }
 544
 545     /* go up then down and check error */
 546     this_mv.as_mv.col = startmv.as_mv.col;
 547
 548     if (startmv.as_mv.row & 7)
 549     {
 550         this_mv.as_mv.row = startmv.as_mv.row - 2;
 551         thismse = vfp->svf(y, y_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 552     }
 553     else
 554     {
 555         this_mv.as_mv.row = (startmv.as_mv.row - 8) | 6;
 556         thismse = vfp->svf(y - y_stride, y_stride, this_mv.as_mv.col & 7, 6, z, b->src_stride, &sse);
 557     }
 558
 559     up = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 560
 561     if (up < bestmse)
 562     {
 563         *bestmv = this_mv;
 564         bestmse = up;
 565         *distortion = thismse;
 566         *sse1 = sse;
 567     }
 568
 569     this_mv.as_mv.row += 4;
 570     thismse = vfp->svf(y, y_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 571     down = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 572
 573     if (down < bestmse)
 574     {
 575         *bestmv = this_mv;
 576         bestmse = down;
 577         *distortion = thismse;
 578         *sse1 = sse;
 579     }
 580
 581
 582     /* now check 1 more diagonal */
 583     whichdir = (left < right ? 0 : 1) + (up < down ? 0 : 2);
 584
 585     this_mv = startmv;
 586
 587     switch (whichdir)
 588     {
 589     case 0:
 590
 591         if (startmv.as_mv.row & 7)
 592         {
 593             this_mv.as_mv.row -= 2;
 594
 595             if (startmv.as_mv.col & 7)
 596             {
 597                 this_mv.as_mv.col -= 2;
 598                 thismse = vfp->svf(y, y_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 599             }
 600             else
 601             {
 602                 this_mv.as_mv.col = (startmv.as_mv.col - 8) | 6;
 603                 thismse = vfp->svf(y - 1, y_stride, 6, this_mv.as_mv.row & 7, z, b->src_stride, &sse);;
 604             }
 605         }
 606         else
 607         {
 608             this_mv.as_mv.row = (startmv.as_mv.row - 8) | 6;
 609
 610             if (startmv.as_mv.col & 7)
 611             {
 612                 this_mv.as_mv.col -= 2;
 613                 thismse = vfp->svf(y - y_stride, y_stride, this_mv.as_mv.col & 7, 6, z, b->src_stride, &sse);
 614             }
 615             else
 616             {
 617                 this_mv.as_mv.col = (startmv.as_mv.col - 8) | 6;
 618                 thismse = vfp->svf(y - y_stride - 1, y_stride, 6, 6, z, b->src_stride, &sse);
 619             }
 620         }
 621
 622         break;
 623     case 1:
 624         this_mv.as_mv.col += 2;
 625
 626         if (startmv.as_mv.row & 7)
 627         {
 628             this_mv.as_mv.row -= 2;
 629             thismse = vfp->svf(y, y_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 630         }
 631         else
 632         {
 633             this_mv.as_mv.row = (startmv.as_mv.row - 8) | 6;
 634             thismse = vfp->svf(y - y_stride, y_stride, this_mv.as_mv.col & 7, 6, z, b->src_stride, &sse);
 635         }
 636
 637         break;
 638     case 2:
 639         this_mv.as_mv.row += 2;
 640
 641         if (startmv.as_mv.col & 7)
 642         {
 643             this_mv.as_mv.col -= 2;
 644             thismse = vfp->svf(y, y_stride, this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 645         }
 646         else
 647         {
 648             this_mv.as_mv.col = (startmv.as_mv.col - 8) | 6;
 649             thismse = vfp->svf(y - 1, y_stride, 6, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 650         }
 651
 652         break;
 653     case 3:
 654         this_mv.as_mv.col += 2;
 655         this_mv.as_mv.row += 2;
 656         thismse = vfp->svf(y, y_stride,  this_mv.as_mv.col & 7, this_mv.as_mv.row & 7, z, b->src_stride, &sse);
 657         break;
 658     }
 659
 660     diag = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 661
 662     if (diag < bestmse)
 663     {
 664         *bestmv = this_mv;
 665         bestmse = diag;
 666         *distortion = thismse;
 667         *sse1 = sse;
 668     }
 669
 670     return bestmse;
 671 }
 672
 673 int vp8_find_best_half_pixel_step(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
 674                                   int_mv *bestmv, int_mv *ref_mv,
 675                                   int error_per_bit,
 676                                   const vp8_variance_fn_ptr_t *vfp,
 677                                   int *mvcost[2], int *distortion,
 678                                   unsigned int *sse1)
 679 {
 680     int bestmse = INT_MAX;
 681     int_mv startmv;
 682     int_mv this_mv;
 683     unsigned char *z = (*(b->base_src) + b->src);
 684     int left, right, up, down, diag;
 685     unsigned int sse;
 686     int whichdir ;
 687     int thismse;
 688     int y_stride;
 689     int pre_stride = x->e_mbd.pre.y_stride;
 690     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
 691
 692 #if ARCH_X86 || ARCH_X86_64
 693     MACROBLOCKD *xd = &x->e_mbd;
 694     unsigned char *y_0 = base_pre + d->offset + (bestmv->as_mv.row) * pre_stride + bestmv->as_mv.col;
 695     unsigned char *y;
 696
 697     y_stride = 32;
 698     /* Copy 18 rows x 32 cols area to intermediate buffer before searching. */
 699     vfp->copymem(y_0 - 1 - pre_stride, pre_stride, xd->y_buf, y_stride, 18);
 700     y = xd->y_buf + y_stride + 1;
 701 #else
 702     unsigned char *y = base_pre + d->offset + (bestmv->as_mv.row) * pre_stride + bestmv->as_mv.col;
 703     y_stride = pre_stride;
 704 #endif
 705
 706     /* central mv */
 707     bestmv->as_mv.row *= 8;
 708     bestmv->as_mv.col *= 8;
 709     startmv = *bestmv;
 710
 711     /* calculate central point error */
 712     bestmse = vfp->vf(y, y_stride, z, b->src_stride, sse1);
 713     *distortion = bestmse;
 714     bestmse += mv_err_cost(bestmv, ref_mv, mvcost, error_per_bit);
 715
 716     /* go left then right and check error */
 717     this_mv.as_mv.row = startmv.as_mv.row;
 718     this_mv.as_mv.col = ((startmv.as_mv.col - 8) | 4);
 719     thismse = vfp->svf_halfpix_h(y - 1, y_stride, z, b->src_stride, &sse);
 720     left = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 721
 722     if (left < bestmse)
 723     {
 724         *bestmv = this_mv;
 725         bestmse = left;
 726         *distortion = thismse;
 727         *sse1 = sse;
 728     }
 729
 730     this_mv.as_mv.col += 8;
 731     thismse = vfp->svf_halfpix_h(y, y_stride, z, b->src_stride, &sse);
 732     right = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 733
 734     if (right < bestmse)
 735     {
 736         *bestmv = this_mv;
 737         bestmse = right;
 738         *distortion = thismse;
 739         *sse1 = sse;
 740     }
 741
 742     /* go up then down and check error */
 743     this_mv.as_mv.col = startmv.as_mv.col;
 744     this_mv.as_mv.row = ((startmv.as_mv.row - 8) | 4);
 745     thismse = vfp->svf_halfpix_v(y - y_stride, y_stride, z, b->src_stride, &sse);
 746     up = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 747
 748     if (up < bestmse)
 749     {
 750         *bestmv = this_mv;
 751         bestmse = up;
 752         *distortion = thismse;
 753         *sse1 = sse;
 754     }
 755
 756     this_mv.as_mv.row += 8;
 757     thismse = vfp->svf_halfpix_v(y, y_stride, z, b->src_stride, &sse);
 758     down = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 759
 760     if (down < bestmse)
 761     {
 762         *bestmv = this_mv;
 763         bestmse = down;
 764         *distortion = thismse;
 765         *sse1 = sse;
 766     }
 767
 768     /* now check 1 more diagonal - */
 769     whichdir = (left < right ? 0 : 1) + (up < down ? 0 : 2);
 770     this_mv = startmv;
 771
 772     switch (whichdir)
 773     {
 774     case 0:
 775         this_mv.as_mv.col = (this_mv.as_mv.col - 8) | 4;
 776         this_mv.as_mv.row = (this_mv.as_mv.row - 8) | 4;
 777         thismse = vfp->svf_halfpix_hv(y - 1 - y_stride, y_stride, z, b->src_stride, &sse);
 778         break;
 779     case 1:
 780         this_mv.as_mv.col += 4;
 781         this_mv.as_mv.row = (this_mv.as_mv.row - 8) | 4;
 782         thismse = vfp->svf_halfpix_hv(y - y_stride, y_stride, z, b->src_stride, &sse);
 783         break;
 784     case 2:
 785         this_mv.as_mv.col = (this_mv.as_mv.col - 8) | 4;
 786         this_mv.as_mv.row += 4;
 787         thismse = vfp->svf_halfpix_hv(y - 1, y_stride, z, b->src_stride, &sse);
 788         break;
 789     case 3:
 790     default:
 791         this_mv.as_mv.col += 4;
 792         this_mv.as_mv.row += 4;
 793         thismse = vfp->svf_halfpix_hv(y, y_stride, z, b->src_stride, &sse);
 794         break;
 795     }
 796
 797     diag = thismse + mv_err_cost(&this_mv, ref_mv, mvcost, error_per_bit);
 798
 799     if (diag < bestmse)
 800     {
 801         *bestmv = this_mv;
 802         bestmse = diag;
 803         *distortion = thismse;
 804         *sse1 = sse;
 805     }
 806
 807     return bestmse;
 808 }
 809
 810 #define CHECK_BOUNDS(range) \
 811 {\
 812     all_in = 1;\
 813     all_in &= ((br-range) >= x->mv_row_min);\
 814     all_in &= ((br+range) <= x->mv_row_max);\
 815     all_in &= ((bc-range) >= x->mv_col_min);\
 816     all_in &= ((bc+range) <= x->mv_col_max);\
 817 }
 818
 819 #define CHECK_POINT \
 820 {\
 821     if (this_mv.as_mv.col < x->mv_col_min) continue;\
 822     if (this_mv.as_mv.col > x->mv_col_max) continue;\
 823     if (this_mv.as_mv.row < x->mv_row_min) continue;\
 824     if (this_mv.as_mv.row > x->mv_row_max) continue;\
 825 }
 826
 827 #define CHECK_BETTER \
 828 {\
 829     if (thissad < bestsad)\
 830     {\
 831         thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, sad_per_bit);\
 832         if (thissad < bestsad)\
 833         {\
 834             bestsad = thissad;\
 835             best_site = i;\
 836         }\
 837     }\
 838 }
 839
 840 static const MV next_chkpts[6][3] =
 841 {
 842     {{ -2, 0}, { -1, -2}, {1, -2}},
 843     {{ -1, -2}, {1, -2}, {2, 0}},
 844     {{1, -2}, {2, 0}, {1, 2}},
 845     {{2, 0}, {1, 2}, { -1, 2}},
 846     {{1, 2}, { -1, 2}, { -2, 0}},
 847     {{ -1, 2}, { -2, 0}, { -1, -2}}
 848 };
 849
 850 int vp8_hex_search
 851 (
 852     MACROBLOCK *x,
 853     BLOCK *b,
 854     BLOCKD *d,
 855     int_mv *ref_mv,
 856     int_mv *best_mv,
 857     int search_param,
 858     int sad_per_bit,
 859     const vp8_variance_fn_ptr_t *vfp,
 860     int *mvsadcost[2],
 861     int *mvcost[2],
 862     int_mv *center_mv
 863 )
 864 {
 865     MV hex[6] = { { -1, -2}, {1, -2}, {2, 0}, {1, 2}, { -1, 2}, { -2, 0} } ;
 866     MV neighbors[4] = {{0, -1}, { -1, 0}, {1, 0}, {0, 1}} ;
 867     int i, j;
 868
 869     unsigned char *what = (*(b->base_src) + b->src);
 870     int what_stride = b->src_stride;
 871     int pre_stride = x->e_mbd.pre.y_stride;
 872     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
 873
 874     int in_what_stride = pre_stride;
 875     int br, bc;
 876     int_mv this_mv;
 877     unsigned int bestsad;
 878     unsigned int thissad;
 879     unsigned char *base_offset;
 880     unsigned char *this_offset;
 881     int k = -1;
 882     int all_in;
 883     int best_site = -1;
 884     int hex_range = 127;
 885     int dia_range = 8;
 886
 887     int_mv fcenter_mv;
 888     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
 889     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
 890
 891     /* adjust ref_mv to make sure it is within MV range */
 892     vp8_clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
 893     br = ref_mv->as_mv.row;
 894     bc = ref_mv->as_mv.col;
 895
 896     /* Work out the start point for the search */
 897     base_offset = (unsigned char *)(base_pre + d->offset);
 898     this_offset = base_offset + (br * (pre_stride)) + bc;
 899     this_mv.as_mv.row = br;
 900     this_mv.as_mv.col = bc;
 901     bestsad = vfp->sdf(what, what_stride, this_offset, in_what_stride, UINT_MAX)
 902             + mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, sad_per_bit);
 903
 904 #if CONFIG_MULTI_RES_ENCODING
 905     /* Lower search range based on prediction info */
 906     if (search_param >= 6) goto cal_neighbors;
 907     else if (search_param >= 5) hex_range = 4;
 908     else if (search_param >= 4) hex_range = 6;
 909     else if (search_param >= 3) hex_range = 15;
 910     else if (search_param >= 2) hex_range = 31;
 911     else if (search_param >= 1) hex_range = 63;
 912
 913     dia_range = 8;
 914 #endif
 915
 916     /* hex search */
 917     CHECK_BOUNDS(2)
 918
 919     if(all_in)
 920     {
 921         for (i = 0; i < 6; i++)
 922         {
 923             this_mv.as_mv.row = br + hex[i].row;
 924             this_mv.as_mv.col = bc + hex[i].col;
 925             this_offset = base_offset + (this_mv.as_mv.row * in_what_stride) + this_mv.as_mv.col;
 926             thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
 927             CHECK_BETTER
 928         }
 929     }else
 930     {
 931         for (i = 0; i < 6; i++)
 932         {
 933             this_mv.as_mv.row = br + hex[i].row;
 934             this_mv.as_mv.col = bc + hex[i].col;
 935             CHECK_POINT
 936             this_offset = base_offset + (this_mv.as_mv.row * in_what_stride) + this_mv.as_mv.col;
 937             thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
 938             CHECK_BETTER
 939         }
 940     }
 941
 942     if (best_site == -1)
 943         goto cal_neighbors;
 944     else
 945     {
 946         br += hex[best_site].row;
 947         bc += hex[best_site].col;
 948         k = best_site;
 949     }
 950
 951     for (j = 1; j < hex_range; j++)
 952     {
 953         best_site = -1;
 954         CHECK_BOUNDS(2)
 955
 956         if(all_in)
 957         {
 958             for (i = 0; i < 3; i++)
 959             {
 960                 this_mv.as_mv.row = br + next_chkpts[k][i].row;
 961                 this_mv.as_mv.col = bc + next_chkpts[k][i].col;
 962                 this_offset = base_offset + (this_mv.as_mv.row * (in_what_stride)) + this_mv.as_mv.col;
 963                 thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
 964                 CHECK_BETTER
 965             }
 966         }else
 967         {
 968             for (i = 0; i < 3; i++)
 969             {
 970                 this_mv.as_mv.row = br + next_chkpts[k][i].row;
 971                 this_mv.as_mv.col = bc + next_chkpts[k][i].col;
 972                 CHECK_POINT
 973                 this_offset = base_offset + (this_mv.as_mv.row * (in_what_stride)) + this_mv.as_mv.col;
 974                 thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
 975                 CHECK_BETTER
 976             }
 977         }
 978
 979         if (best_site == -1)
 980             break;
 981         else
 982         {
 983             br += next_chkpts[k][best_site].row;
 984             bc += next_chkpts[k][best_site].col;
 985             k += 5 + best_site;
 986             if (k >= 12) k -= 12;
 987             else if (k >= 6) k -= 6;
 988         }
 989     }
 990
 991     /* check 4 1-away neighbors */
 992 cal_neighbors:
 993     for (j = 0; j < dia_range; j++)
 994     {
 995         best_site = -1;
 996         CHECK_BOUNDS(1)
 997
 998         if(all_in)
 999         {
1000             for (i = 0; i < 4; i++)
1001             {
1002                 this_mv.as_mv.row = br + neighbors[i].row;
1003                 this_mv.as_mv.col = bc + neighbors[i].col;
1004                 this_offset = base_offset + (this_mv.as_mv.row * (in_what_stride)) + this_mv.as_mv.col;
1005                 thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
1006                 CHECK_BETTER
1007             }
1008         }else
1009         {
1010             for (i = 0; i < 4; i++)
1011             {
1012                 this_mv.as_mv.row = br + neighbors[i].row;
1013                 this_mv.as_mv.col = bc + neighbors[i].col;
1014                 CHECK_POINT
1015                 this_offset = base_offset + (this_mv.as_mv.row * (in_what_stride)) + this_mv.as_mv.col;
1016                 thissad = vfp->sdf(what, what_stride, this_offset, in_what_stride, bestsad);
1017                 CHECK_BETTER
1018             }
1019         }
1020
1021         if (best_site == -1)
1022             break;
1023         else
1024         {
1025             br += neighbors[best_site].row;
1026             bc += neighbors[best_site].col;
1027         }
1028     }
1029
1030     best_mv->as_mv.row = br;
1031     best_mv->as_mv.col = bc;
1032
1033     return bestsad;
1034 }
1035 #undef CHECK_BOUNDS
1036 #undef CHECK_POINT
1037 #undef CHECK_BETTER
1038
1039 int vp8_diamond_search_sad_c
1040 (
1041     MACROBLOCK *x,
1042     BLOCK *b,
1043     BLOCKD *d,
1044     int_mv *ref_mv,
1045     int_mv *best_mv,
1046     int search_param,
1047     int sad_per_bit,
1048     int *num00,
1049     vp8_variance_fn_ptr_t *fn_ptr,
1050     int *mvcost[2],
1051     int_mv *center_mv
1052 )
1053 {
1054     int i, j, step;
1055
1056     unsigned char *what = (*(b->base_src) + b->src);
1057     int what_stride = b->src_stride;
1058     unsigned char *in_what;
1059     int pre_stride = x->e_mbd.pre.y_stride;
1060     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
1061     int in_what_stride = pre_stride;
1062     unsigned char *best_address;
1063
1064     int tot_steps;
1065     int_mv this_mv;
1066
1067     unsigned int bestsad;
1068     unsigned int thissad;
1069     int best_site = 0;
1070     int last_site = 0;
1071
1072     int ref_row;
1073     int ref_col;
1074     int this_row_offset;
1075     int this_col_offset;
1076     search_site *ss;
1077
1078     unsigned char *check_here;
1079
1080     int *mvsadcost[2];
1081     int_mv fcenter_mv;
1082
1083     mvsadcost[0] = x->mvsadcost[0];
1084     mvsadcost[1] = x->mvsadcost[1];
1085     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
1086     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
1087
1088     vp8_clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
1089     ref_row = ref_mv->as_mv.row;
1090     ref_col = ref_mv->as_mv.col;
1091     *num00 = 0;
1092     best_mv->as_mv.row = ref_row;
1093     best_mv->as_mv.col = ref_col;
1094
1095     /* Work out the start point for the search */
1096     in_what = (unsigned char *)(base_pre + d->offset + (ref_row * pre_stride) + ref_col);
1097     best_address = in_what;
1098
1099     /* Check the starting position */
1100     bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride, UINT_MAX)
1101             + mvsad_err_cost(best_mv, &fcenter_mv, mvsadcost, sad_per_bit);
1102
1103     /* search_param determines the length of the initial step and hence
1104      * the number of iterations 0 = initial step (MAX_FIRST_STEP) pel :
1105      * 1 = (MAX_FIRST_STEP/2) pel, 2 = (MAX_FIRST_STEP/4) pel... etc.
1106      */
1107     ss = &x->ss[search_param * x->searches_per_step];
1108     tot_steps = (x->ss_count / x->searches_per_step) - search_param;
1109
1110     i = 1;
1111
1112     for (step = 0; step < tot_steps ; step++)
1113     {
1114         for (j = 0 ; j < x->searches_per_step ; j++)
1115         {
1116             /* Trap illegal vectors */
1117             this_row_offset = best_mv->as_mv.row + ss[i].mv.row;
1118             this_col_offset = best_mv->as_mv.col + ss[i].mv.col;
1119
1120             if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
1121             (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
1122
1123             {
1124                 check_here = ss[i].offset + best_address;
1125                 thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride, bestsad);
1126
1127                 if (thissad < bestsad)
1128                 {
1129                     this_mv.as_mv.row = this_row_offset;
1130                     this_mv.as_mv.col = this_col_offset;
1131                     thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
1132                                               mvsadcost, sad_per_bit);
1133
1134                     if (thissad < bestsad)
1135                     {
1136                         bestsad = thissad;
1137                         best_site = i;
1138                     }
1139                 }
1140             }
1141
1142             i++;
1143         }
1144
1145         if (best_site != last_site)
1146         {
1147             best_mv->as_mv.row += ss[best_site].mv.row;
1148             best_mv->as_mv.col += ss[best_site].mv.col;
1149             best_address += ss[best_site].offset;
1150             last_site = best_site;
1151         }
1152         else if (best_address == in_what)
1153             (*num00)++;
1154     }
1155
1156     this_mv.as_mv.row = best_mv->as_mv.row << 3;
1157     this_mv.as_mv.col = best_mv->as_mv.col << 3;
1158
1159     return fn_ptr->vf(what, what_stride, best_address, in_what_stride, &thissad)
1160            + mv_err_cost(&this_mv, center_mv, mvcost, x->errorperbit);
1161 }
1162
1163 int vp8_diamond_search_sadx4
1164 (
1165     MACROBLOCK *x,
1166     BLOCK *b,
1167     BLOCKD *d,
1168     int_mv *ref_mv,
1169     int_mv *best_mv,
1170     int search_param,
1171     int sad_per_bit,
1172     int *num00,
1173     vp8_variance_fn_ptr_t *fn_ptr,
1174     int *mvcost[2],
1175     int_mv *center_mv
1176 )
1177 {
1178     int i, j, step;
1179
1180     unsigned char *what = (*(b->base_src) + b->src);
1181     int what_stride = b->src_stride;
1182     unsigned char *in_what;
1183     int pre_stride = x->e_mbd.pre.y_stride;
1184     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
1185     int in_what_stride = pre_stride;
1186     unsigned char *best_address;
1187
1188     int tot_steps;
1189     int_mv this_mv;
1190
1191     unsigned int bestsad;
1192     unsigned int thissad;
1193     int best_site = 0;
1194     int last_site = 0;
1195
1196     int ref_row;
1197     int ref_col;
1198     int this_row_offset;
1199     int this_col_offset;
1200     search_site *ss;
1201
1202     unsigned char *check_here;
1203
1204     int *mvsadcost[2];
1205     int_mv fcenter_mv;
1206
1207     mvsadcost[0] = x->mvsadcost[0];
1208     mvsadcost[1] = x->mvsadcost[1];
1209     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
1210     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
1211
1212     vp8_clamp_mv(ref_mv, x->mv_col_min, x->mv_col_max, x->mv_row_min, x->mv_row_max);
1213     ref_row = ref_mv->as_mv.row;
1214     ref_col = ref_mv->as_mv.col;
1215     *num00 = 0;
1216     best_mv->as_mv.row = ref_row;
1217     best_mv->as_mv.col = ref_col;
1218
1219     /* Work out the start point for the search */
1220     in_what = (unsigned char *)(base_pre + d->offset + (ref_row * pre_stride) + ref_col);
1221     best_address = in_what;
1222
1223     /* Check the starting position */
1224     bestsad = fn_ptr->sdf(what, what_stride, in_what, in_what_stride, UINT_MAX)
1225             + mvsad_err_cost(best_mv, &fcenter_mv, mvsadcost, sad_per_bit);
1226
1227     /* search_param determines the length of the initial step and hence the
1228      * number of iterations 0 = initial step (MAX_FIRST_STEP) pel : 1 =
1229      * (MAX_FIRST_STEP/2) pel, 2 = (MAX_FIRST_STEP/4) pel... etc.
1230      */
1231     ss = &x->ss[search_param * x->searches_per_step];
1232     tot_steps = (x->ss_count / x->searches_per_step) - search_param;
1233
1234     i = 1;
1235
1236     for (step = 0; step < tot_steps ; step++)
1237     {
1238         int all_in = 1, t;
1239
1240         /* To know if all neighbor points are within the bounds, 4 bounds
1241          * checking are enough instead of checking 4 bounds for each
1242          * points.
1243          */
1244         all_in &= ((best_mv->as_mv.row + ss[i].mv.row)> x->mv_row_min);
1245         all_in &= ((best_mv->as_mv.row + ss[i+1].mv.row) < x->mv_row_max);
1246         all_in &= ((best_mv->as_mv.col + ss[i+2].mv.col) > x->mv_col_min);
1247         all_in &= ((best_mv->as_mv.col + ss[i+3].mv.col) < x->mv_col_max);
1248
1249         if (all_in)
1250         {
1251             unsigned int sad_array[4];
1252
1253             for (j = 0 ; j < x->searches_per_step ; j += 4)
1254             {
1255                 const unsigned char *block_offset[4];
1256
1257                 for (t = 0; t < 4; t++)
1258                     block_offset[t] = ss[i+t].offset + best_address;
1259
1260                 fn_ptr->sdx4df(what, what_stride, block_offset, in_what_stride, sad_array);
1261
1262                 for (t = 0; t < 4; t++, i++)
1263                 {
1264                     if (sad_array[t] < bestsad)
1265                     {
1266                         this_mv.as_mv.row = best_mv->as_mv.row + ss[i].mv.row;
1267                         this_mv.as_mv.col = best_mv->as_mv.col + ss[i].mv.col;
1268                         sad_array[t] += mvsad_err_cost(&this_mv, &fcenter_mv,
1269                                                        mvsadcost, sad_per_bit);
1270
1271                         if (sad_array[t] < bestsad)
1272                         {
1273                             bestsad = sad_array[t];
1274                             best_site = i;
1275                         }
1276                     }
1277                 }
1278             }
1279         }
1280         else
1281         {
1282             for (j = 0 ; j < x->searches_per_step ; j++)
1283             {
1284                 /* Trap illegal vectors */
1285                 this_row_offset = best_mv->as_mv.row + ss[i].mv.row;
1286                 this_col_offset = best_mv->as_mv.col + ss[i].mv.col;
1287
1288                 if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
1289                 (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
1290                 {
1291                     check_here = ss[i].offset + best_address;
1292                     thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride, bestsad);
1293
1294                     if (thissad < bestsad)
1295                     {
1296                         this_mv.as_mv.row = this_row_offset;
1297                         this_mv.as_mv.col = this_col_offset;
1298                         thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
1299                                                   mvsadcost, sad_per_bit);
1300
1301                         if (thissad < bestsad)
1302                         {
1303                             bestsad = thissad;
1304                             best_site = i;
1305                         }
1306                     }
1307                 }
1308                 i++;
1309             }
1310         }
1311
1312         if (best_site != last_site)
1313         {
1314             best_mv->as_mv.row += ss[best_site].mv.row;
1315             best_mv->as_mv.col += ss[best_site].mv.col;
1316             best_address += ss[best_site].offset;
1317             last_site = best_site;
1318         }
1319         else if (best_address == in_what)
1320             (*num00)++;
1321     }
1322
1323     this_mv.as_mv.row = best_mv->as_mv.row * 8;
1324     this_mv.as_mv.col = best_mv->as_mv.col * 8;
1325
1326     return fn_ptr->vf(what, what_stride, best_address, in_what_stride, &thissad)
1327            + mv_err_cost(&this_mv, center_mv, mvcost, x->errorperbit);
1328 }
1329
1330 int vp8_full_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
1331                         int sad_per_bit, int distance,
1332                         vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2],
1333                         int_mv *center_mv)
1334 {
1335     unsigned char *what = (*(b->base_src) + b->src);
1336     int what_stride = b->src_stride;
1337     unsigned char *in_what;
1338     int pre_stride = x->e_mbd.pre.y_stride;
1339     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
1340     int in_what_stride = pre_stride;
1341     int mv_stride = pre_stride;
1342     unsigned char *bestaddress;
1343     int_mv *best_mv = &d->bmi.mv;
1344     int_mv this_mv;
1345     unsigned int bestsad;
1346     unsigned int thissad;
1347     int r, c;
1348
1349     unsigned char *check_here;
1350
1351     int ref_row = ref_mv->as_mv.row;
1352     int ref_col = ref_mv->as_mv.col;
1353
1354     int row_min = ref_row - distance;
1355     int row_max = ref_row + distance;
1356     int col_min = ref_col - distance;
1357     int col_max = ref_col + distance;
1358
1359     int *mvsadcost[2];
1360     int_mv fcenter_mv;
1361
1362     mvsadcost[0] = x->mvsadcost[0];
1363     mvsadcost[1] = x->mvsadcost[1];
1364     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
1365     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
1366
1367     /* Work out the mid point for the search */
1368     in_what = base_pre + d->offset;
1369     bestaddress = in_what + (ref_row * pre_stride) + ref_col;
1370
1371     best_mv->as_mv.row = ref_row;
1372     best_mv->as_mv.col = ref_col;
1373
1374     /* Baseline value at the centre */
1375     bestsad = fn_ptr->sdf(what, what_stride, bestaddress,
1376                           in_what_stride, UINT_MAX)
1377             + mvsad_err_cost(best_mv, &fcenter_mv, mvsadcost, sad_per_bit);
1378
1379     /* Apply further limits to prevent us looking using vectors that
1380      * stretch beyiond the UMV border
1381      */
1382     if (col_min < x->mv_col_min)
1383         col_min = x->mv_col_min;
1384
1385     if (col_max > x->mv_col_max)
1386         col_max = x->mv_col_max;
1387
1388     if (row_min < x->mv_row_min)
1389         row_min = x->mv_row_min;
1390
1391     if (row_max > x->mv_row_max)
1392         row_max = x->mv_row_max;
1393
1394     for (r = row_min; r < row_max ; r++)
1395     {
1396         this_mv.as_mv.row = r;
1397         check_here = r * mv_stride + in_what + col_min;
1398
1399         for (c = col_min; c < col_max; c++)
1400         {
1401             thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride, bestsad);
1402
1403             this_mv.as_mv.col = c;
1404             thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
1405                                       mvsadcost, sad_per_bit);
1406
1407             if (thissad < bestsad)
1408             {
1409                 bestsad = thissad;
1410                 best_mv->as_mv.row = r;
1411                 best_mv->as_mv.col = c;
1412                 bestaddress = check_here;
1413             }
1414
1415             check_here++;
1416         }
1417     }
1418
1419     this_mv.as_mv.row = best_mv->as_mv.row << 3;
1420     this_mv.as_mv.col = best_mv->as_mv.col << 3;
1421
1422     return fn_ptr->vf(what, what_stride, bestaddress, in_what_stride, &thissad)
1423            + mv_err_cost(&this_mv, center_mv, mvcost, x->errorperbit);
1424 }
1425
1426 int vp8_full_search_sadx3(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
1427                           int sad_per_bit, int distance,
1428                           vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2],
1429                           int_mv *center_mv)
1430 {
1431     unsigned char *what = (*(b->base_src) + b->src);
1432     int what_stride = b->src_stride;
1433     unsigned char *in_what;
1434     int pre_stride = x->e_mbd.pre.y_stride;
1435     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
1436     int in_what_stride = pre_stride;
1437     int mv_stride = pre_stride;
1438     unsigned char *bestaddress;
1439     int_mv *best_mv = &d->bmi.mv;
1440     int_mv this_mv;
1441     unsigned int bestsad;
1442     unsigned int thissad;
1443     int r, c;
1444
1445     unsigned char *check_here;
1446
1447     int ref_row = ref_mv->as_mv.row;
1448     int ref_col = ref_mv->as_mv.col;
1449
1450     int row_min = ref_row - distance;
1451     int row_max = ref_row + distance;
1452     int col_min = ref_col - distance;
1453     int col_max = ref_col + distance;
1454
1455     unsigned int sad_array[3];
1456
1457     int *mvsadcost[2];
1458     int_mv fcenter_mv;
1459
1460     mvsadcost[0] = x->mvsadcost[0];
1461     mvsadcost[1] = x->mvsadcost[1];
1462     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
1463     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
1464
1465     /* Work out the mid point for the search */
1466     in_what = base_pre + d->offset;
1467     bestaddress = in_what + (ref_row * pre_stride) + ref_col;
1468
1469     best_mv->as_mv.row = ref_row;
1470     best_mv->as_mv.col = ref_col;
1471
1472     /* Baseline value at the centre */
1473     bestsad = fn_ptr->sdf(what, what_stride, bestaddress,
1474                           in_what_stride, UINT_MAX)
1475             + mvsad_err_cost(best_mv, &fcenter_mv, mvsadcost, sad_per_bit);
1476
1477     /* Apply further limits to prevent us looking using vectors that stretch
1478      * beyond the UMV border
1479      */
1480     if (col_min < x->mv_col_min)
1481         col_min = x->mv_col_min;
1482
1483     if (col_max > x->mv_col_max)
1484         col_max = x->mv_col_max;
1485
1486     if (row_min < x->mv_row_min)
1487         row_min = x->mv_row_min;
1488
1489     if (row_max > x->mv_row_max)
1490         row_max = x->mv_row_max;
1491
1492     for (r = row_min; r < row_max ; r++)
1493     {
1494         this_mv.as_mv.row = r;
1495         check_here = r * mv_stride + in_what + col_min;
1496         c = col_min;
1497
1498         while ((c + 2) < col_max)
1499         {
1500             int i;
1501
1502             fn_ptr->sdx3f(what, what_stride, check_here, in_what_stride, sad_array);
1503
1504             for (i = 0; i < 3; i++)
1505             {
1506                 thissad = sad_array[i];
1507
1508                 if (thissad < bestsad)
1509                 {
1510                     this_mv.as_mv.col = c;
1511                     thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
1512                                               mvsadcost, sad_per_bit);
1513
1514                     if (thissad < bestsad)
1515                     {
1516                         bestsad = thissad;
1517                         best_mv->as_mv.row = r;
1518                         best_mv->as_mv.col = c;
1519                         bestaddress = check_here;
1520                     }
1521                 }
1522
1523                 check_here++;
1524                 c++;
1525             }
1526         }
1527
1528         while (c < col_max)
1529         {
1530             thissad = fn_ptr->sdf(what, what_stride, check_here, in_what_stride, bestsad);
1531
1532             if (thissad < bestsad)
1533             {
1534                 this_mv.as_mv.col = c;
1535                 thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
1536                                           mvsadcost, sad_per_bit);
1537
1538                 if (thissad < bestsad)
1539                 {
1540                     bestsad = thissad;
1541                     best_mv->as_mv.row = r;
1542                     best_mv->as_mv.col = c;
1543                     bestaddress = check_here;
1544                 }
1545             }
1546
1547             check_here ++;
1548             c ++;
1549         }
1550
1551     }
1552
1553     this_mv.as_mv.row = best_mv->as_mv.row << 3;
1554     this_mv.as_mv.col = best_mv->as_mv.col << 3;
1555
1556     return fn_ptr->vf(what, what_stride, bestaddress, in_what_stride, &thissad)
1557            + mv_err_cost(&this_mv, center_mv, mvcost, x->errorperbit);
1558 }
1559
1560 int vp8_full_search_sadx8(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
1561                           int sad_per_bit, int distance,
1562                           vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2],
1563                           int_mv *center_mv)
1564 {
1565     unsigned char *what = (*(b->base_src) + b->src);
1566     int what_stride = b->src_stride;
1567     int pre_stride = x->e_mbd.pre.y_stride;
1568     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
1569     unsigned char *in_what;
1570     int in_what_stride = pre_stride;
1571     int mv_stride = pre_stride;
1572     unsigned char *bestaddress;
1573     int_mv *best_mv = &d->bmi.mv;
1574     int_mv this_mv;
1575     unsigned int bestsad;
1576     unsigned int thissad;
1577     int r, c;
1578
1579     unsigned char *check_here;
1580
1581     int ref_row = ref_mv->as_mv.row;
1582     int ref_col = ref_mv->as_mv.col;
1583
1584     int row_min = ref_row - distance;
1585     int row_max = ref_row + distance;
1586     int col_min = ref_col - distance;
1587     int col_max = ref_col + distance;
1588
1589     DECLARE_ALIGNED_ARRAY(16, unsigned short, sad_array8, 8);
1590     unsigned int sad_array[3];
1591
1592     int *mvsadcost[2];
1593     int_mv fcenter_mv;
1594
1595     mvsadcost[0] = x->mvsadcost[0];
1596     mvsadcost[1] = x->mvsadcost[1];
1597     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
1598     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
1599
1600     /* Work out the mid point for the search */
1601     in_what = base_pre + d->offset;
1602     bestaddress = in_what + (ref_row * pre_stride) + ref_col;
1603
1604     best_mv->as_mv.row = ref_row;
1605     best_mv->as_mv.col = ref_col;
1606
1607     /* Baseline value at the centre */
1608     bestsad = fn_ptr->sdf(what, what_stride,
1609                           bestaddress, in_what_stride, UINT_MAX)
1610             + mvsad_err_cost(best_mv, &fcenter_mv, mvsadcost, sad_per_bit);
1611
1612     /* Apply further limits to prevent us looking using vectors that stretch
1613      * beyond the UMV border
1614      */
1615     if (col_min < x->mv_col_min)
1616         col_min = x->mv_col_min;
1617
1618     if (col_max > x->mv_col_max)
1619         col_max = x->mv_col_max;
1620
1621     if (row_min < x->mv_row_min)
1622         row_min = x->mv_row_min;
1623
1624     if (row_max > x->mv_row_max)
1625         row_max = x->mv_row_max;
1626
1627     for (r = row_min; r < row_max ; r++)
1628     {
1629         this_mv.as_mv.row = r;
1630         check_here = r * mv_stride + in_what + col_min;
1631         c = col_min;
1632
1633         while ((c + 7) < col_max)
1634         {
1635             int i;
1636
1637             fn_ptr->sdx8f(what, what_stride, check_here, in_what_stride, sad_array8);
1638
1639             for (i = 0; i < 8; i++)
1640             {
1641                 thissad = sad_array8[i];
1642
1643                 if (thissad < bestsad)
1644                 {
1645                     this_mv.as_mv.col = c;
1646                     thissad += mvsad_err_cost(&this_mv, &fcenter_mv,
1647                                               mvsadcost, sad_per_bit);
1648
1649                     if (thissad < bestsad)
1650                     {
1651                         bestsad = thissad;
1652                         best_mv->as_mv.row = r;
1653                         best_mv->as_mv.col = c;
1654                         bestaddress = check_here;
1655                     }
1656                 }
1657
1658                 check_here++;
1659                 c++;
1660             }
1661         }
1662
1663         while ((c + 2) < col_max)
1664         {
1665             int i;
1666
1667             fn_ptr->sdx3f(what, what_stride, check_here , in_what_stride, sad_array);
1668
1669             for (i = 0; i < 3; i++)
1670             {
1671                 thissad = sad_array[i];
1672
1673                 if (thissad < bestsad)
1674                 {
1675                     this_mv.as_mv.col = c;
1676                     thissad  += mvsad_err_cost(&this_mv, &fcenter_mv,
1677                         mvsadcost, sad_per_bit);
1678
1679                     if (thissad < bestsad)
1680                     {
1681                         bestsad = thissad;
1682                         best_mv->as_mv.row = r;
1683                         best_mv->as_mv.col = c;
1684                         bestaddress = check_here;
1685                     }
1686                 }
1687
1688                 check_here++;
1689                 c++;
1690             }
1691         }
1692
1693         while (c < col_max)
1694         {
1695             thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride, bestsad);
1696
1697             if (thissad < bestsad)
1698             {
1699                 this_mv.as_mv.col = c;
1700                 thissad  += mvsad_err_cost(&this_mv, &fcenter_mv,
1701                     mvsadcost, sad_per_bit);
1702
1703                 if (thissad < bestsad)
1704                 {
1705                     bestsad = thissad;
1706                     best_mv->as_mv.row = r;
1707                     best_mv->as_mv.col = c;
1708                     bestaddress = check_here;
1709                 }
1710             }
1711
1712             check_here ++;
1713             c ++;
1714         }
1715     }
1716
1717     this_mv.as_mv.row = best_mv->as_mv.row * 8;
1718     this_mv.as_mv.col = best_mv->as_mv.col * 8;
1719
1720     return fn_ptr->vf(what, what_stride, bestaddress, in_what_stride, &thissad)
1721            + mv_err_cost(&this_mv, center_mv, mvcost, x->errorperbit);
1722 }
1723
1724 int vp8_refining_search_sad_c(MACROBLOCK *x, BLOCK *b, BLOCKD *d, int_mv *ref_mv,
1725                             int error_per_bit, int search_range,
1726                             vp8_variance_fn_ptr_t *fn_ptr, int *mvcost[2],
1727                             int_mv *center_mv)
1728 {
1729     MV neighbors[4] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
1730     int i, j;
1731     short this_row_offset, this_col_offset;
1732
1733     int what_stride = b->src_stride;
1734     int pre_stride = x->e_mbd.pre.y_stride;
1735     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
1736     int in_what_stride = pre_stride;
1737     unsigned char *what = (*(b->base_src) + b->src);
1738     unsigned char *best_address = (unsigned char *)(base_pre + d->offset +
1739         (ref_mv->as_mv.row * pre_stride) + ref_mv->as_mv.col);
1740     unsigned char *check_here;
1741     int_mv this_mv;
1742     unsigned int bestsad;
1743     unsigned int thissad;
1744
1745     int *mvsadcost[2];
1746     int_mv fcenter_mv;
1747
1748     mvsadcost[0] = x->mvsadcost[0];
1749     mvsadcost[1] = x->mvsadcost[1];
1750     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
1751     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
1752
1753     bestsad = fn_ptr->sdf(what, what_stride, best_address,
1754                           in_what_stride, UINT_MAX)
1755             + mvsad_err_cost(ref_mv, &fcenter_mv, mvsadcost, error_per_bit);
1756
1757     for (i=0; i<search_range; i++)
1758     {
1759         int best_site = -1;
1760
1761         for (j = 0 ; j < 4 ; j++)
1762         {
1763             this_row_offset = ref_mv->as_mv.row + neighbors[j].row;
1764             this_col_offset = ref_mv->as_mv.col + neighbors[j].col;
1765
1766             if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
1767             (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
1768             {
1769                 check_here = (neighbors[j].row)*in_what_stride + neighbors[j].col + best_address;
1770                 thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride, bestsad);
1771
1772                 if (thissad < bestsad)
1773                 {
1774                     this_mv.as_mv.row = this_row_offset;
1775                     this_mv.as_mv.col = this_col_offset;
1776                     thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
1777
1778                     if (thissad < bestsad)
1779                     {
1780                         bestsad = thissad;
1781                         best_site = j;
1782                     }
1783                 }
1784             }
1785         }
1786
1787         if (best_site == -1)
1788             break;
1789         else
1790         {
1791             ref_mv->as_mv.row += neighbors[best_site].row;
1792             ref_mv->as_mv.col += neighbors[best_site].col;
1793             best_address += (neighbors[best_site].row)*in_what_stride + neighbors[best_site].col;
1794         }
1795     }
1796
1797     this_mv.as_mv.row = ref_mv->as_mv.row << 3;
1798     this_mv.as_mv.col = ref_mv->as_mv.col << 3;
1799
1800     return fn_ptr->vf(what, what_stride, best_address, in_what_stride, &thissad)
1801            + mv_err_cost(&this_mv, center_mv, mvcost, x->errorperbit);
1802 }
1803
1804 int vp8_refining_search_sadx4(MACROBLOCK *x, BLOCK *b, BLOCKD *d,
1805                               int_mv *ref_mv, int error_per_bit,
1806                               int search_range, vp8_variance_fn_ptr_t *fn_ptr,
1807                               int *mvcost[2], int_mv *center_mv)
1808 {
1809     MV neighbors[4] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
1810     int i, j;
1811     short this_row_offset, this_col_offset;
1812
1813     int what_stride = b->src_stride;
1814     int pre_stride = x->e_mbd.pre.y_stride;
1815     unsigned char *base_pre = x->e_mbd.pre.y_buffer;
1816     int in_what_stride = pre_stride;
1817     unsigned char *what = (*(b->base_src) + b->src);
1818     unsigned char *best_address = (unsigned char *)(base_pre + d->offset +
1819         (ref_mv->as_mv.row * pre_stride) + ref_mv->as_mv.col);
1820     unsigned char *check_here;
1821     int_mv this_mv;
1822     unsigned int bestsad;
1823     unsigned int thissad;
1824
1825     int *mvsadcost[2];
1826     int_mv fcenter_mv;
1827
1828     mvsadcost[0] = x->mvsadcost[0];
1829     mvsadcost[1] = x->mvsadcost[1];
1830     fcenter_mv.as_mv.row = center_mv->as_mv.row >> 3;
1831     fcenter_mv.as_mv.col = center_mv->as_mv.col >> 3;
1832
1833     bestsad = fn_ptr->sdf(what, what_stride, best_address,
1834                           in_what_stride, UINT_MAX)
1835             + mvsad_err_cost(ref_mv, &fcenter_mv, mvsadcost, error_per_bit);
1836
1837     for (i=0; i<search_range; i++)
1838     {
1839         int best_site = -1;
1840         int all_in = 1;
1841
1842         all_in &= ((ref_mv->as_mv.row - 1) > x->mv_row_min);
1843         all_in &= ((ref_mv->as_mv.row + 1) < x->mv_row_max);
1844         all_in &= ((ref_mv->as_mv.col - 1) > x->mv_col_min);
1845         all_in &= ((ref_mv->as_mv.col + 1) < x->mv_col_max);
1846
1847         if(all_in)
1848         {
1849             unsigned int sad_array[4];
1850             const unsigned char *block_offset[4];
1851             block_offset[0] = best_address - in_what_stride;
1852             block_offset[1] = best_address - 1;
1853             block_offset[2] = best_address + 1;
1854             block_offset[3] = best_address + in_what_stride;
1855
1856             fn_ptr->sdx4df(what, what_stride, block_offset, in_what_stride, sad_array);
1857
1858             for (j = 0; j < 4; j++)
1859             {
1860                 if (sad_array[j] < bestsad)
1861                 {
1862                     this_mv.as_mv.row = ref_mv->as_mv.row + neighbors[j].row;
1863                     this_mv.as_mv.col = ref_mv->as_mv.col + neighbors[j].col;
1864                     sad_array[j] += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
1865
1866                     if (sad_array[j] < bestsad)
1867                     {
1868                         bestsad = sad_array[j];
1869                         best_site = j;
1870                     }
1871                 }
1872             }
1873         }
1874         else
1875         {
1876             for (j = 0 ; j < 4 ; j++)
1877             {
1878                 this_row_offset = ref_mv->as_mv.row + neighbors[j].row;
1879                 this_col_offset = ref_mv->as_mv.col + neighbors[j].col;
1880
1881                 if ((this_col_offset > x->mv_col_min) && (this_col_offset < x->mv_col_max) &&
1882                 (this_row_offset > x->mv_row_min) && (this_row_offset < x->mv_row_max))
1883                 {
1884                     check_here = (neighbors[j].row)*in_what_stride + neighbors[j].col + best_address;
1885                     thissad = fn_ptr->sdf(what, what_stride, check_here , in_what_stride, bestsad);
1886
1887                     if (thissad < bestsad)
1888                     {
1889                         this_mv.as_mv.row = this_row_offset;
1890                         this_mv.as_mv.col = this_col_offset;
1891                         thissad += mvsad_err_cost(&this_mv, &fcenter_mv, mvsadcost, error_per_bit);
1892
1893                         if (thissad < bestsad)
1894                         {
1895                             bestsad = thissad;
1896                             best_site = j;
1897                         }
1898                     }
1899                 }
1900             }
1901         }
1902
1903         if (best_site == -1)
1904             break;
1905         else
1906         {
1907             ref_mv->as_mv.row += neighbors[best_site].row;
1908             ref_mv->as_mv.col += neighbors[best_site].col;
1909             best_address += (neighbors[best_site].row)*in_what_stride + neighbors[best_site].col;
1910         }
1911     }
1912
1913     this_mv.as_mv.row = ref_mv->as_mv.row * 8;
1914     this_mv.as_mv.col = ref_mv->as_mv.col * 8;
1915
1916     return fn_ptr->vf(what, what_stride, best_address, in_what_stride, &thissad)
1917            + mv_err_cost(&this_mv, center_mv, mvcost, x->errorperbit);
1918 }
1919
1920 #ifdef VP8_ENTROPY_STATS
1921 void print_mode_context(void)
1922 {
1923     FILE *f = fopen("modecont.c", "w");
1924     int i, j;
1925
1926     fprintf(f, "#include \"entropy.h\"\n");
1927     fprintf(f, "const int vp8_mode_contexts[6][4] =\n");
1928     fprintf(f, "{\n");
1929
1930     for (j = 0; j < 6; j++)
1931     {
1932         fprintf(f, "  { /* %d */\n", j);
1933         fprintf(f, "    ");
1934
1935         for (i = 0; i < 4; i++)
1936         {
1937             int overal_prob;
1938             int this_prob;
1939             int count;
1940
1941             /* Overall probs */
1942             count = mv_mode_cts[i][0] + mv_mode_cts[i][1];
1943
1944             if (count)
1945                 overal_prob = 256 * mv_mode_cts[i][0] / count;
1946             else
1947                 overal_prob = 128;
1948
1949             if (overal_prob == 0)
1950                 overal_prob = 1;
1951
1952             /* context probs */
1953             count = mv_ref_ct[j][i][0] + mv_ref_ct[j][i][1];
1954
1955             if (count)
1956                 this_prob = 256 * mv_ref_ct[j][i][0] / count;
1957             else
1958                 this_prob = 128;
1959
1960             if (this_prob == 0)
1961                 this_prob = 1;
1962
1963             fprintf(f, "%5d, ", this_prob);
1964         }
1965
1966         fprintf(f, "  },\n");
1967     }
1968
1969     fprintf(f, "};\n");
1970     fclose(f);
1971 }
1972
1973 /* MV ref count VP8_ENTROPY_STATS stats code */
1974 #ifdef VP8_ENTROPY_STATS
1975 void init_mv_ref_counts()
1976 {
1977     vpx_memset(mv_ref_ct, 0, sizeof(mv_ref_ct));
1978     vpx_memset(mv_mode_cts, 0, sizeof(mv_mode_cts));
1979 }
1980
1981 void accum_mv_refs(MB_PREDICTION_MODE m, const int ct[4])
1982 {
1983     if (m == ZEROMV)
1984     {
1985         ++mv_ref_ct [ct[0]] [0] [0];
1986         ++mv_mode_cts[0][0];
1987     }
1988     else
1989     {
1990         ++mv_ref_ct [ct[0]] [0] [1];
1991         ++mv_mode_cts[0][1];
1992
1993         if (m == NEARESTMV)
1994         {
1995             ++mv_ref_ct [ct[1]] [1] [0];
1996             ++mv_mode_cts[1][0];
1997         }
1998         else
1999         {
2000             ++mv_ref_ct [ct[1]] [1] [1];
2001             ++mv_mode_cts[1][1];
2002
2003             if (m == NEARMV)
2004             {
2005                 ++mv_ref_ct [ct[2]] [2] [0];
2006                 ++mv_mode_cts[2][0];
2007             }
2008             else
2009             {
2010                 ++mv_ref_ct [ct[2]] [2] [1];
2011                 ++mv_mode_cts[2][1];
2012
2013                 if (m == NEWMV)
2014                 {
2015                     ++mv_ref_ct [ct[3]] [3] [0];
2016                     ++mv_mode_cts[3][0];
2017                 }
2018                 else
2019                 {
2020                     ++mv_ref_ct [ct[3]] [3] [1];
2021                     ++mv_mode_cts[3][1];
2022                 }
2023             }
2024         }
2025     }
2026 }
2027
2028 #endif/* END MV ref count VP8_ENTROPY_STATS stats code */
2029
2030 #endif