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