vp8/common/reconintra4x4.c

   1 /*
   2  *  Copyright (c) 2010 The VP8 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 "vpx_mem/vpx_mem.h"
  15 #include "reconintra.h"
  16
  17 void vp8_predict_intra4x4(BLOCKD *x,
  18                           int b_mode,
  19                           unsigned char *predictor)
  20 {
  21     int i, r, c;
  22
  23     unsigned char *Above = *(x->base_dst) + x->dst - x->dst_stride;
  24     unsigned char Left[4];
  25     unsigned char top_left = Above[-1];
  26
  27     Left[0] = (*(x->base_dst))[x->dst - 1];
  28     Left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride];
  29     Left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride];
  30     Left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride];
  31
  32     switch (b_mode)
  33     {
  34     case B_DC_PRED:
  35     {
  36         int expected_dc = 0;
  37
  38         for (i = 0; i < 4; i++)
  39         {
  40             expected_dc += Above[i];
  41             expected_dc += Left[i];
  42         }
  43
  44         expected_dc = (expected_dc + 4) >> 3;
  45
  46         for (r = 0; r < 4; r++)
  47         {
  48             for (c = 0; c < 4; c++)
  49             {
  50                 predictor[c] = expected_dc;
  51             }
  52
  53             predictor += 16;
  54         }
  55     }
  56     break;
  57     case B_TM_PRED:
  58     {
  59         // prediction similar to true_motion prediction
  60         for (r = 0; r < 4; r++)
  61         {
  62             for (c = 0; c < 4; c++)
  63             {
  64                 int pred = Above[c] - top_left + Left[r];
  65
  66                 if (pred < 0)
  67                     pred = 0;
  68
  69                 if (pred > 255)
  70                     pred = 255;
  71
  72                 predictor[c] = pred;
  73             }
  74
  75             predictor += 16;
  76         }
  77     }
  78     break;
  79
  80     case B_VE_PRED:
  81     {
  82
  83         unsigned int ap[4];
  84         ap[0] = (top_left  + 2 * Above[0] + Above[1] + 2) >> 2;
  85         ap[1] = (Above[0] + 2 * Above[1] + Above[2] + 2) >> 2;
  86         ap[2] = (Above[1] + 2 * Above[2] + Above[3] + 2) >> 2;
  87         ap[3] = (Above[2] + 2 * Above[3] + Above[4] + 2) >> 2;
  88
  89         for (r = 0; r < 4; r++)
  90         {
  91             for (c = 0; c < 4; c++)
  92             {
  93
  94                 predictor[c] = ap[c];
  95             }
  96
  97             predictor += 16;
  98         }
  99
 100     }
 101     break;
 102
 103
 104     case B_HE_PRED:
 105     {
 106
 107         unsigned int lp[4];
 108         lp[0] = (top_left + 2 * Left[0] + Left[1] + 2) >> 2;
 109         lp[1] = (Left[0] + 2 * Left[1] + Left[2] + 2) >> 2;
 110         lp[2] = (Left[1] + 2 * Left[2] + Left[3] + 2) >> 2;
 111         lp[3] = (Left[2] + 2 * Left[3] + Left[3] + 2) >> 2;
 112
 113         for (r = 0; r < 4; r++)
 114         {
 115             for (c = 0; c < 4; c++)
 116             {
 117                 predictor[c] = lp[r];
 118             }
 119
 120             predictor += 16;
 121         }
 122     }
 123     break;
 124     case B_LD_PRED:
 125     {
 126         unsigned char *ptr = Above;
 127         predictor[0 * 16 + 0] = (ptr[0] + ptr[1] * 2 + ptr[2] + 2) >> 2;
 128         predictor[0 * 16 + 1] =
 129             predictor[1 * 16 + 0] = (ptr[1] + ptr[2] * 2 + ptr[3] + 2) >> 2;
 130         predictor[0 * 16 + 2] =
 131             predictor[1 * 16 + 1] =
 132                 predictor[2 * 16 + 0] = (ptr[2] + ptr[3] * 2 + ptr[4] + 2) >> 2;
 133         predictor[0 * 16 + 3] =
 134             predictor[1 * 16 + 2] =
 135                 predictor[2 * 16 + 1] =
 136                     predictor[3 * 16 + 0] = (ptr[3] + ptr[4] * 2 + ptr[5] + 2) >> 2;
 137         predictor[1 * 16 + 3] =
 138             predictor[2 * 16 + 2] =
 139                 predictor[3 * 16 + 1] = (ptr[4] + ptr[5] * 2 + ptr[6] + 2) >> 2;
 140         predictor[2 * 16 + 3] =
 141             predictor[3 * 16 + 2] = (ptr[5] + ptr[6] * 2 + ptr[7] + 2) >> 2;
 142         predictor[3 * 16 + 3] = (ptr[6] + ptr[7] * 2 + ptr[7] + 2) >> 2;
 143
 144     }
 145     break;
 146     case B_RD_PRED:
 147     {
 148
 149         unsigned char pp[9];
 150
 151         pp[0] = Left[3];
 152         pp[1] = Left[2];
 153         pp[2] = Left[1];
 154         pp[3] = Left[0];
 155         pp[4] = top_left;
 156         pp[5] = Above[0];
 157         pp[6] = Above[1];
 158         pp[7] = Above[2];
 159         pp[8] = Above[3];
 160
 161         predictor[3 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
 162         predictor[3 * 16 + 1] =
 163             predictor[2 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
 164         predictor[3 * 16 + 2] =
 165             predictor[2 * 16 + 1] =
 166                 predictor[1 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
 167         predictor[3 * 16 + 3] =
 168             predictor[2 * 16 + 2] =
 169                 predictor[1 * 16 + 1] =
 170                     predictor[0 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
 171         predictor[2 * 16 + 3] =
 172             predictor[1 * 16 + 2] =
 173                 predictor[0 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
 174         predictor[1 * 16 + 3] =
 175             predictor[0 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
 176         predictor[0 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2;
 177
 178     }
 179     break;
 180     case B_VR_PRED:
 181     {
 182
 183         unsigned char pp[9];
 184
 185         pp[0] = Left[3];
 186         pp[1] = Left[2];
 187         pp[2] = Left[1];
 188         pp[3] = Left[0];
 189         pp[4] = top_left;
 190         pp[5] = Above[0];
 191         pp[6] = Above[1];
 192         pp[7] = Above[2];
 193         pp[8] = Above[3];
 194
 195
 196         predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
 197         predictor[2 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
 198         predictor[3 * 16 + 1] =
 199             predictor[1 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
 200         predictor[2 * 16 + 1] =
 201             predictor[0 * 16 + 0] = (pp[4] + pp[5] + 1) >> 1;
 202         predictor[3 * 16 + 2] =
 203             predictor[1 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
 204         predictor[2 * 16 + 2] =
 205             predictor[0 * 16 + 1] = (pp[5] + pp[6] + 1) >> 1;
 206         predictor[3 * 16 + 3] =
 207             predictor[1 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
 208         predictor[2 * 16 + 3] =
 209             predictor[0 * 16 + 2] = (pp[6] + pp[7] + 1) >> 1;
 210         predictor[1 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2;
 211         predictor[0 * 16 + 3] = (pp[7] + pp[8] + 1) >> 1;
 212
 213     }
 214     break;
 215     case B_VL_PRED:
 216     {
 217
 218         unsigned char *pp = Above;
 219
 220         predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
 221         predictor[1 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
 222         predictor[2 * 16 + 0] =
 223             predictor[0 * 16 + 1] = (pp[1] + pp[2] + 1) >> 1;
 224         predictor[1 * 16 + 1] =
 225             predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
 226         predictor[2 * 16 + 1] =
 227             predictor[0 * 16 + 2] = (pp[2] + pp[3] + 1) >> 1;
 228         predictor[3 * 16 + 1] =
 229             predictor[1 * 16 + 2] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
 230         predictor[0 * 16 + 3] =
 231             predictor[2 * 16 + 2] = (pp[3] + pp[4] + 1) >> 1;
 232         predictor[1 * 16 + 3] =
 233             predictor[3 * 16 + 2] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
 234         predictor[2 * 16 + 3] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
 235         predictor[3 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
 236     }
 237     break;
 238
 239     case B_HD_PRED:
 240     {
 241         unsigned char pp[9];
 242         pp[0] = Left[3];
 243         pp[1] = Left[2];
 244         pp[2] = Left[1];
 245         pp[3] = Left[0];
 246         pp[4] = top_left;
 247         pp[5] = Above[0];
 248         pp[6] = Above[1];
 249         pp[7] = Above[2];
 250         pp[8] = Above[3];
 251
 252
 253         predictor[3 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
 254         predictor[3 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
 255         predictor[2 * 16 + 0] =
 256             predictor[3 * 16 + 2] = (pp[1] + pp[2] + 1) >> 1;
 257         predictor[2 * 16 + 1] =
 258             predictor[3 * 16 + 3] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
 259         predictor[2 * 16 + 2] =
 260             predictor[1 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1;
 261         predictor[2 * 16 + 3] =
 262             predictor[1 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
 263         predictor[1 * 16 + 2] =
 264             predictor[0 * 16 + 0] = (pp[3] + pp[4] + 1) >> 1;
 265         predictor[1 * 16 + 3] =
 266             predictor[0 * 16 + 1] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
 267         predictor[0 * 16 + 2] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
 268         predictor[0 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
 269     }
 270     break;
 271
 272
 273     case B_HU_PRED:
 274     {
 275         unsigned char *pp = Left;
 276         predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
 277         predictor[0 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
 278         predictor[0 * 16 + 2] =
 279             predictor[1 * 16 + 0] = (pp[1] + pp[2] + 1) >> 1;
 280         predictor[0 * 16 + 3] =
 281             predictor[1 * 16 + 1] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
 282         predictor[1 * 16 + 2] =
 283             predictor[2 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1;
 284         predictor[1 * 16 + 3] =
 285             predictor[2 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[3] + 2) >> 2;
 286         predictor[2 * 16 + 2] =
 287             predictor[2 * 16 + 3] =
 288                 predictor[3 * 16 + 0] =
 289                     predictor[3 * 16 + 1] =
 290                         predictor[3 * 16 + 2] =
 291                             predictor[3 * 16 + 3] = pp[3];
 292     }
 293     break;
 294
 295
 296     }
 297 }
 298 // copy 4 bytes from the above right down so that the 4x4 prediction modes using pixels above and
 299 // to the right prediction have filled in pixels to use.
 300 void vp8_intra_prediction_down_copy(MACROBLOCKD *x)
 301 {
 302     unsigned char *above_right = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16;
 303
 304     unsigned int *src_ptr = (unsigned int *)above_right;
 305     unsigned int *dst_ptr0 = (unsigned int *)(above_right + 4 * x->block[0].dst_stride);
 306     unsigned int *dst_ptr1 = (unsigned int *)(above_right + 8 * x->block[0].dst_stride);
 307     unsigned int *dst_ptr2 = (unsigned int *)(above_right + 12 * x->block[0].dst_stride);
 308
 309     *dst_ptr0 = *src_ptr;
 310     *dst_ptr1 = *src_ptr;
 311     *dst_ptr2 = *src_ptr;
 312 }
 313
 314
 315 void vp8_recon_intra4x4mb(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x)
 316 {
 317     int i;
 318
 319     vp8_intra_prediction_down_copy(x);
 320
 321     for (i = 0; i < 16; i++)
 322     {
 323         BLOCKD *b = &x->block[i];
 324
 325         vp8_predict_intra4x4(b, x->block[i].bmi.mode, x->block[i].predictor);
 326         RECON_INVOKE(rtcd, recon)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
 327     }
 328
 329     vp8_recon_intra_mbuv(rtcd, x);
 330
 331 }