vp8/common/reconinter.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 "vpx_ports/config.h"
  13 #include "recon.h"
  14 #include "subpixel.h"
  15 #include "blockd.h"
  16 #include "reconinter.h"
  17 #if CONFIG_RUNTIME_CPU_DETECT
  18 #include "onyxc_int.h"
  19 #endif
  20
  21 /* use this define on systems where unaligned int reads and writes are
  22  * not allowed, i.e. ARM architectures
  23  */
  24 /*#define MUST_BE_ALIGNED*/
  25
  26
  27 static const int bbb[4] = {0, 2, 8, 10};
  28
  29
  30
  31 void vp8_copy_mem16x16_c(
  32     unsigned char *src,
  33     int src_stride,
  34     unsigned char *dst,
  35     int dst_stride)
  36 {
  37
  38     int r;
  39
  40     for (r = 0; r < 16; r++)
  41     {
  42 #ifdef MUST_BE_ALIGNED
  43         dst[0] = src[0];
  44         dst[1] = src[1];
  45         dst[2] = src[2];
  46         dst[3] = src[3];
  47         dst[4] = src[4];
  48         dst[5] = src[5];
  49         dst[6] = src[6];
  50         dst[7] = src[7];
  51         dst[8] = src[8];
  52         dst[9] = src[9];
  53         dst[10] = src[10];
  54         dst[11] = src[11];
  55         dst[12] = src[12];
  56         dst[13] = src[13];
  57         dst[14] = src[14];
  58         dst[15] = src[15];
  59
  60 #else
  61         ((int *)dst)[0] = ((int *)src)[0] ;
  62         ((int *)dst)[1] = ((int *)src)[1] ;
  63         ((int *)dst)[2] = ((int *)src)[2] ;
  64         ((int *)dst)[3] = ((int *)src)[3] ;
  65
  66 #endif
  67         src += src_stride;
  68         dst += dst_stride;
  69
  70     }
  71
  72 }
  73
  74 void vp8_copy_mem8x8_c(
  75     unsigned char *src,
  76     int src_stride,
  77     unsigned char *dst,
  78     int dst_stride)
  79 {
  80     int r;
  81
  82     for (r = 0; r < 8; r++)
  83     {
  84 #ifdef MUST_BE_ALIGNED
  85         dst[0] = src[0];
  86         dst[1] = src[1];
  87         dst[2] = src[2];
  88         dst[3] = src[3];
  89         dst[4] = src[4];
  90         dst[5] = src[5];
  91         dst[6] = src[6];
  92         dst[7] = src[7];
  93 #else
  94         ((int *)dst)[0] = ((int *)src)[0] ;
  95         ((int *)dst)[1] = ((int *)src)[1] ;
  96 #endif
  97         src += src_stride;
  98         dst += dst_stride;
  99
 100     }
 101
 102 }
 103
 104 void vp8_copy_mem8x4_c(
 105     unsigned char *src,
 106     int src_stride,
 107     unsigned char *dst,
 108     int dst_stride)
 109 {
 110     int r;
 111
 112     for (r = 0; r < 4; r++)
 113     {
 114 #ifdef MUST_BE_ALIGNED
 115         dst[0] = src[0];
 116         dst[1] = src[1];
 117         dst[2] = src[2];
 118         dst[3] = src[3];
 119         dst[4] = src[4];
 120         dst[5] = src[5];
 121         dst[6] = src[6];
 122         dst[7] = src[7];
 123 #else
 124         ((int *)dst)[0] = ((int *)src)[0] ;
 125         ((int *)dst)[1] = ((int *)src)[1] ;
 126 #endif
 127         src += src_stride;
 128         dst += dst_stride;
 129
 130     }
 131
 132 }
 133
 134
 135
 136 void vp8_build_inter_predictors_b(BLOCKD *d, int pitch, vp8_subpix_fn_t sppf)
 137 {
 138     int r;
 139     unsigned char *ptr_base;
 140     unsigned char *ptr;
 141     unsigned char *pred_ptr = d->predictor;
 142
 143     ptr_base = *(d->base_pre);
 144
 145     if (d->bmi.mv.as_mv.row & 7 || d->bmi.mv.as_mv.col & 7)
 146     {
 147         ptr = ptr_base + d->pre + (d->bmi.mv.as_mv.row >> 3) * d->pre_stride + (d->bmi.mv.as_mv.col >> 3);
 148         sppf(ptr, d->pre_stride, d->bmi.mv.as_mv.col & 7, d->bmi.mv.as_mv.row & 7, pred_ptr, pitch);
 149     }
 150     else
 151     {
 152         ptr_base += d->pre + (d->bmi.mv.as_mv.row >> 3) * d->pre_stride + (d->bmi.mv.as_mv.col >> 3);
 153         ptr = ptr_base;
 154
 155         for (r = 0; r < 4; r++)
 156         {
 157 #ifdef MUST_BE_ALIGNED
 158             pred_ptr[0]  = ptr[0];
 159             pred_ptr[1]  = ptr[1];
 160             pred_ptr[2]  = ptr[2];
 161             pred_ptr[3]  = ptr[3];
 162 #else
 163             *(int *)pred_ptr = *(int *)ptr ;
 164 #endif
 165             pred_ptr     += pitch;
 166             ptr         += d->pre_stride;
 167         }
 168     }
 169 }
 170
 171 static void build_inter_predictors4b(MACROBLOCKD *x, BLOCKD *d, int pitch)
 172 {
 173     unsigned char *ptr_base;
 174     unsigned char *ptr;
 175     unsigned char *pred_ptr = d->predictor;
 176
 177     ptr_base = *(d->base_pre);
 178     ptr = ptr_base + d->pre + (d->bmi.mv.as_mv.row >> 3) * d->pre_stride + (d->bmi.mv.as_mv.col >> 3);
 179
 180     if (d->bmi.mv.as_mv.row & 7 || d->bmi.mv.as_mv.col & 7)
 181     {
 182         x->subpixel_predict8x8(ptr, d->pre_stride, d->bmi.mv.as_mv.col & 7, d->bmi.mv.as_mv.row & 7, pred_ptr, pitch);
 183     }
 184     else
 185     {
 186         RECON_INVOKE(&x->rtcd->recon, copy8x8)(ptr, d->pre_stride, pred_ptr, pitch);
 187     }
 188 }
 189
 190 static void build_inter_predictors2b(MACROBLOCKD *x, BLOCKD *d, int pitch)
 191 {
 192     unsigned char *ptr_base;
 193     unsigned char *ptr;
 194     unsigned char *pred_ptr = d->predictor;
 195
 196     ptr_base = *(d->base_pre);
 197     ptr = ptr_base + d->pre + (d->bmi.mv.as_mv.row >> 3) * d->pre_stride + (d->bmi.mv.as_mv.col >> 3);
 198
 199     if (d->bmi.mv.as_mv.row & 7 || d->bmi.mv.as_mv.col & 7)
 200     {
 201         x->subpixel_predict8x4(ptr, d->pre_stride, d->bmi.mv.as_mv.col & 7, d->bmi.mv.as_mv.row & 7, pred_ptr, pitch);
 202     }
 203     else
 204     {
 205         RECON_INVOKE(&x->rtcd->recon, copy8x4)(ptr, d->pre_stride, pred_ptr, pitch);
 206     }
 207 }
 208
 209
 210 /*encoder only*/
 211 void vp8_build_inter_predictors_mbuv(MACROBLOCKD *x)
 212 {
 213     int i;
 214
 215     if (x->mode_info_context->mbmi.mode != SPLITMV)
 216     {
 217         unsigned char *uptr, *vptr;
 218         unsigned char *upred_ptr = &x->predictor[256];
 219         unsigned char *vpred_ptr = &x->predictor[320];
 220
 221         int mv_row = x->block[16].bmi.mv.as_mv.row;
 222         int mv_col = x->block[16].bmi.mv.as_mv.col;
 223         int offset;
 224         int pre_stride = x->block[16].pre_stride;
 225
 226         offset = (mv_row >> 3) * pre_stride + (mv_col >> 3);
 227         uptr = x->pre.u_buffer + offset;
 228         vptr = x->pre.v_buffer + offset;
 229
 230         if ((mv_row | mv_col) & 7)
 231         {
 232             x->subpixel_predict8x8(uptr, pre_stride, mv_col & 7, mv_row & 7, upred_ptr, 8);
 233             x->subpixel_predict8x8(vptr, pre_stride, mv_col & 7, mv_row & 7, vpred_ptr, 8);
 234         }
 235         else
 236         {
 237             RECON_INVOKE(&x->rtcd->recon, copy8x8)(uptr, pre_stride, upred_ptr, 8);
 238             RECON_INVOKE(&x->rtcd->recon, copy8x8)(vptr, pre_stride, vpred_ptr, 8);
 239         }
 240     }
 241     else
 242     {
 243         for (i = 16; i < 24; i += 2)
 244         {
 245             BLOCKD *d0 = &x->block[i];
 246             BLOCKD *d1 = &x->block[i+1];
 247
 248             if (d0->bmi.mv.as_int == d1->bmi.mv.as_int)
 249                 build_inter_predictors2b(x, d0, 8);
 250             else
 251             {
 252                 vp8_build_inter_predictors_b(d0, 8, x->subpixel_predict);
 253                 vp8_build_inter_predictors_b(d1, 8, x->subpixel_predict);
 254             }
 255         }
 256     }
 257 }
 258
 259 /*encoder only*/
 260 void vp8_build_inter16x16_predictors_mby(MACROBLOCKD *x)
 261 {
 262     unsigned char *ptr_base;
 263     unsigned char *ptr;
 264     unsigned char *pred_ptr = x->predictor;
 265     int mv_row = x->mode_info_context->mbmi.mv.as_mv.row;
 266     int mv_col = x->mode_info_context->mbmi.mv.as_mv.col;
 267     int pre_stride = x->block[0].pre_stride;
 268
 269     ptr_base = x->pre.y_buffer;
 270     ptr = ptr_base + (mv_row >> 3) * pre_stride + (mv_col >> 3);
 271
 272     if ((mv_row | mv_col) & 7)
 273     {
 274         x->subpixel_predict16x16(ptr, pre_stride, mv_col & 7, mv_row & 7, pred_ptr, 16);
 275     }
 276     else
 277     {
 278         RECON_INVOKE(&x->rtcd->recon, copy16x16)(ptr, pre_stride, pred_ptr, 16);
 279     }
 280 }
 281
 282 void vp8_build_inter16x16_predictors_mb(MACROBLOCKD *x,
 283                                         unsigned char *dst_y,
 284                                         unsigned char *dst_u,
 285                                         unsigned char *dst_v,
 286                                         int dst_ystride,
 287                                         int dst_uvstride)
 288 {
 289     int offset;
 290     unsigned char *ptr;
 291     unsigned char *uptr, *vptr;
 292
 293     int mv_row = x->mode_info_context->mbmi.mv.as_mv.row;
 294     int mv_col = x->mode_info_context->mbmi.mv.as_mv.col;
 295
 296     unsigned char *ptr_base = x->pre.y_buffer;
 297     int pre_stride = x->block[0].pre_stride;
 298
 299     ptr = ptr_base + (mv_row >> 3) * pre_stride + (mv_col >> 3);
 300
 301     if ((mv_row | mv_col) & 7)
 302     {
 303         x->subpixel_predict16x16(ptr, pre_stride, mv_col & 7, mv_row & 7, dst_y, dst_ystride);
 304     }
 305     else
 306     {
 307         RECON_INVOKE(&x->rtcd->recon, copy16x16)(ptr, pre_stride, dst_y, dst_ystride);
 308     }
 309
 310     mv_row = x->block[16].bmi.mv.as_mv.row;
 311     mv_col = x->block[16].bmi.mv.as_mv.col;
 312     pre_stride >>= 1;
 313     offset = (mv_row >> 3) * pre_stride + (mv_col >> 3);
 314     uptr = x->pre.u_buffer + offset;
 315     vptr = x->pre.v_buffer + offset;
 316
 317     if ((mv_row | mv_col) & 7)
 318     {
 319         x->subpixel_predict8x8(uptr, pre_stride, mv_col & 7, mv_row & 7, dst_u, dst_uvstride);
 320         x->subpixel_predict8x8(vptr, pre_stride, mv_col & 7, mv_row & 7, dst_v, dst_uvstride);
 321     }
 322     else
 323     {
 324         RECON_INVOKE(&x->rtcd->recon, copy8x8)(uptr, pre_stride, dst_u, dst_uvstride);
 325         RECON_INVOKE(&x->rtcd->recon, copy8x8)(vptr, pre_stride, dst_v, dst_uvstride);
 326     }
 327
 328 }
 329
 330 void vp8_build_inter4x4_predictors_mb(MACROBLOCKD *x)
 331 {
 332     int i;
 333
 334     if (x->mode_info_context->mbmi.partitioning < 3)
 335     {
 336         for (i = 0; i < 4; i++)
 337         {
 338             BLOCKD *d = &x->block[bbb[i]];
 339             build_inter_predictors4b(x, d, 16);
 340         }
 341     }
 342     else
 343     {
 344         for (i = 0; i < 16; i += 2)
 345         {
 346             BLOCKD *d0 = &x->block[i];
 347             BLOCKD *d1 = &x->block[i+1];
 348
 349             if (d0->bmi.mv.as_int == d1->bmi.mv.as_int)
 350                 build_inter_predictors2b(x, d0, 16);
 351             else
 352             {
 353                 vp8_build_inter_predictors_b(d0, 16, x->subpixel_predict);
 354                 vp8_build_inter_predictors_b(d1, 16, x->subpixel_predict);
 355             }
 356
 357         }
 358
 359     }
 360
 361     for (i = 16; i < 24; i += 2)
 362     {
 363         BLOCKD *d0 = &x->block[i];
 364         BLOCKD *d1 = &x->block[i+1];
 365
 366         if (d0->bmi.mv.as_int == d1->bmi.mv.as_int)
 367             build_inter_predictors2b(x, d0, 8);
 368         else
 369         {
 370             vp8_build_inter_predictors_b(d0, 8, x->subpixel_predict);
 371             vp8_build_inter_predictors_b(d1, 8, x->subpixel_predict);
 372         }
 373     }
 374 }
 375
 376 void vp8_build_inter_predictors_mb(MACROBLOCKD *x)
 377 {
 378     if (x->mode_info_context->mbmi.mode != SPLITMV)
 379     {
 380         vp8_build_inter16x16_predictors_mb(x, x->predictor, &x->predictor[256],
 381                                            &x->predictor[320], 16, 8);
 382     }
 383     else
 384     {
 385         vp8_build_inter4x4_predictors_mb(x);
 386     }
 387 }
 388
 389 void vp8_build_uvmvs(MACROBLOCKD *x, int fullpixel)
 390 {
 391     int i, j;
 392
 393     if (x->mode_info_context->mbmi.mode == SPLITMV)
 394     {
 395         for (i = 0; i < 2; i++)
 396         {
 397             for (j = 0; j < 2; j++)
 398             {
 399                 int yoffset = i * 8 + j * 2;
 400                 int uoffset = 16 + i * 2 + j;
 401                 int voffset = 20 + i * 2 + j;
 402
 403                 int temp;
 404
 405                 temp = x->block[yoffset  ].bmi.mv.as_mv.row
 406                        + x->block[yoffset+1].bmi.mv.as_mv.row
 407                        + x->block[yoffset+4].bmi.mv.as_mv.row
 408                        + x->block[yoffset+5].bmi.mv.as_mv.row;
 409
 410                 if (temp < 0) temp -= 4;
 411                 else temp += 4;
 412
 413                 x->block[uoffset].bmi.mv.as_mv.row = temp / 8;
 414
 415                 if (fullpixel)
 416                     x->block[uoffset].bmi.mv.as_mv.row = (temp / 8) & 0xfffffff8;
 417
 418                 temp = x->block[yoffset  ].bmi.mv.as_mv.col
 419                        + x->block[yoffset+1].bmi.mv.as_mv.col
 420                        + x->block[yoffset+4].bmi.mv.as_mv.col
 421                        + x->block[yoffset+5].bmi.mv.as_mv.col;
 422
 423                 if (temp < 0) temp -= 4;
 424                 else temp += 4;
 425
 426                 x->block[uoffset].bmi.mv.as_mv.col = temp / 8;
 427
 428                 if (fullpixel)
 429                     x->block[uoffset].bmi.mv.as_mv.col = (temp / 8) & 0xfffffff8;
 430
 431                 x->block[voffset].bmi.mv.as_mv.row = x->block[uoffset].bmi.mv.as_mv.row ;
 432                 x->block[voffset].bmi.mv.as_mv.col = x->block[uoffset].bmi.mv.as_mv.col ;
 433             }
 434         }
 435     }
 436     else
 437     {
 438         int mvrow = x->mode_info_context->mbmi.mv.as_mv.row;
 439         int mvcol = x->mode_info_context->mbmi.mv.as_mv.col;
 440
 441         if (mvrow < 0)
 442             mvrow -= 1;
 443         else
 444             mvrow += 1;
 445
 446         if (mvcol < 0)
 447             mvcol -= 1;
 448         else
 449             mvcol += 1;
 450
 451         mvrow /= 2;
 452         mvcol /= 2;
 453
 454         for (i = 0; i < 8; i++)
 455         {
 456             x->block[ 16 + i].bmi.mv.as_mv.row = mvrow;
 457             x->block[ 16 + i].bmi.mv.as_mv.col = mvcol;
 458
 459             if (fullpixel)
 460             {
 461                 x->block[ 16 + i].bmi.mv.as_mv.row = mvrow & 0xfffffff8;
 462                 x->block[ 16 + i].bmi.mv.as_mv.col = mvcol & 0xfffffff8;
 463             }
 464         }
 465     }
 466 }
 467
 468
 469
 470