LCOV - code coverage report
Current view: directory - media/libvpx/vp8/common - reconintra4x4.c (source / functions) Found Hit Coverage
Test: app.info Lines: 189 0 0.0 %
Date: 2012-06-02 Functions: 2 0 0.0 %

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

Generated by: LCOV version 1.7