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