LCOV - code coverage report
Current view: directory - media/libvpx/vp8/common - reconintra.c (source / functions) Found Hit Coverage
Test: app.info Lines: 221 0 0.0 %
Date: 2012-06-02 Functions: 5 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 "reconintra.h"
      15                 : #include "vpx_mem/vpx_mem.h"
      16                 : 
      17                 : /* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *x) and
      18                 :  * vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x).
      19                 :  */
      20               0 : void vp8_recon_intra_mbuv(const vp8_recon_rtcd_vtable_t *rtcd, MACROBLOCKD *x)
      21                 : {
      22                 :     int i;
      23                 : 
      24               0 :     for (i = 16; i < 24; i += 2)
      25                 :     {
      26               0 :         BLOCKD *b = &x->block[i];
      27               0 :         RECON_INVOKE(rtcd, recon2)(b->predictor, b->diff, *(b->base_dst) + b->dst, b->dst_stride);
      28                 :     }
      29               0 : }
      30                 : 
      31               0 : void vp8_build_intra_predictors_mby(MACROBLOCKD *x)
      32                 : {
      33                 : 
      34               0 :     unsigned char *yabove_row = x->dst.y_buffer - x->dst.y_stride;
      35                 :     unsigned char yleft_col[16];
      36               0 :     unsigned char ytop_left = yabove_row[-1];
      37               0 :     unsigned char *ypred_ptr = x->predictor;
      38                 :     int r, c, i;
      39                 : 
      40               0 :     for (i = 0; i < 16; i++)
      41                 :     {
      42               0 :         yleft_col[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
      43                 :     }
      44                 : 
      45                 :     /* for Y */
      46               0 :     switch (x->mode_info_context->mbmi.mode)
      47                 :     {
      48                 :     case DC_PRED:
      49                 :     {
      50                 :         int expected_dc;
      51                 :         int i;
      52                 :         int shift;
      53               0 :         int average = 0;
      54                 : 
      55                 : 
      56               0 :         if (x->up_available || x->left_available)
      57                 :         {
      58               0 :             if (x->up_available)
      59                 :             {
      60               0 :                 for (i = 0; i < 16; i++)
      61                 :                 {
      62               0 :                     average += yabove_row[i];
      63                 :                 }
      64                 :             }
      65                 : 
      66               0 :             if (x->left_available)
      67                 :             {
      68                 : 
      69               0 :                 for (i = 0; i < 16; i++)
      70                 :                 {
      71               0 :                     average += yleft_col[i];
      72                 :                 }
      73                 : 
      74                 :             }
      75                 : 
      76                 : 
      77                 : 
      78               0 :             shift = 3 + x->up_available + x->left_available;
      79               0 :             expected_dc = (average + (1 << (shift - 1))) >> shift;
      80                 :         }
      81                 :         else
      82                 :         {
      83               0 :             expected_dc = 128;
      84                 :         }
      85                 : 
      86               0 :         vpx_memset(ypred_ptr, expected_dc, 256);
      87                 :     }
      88               0 :     break;
      89                 :     case V_PRED:
      90                 :     {
      91                 : 
      92               0 :         for (r = 0; r < 16; r++)
      93                 :         {
      94                 : 
      95               0 :             ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
      96               0 :             ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
      97               0 :             ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
      98               0 :             ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
      99               0 :             ypred_ptr += 16;
     100                 :         }
     101                 :     }
     102               0 :     break;
     103                 :     case H_PRED:
     104                 :     {
     105                 : 
     106               0 :         for (r = 0; r < 16; r++)
     107                 :         {
     108                 : 
     109               0 :             vpx_memset(ypred_ptr, yleft_col[r], 16);
     110               0 :             ypred_ptr += 16;
     111                 :         }
     112                 : 
     113                 :     }
     114               0 :     break;
     115                 :     case TM_PRED:
     116                 :     {
     117                 : 
     118               0 :         for (r = 0; r < 16; r++)
     119                 :         {
     120               0 :             for (c = 0; c < 16; c++)
     121                 :             {
     122               0 :                 int pred =  yleft_col[r] + yabove_row[ c] - ytop_left;
     123                 : 
     124               0 :                 if (pred < 0)
     125               0 :                     pred = 0;
     126                 : 
     127               0 :                 if (pred > 255)
     128               0 :                     pred = 255;
     129                 : 
     130               0 :                 ypred_ptr[c] = pred;
     131                 :             }
     132                 : 
     133               0 :             ypred_ptr += 16;
     134                 :         }
     135                 : 
     136                 :     }
     137               0 :     break;
     138                 :     case B_PRED:
     139                 :     case NEARESTMV:
     140                 :     case NEARMV:
     141                 :     case ZEROMV:
     142                 :     case NEWMV:
     143                 :     case SPLITMV:
     144                 :     case MB_MODE_COUNT:
     145               0 :         break;
     146                 :     }
     147               0 : }
     148                 : 
     149               0 : void vp8_build_intra_predictors_mby_s(MACROBLOCKD *x)
     150                 : {
     151                 : 
     152               0 :     unsigned char *yabove_row = x->dst.y_buffer - x->dst.y_stride;
     153                 :     unsigned char yleft_col[16];
     154               0 :     unsigned char ytop_left = yabove_row[-1];
     155               0 :     unsigned char *ypred_ptr = x->predictor;
     156                 :     int r, c, i;
     157                 : 
     158               0 :     int y_stride = x->dst.y_stride;
     159               0 :     ypred_ptr = x->dst.y_buffer; /*x->predictor;*/
     160                 : 
     161               0 :     for (i = 0; i < 16; i++)
     162                 :     {
     163               0 :         yleft_col[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
     164                 :     }
     165                 : 
     166                 :     /* for Y */
     167               0 :     switch (x->mode_info_context->mbmi.mode)
     168                 :     {
     169                 :     case DC_PRED:
     170                 :     {
     171                 :         int expected_dc;
     172                 :         int i;
     173                 :         int shift;
     174               0 :         int average = 0;
     175                 : 
     176                 : 
     177               0 :         if (x->up_available || x->left_available)
     178                 :         {
     179               0 :             if (x->up_available)
     180                 :             {
     181               0 :                 for (i = 0; i < 16; i++)
     182                 :                 {
     183               0 :                     average += yabove_row[i];
     184                 :                 }
     185                 :             }
     186                 : 
     187               0 :             if (x->left_available)
     188                 :             {
     189                 : 
     190               0 :                 for (i = 0; i < 16; i++)
     191                 :                 {
     192               0 :                     average += yleft_col[i];
     193                 :                 }
     194                 : 
     195                 :             }
     196                 : 
     197                 : 
     198                 : 
     199               0 :             shift = 3 + x->up_available + x->left_available;
     200               0 :             expected_dc = (average + (1 << (shift - 1))) >> shift;
     201                 :         }
     202                 :         else
     203                 :         {
     204               0 :             expected_dc = 128;
     205                 :         }
     206                 : 
     207                 :         /*vpx_memset(ypred_ptr, expected_dc, 256);*/
     208               0 :         for (r = 0; r < 16; r++)
     209                 :         {
     210               0 :             vpx_memset(ypred_ptr, expected_dc, 16);
     211               0 :             ypred_ptr += y_stride; /*16;*/
     212                 :         }
     213                 :     }
     214               0 :     break;
     215                 :     case V_PRED:
     216                 :     {
     217                 : 
     218               0 :         for (r = 0; r < 16; r++)
     219                 :         {
     220                 : 
     221               0 :             ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
     222               0 :             ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
     223               0 :             ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
     224               0 :             ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
     225               0 :             ypred_ptr += y_stride; /*16;*/
     226                 :         }
     227                 :     }
     228               0 :     break;
     229                 :     case H_PRED:
     230                 :     {
     231                 : 
     232               0 :         for (r = 0; r < 16; r++)
     233                 :         {
     234                 : 
     235               0 :             vpx_memset(ypred_ptr, yleft_col[r], 16);
     236               0 :             ypred_ptr += y_stride;  /*16;*/
     237                 :         }
     238                 : 
     239                 :     }
     240               0 :     break;
     241                 :     case TM_PRED:
     242                 :     {
     243                 : 
     244               0 :         for (r = 0; r < 16; r++)
     245                 :         {
     246               0 :             for (c = 0; c < 16; c++)
     247                 :             {
     248               0 :                 int pred =  yleft_col[r] + yabove_row[ c] - ytop_left;
     249                 : 
     250               0 :                 if (pred < 0)
     251               0 :                     pred = 0;
     252                 : 
     253               0 :                 if (pred > 255)
     254               0 :                     pred = 255;
     255                 : 
     256               0 :                 ypred_ptr[c] = pred;
     257                 :             }
     258                 : 
     259               0 :             ypred_ptr += y_stride;  /*16;*/
     260                 :         }
     261                 : 
     262                 :     }
     263               0 :     break;
     264                 :     case B_PRED:
     265                 :     case NEARESTMV:
     266                 :     case NEARMV:
     267                 :     case ZEROMV:
     268                 :     case NEWMV:
     269                 :     case SPLITMV:
     270                 :     case MB_MODE_COUNT:
     271               0 :         break;
     272                 :     }
     273               0 : }
     274                 : 
     275               0 : void vp8_build_intra_predictors_mbuv(MACROBLOCKD *x)
     276                 : {
     277               0 :     unsigned char *uabove_row = x->dst.u_buffer - x->dst.uv_stride;
     278                 :     unsigned char uleft_col[16];
     279               0 :     unsigned char utop_left = uabove_row[-1];
     280               0 :     unsigned char *vabove_row = x->dst.v_buffer - x->dst.uv_stride;
     281                 :     unsigned char vleft_col[20];
     282               0 :     unsigned char vtop_left = vabove_row[-1];
     283               0 :     unsigned char *upred_ptr = &x->predictor[256];
     284               0 :     unsigned char *vpred_ptr = &x->predictor[320];
     285                 :     int i, j;
     286                 : 
     287               0 :     for (i = 0; i < 8; i++)
     288                 :     {
     289               0 :         uleft_col[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
     290               0 :         vleft_col[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
     291                 :     }
     292                 : 
     293               0 :     switch (x->mode_info_context->mbmi.uv_mode)
     294                 :     {
     295                 :     case DC_PRED:
     296                 :     {
     297                 :         int expected_udc;
     298                 :         int expected_vdc;
     299                 :         int i;
     300                 :         int shift;
     301               0 :         int Uaverage = 0;
     302               0 :         int Vaverage = 0;
     303                 : 
     304               0 :         if (x->up_available)
     305                 :         {
     306               0 :             for (i = 0; i < 8; i++)
     307                 :             {
     308               0 :                 Uaverage += uabove_row[i];
     309               0 :                 Vaverage += vabove_row[i];
     310                 :             }
     311                 :         }
     312                 : 
     313               0 :         if (x->left_available)
     314                 :         {
     315               0 :             for (i = 0; i < 8; i++)
     316                 :             {
     317               0 :                 Uaverage += uleft_col[i];
     318               0 :                 Vaverage += vleft_col[i];
     319                 :             }
     320                 :         }
     321                 : 
     322               0 :         if (!x->up_available && !x->left_available)
     323                 :         {
     324               0 :             expected_udc = 128;
     325               0 :             expected_vdc = 128;
     326                 :         }
     327                 :         else
     328                 :         {
     329               0 :             shift = 2 + x->up_available + x->left_available;
     330               0 :             expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
     331               0 :             expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
     332                 :         }
     333                 : 
     334                 : 
     335               0 :         vpx_memset(upred_ptr, expected_udc, 64);
     336               0 :         vpx_memset(vpred_ptr, expected_vdc, 64);
     337                 : 
     338                 : 
     339                 :     }
     340               0 :     break;
     341                 :     case V_PRED:
     342                 :     {
     343                 :         int i;
     344                 : 
     345               0 :         for (i = 0; i < 8; i++)
     346                 :         {
     347               0 :             vpx_memcpy(upred_ptr, uabove_row, 8);
     348               0 :             vpx_memcpy(vpred_ptr, vabove_row, 8);
     349               0 :             upred_ptr += 8;
     350               0 :             vpred_ptr += 8;
     351                 :         }
     352                 : 
     353                 :     }
     354               0 :     break;
     355                 :     case H_PRED:
     356                 :     {
     357                 :         int i;
     358                 : 
     359               0 :         for (i = 0; i < 8; i++)
     360                 :         {
     361               0 :             vpx_memset(upred_ptr, uleft_col[i], 8);
     362               0 :             vpx_memset(vpred_ptr, vleft_col[i], 8);
     363               0 :             upred_ptr += 8;
     364               0 :             vpred_ptr += 8;
     365                 :         }
     366                 :     }
     367                 : 
     368               0 :     break;
     369                 :     case TM_PRED:
     370                 :     {
     371                 :         int i;
     372                 : 
     373               0 :         for (i = 0; i < 8; i++)
     374                 :         {
     375               0 :             for (j = 0; j < 8; j++)
     376                 :             {
     377               0 :                 int predu = uleft_col[i] + uabove_row[j] - utop_left;
     378               0 :                 int predv = vleft_col[i] + vabove_row[j] - vtop_left;
     379                 : 
     380               0 :                 if (predu < 0)
     381               0 :                     predu = 0;
     382                 : 
     383               0 :                 if (predu > 255)
     384               0 :                     predu = 255;
     385                 : 
     386               0 :                 if (predv < 0)
     387               0 :                     predv = 0;
     388                 : 
     389               0 :                 if (predv > 255)
     390               0 :                     predv = 255;
     391                 : 
     392               0 :                 upred_ptr[j] = predu;
     393               0 :                 vpred_ptr[j] = predv;
     394                 :             }
     395                 : 
     396               0 :             upred_ptr += 8;
     397               0 :             vpred_ptr += 8;
     398                 :         }
     399                 : 
     400                 :     }
     401               0 :     break;
     402                 :     case B_PRED:
     403                 :     case NEARESTMV:
     404                 :     case NEARMV:
     405                 :     case ZEROMV:
     406                 :     case NEWMV:
     407                 :     case SPLITMV:
     408                 :     case MB_MODE_COUNT:
     409               0 :         break;
     410                 :     }
     411               0 : }
     412                 : 
     413               0 : void vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x)
     414                 : {
     415               0 :     unsigned char *uabove_row = x->dst.u_buffer - x->dst.uv_stride;
     416                 :     unsigned char uleft_col[16];
     417               0 :     unsigned char utop_left = uabove_row[-1];
     418               0 :     unsigned char *vabove_row = x->dst.v_buffer - x->dst.uv_stride;
     419                 :     unsigned char vleft_col[20];
     420               0 :     unsigned char vtop_left = vabove_row[-1];
     421               0 :     unsigned char *upred_ptr = x->dst.u_buffer; /*&x->predictor[256];*/
     422               0 :     unsigned char *vpred_ptr = x->dst.v_buffer; /*&x->predictor[320];*/
     423               0 :     int uv_stride = x->dst.uv_stride;
     424                 : 
     425                 :     int i, j;
     426                 : 
     427               0 :     for (i = 0; i < 8; i++)
     428                 :     {
     429               0 :         uleft_col[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
     430               0 :         vleft_col[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
     431                 :     }
     432                 : 
     433               0 :     switch (x->mode_info_context->mbmi.uv_mode)
     434                 :     {
     435                 :     case DC_PRED:
     436                 :     {
     437                 :         int expected_udc;
     438                 :         int expected_vdc;
     439                 :         int i;
     440                 :         int shift;
     441               0 :         int Uaverage = 0;
     442               0 :         int Vaverage = 0;
     443                 : 
     444               0 :         if (x->up_available)
     445                 :         {
     446               0 :             for (i = 0; i < 8; i++)
     447                 :             {
     448               0 :                 Uaverage += uabove_row[i];
     449               0 :                 Vaverage += vabove_row[i];
     450                 :             }
     451                 :         }
     452                 : 
     453               0 :         if (x->left_available)
     454                 :         {
     455               0 :             for (i = 0; i < 8; i++)
     456                 :             {
     457               0 :                 Uaverage += uleft_col[i];
     458               0 :                 Vaverage += vleft_col[i];
     459                 :             }
     460                 :         }
     461                 : 
     462               0 :         if (!x->up_available && !x->left_available)
     463                 :         {
     464               0 :             expected_udc = 128;
     465               0 :             expected_vdc = 128;
     466                 :         }
     467                 :         else
     468                 :         {
     469               0 :             shift = 2 + x->up_available + x->left_available;
     470               0 :             expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
     471               0 :             expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
     472                 :         }
     473                 : 
     474                 : 
     475                 :         /*vpx_memset(upred_ptr,expected_udc,64);*/
     476                 :         /*vpx_memset(vpred_ptr,expected_vdc,64);*/
     477               0 :         for (i = 0; i < 8; i++)
     478                 :         {
     479               0 :             vpx_memset(upred_ptr, expected_udc, 8);
     480               0 :             vpx_memset(vpred_ptr, expected_vdc, 8);
     481               0 :             upred_ptr += uv_stride; /*8;*/
     482               0 :             vpred_ptr += uv_stride; /*8;*/
     483                 :         }
     484                 :     }
     485               0 :     break;
     486                 :     case V_PRED:
     487                 :     {
     488                 :         int i;
     489                 : 
     490               0 :         for (i = 0; i < 8; i++)
     491                 :         {
     492               0 :             vpx_memcpy(upred_ptr, uabove_row, 8);
     493               0 :             vpx_memcpy(vpred_ptr, vabove_row, 8);
     494               0 :             upred_ptr += uv_stride; /*8;*/
     495               0 :             vpred_ptr += uv_stride; /*8;*/
     496                 :         }
     497                 : 
     498                 :     }
     499               0 :     break;
     500                 :     case H_PRED:
     501                 :     {
     502                 :         int i;
     503                 : 
     504               0 :         for (i = 0; i < 8; i++)
     505                 :         {
     506               0 :             vpx_memset(upred_ptr, uleft_col[i], 8);
     507               0 :             vpx_memset(vpred_ptr, vleft_col[i], 8);
     508               0 :             upred_ptr += uv_stride; /*8;*/
     509               0 :             vpred_ptr += uv_stride; /*8;*/
     510                 :         }
     511                 :     }
     512                 : 
     513               0 :     break;
     514                 :     case TM_PRED:
     515                 :     {
     516                 :         int i;
     517                 : 
     518               0 :         for (i = 0; i < 8; i++)
     519                 :         {
     520               0 :             for (j = 0; j < 8; j++)
     521                 :             {
     522               0 :                 int predu = uleft_col[i] + uabove_row[j] - utop_left;
     523               0 :                 int predv = vleft_col[i] + vabove_row[j] - vtop_left;
     524                 : 
     525               0 :                 if (predu < 0)
     526               0 :                     predu = 0;
     527                 : 
     528               0 :                 if (predu > 255)
     529               0 :                     predu = 255;
     530                 : 
     531               0 :                 if (predv < 0)
     532               0 :                     predv = 0;
     533                 : 
     534               0 :                 if (predv > 255)
     535               0 :                     predv = 255;
     536                 : 
     537               0 :                 upred_ptr[j] = predu;
     538               0 :                 vpred_ptr[j] = predv;
     539                 :             }
     540                 : 
     541               0 :             upred_ptr += uv_stride; /*8;*/
     542               0 :             vpred_ptr += uv_stride; /*8;*/
     543                 :         }
     544                 : 
     545                 :     }
     546               0 :     break;
     547                 :     case B_PRED:
     548                 :     case NEARESTMV:
     549                 :     case NEARMV:
     550                 :     case ZEROMV:
     551                 :     case NEWMV:
     552                 :     case SPLITMV:
     553                 :     case MB_MODE_COUNT:
     554               0 :         break;
     555                 :     }
     556               0 : }

Generated by: LCOV version 1.7