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