LCOV - code coverage report
Current view: directory - media/libvpx/vp8/decoder - reconintra_mt.c (source / functions) Found Hit Coverage
Test: app.info Lines: 437 0 0.0 %
Date: 2012-06-02 Functions: 6 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 "vp8/common/recon.h"
      14                 : #include "vp8/common/reconintra.h"
      15                 : #include "vpx_mem/vpx_mem.h"
      16                 : #include "onyxd_int.h"
      17                 : 
      18                 : /* For skip_recon_mb(), add vp8_build_intra_predictors_mby_s(MACROBLOCKD *x) and
      19                 :  * vp8_build_intra_predictors_mbuv_s(MACROBLOCKD *x).
      20                 :  */
      21                 : 
      22               0 : void vp8mt_build_intra_predictors_mby(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
      23                 : {
      24                 :     unsigned char *yabove_row;    /* = x->dst.y_buffer - x->dst.y_stride; */
      25                 :     unsigned char *yleft_col;
      26                 :     unsigned char yleft_buf[16];
      27                 :     unsigned char ytop_left;      /* = yabove_row[-1]; */
      28               0 :     unsigned char *ypred_ptr = x->predictor;
      29                 :     int r, c, i;
      30                 : 
      31               0 :     if (pbi->common.filter_level)
      32                 :     {
      33               0 :         yabove_row = pbi->mt_yabove_row[mb_row] + mb_col*16 +32;
      34               0 :         yleft_col = pbi->mt_yleft_col[mb_row];
      35                 :     } else
      36                 :     {
      37               0 :         yabove_row = x->dst.y_buffer - x->dst.y_stride;
      38                 : 
      39               0 :         for (i = 0; i < 16; i++)
      40               0 :             yleft_buf[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
      41               0 :         yleft_col = yleft_buf;
      42                 :     }
      43                 : 
      44               0 :     ytop_left = yabove_row[-1];
      45                 : 
      46                 :     /* for Y */
      47               0 :     switch (x->mode_info_context->mbmi.mode)
      48                 :     {
      49                 :     case DC_PRED:
      50                 :     {
      51                 :         int expected_dc;
      52                 :         int i;
      53                 :         int shift;
      54               0 :         int average = 0;
      55                 : 
      56                 : 
      57               0 :         if (x->up_available || x->left_available)
      58                 :         {
      59               0 :             if (x->up_available)
      60                 :             {
      61               0 :                 for (i = 0; i < 16; i++)
      62                 :                 {
      63               0 :                     average += yabove_row[i];
      64                 :                 }
      65                 :             }
      66                 : 
      67               0 :             if (x->left_available)
      68                 :             {
      69                 : 
      70               0 :                 for (i = 0; i < 16; i++)
      71                 :                 {
      72               0 :                     average += yleft_col[i];
      73                 :                 }
      74                 : 
      75                 :             }
      76                 : 
      77                 : 
      78                 : 
      79               0 :             shift = 3 + x->up_available + x->left_available;
      80               0 :             expected_dc = (average + (1 << (shift - 1))) >> shift;
      81                 :         }
      82                 :         else
      83                 :         {
      84               0 :             expected_dc = 128;
      85                 :         }
      86                 : 
      87               0 :         vpx_memset(ypred_ptr, expected_dc, 256);
      88                 :     }
      89               0 :     break;
      90                 :     case V_PRED:
      91                 :     {
      92                 : 
      93               0 :         for (r = 0; r < 16; r++)
      94                 :         {
      95                 : 
      96               0 :             ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
      97               0 :             ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
      98               0 :             ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
      99               0 :             ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
     100               0 :             ypred_ptr += 16;
     101                 :         }
     102                 :     }
     103               0 :     break;
     104                 :     case H_PRED:
     105                 :     {
     106                 : 
     107               0 :         for (r = 0; r < 16; r++)
     108                 :         {
     109                 : 
     110               0 :             vpx_memset(ypred_ptr, yleft_col[r], 16);
     111               0 :             ypred_ptr += 16;
     112                 :         }
     113                 : 
     114                 :     }
     115               0 :     break;
     116                 :     case TM_PRED:
     117                 :     {
     118                 : 
     119               0 :         for (r = 0; r < 16; r++)
     120                 :         {
     121               0 :             for (c = 0; c < 16; c++)
     122                 :             {
     123               0 :                 int pred =  yleft_col[r] + yabove_row[ c] - ytop_left;
     124                 : 
     125               0 :                 if (pred < 0)
     126               0 :                     pred = 0;
     127                 : 
     128               0 :                 if (pred > 255)
     129               0 :                     pred = 255;
     130                 : 
     131               0 :                 ypred_ptr[c] = pred;
     132                 :             }
     133                 : 
     134               0 :             ypred_ptr += 16;
     135                 :         }
     136                 : 
     137                 :     }
     138               0 :     break;
     139                 :     case B_PRED:
     140                 :     case NEARESTMV:
     141                 :     case NEARMV:
     142                 :     case ZEROMV:
     143                 :     case NEWMV:
     144                 :     case SPLITMV:
     145                 :     case MB_MODE_COUNT:
     146               0 :         break;
     147                 :     }
     148               0 : }
     149                 : 
     150               0 : void vp8mt_build_intra_predictors_mby_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
     151                 : {
     152                 :     unsigned char *yabove_row;    /* = x->dst.y_buffer - x->dst.y_stride; */
     153                 :     unsigned char *yleft_col;
     154                 :     unsigned char yleft_buf[16];
     155                 :     unsigned char ytop_left;      /* = yabove_row[-1]; */
     156               0 :     unsigned char *ypred_ptr = x->predictor;
     157                 :     int r, c, i;
     158                 : 
     159               0 :     int y_stride = x->dst.y_stride;
     160               0 :     ypred_ptr = x->dst.y_buffer; /*x->predictor;*/
     161                 : 
     162               0 :     if (pbi->common.filter_level)
     163                 :     {
     164               0 :         yabove_row = pbi->mt_yabove_row[mb_row] + mb_col*16 +32;
     165               0 :         yleft_col = pbi->mt_yleft_col[mb_row];
     166                 :     } else
     167                 :     {
     168               0 :         yabove_row = x->dst.y_buffer - x->dst.y_stride;
     169                 : 
     170               0 :         for (i = 0; i < 16; i++)
     171               0 :             yleft_buf[i] = x->dst.y_buffer [i* x->dst.y_stride -1];
     172               0 :         yleft_col = yleft_buf;
     173                 :     }
     174                 : 
     175               0 :     ytop_left = yabove_row[-1];
     176                 : 
     177                 :     /* for Y */
     178               0 :     switch (x->mode_info_context->mbmi.mode)
     179                 :     {
     180                 :     case DC_PRED:
     181                 :     {
     182                 :         int expected_dc;
     183                 :         int i;
     184                 :         int shift;
     185               0 :         int average = 0;
     186                 : 
     187                 : 
     188               0 :         if (x->up_available || x->left_available)
     189                 :         {
     190               0 :             if (x->up_available)
     191                 :             {
     192               0 :                 for (i = 0; i < 16; i++)
     193                 :                 {
     194               0 :                     average += yabove_row[i];
     195                 :                 }
     196                 :             }
     197                 : 
     198               0 :             if (x->left_available)
     199                 :             {
     200                 : 
     201               0 :                 for (i = 0; i < 16; i++)
     202                 :                 {
     203               0 :                     average += yleft_col[i];
     204                 :                 }
     205                 : 
     206                 :             }
     207                 : 
     208                 : 
     209                 : 
     210               0 :             shift = 3 + x->up_available + x->left_available;
     211               0 :             expected_dc = (average + (1 << (shift - 1))) >> shift;
     212                 :         }
     213                 :         else
     214                 :         {
     215               0 :             expected_dc = 128;
     216                 :         }
     217                 : 
     218                 :         /*vpx_memset(ypred_ptr, expected_dc, 256);*/
     219               0 :         for (r = 0; r < 16; r++)
     220                 :         {
     221               0 :             vpx_memset(ypred_ptr, expected_dc, 16);
     222               0 :             ypred_ptr += y_stride; /*16;*/
     223                 :         }
     224                 :     }
     225               0 :     break;
     226                 :     case V_PRED:
     227                 :     {
     228                 : 
     229               0 :         for (r = 0; r < 16; r++)
     230                 :         {
     231                 : 
     232               0 :             ((int *)ypred_ptr)[0] = ((int *)yabove_row)[0];
     233               0 :             ((int *)ypred_ptr)[1] = ((int *)yabove_row)[1];
     234               0 :             ((int *)ypred_ptr)[2] = ((int *)yabove_row)[2];
     235               0 :             ((int *)ypred_ptr)[3] = ((int *)yabove_row)[3];
     236               0 :             ypred_ptr += y_stride; /*16;*/
     237                 :         }
     238                 :     }
     239               0 :     break;
     240                 :     case H_PRED:
     241                 :     {
     242                 : 
     243               0 :         for (r = 0; r < 16; r++)
     244                 :         {
     245                 : 
     246               0 :             vpx_memset(ypred_ptr, yleft_col[r], 16);
     247               0 :             ypred_ptr += y_stride;  /*16;*/
     248                 :         }
     249                 : 
     250                 :     }
     251               0 :     break;
     252                 :     case TM_PRED:
     253                 :     {
     254                 : 
     255               0 :         for (r = 0; r < 16; r++)
     256                 :         {
     257               0 :             for (c = 0; c < 16; c++)
     258                 :             {
     259               0 :                 int pred =  yleft_col[r] + yabove_row[ c] - ytop_left;
     260                 : 
     261               0 :                 if (pred < 0)
     262               0 :                     pred = 0;
     263                 : 
     264               0 :                 if (pred > 255)
     265               0 :                     pred = 255;
     266                 : 
     267               0 :                 ypred_ptr[c] = pred;
     268                 :             }
     269                 : 
     270               0 :             ypred_ptr += y_stride;  /*16;*/
     271                 :         }
     272                 : 
     273                 :     }
     274               0 :     break;
     275                 :     case B_PRED:
     276                 :     case NEARESTMV:
     277                 :     case NEARMV:
     278                 :     case ZEROMV:
     279                 :     case NEWMV:
     280                 :     case SPLITMV:
     281                 :     case MB_MODE_COUNT:
     282               0 :         break;
     283                 :     }
     284               0 : }
     285                 : 
     286               0 : void vp8mt_build_intra_predictors_mbuv(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
     287                 : {
     288                 :     unsigned char *uabove_row;   /* = x->dst.u_buffer - x->dst.uv_stride; */
     289                 :     unsigned char *uleft_col;    /*[16];*/
     290                 :     unsigned char uleft_buf[8];
     291                 :     unsigned char utop_left;     /* = uabove_row[-1]; */
     292                 :     unsigned char *vabove_row;   /* = x->dst.v_buffer - x->dst.uv_stride; */
     293                 :     unsigned char *vleft_col;    /*[20];*/
     294                 :     unsigned char vleft_buf[8];
     295                 :     unsigned char vtop_left;     /* = vabove_row[-1]; */
     296               0 :     unsigned char *upred_ptr = &x->predictor[256];
     297               0 :     unsigned char *vpred_ptr = &x->predictor[320];
     298                 :     int i, j;
     299                 : 
     300               0 :     if (pbi->common.filter_level)
     301                 :     {
     302               0 :         uabove_row = pbi->mt_uabove_row[mb_row] + mb_col*8 +16;
     303               0 :         vabove_row = pbi->mt_vabove_row[mb_row] + mb_col*8 +16;
     304               0 :         uleft_col = pbi->mt_uleft_col[mb_row];
     305               0 :         vleft_col = pbi->mt_vleft_col[mb_row];
     306                 :     } else
     307                 :     {
     308               0 :         uabove_row = x->dst.u_buffer - x->dst.uv_stride;
     309               0 :         vabove_row = x->dst.v_buffer - x->dst.uv_stride;
     310                 : 
     311               0 :         for (i = 0; i < 8; i++)
     312                 :         {
     313               0 :             uleft_buf[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
     314               0 :             vleft_buf[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
     315                 :         }
     316               0 :         uleft_col = uleft_buf;
     317               0 :         vleft_col = vleft_buf;
     318                 :     }
     319               0 :     utop_left = uabove_row[-1];
     320               0 :     vtop_left = vabove_row[-1];
     321                 : 
     322               0 :     switch (x->mode_info_context->mbmi.uv_mode)
     323                 :     {
     324                 :     case DC_PRED:
     325                 :     {
     326                 :         int expected_udc;
     327                 :         int expected_vdc;
     328                 :         int i;
     329                 :         int shift;
     330               0 :         int Uaverage = 0;
     331               0 :         int Vaverage = 0;
     332                 : 
     333               0 :         if (x->up_available)
     334                 :         {
     335               0 :             for (i = 0; i < 8; i++)
     336                 :             {
     337               0 :                 Uaverage += uabove_row[i];
     338               0 :                 Vaverage += vabove_row[i];
     339                 :             }
     340                 :         }
     341                 : 
     342               0 :         if (x->left_available)
     343                 :         {
     344               0 :             for (i = 0; i < 8; i++)
     345                 :             {
     346               0 :                 Uaverage += uleft_col[i];
     347               0 :                 Vaverage += vleft_col[i];
     348                 :             }
     349                 :         }
     350                 : 
     351               0 :         if (!x->up_available && !x->left_available)
     352                 :         {
     353               0 :             expected_udc = 128;
     354               0 :             expected_vdc = 128;
     355                 :         }
     356                 :         else
     357                 :         {
     358               0 :             shift = 2 + x->up_available + x->left_available;
     359               0 :             expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
     360               0 :             expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
     361                 :         }
     362                 : 
     363                 : 
     364               0 :         vpx_memset(upred_ptr, expected_udc, 64);
     365               0 :         vpx_memset(vpred_ptr, expected_vdc, 64);
     366                 : 
     367                 : 
     368                 :     }
     369               0 :     break;
     370                 :     case V_PRED:
     371                 :     {
     372                 :         int i;
     373                 : 
     374               0 :         for (i = 0; i < 8; i++)
     375                 :         {
     376               0 :             vpx_memcpy(upred_ptr, uabove_row, 8);
     377               0 :             vpx_memcpy(vpred_ptr, vabove_row, 8);
     378               0 :             upred_ptr += 8;
     379               0 :             vpred_ptr += 8;
     380                 :         }
     381                 : 
     382                 :     }
     383               0 :     break;
     384                 :     case H_PRED:
     385                 :     {
     386                 :         int i;
     387                 : 
     388               0 :         for (i = 0; i < 8; i++)
     389                 :         {
     390               0 :             vpx_memset(upred_ptr, uleft_col[i], 8);
     391               0 :             vpx_memset(vpred_ptr, vleft_col[i], 8);
     392               0 :             upred_ptr += 8;
     393               0 :             vpred_ptr += 8;
     394                 :         }
     395                 :     }
     396                 : 
     397               0 :     break;
     398                 :     case TM_PRED:
     399                 :     {
     400                 :         int i;
     401                 : 
     402               0 :         for (i = 0; i < 8; i++)
     403                 :         {
     404               0 :             for (j = 0; j < 8; j++)
     405                 :             {
     406               0 :                 int predu = uleft_col[i] + uabove_row[j] - utop_left;
     407               0 :                 int predv = vleft_col[i] + vabove_row[j] - vtop_left;
     408                 : 
     409               0 :                 if (predu < 0)
     410               0 :                     predu = 0;
     411                 : 
     412               0 :                 if (predu > 255)
     413               0 :                     predu = 255;
     414                 : 
     415               0 :                 if (predv < 0)
     416               0 :                     predv = 0;
     417                 : 
     418               0 :                 if (predv > 255)
     419               0 :                     predv = 255;
     420                 : 
     421               0 :                 upred_ptr[j] = predu;
     422               0 :                 vpred_ptr[j] = predv;
     423                 :             }
     424                 : 
     425               0 :             upred_ptr += 8;
     426               0 :             vpred_ptr += 8;
     427                 :         }
     428                 : 
     429                 :     }
     430               0 :     break;
     431                 :     case B_PRED:
     432                 :     case NEARESTMV:
     433                 :     case NEARMV:
     434                 :     case ZEROMV:
     435                 :     case NEWMV:
     436                 :     case SPLITMV:
     437                 :     case MB_MODE_COUNT:
     438               0 :         break;
     439                 :     }
     440               0 : }
     441                 : 
     442               0 : void vp8mt_build_intra_predictors_mbuv_s(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
     443                 : {
     444                 :     unsigned char *uabove_row;  /* = x->dst.u_buffer - x->dst.uv_stride; */
     445                 :     unsigned char *uleft_col;   /*[16];*/
     446                 :     unsigned char uleft_buf[8];
     447                 :     unsigned char utop_left;    /* = uabove_row[-1]; */
     448                 :     unsigned char *vabove_row;  /* = x->dst.v_buffer - x->dst.uv_stride; */
     449                 :     unsigned char *vleft_col;   /*[20];*/
     450                 :     unsigned char vleft_buf[8];
     451                 :     unsigned char vtop_left;    /* = vabove_row[-1]; */
     452               0 :     unsigned char *upred_ptr = x->dst.u_buffer; /*&x->predictor[256];*/
     453               0 :     unsigned char *vpred_ptr = x->dst.v_buffer; /*&x->predictor[320];*/
     454               0 :     int uv_stride = x->dst.uv_stride;
     455                 :     int i, j;
     456                 : 
     457               0 :     if (pbi->common.filter_level)
     458                 :     {
     459               0 :         uabove_row = pbi->mt_uabove_row[mb_row] + mb_col*8 +16;
     460               0 :         vabove_row = pbi->mt_vabove_row[mb_row] + mb_col*8 +16;
     461               0 :         uleft_col = pbi->mt_uleft_col[mb_row];
     462               0 :         vleft_col = pbi->mt_vleft_col[mb_row];
     463                 :     } else
     464                 :     {
     465               0 :         uabove_row = x->dst.u_buffer - x->dst.uv_stride;
     466               0 :         vabove_row = x->dst.v_buffer - x->dst.uv_stride;
     467                 : 
     468               0 :         for (i = 0; i < 8; i++)
     469                 :         {
     470               0 :             uleft_buf[i] = x->dst.u_buffer [i* x->dst.uv_stride -1];
     471               0 :             vleft_buf[i] = x->dst.v_buffer [i* x->dst.uv_stride -1];
     472                 :         }
     473               0 :         uleft_col = uleft_buf;
     474               0 :         vleft_col = vleft_buf;
     475                 :     }
     476               0 :     utop_left = uabove_row[-1];
     477               0 :     vtop_left = vabove_row[-1];
     478                 : 
     479               0 :     switch (x->mode_info_context->mbmi.uv_mode)
     480                 :     {
     481                 :     case DC_PRED:
     482                 :     {
     483                 :         int expected_udc;
     484                 :         int expected_vdc;
     485                 :         int i;
     486                 :         int shift;
     487               0 :         int Uaverage = 0;
     488               0 :         int Vaverage = 0;
     489                 : 
     490               0 :         if (x->up_available)
     491                 :         {
     492               0 :             for (i = 0; i < 8; i++)
     493                 :             {
     494               0 :                 Uaverage += uabove_row[i];
     495               0 :                 Vaverage += vabove_row[i];
     496                 :             }
     497                 :         }
     498                 : 
     499               0 :         if (x->left_available)
     500                 :         {
     501               0 :             for (i = 0; i < 8; i++)
     502                 :             {
     503               0 :                 Uaverage += uleft_col[i];
     504               0 :                 Vaverage += vleft_col[i];
     505                 :             }
     506                 :         }
     507                 : 
     508               0 :         if (!x->up_available && !x->left_available)
     509                 :         {
     510               0 :             expected_udc = 128;
     511               0 :             expected_vdc = 128;
     512                 :         }
     513                 :         else
     514                 :         {
     515               0 :             shift = 2 + x->up_available + x->left_available;
     516               0 :             expected_udc = (Uaverage + (1 << (shift - 1))) >> shift;
     517               0 :             expected_vdc = (Vaverage + (1 << (shift - 1))) >> shift;
     518                 :         }
     519                 : 
     520                 : 
     521                 :         /*vpx_memset(upred_ptr,expected_udc,64);
     522                 :         vpx_memset(vpred_ptr,expected_vdc,64);*/
     523               0 :         for (i = 0; i < 8; i++)
     524                 :         {
     525               0 :             vpx_memset(upred_ptr, expected_udc, 8);
     526               0 :             vpx_memset(vpred_ptr, expected_vdc, 8);
     527               0 :             upred_ptr += uv_stride; /*8;*/
     528               0 :             vpred_ptr += uv_stride; /*8;*/
     529                 :         }
     530                 :     }
     531               0 :     break;
     532                 :     case V_PRED:
     533                 :     {
     534                 :         int i;
     535                 : 
     536               0 :         for (i = 0; i < 8; i++)
     537                 :         {
     538               0 :             vpx_memcpy(upred_ptr, uabove_row, 8);
     539               0 :             vpx_memcpy(vpred_ptr, vabove_row, 8);
     540               0 :             upred_ptr += uv_stride; /*8;*/
     541               0 :             vpred_ptr += uv_stride; /*8;*/
     542                 :         }
     543                 : 
     544                 :     }
     545               0 :     break;
     546                 :     case H_PRED:
     547                 :     {
     548                 :         int i;
     549                 : 
     550               0 :         for (i = 0; i < 8; i++)
     551                 :         {
     552               0 :             vpx_memset(upred_ptr, uleft_col[i], 8);
     553               0 :             vpx_memset(vpred_ptr, vleft_col[i], 8);
     554               0 :             upred_ptr += uv_stride; /*8;*/
     555               0 :             vpred_ptr += uv_stride; /*8;*/
     556                 :         }
     557                 :     }
     558                 : 
     559               0 :     break;
     560                 :     case TM_PRED:
     561                 :     {
     562                 :         int i;
     563                 : 
     564               0 :         for (i = 0; i < 8; i++)
     565                 :         {
     566               0 :             for (j = 0; j < 8; j++)
     567                 :             {
     568               0 :                 int predu = uleft_col[i] + uabove_row[j] - utop_left;
     569               0 :                 int predv = vleft_col[i] + vabove_row[j] - vtop_left;
     570                 : 
     571               0 :                 if (predu < 0)
     572               0 :                     predu = 0;
     573                 : 
     574               0 :                 if (predu > 255)
     575               0 :                     predu = 255;
     576                 : 
     577               0 :                 if (predv < 0)
     578               0 :                     predv = 0;
     579                 : 
     580               0 :                 if (predv > 255)
     581               0 :                     predv = 255;
     582                 : 
     583               0 :                 upred_ptr[j] = predu;
     584               0 :                 vpred_ptr[j] = predv;
     585                 :             }
     586                 : 
     587               0 :             upred_ptr += uv_stride; /*8;*/
     588               0 :             vpred_ptr += uv_stride; /*8;*/
     589                 :         }
     590                 : 
     591                 :     }
     592               0 :     break;
     593                 :     case B_PRED:
     594                 :     case NEARESTMV:
     595                 :     case NEARMV:
     596                 :     case ZEROMV:
     597                 :     case NEWMV:
     598                 :     case SPLITMV:
     599                 :     case MB_MODE_COUNT:
     600               0 :         break;
     601                 :     }
     602               0 : }
     603                 : 
     604                 : 
     605               0 : void vp8mt_predict_intra4x4(VP8D_COMP *pbi,
     606                 :                           MACROBLOCKD *xd,
     607                 :                           int b_mode,
     608                 :                           unsigned char *predictor,
     609                 :                           int mb_row,
     610                 :                           int mb_col,
     611                 :                           int num)
     612                 : {
     613                 :     int i, r, c;
     614                 : 
     615                 :     unsigned char *Above;   /* = *(x->base_dst) + x->dst - x->dst_stride; */
     616                 :     unsigned char Left[4];
     617                 :     unsigned char top_left; /* = Above[-1]; */
     618                 : 
     619               0 :     BLOCKD *x = &xd->block[num];
     620                 : 
     621                 :     /*Caution: For some b_mode, it needs 8 pixels (4 above + 4 above-right).*/
     622               0 :     if (num < 4 && pbi->common.filter_level)
     623               0 :         Above = pbi->mt_yabove_row[mb_row] + mb_col*16 + num*4 + 32;
     624                 :     else
     625               0 :         Above = *(x->base_dst) + x->dst - x->dst_stride;
     626                 : 
     627               0 :     if (num%4==0 && pbi->common.filter_level)
     628                 :     {
     629               0 :         for (i=0; i<4; i++)
     630               0 :             Left[i] = pbi->mt_yleft_col[mb_row][num + i];
     631                 :     }else
     632                 :     {
     633               0 :         Left[0] = (*(x->base_dst))[x->dst - 1];
     634               0 :         Left[1] = (*(x->base_dst))[x->dst - 1 + x->dst_stride];
     635               0 :         Left[2] = (*(x->base_dst))[x->dst - 1 + 2 * x->dst_stride];
     636               0 :         Left[3] = (*(x->base_dst))[x->dst - 1 + 3 * x->dst_stride];
     637                 :     }
     638                 : 
     639               0 :     if ((num==4 || num==8 || num==12) && pbi->common.filter_level)
     640               0 :         top_left = pbi->mt_yleft_col[mb_row][num-1];
     641                 :     else
     642               0 :         top_left = Above[-1];
     643                 : 
     644               0 :      switch (b_mode)
     645                 :     {
     646                 :     case B_DC_PRED:
     647                 :     {
     648               0 :         int expected_dc = 0;
     649                 : 
     650               0 :         for (i = 0; i < 4; i++)
     651                 :         {
     652               0 :             expected_dc += Above[i];
     653               0 :             expected_dc += Left[i];
     654                 :         }
     655                 : 
     656               0 :         expected_dc = (expected_dc + 4) >> 3;
     657                 : 
     658               0 :         for (r = 0; r < 4; r++)
     659                 :         {
     660               0 :             for (c = 0; c < 4; c++)
     661                 :             {
     662               0 :                 predictor[c] = expected_dc;
     663                 :             }
     664                 : 
     665               0 :             predictor += 16;
     666                 :         }
     667                 :     }
     668               0 :     break;
     669                 :     case B_TM_PRED:
     670                 :     {
     671                 :         /* prediction similar to true_motion prediction */
     672               0 :         for (r = 0; r < 4; r++)
     673                 :         {
     674               0 :             for (c = 0; c < 4; c++)
     675                 :             {
     676               0 :                 int pred = Above[c] - top_left + Left[r];
     677                 : 
     678               0 :                 if (pred < 0)
     679               0 :                     pred = 0;
     680                 : 
     681               0 :                 if (pred > 255)
     682               0 :                     pred = 255;
     683                 : 
     684               0 :                 predictor[c] = pred;
     685                 :             }
     686                 : 
     687               0 :             predictor += 16;
     688                 :         }
     689                 :     }
     690               0 :     break;
     691                 : 
     692                 :     case B_VE_PRED:
     693                 :     {
     694                 : 
     695                 :         unsigned int ap[4];
     696               0 :         ap[0] = (top_left  + 2 * Above[0] + Above[1] + 2) >> 2;
     697               0 :         ap[1] = (Above[0] + 2 * Above[1] + Above[2] + 2) >> 2;
     698               0 :         ap[2] = (Above[1] + 2 * Above[2] + Above[3] + 2) >> 2;
     699               0 :         ap[3] = (Above[2] + 2 * Above[3] + Above[4] + 2) >> 2;
     700                 : 
     701               0 :         for (r = 0; r < 4; r++)
     702                 :         {
     703               0 :             for (c = 0; c < 4; c++)
     704                 :             {
     705                 : 
     706               0 :                 predictor[c] = ap[c];
     707                 :             }
     708                 : 
     709               0 :             predictor += 16;
     710                 :         }
     711                 : 
     712                 :     }
     713               0 :     break;
     714                 : 
     715                 : 
     716                 :     case B_HE_PRED:
     717                 :     {
     718                 : 
     719                 :         unsigned int lp[4];
     720               0 :         lp[0] = (top_left + 2 * Left[0] + Left[1] + 2) >> 2;
     721               0 :         lp[1] = (Left[0] + 2 * Left[1] + Left[2] + 2) >> 2;
     722               0 :         lp[2] = (Left[1] + 2 * Left[2] + Left[3] + 2) >> 2;
     723               0 :         lp[3] = (Left[2] + 2 * Left[3] + Left[3] + 2) >> 2;
     724                 : 
     725               0 :         for (r = 0; r < 4; r++)
     726                 :         {
     727               0 :             for (c = 0; c < 4; c++)
     728                 :             {
     729               0 :                 predictor[c] = lp[r];
     730                 :             }
     731                 : 
     732               0 :             predictor += 16;
     733                 :         }
     734                 :     }
     735               0 :     break;
     736                 :     case B_LD_PRED:
     737                 :     {
     738               0 :         unsigned char *ptr = Above;
     739               0 :         predictor[0 * 16 + 0] = (ptr[0] + ptr[1] * 2 + ptr[2] + 2) >> 2;
     740               0 :         predictor[0 * 16 + 1] =
     741               0 :             predictor[1 * 16 + 0] = (ptr[1] + ptr[2] * 2 + ptr[3] + 2) >> 2;
     742               0 :         predictor[0 * 16 + 2] =
     743               0 :             predictor[1 * 16 + 1] =
     744               0 :                 predictor[2 * 16 + 0] = (ptr[2] + ptr[3] * 2 + ptr[4] + 2) >> 2;
     745               0 :         predictor[0 * 16 + 3] =
     746               0 :             predictor[1 * 16 + 2] =
     747               0 :                 predictor[2 * 16 + 1] =
     748               0 :                     predictor[3 * 16 + 0] = (ptr[3] + ptr[4] * 2 + ptr[5] + 2) >> 2;
     749               0 :         predictor[1 * 16 + 3] =
     750               0 :             predictor[2 * 16 + 2] =
     751               0 :                 predictor[3 * 16 + 1] = (ptr[4] + ptr[5] * 2 + ptr[6] + 2) >> 2;
     752               0 :         predictor[2 * 16 + 3] =
     753               0 :             predictor[3 * 16 + 2] = (ptr[5] + ptr[6] * 2 + ptr[7] + 2) >> 2;
     754               0 :         predictor[3 * 16 + 3] = (ptr[6] + ptr[7] * 2 + ptr[7] + 2) >> 2;
     755                 : 
     756                 :     }
     757               0 :     break;
     758                 :     case B_RD_PRED:
     759                 :     {
     760                 : 
     761                 :         unsigned char pp[9];
     762                 : 
     763               0 :         pp[0] = Left[3];
     764               0 :         pp[1] = Left[2];
     765               0 :         pp[2] = Left[1];
     766               0 :         pp[3] = Left[0];
     767               0 :         pp[4] = top_left;
     768               0 :         pp[5] = Above[0];
     769               0 :         pp[6] = Above[1];
     770               0 :         pp[7] = Above[2];
     771               0 :         pp[8] = Above[3];
     772                 : 
     773               0 :         predictor[3 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
     774               0 :         predictor[3 * 16 + 1] =
     775               0 :             predictor[2 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
     776               0 :         predictor[3 * 16 + 2] =
     777               0 :             predictor[2 * 16 + 1] =
     778               0 :                 predictor[1 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
     779               0 :         predictor[3 * 16 + 3] =
     780               0 :             predictor[2 * 16 + 2] =
     781               0 :                 predictor[1 * 16 + 1] =
     782               0 :                     predictor[0 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
     783               0 :         predictor[2 * 16 + 3] =
     784               0 :             predictor[1 * 16 + 2] =
     785               0 :                 predictor[0 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
     786               0 :         predictor[1 * 16 + 3] =
     787               0 :             predictor[0 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
     788               0 :         predictor[0 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2;
     789                 : 
     790                 :     }
     791               0 :     break;
     792                 :     case B_VR_PRED:
     793                 :     {
     794                 : 
     795                 :         unsigned char pp[9];
     796                 : 
     797               0 :         pp[0] = Left[3];
     798               0 :         pp[1] = Left[2];
     799               0 :         pp[2] = Left[1];
     800               0 :         pp[3] = Left[0];
     801               0 :         pp[4] = top_left;
     802               0 :         pp[5] = Above[0];
     803               0 :         pp[6] = Above[1];
     804               0 :         pp[7] = Above[2];
     805               0 :         pp[8] = Above[3];
     806                 : 
     807                 : 
     808               0 :         predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
     809               0 :         predictor[2 * 16 + 0] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
     810               0 :         predictor[3 * 16 + 1] =
     811               0 :             predictor[1 * 16 + 0] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
     812               0 :         predictor[2 * 16 + 1] =
     813               0 :             predictor[0 * 16 + 0] = (pp[4] + pp[5] + 1) >> 1;
     814               0 :         predictor[3 * 16 + 2] =
     815               0 :             predictor[1 * 16 + 1] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
     816               0 :         predictor[2 * 16 + 2] =
     817               0 :             predictor[0 * 16 + 1] = (pp[5] + pp[6] + 1) >> 1;
     818               0 :         predictor[3 * 16 + 3] =
     819               0 :             predictor[1 * 16 + 2] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
     820               0 :         predictor[2 * 16 + 3] =
     821               0 :             predictor[0 * 16 + 2] = (pp[6] + pp[7] + 1) >> 1;
     822               0 :         predictor[1 * 16 + 3] = (pp[6] + pp[7] * 2 + pp[8] + 2) >> 2;
     823               0 :         predictor[0 * 16 + 3] = (pp[7] + pp[8] + 1) >> 1;
     824                 : 
     825                 :     }
     826               0 :     break;
     827                 :     case B_VL_PRED:
     828                 :     {
     829                 : 
     830               0 :         unsigned char *pp = Above;
     831                 : 
     832               0 :         predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
     833               0 :         predictor[1 * 16 + 0] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
     834               0 :         predictor[2 * 16 + 0] =
     835               0 :             predictor[0 * 16 + 1] = (pp[1] + pp[2] + 1) >> 1;
     836               0 :         predictor[1 * 16 + 1] =
     837               0 :             predictor[3 * 16 + 0] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
     838               0 :         predictor[2 * 16 + 1] =
     839               0 :             predictor[0 * 16 + 2] = (pp[2] + pp[3] + 1) >> 1;
     840               0 :         predictor[3 * 16 + 1] =
     841               0 :             predictor[1 * 16 + 2] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
     842               0 :         predictor[0 * 16 + 3] =
     843               0 :             predictor[2 * 16 + 2] = (pp[3] + pp[4] + 1) >> 1;
     844               0 :         predictor[1 * 16 + 3] =
     845               0 :             predictor[3 * 16 + 2] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
     846               0 :         predictor[2 * 16 + 3] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
     847               0 :         predictor[3 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
     848                 :     }
     849               0 :     break;
     850                 : 
     851                 :     case B_HD_PRED:
     852                 :     {
     853                 :         unsigned char pp[9];
     854               0 :         pp[0] = Left[3];
     855               0 :         pp[1] = Left[2];
     856               0 :         pp[2] = Left[1];
     857               0 :         pp[3] = Left[0];
     858               0 :         pp[4] = top_left;
     859               0 :         pp[5] = Above[0];
     860               0 :         pp[6] = Above[1];
     861               0 :         pp[7] = Above[2];
     862               0 :         pp[8] = Above[3];
     863                 : 
     864                 : 
     865               0 :         predictor[3 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
     866               0 :         predictor[3 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
     867               0 :         predictor[2 * 16 + 0] =
     868               0 :             predictor[3 * 16 + 2] = (pp[1] + pp[2] + 1) >> 1;
     869               0 :         predictor[2 * 16 + 1] =
     870               0 :             predictor[3 * 16 + 3] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
     871               0 :         predictor[2 * 16 + 2] =
     872               0 :             predictor[1 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1;
     873               0 :         predictor[2 * 16 + 3] =
     874               0 :             predictor[1 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[4] + 2) >> 2;
     875               0 :         predictor[1 * 16 + 2] =
     876               0 :             predictor[0 * 16 + 0] = (pp[3] + pp[4] + 1) >> 1;
     877               0 :         predictor[1 * 16 + 3] =
     878               0 :             predictor[0 * 16 + 1] = (pp[3] + pp[4] * 2 + pp[5] + 2) >> 2;
     879               0 :         predictor[0 * 16 + 2] = (pp[4] + pp[5] * 2 + pp[6] + 2) >> 2;
     880               0 :         predictor[0 * 16 + 3] = (pp[5] + pp[6] * 2 + pp[7] + 2) >> 2;
     881                 :     }
     882               0 :     break;
     883                 : 
     884                 : 
     885                 :     case B_HU_PRED:
     886                 :     {
     887               0 :         unsigned char *pp = Left;
     888               0 :         predictor[0 * 16 + 0] = (pp[0] + pp[1] + 1) >> 1;
     889               0 :         predictor[0 * 16 + 1] = (pp[0] + pp[1] * 2 + pp[2] + 2) >> 2;
     890               0 :         predictor[0 * 16 + 2] =
     891               0 :             predictor[1 * 16 + 0] = (pp[1] + pp[2] + 1) >> 1;
     892               0 :         predictor[0 * 16 + 3] =
     893               0 :             predictor[1 * 16 + 1] = (pp[1] + pp[2] * 2 + pp[3] + 2) >> 2;
     894               0 :         predictor[1 * 16 + 2] =
     895               0 :             predictor[2 * 16 + 0] = (pp[2] + pp[3] + 1) >> 1;
     896               0 :         predictor[1 * 16 + 3] =
     897               0 :             predictor[2 * 16 + 1] = (pp[2] + pp[3] * 2 + pp[3] + 2) >> 2;
     898               0 :         predictor[2 * 16 + 2] =
     899               0 :             predictor[2 * 16 + 3] =
     900               0 :                 predictor[3 * 16 + 0] =
     901               0 :                     predictor[3 * 16 + 1] =
     902               0 :                         predictor[3 * 16 + 2] =
     903               0 :                             predictor[3 * 16 + 3] = pp[3];
     904                 :     }
     905               0 :     break;
     906                 : 
     907                 : 
     908                 :     }
     909               0 : }
     910                 : 
     911                 : /* copy 4 bytes from the above right down so that the 4x4 prediction modes using pixels above and
     912                 :  * to the right prediction have filled in pixels to use.
     913                 :  */
     914               0 : void vp8mt_intra_prediction_down_copy(VP8D_COMP *pbi, MACROBLOCKD *x, int mb_row, int mb_col)
     915                 : {
     916                 :     unsigned char *above_right;   /* = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16; */
     917                 :     unsigned int *src_ptr;
     918                 :     unsigned int *dst_ptr0;
     919                 :     unsigned int *dst_ptr1;
     920                 :     unsigned int *dst_ptr2;
     921                 : 
     922               0 :     if (pbi->common.filter_level)
     923               0 :         above_right = pbi->mt_yabove_row[mb_row] + mb_col*16 + 32 +16;
     924                 :     else
     925               0 :         above_right = *(x->block[0].base_dst) + x->block[0].dst - x->block[0].dst_stride + 16;
     926                 : 
     927               0 :     src_ptr = (unsigned int *)above_right;
     928                 :     /*dst_ptr0 = (unsigned int *)(above_right + 4 * x->block[0].dst_stride);
     929                 :     dst_ptr1 = (unsigned int *)(above_right + 8 * x->block[0].dst_stride);
     930                 :     dst_ptr2 = (unsigned int *)(above_right + 12 * x->block[0].dst_stride);*/
     931               0 :     dst_ptr0 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 3 * x->block[0].dst_stride);
     932               0 :     dst_ptr1 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 7 * x->block[0].dst_stride);
     933               0 :     dst_ptr2 = (unsigned int *)(*(x->block[0].base_dst) + x->block[0].dst + 16 + 11 * x->block[0].dst_stride);
     934               0 :     *dst_ptr0 = *src_ptr;
     935               0 :     *dst_ptr1 = *src_ptr;
     936               0 :     *dst_ptr2 = *src_ptr;
     937               0 : }

Generated by: LCOV version 1.7