LCOV - app.info - media/libvpx/vp8/common/reconintra.c

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-04-21 | 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