LCOV - code coverage report
Current view: top level - libavcodec - h264pred_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 822 888 92.6 %
Date: 2017-12-17 16:07:53 Functions: 176 360 48.9 %

          Line data    Source code
       1             : /*
       2             :  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
       3             :  * Copyright (c) 2003-2011 Michael Niedermayer <michaelni@gmx.at>
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * H.264 / AVC / MPEG-4 part10 prediction functions.
      25             :  * @author Michael Niedermayer <michaelni@gmx.at>
      26             :  */
      27             : 
      28             : #include "libavutil/intreadwrite.h"
      29             : 
      30             : #include "mathops.h"
      31             : 
      32             : #include "bit_depth_template.c"
      33             : 
      34     4057860 : static void FUNCC(pred4x4_vertical)(uint8_t *_src, const uint8_t *topright,
      35             :                                     ptrdiff_t _stride)
      36             : {
      37     4057860 :     pixel *src = (pixel*)_src;
      38     4057860 :     int stride = _stride>>(sizeof(pixel)-1);
      39     4057860 :     const pixel4 a= AV_RN4PA(src-stride);
      40             : 
      41     4057860 :     AV_WN4PA(src+0*stride, a);
      42     4057860 :     AV_WN4PA(src+1*stride, a);
      43     4057860 :     AV_WN4PA(src+2*stride, a);
      44     4057860 :     AV_WN4PA(src+3*stride, a);
      45     4057860 : }
      46             : 
      47     6650872 : static void FUNCC(pred4x4_horizontal)(uint8_t *_src, const uint8_t *topright,
      48             :                                       ptrdiff_t _stride)
      49             : {
      50     6650872 :     pixel *src = (pixel*)_src;
      51     6650872 :     int stride = _stride>>(sizeof(pixel)-1);
      52     6650872 :     AV_WN4PA(src+0*stride, PIXEL_SPLAT_X4(src[-1+0*stride]));
      53     6650872 :     AV_WN4PA(src+1*stride, PIXEL_SPLAT_X4(src[-1+1*stride]));
      54     6650872 :     AV_WN4PA(src+2*stride, PIXEL_SPLAT_X4(src[-1+2*stride]));
      55     6650872 :     AV_WN4PA(src+3*stride, PIXEL_SPLAT_X4(src[-1+3*stride]));
      56     6650872 : }
      57             : 
      58     2933575 : static void FUNCC(pred4x4_dc)(uint8_t *_src, const uint8_t *topright,
      59             :                               ptrdiff_t _stride)
      60             : {
      61     2933575 :     pixel *src = (pixel*)_src;
      62     2933575 :     int stride = _stride>>(sizeof(pixel)-1);
      63     5867150 :     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride]
      64     2933575 :                    + src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 4) >>3;
      65     2933575 :     const pixel4 a = PIXEL_SPLAT_X4(dc);
      66             : 
      67     2933575 :     AV_WN4PA(src+0*stride, a);
      68     2933575 :     AV_WN4PA(src+1*stride, a);
      69     2933575 :     AV_WN4PA(src+2*stride, a);
      70     2933575 :     AV_WN4PA(src+3*stride, a);
      71     2933575 : }
      72             : 
      73      281759 : static void FUNCC(pred4x4_left_dc)(uint8_t *_src, const uint8_t *topright,
      74             :                                    ptrdiff_t _stride)
      75             : {
      76      281759 :     pixel *src = (pixel*)_src;
      77      281759 :     int stride = _stride>>(sizeof(pixel)-1);
      78      281759 :     const int dc= (  src[-1+0*stride] + src[-1+1*stride] + src[-1+2*stride] + src[-1+3*stride] + 2) >>2;
      79      281759 :     const pixel4 a = PIXEL_SPLAT_X4(dc);
      80             : 
      81      281759 :     AV_WN4PA(src+0*stride, a);
      82      281759 :     AV_WN4PA(src+1*stride, a);
      83      281759 :     AV_WN4PA(src+2*stride, a);
      84      281759 :     AV_WN4PA(src+3*stride, a);
      85      281759 : }
      86             : 
      87       50564 : static void FUNCC(pred4x4_top_dc)(uint8_t *_src, const uint8_t *topright,
      88             :                                   ptrdiff_t _stride)
      89             : {
      90       50564 :     pixel *src = (pixel*)_src;
      91       50564 :     int stride = _stride>>(sizeof(pixel)-1);
      92       50564 :     const int dc= (  src[-stride] + src[1-stride] + src[2-stride] + src[3-stride] + 2) >>2;
      93       50564 :     const pixel4 a = PIXEL_SPLAT_X4(dc);
      94             : 
      95       50564 :     AV_WN4PA(src+0*stride, a);
      96       50564 :     AV_WN4PA(src+1*stride, a);
      97       50564 :     AV_WN4PA(src+2*stride, a);
      98       50564 :     AV_WN4PA(src+3*stride, a);
      99       50564 : }
     100             : 
     101        7174 : static void FUNCC(pred4x4_128_dc)(uint8_t *_src, const uint8_t *topright,
     102             :                                   ptrdiff_t _stride)
     103             : {
     104        7174 :     pixel *src = (pixel*)_src;
     105        7174 :     int stride = _stride>>(sizeof(pixel)-1);
     106        7174 :     const pixel4 a = PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1));
     107             : 
     108        7174 :     AV_WN4PA(src+0*stride, a);
     109        7174 :     AV_WN4PA(src+1*stride, a);
     110        7174 :     AV_WN4PA(src+2*stride, a);
     111        7174 :     AV_WN4PA(src+3*stride, a);
     112        7174 : }
     113             : 
     114          26 : static void FUNCC(pred4x4_127_dc)(uint8_t *_src, const uint8_t *topright,
     115             :                                   ptrdiff_t _stride)
     116             : {
     117          26 :     pixel *src = (pixel*)_src;
     118          26 :     int stride = _stride>>(sizeof(pixel)-1);
     119          26 :     const pixel4 a = PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))-1);
     120             : 
     121          26 :     AV_WN4PA(src+0*stride, a);
     122          26 :     AV_WN4PA(src+1*stride, a);
     123          26 :     AV_WN4PA(src+2*stride, a);
     124          26 :     AV_WN4PA(src+3*stride, a);
     125          26 : }
     126             : 
     127          47 : static void FUNCC(pred4x4_129_dc)(uint8_t *_src, const uint8_t *topright,
     128             :                                   ptrdiff_t _stride)
     129             : {
     130          47 :     pixel *src = (pixel*)_src;
     131          47 :     int stride = _stride>>(sizeof(pixel)-1);
     132          47 :     const pixel4 a = PIXEL_SPLAT_X4((1<<(BIT_DEPTH-1))+1);
     133             : 
     134          47 :     AV_WN4PA(src+0*stride, a);
     135          47 :     AV_WN4PA(src+1*stride, a);
     136          47 :     AV_WN4PA(src+2*stride, a);
     137          47 :     AV_WN4PA(src+3*stride, a);
     138          47 : }
     139             : 
     140             : 
     141             : #define LOAD_TOP_RIGHT_EDGE\
     142             :     const unsigned av_unused t4 = topright[0];\
     143             :     const unsigned av_unused t5 = topright[1];\
     144             :     const unsigned av_unused t6 = topright[2];\
     145             :     const unsigned av_unused t7 = topright[3];\
     146             : 
     147             : #define LOAD_DOWN_LEFT_EDGE\
     148             :     const unsigned av_unused l4 = src[-1+4*stride];\
     149             :     const unsigned av_unused l5 = src[-1+5*stride];\
     150             :     const unsigned av_unused l6 = src[-1+6*stride];\
     151             :     const unsigned av_unused l7 = src[-1+7*stride];\
     152             : 
     153             : #define LOAD_LEFT_EDGE\
     154             :     const unsigned av_unused l0 = src[-1+0*stride];\
     155             :     const unsigned av_unused l1 = src[-1+1*stride];\
     156             :     const unsigned av_unused l2 = src[-1+2*stride];\
     157             :     const unsigned av_unused l3 = src[-1+3*stride];\
     158             : 
     159             : #define LOAD_TOP_EDGE\
     160             :     const unsigned av_unused t0 = src[ 0-1*stride];\
     161             :     const unsigned av_unused t1 = src[ 1-1*stride];\
     162             :     const unsigned av_unused t2 = src[ 2-1*stride];\
     163             :     const unsigned av_unused t3 = src[ 3-1*stride];\
     164             : 
     165     1879316 : static void FUNCC(pred4x4_down_right)(uint8_t *_src, const uint8_t *topright,
     166             :                                       ptrdiff_t _stride)
     167             : {
     168     1879316 :     pixel *src = (pixel*)_src;
     169     1879316 :     int stride = _stride>>(sizeof(pixel)-1);
     170     1879316 :     const int lt= src[-1-1*stride];
     171     1879316 :     LOAD_TOP_EDGE
     172     1879316 :     LOAD_LEFT_EDGE
     173             : 
     174     1879316 :     src[0+3*stride]=(l3 + 2*l2 + l1 + 2)>>2;
     175     3758632 :     src[0+2*stride]=
     176     3758632 :     src[1+3*stride]=(l2 + 2*l1 + l0 + 2)>>2;
     177     3758632 :     src[0+1*stride]=
     178     5637948 :     src[1+2*stride]=
     179     3758632 :     src[2+3*stride]=(l1 + 2*l0 + lt + 2)>>2;
     180     1879316 :     src[0+0*stride]=
     181     3758632 :     src[1+1*stride]=
     182     5637948 :     src[2+2*stride]=
     183     3758632 :     src[3+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
     184     3758632 :     src[1+0*stride]=
     185     5637948 :     src[2+1*stride]=
     186     3758632 :     src[3+2*stride]=(lt + 2*t0 + t1 + 2)>>2;
     187     3758632 :     src[2+0*stride]=
     188     3758632 :     src[3+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
     189     1879316 :     src[3+0*stride]=(t1 + 2*t2 + t3 + 2)>>2;
     190     1879316 : }
     191             : 
     192     1118126 : static void FUNCC(pred4x4_down_left)(uint8_t *_src, const uint8_t *_topright,
     193             :                                      ptrdiff_t _stride)
     194             : {
     195     1118126 :     pixel *src = (pixel*)_src;
     196     1118126 :     const pixel *topright = (const pixel*)_topright;
     197     1118126 :     int stride = _stride>>(sizeof(pixel)-1);
     198     1118126 :     LOAD_TOP_EDGE
     199     1118126 :     LOAD_TOP_RIGHT_EDGE
     200             : //    LOAD_LEFT_EDGE
     201             : 
     202     1118126 :     src[0+0*stride]=(t0 + t2 + 2*t1 + 2)>>2;
     203     2236252 :     src[1+0*stride]=
     204     2236252 :     src[0+1*stride]=(t1 + t3 + 2*t2 + 2)>>2;
     205     2236252 :     src[2+0*stride]=
     206     3354378 :     src[1+1*stride]=
     207     2236252 :     src[0+2*stride]=(t2 + t4 + 2*t3 + 2)>>2;
     208     2236252 :     src[3+0*stride]=
     209     3354378 :     src[2+1*stride]=
     210     3354378 :     src[1+2*stride]=
     211     2236252 :     src[0+3*stride]=(t3 + t5 + 2*t4 + 2)>>2;
     212     2236252 :     src[3+1*stride]=
     213     3354378 :     src[2+2*stride]=
     214     2236252 :     src[1+3*stride]=(t4 + t6 + 2*t5 + 2)>>2;
     215     2236252 :     src[3+2*stride]=
     216     2236252 :     src[2+3*stride]=(t5 + t7 + 2*t6 + 2)>>2;
     217     1118126 :     src[3+3*stride]=(t6 + 3*t7 + 2)>>2;
     218     1118126 : }
     219             : 
     220     1287711 : static void FUNCC(pred4x4_vertical_right)(uint8_t *_src,
     221             :                                           const uint8_t *topright,
     222             :                                           ptrdiff_t _stride)
     223             : {
     224     1287711 :     pixel *src = (pixel*)_src;
     225     1287711 :     int stride = _stride>>(sizeof(pixel)-1);
     226     1287711 :     const int lt= src[-1-1*stride];
     227     1287711 :     LOAD_TOP_EDGE
     228     1287711 :     LOAD_LEFT_EDGE
     229             : 
     230     1287711 :     src[0+0*stride]=
     231     1287711 :     src[1+2*stride]=(lt + t0 + 1)>>1;
     232     2575422 :     src[1+0*stride]=
     233     2575422 :     src[2+2*stride]=(t0 + t1 + 1)>>1;
     234     2575422 :     src[2+0*stride]=
     235     2575422 :     src[3+2*stride]=(t1 + t2 + 1)>>1;
     236     1287711 :     src[3+0*stride]=(t2 + t3 + 1)>>1;
     237     2575422 :     src[0+1*stride]=
     238     2575422 :     src[1+3*stride]=(l0 + 2*lt + t0 + 2)>>2;
     239     2575422 :     src[1+1*stride]=
     240     2575422 :     src[2+3*stride]=(lt + 2*t0 + t1 + 2)>>2;
     241     2575422 :     src[2+1*stride]=
     242     2575422 :     src[3+3*stride]=(t0 + 2*t1 + t2 + 2)>>2;
     243     1287711 :     src[3+1*stride]=(t1 + 2*t2 + t3 + 2)>>2;
     244     1287711 :     src[0+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
     245     1287711 :     src[0+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
     246     1287711 : }
     247             : 
     248     1058878 : static void FUNCC(pred4x4_vertical_left)(uint8_t *_src,
     249             :                                          const uint8_t *_topright,
     250             :                                          ptrdiff_t _stride)
     251             : {
     252     1058878 :     pixel *src = (pixel*)_src;
     253     1058878 :     const pixel *topright = (const pixel*)_topright;
     254     1058878 :     int stride = _stride>>(sizeof(pixel)-1);
     255     1058878 :     LOAD_TOP_EDGE
     256     1058878 :     LOAD_TOP_RIGHT_EDGE
     257             : 
     258     1058878 :     src[0+0*stride]=(t0 + t1 + 1)>>1;
     259     2117756 :     src[1+0*stride]=
     260     2117756 :     src[0+2*stride]=(t1 + t2 + 1)>>1;
     261     2117756 :     src[2+0*stride]=
     262     2117756 :     src[1+2*stride]=(t2 + t3 + 1)>>1;
     263     2117756 :     src[3+0*stride]=
     264     2117756 :     src[2+2*stride]=(t3 + t4+ 1)>>1;
     265     1058878 :     src[3+2*stride]=(t4 + t5+ 1)>>1;
     266     1058878 :     src[0+1*stride]=(t0 + 2*t1 + t2 + 2)>>2;
     267     2117756 :     src[1+1*stride]=
     268     2117756 :     src[0+3*stride]=(t1 + 2*t2 + t3 + 2)>>2;
     269     2117756 :     src[2+1*stride]=
     270     2117756 :     src[1+3*stride]=(t2 + 2*t3 + t4 + 2)>>2;
     271     2117756 :     src[3+1*stride]=
     272     2117756 :     src[2+3*stride]=(t3 + 2*t4 + t5 + 2)>>2;
     273     1058878 :     src[3+3*stride]=(t4 + 2*t5 + t6 + 2)>>2;
     274     1058878 : }
     275             : 
     276     1980711 : static void FUNCC(pred4x4_horizontal_up)(uint8_t *_src, const uint8_t *topright,
     277             :                                          ptrdiff_t _stride)
     278             : {
     279     1980711 :     pixel *src = (pixel*)_src;
     280     1980711 :     int stride = _stride>>(sizeof(pixel)-1);
     281     1980711 :     LOAD_LEFT_EDGE
     282             : 
     283     1980711 :     src[0+0*stride]=(l0 + l1 + 1)>>1;
     284     1980711 :     src[1+0*stride]=(l0 + 2*l1 + l2 + 2)>>2;
     285     3961422 :     src[2+0*stride]=
     286     3961422 :     src[0+1*stride]=(l1 + l2 + 1)>>1;
     287     3961422 :     src[3+0*stride]=
     288     3961422 :     src[1+1*stride]=(l1 + 2*l2 + l3 + 2)>>2;
     289     3961422 :     src[2+1*stride]=
     290     3961422 :     src[0+2*stride]=(l2 + l3 + 1)>>1;
     291     3961422 :     src[3+1*stride]=
     292     3961422 :     src[1+2*stride]=(l2 + 2*l3 + l3 + 2)>>2;
     293     3961422 :     src[3+2*stride]=
     294     5942133 :     src[1+3*stride]=
     295     5942133 :     src[0+3*stride]=
     296     5942133 :     src[2+2*stride]=
     297     5942133 :     src[2+3*stride]=
     298     3961422 :     src[3+3*stride]=l3;
     299     1980711 : }
     300             : 
     301     2136999 : static void FUNCC(pred4x4_horizontal_down)(uint8_t *_src,
     302             :                                            const uint8_t *topright,
     303             :                                            ptrdiff_t _stride)
     304             : {
     305     2136999 :     pixel *src = (pixel*)_src;
     306     2136999 :     int stride = _stride>>(sizeof(pixel)-1);
     307     2136999 :     const int lt= src[-1-1*stride];
     308     2136999 :     LOAD_TOP_EDGE
     309     2136999 :     LOAD_LEFT_EDGE
     310             : 
     311     2136999 :     src[0+0*stride]=
     312     2136999 :     src[2+1*stride]=(lt + l0 + 1)>>1;
     313     4273998 :     src[1+0*stride]=
     314     4273998 :     src[3+1*stride]=(l0 + 2*lt + t0 + 2)>>2;
     315     2136999 :     src[2+0*stride]=(lt + 2*t0 + t1 + 2)>>2;
     316     2136999 :     src[3+0*stride]=(t0 + 2*t1 + t2 + 2)>>2;
     317     4273998 :     src[0+1*stride]=
     318     4273998 :     src[2+2*stride]=(l0 + l1 + 1)>>1;
     319     4273998 :     src[1+1*stride]=
     320     4273998 :     src[3+2*stride]=(lt + 2*l0 + l1 + 2)>>2;
     321     4273998 :     src[0+2*stride]=
     322     4273998 :     src[2+3*stride]=(l1 + l2+ 1)>>1;
     323     4273998 :     src[1+2*stride]=
     324     4273998 :     src[3+3*stride]=(l0 + 2*l1 + l2 + 2)>>2;
     325     2136999 :     src[0+3*stride]=(l2 + l3 + 1)>>1;
     326     2136999 :     src[1+3*stride]=(l1 + 2*l2 + l3 + 2)>>2;
     327     2136999 : }
     328             : 
     329      212236 : static void FUNCC(pred16x16_vertical)(uint8_t *_src, ptrdiff_t _stride)
     330             : {
     331             :     int i;
     332      212236 :     pixel *src = (pixel*)_src;
     333      212236 :     int stride = _stride>>(sizeof(pixel)-1);
     334      212236 :     const pixel4 a = AV_RN4PA(((pixel4*)(src-stride))+0);
     335      212236 :     const pixel4 b = AV_RN4PA(((pixel4*)(src-stride))+1);
     336      212236 :     const pixel4 c = AV_RN4PA(((pixel4*)(src-stride))+2);
     337      212236 :     const pixel4 d = AV_RN4PA(((pixel4*)(src-stride))+3);
     338             : 
     339     3608012 :     for(i=0; i<16; i++){
     340     3395776 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
     341     3395776 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, b);
     342     3395776 :         AV_WN4PA(((pixel4*)(src+i*stride))+2, c);
     343     3395776 :         AV_WN4PA(((pixel4*)(src+i*stride))+3, d);
     344             :     }
     345      212236 : }
     346             : 
     347      237276 : static void FUNCC(pred16x16_horizontal)(uint8_t *_src, ptrdiff_t stride)
     348             : {
     349             :     int i;
     350      237276 :     pixel *src = (pixel*)_src;
     351      237276 :     stride >>= sizeof(pixel)-1;
     352             : 
     353     4033692 :     for(i=0; i<16; i++){
     354     3796416 :         const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
     355             : 
     356     3796416 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
     357     3796416 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, a);
     358     3796416 :         AV_WN4PA(((pixel4*)(src+i*stride))+2, a);
     359     3796416 :         AV_WN4PA(((pixel4*)(src+i*stride))+3, a);
     360             :     }
     361      237276 : }
     362             : 
     363             : #define PREDICT_16x16_DC(v)\
     364             :     for(i=0; i<16; i++){\
     365             :         AV_WN4PA(src+ 0, v);\
     366             :         AV_WN4PA(src+ 4, v);\
     367             :         AV_WN4PA(src+ 8, v);\
     368             :         AV_WN4PA(src+12, v);\
     369             :         src += stride;\
     370             :     }
     371             : 
     372      244015 : static void FUNCC(pred16x16_dc)(uint8_t *_src, ptrdiff_t stride)
     373             : {
     374      244015 :     int i, dc=0;
     375      244015 :     pixel *src = (pixel*)_src;
     376             :     pixel4 dcsplat;
     377      244015 :     stride >>= sizeof(pixel)-1;
     378             : 
     379     4148255 :     for(i=0;i<16; i++){
     380     3904240 :         dc+= src[-1+i*stride];
     381             :     }
     382             : 
     383     4148255 :     for(i=0;i<16; i++){
     384     3904240 :         dc+= src[i-stride];
     385             :     }
     386             : 
     387      244015 :     dcsplat = PIXEL_SPLAT_X4((dc+16)>>5);
     388      244015 :     PREDICT_16x16_DC(dcsplat);
     389      244015 : }
     390             : 
     391       32851 : static void FUNCC(pred16x16_left_dc)(uint8_t *_src, ptrdiff_t stride)
     392             : {
     393       32851 :     int i, dc=0;
     394       32851 :     pixel *src = (pixel*)_src;
     395             :     pixel4 dcsplat;
     396       32851 :     stride >>= sizeof(pixel)-1;
     397             : 
     398      558467 :     for(i=0;i<16; i++){
     399      525616 :         dc+= src[-1+i*stride];
     400             :     }
     401             : 
     402       32851 :     dcsplat = PIXEL_SPLAT_X4((dc+8)>>4);
     403       32851 :     PREDICT_16x16_DC(dcsplat);
     404       32851 : }
     405             : 
     406        5538 : static void FUNCC(pred16x16_top_dc)(uint8_t *_src, ptrdiff_t stride)
     407             : {
     408        5538 :     int i, dc=0;
     409        5538 :     pixel *src = (pixel*)_src;
     410             :     pixel4 dcsplat;
     411        5538 :     stride >>= sizeof(pixel)-1;
     412             : 
     413       94146 :     for(i=0;i<16; i++){
     414       88608 :         dc+= src[i-stride];
     415             :     }
     416             : 
     417        5538 :     dcsplat = PIXEL_SPLAT_X4((dc+8)>>4);
     418        5538 :     PREDICT_16x16_DC(dcsplat);
     419        5538 : }
     420             : 
     421             : #define PRED16x16_X(n, v) \
     422             : static void FUNCC(pred16x16_##n##_dc)(uint8_t *_src, ptrdiff_t stride)\
     423             : {\
     424             :     int i;\
     425             :     pixel *src = (pixel*)_src;\
     426             :     stride >>= sizeof(pixel)-1;\
     427             :     PREDICT_16x16_DC(PIXEL_SPLAT_X4(v));\
     428             : }
     429             : 
     430          12 : PRED16x16_X(127, (1<<(BIT_DEPTH-1))-1)
     431        2007 : PRED16x16_X(128, (1<<(BIT_DEPTH-1))+0)
     432          10 : PRED16x16_X(129, (1<<(BIT_DEPTH-1))+1)
     433             : 
     434      149617 : static inline void FUNCC(pred16x16_plane_compat)(uint8_t *_src,
     435             :                                                  ptrdiff_t _stride,
     436             :                                                  const int svq3,
     437             :                                                  const int rv40)
     438             : {
     439             :   int i, j, k;
     440             :   int a;
     441             :   INIT_CLIP
     442      149617 :   pixel *src = (pixel*)_src;
     443      149617 :   int stride = _stride>>(sizeof(pixel)-1);
     444      149617 :   const pixel * const src0 = src +7-stride;
     445      149617 :   const pixel *       src1 = src +8*stride-1;
     446      149617 :   const pixel *       src2 = src1-2*stride;    // == src+6*stride-1;
     447      149617 :   int H = src0[1] - src0[-1];
     448      149617 :   int V = src1[0] - src2[ 0];
     449     1196936 :   for(k=2; k<=8; ++k) {
     450     1047319 :     src1 += stride; src2 -= stride;
     451     1047319 :     H += k*(src0[k] - src0[-k]);
     452     1047319 :     V += k*(src1[0] - src2[ 0]);
     453             :   }
     454      149617 :   if(svq3){
     455          56 :     H = ( 5*(H/4) ) / 16;
     456          56 :     V = ( 5*(V/4) ) / 16;
     457             : 
     458             :     /* required for 100% accuracy */
     459          56 :     i = H; H = V; V = i;
     460      149561 :   }else if(rv40){
     461        1216 :     H = ( H + (H>>2) ) >> 4;
     462        1216 :     V = ( V + (V>>2) ) >> 4;
     463             :   }else{
     464      148345 :     H = ( 5*H+32 ) >> 6;
     465      148345 :     V = ( 5*V+32 ) >> 6;
     466             :   }
     467             : 
     468      149617 :   a = 16*(src1[0] + src2[16] + 1) - 7*(V+H);
     469     2543489 :   for(j=16; j>0; --j) {
     470     2393872 :     int b = a;
     471     2393872 :     a += V;
     472    11969360 :     for(i=-16; i<0; i+=4) {
     473     9575488 :       src[16+i] = CLIP((b    ) >> 5);
     474     9575488 :       src[17+i] = CLIP((b+  H) >> 5);
     475     9575488 :       src[18+i] = CLIP((b+2*H) >> 5);
     476     9575488 :       src[19+i] = CLIP((b+3*H) >> 5);
     477     9575488 :       b += 4*H;
     478             :     }
     479     2393872 :     src += stride;
     480             :   }
     481      149617 : }
     482             : 
     483      148345 : static void FUNCC(pred16x16_plane)(uint8_t *src, ptrdiff_t stride)
     484             : {
     485      148345 :     FUNCC(pred16x16_plane_compat)(src, stride, 0, 0);
     486      148345 : }
     487             : 
     488      697584 : static void FUNCC(pred8x8_vertical)(uint8_t *_src, ptrdiff_t _stride)
     489             : {
     490             :     int i;
     491      697584 :     pixel *src = (pixel*)_src;
     492      697584 :     int stride = _stride>>(sizeof(pixel)-1);
     493      697584 :     const pixel4 a= AV_RN4PA(((pixel4*)(src-stride))+0);
     494      697584 :     const pixel4 b= AV_RN4PA(((pixel4*)(src-stride))+1);
     495             : 
     496     6278256 :     for(i=0; i<8; i++){
     497     5580672 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
     498     5580672 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, b);
     499             :     }
     500      697584 : }
     501             : 
     502      161462 : static void FUNCC(pred8x16_vertical)(uint8_t *_src, ptrdiff_t _stride)
     503             : {
     504             :     int i;
     505      161462 :     pixel *src = (pixel*)_src;
     506      161462 :     int stride = _stride>>(sizeof(pixel)-1);
     507      161462 :     const pixel4 a= AV_RN4PA(((pixel4*)(src-stride))+0);
     508      161462 :     const pixel4 b= AV_RN4PA(((pixel4*)(src-stride))+1);
     509             : 
     510     2744854 :     for(i=0; i<16; i++){
     511     2583392 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
     512     2583392 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, b);
     513             :     }
     514      161462 : }
     515             : 
     516     1452558 : static void FUNCC(pred8x8_horizontal)(uint8_t *_src, ptrdiff_t stride)
     517             : {
     518             :     int i;
     519     1452558 :     pixel *src = (pixel*)_src;
     520     1452558 :     stride >>= sizeof(pixel)-1;
     521             : 
     522    13073022 :     for(i=0; i<8; i++){
     523    11620464 :         const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
     524    11620464 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
     525    11620464 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, a);
     526             :     }
     527     1452558 : }
     528             : 
     529      297988 : static void FUNCC(pred8x16_horizontal)(uint8_t *_src, ptrdiff_t stride)
     530             : {
     531             :     int i;
     532      297988 :     pixel *src = (pixel*)_src;
     533      297988 :     stride >>= sizeof(pixel)-1;
     534     5065796 :     for(i=0; i<16; i++){
     535     4767808 :         const pixel4 a = PIXEL_SPLAT_X4(src[-1+i*stride]);
     536     4767808 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, a);
     537     4767808 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, a);
     538             :     }
     539      297988 : }
     540             : 
     541             : #define PRED8x8_X(n, v)\
     542             : static void FUNCC(pred8x8_##n##_dc)(uint8_t *_src, ptrdiff_t stride)\
     543             : {\
     544             :     int i;\
     545             :     const pixel4 a = PIXEL_SPLAT_X4(v);\
     546             :     pixel *src = (pixel*)_src;\
     547             :     stride >>= sizeof(pixel)-1;\
     548             :     for(i=0; i<8; i++){\
     549             :         AV_WN4PA(((pixel4*)(src+i*stride))+0, a);\
     550             :         AV_WN4PA(((pixel4*)(src+i*stride))+1, a);\
     551             :     }\
     552             : }
     553             : 
     554         114 : PRED8x8_X(127, (1<<(BIT_DEPTH-1))-1)
     555      128458 : PRED8x8_X(128, (1<<(BIT_DEPTH-1))+0)
     556         268 : PRED8x8_X(129, (1<<(BIT_DEPTH-1))+1)
     557             : 
     558        1538 : static void FUNCC(pred8x16_128_dc)(uint8_t *_src, ptrdiff_t stride)
     559             : {
     560        1538 :     FUNCC(pred8x8_128_dc)(_src, stride);
     561        1538 :     FUNCC(pred8x8_128_dc)(_src+8*stride, stride);
     562        1538 : }
     563             : 
     564      528644 : static void FUNCC(pred8x8_left_dc)(uint8_t *_src, ptrdiff_t stride)
     565             : {
     566             :     int i;
     567             :     int dc0, dc2;
     568             :     pixel4 dc0splat, dc2splat;
     569      528644 :     pixel *src = (pixel*)_src;
     570      528644 :     stride >>= sizeof(pixel)-1;
     571             : 
     572      528644 :     dc0=dc2=0;
     573     2643220 :     for(i=0;i<4; i++){
     574     2114576 :         dc0+= src[-1+i*stride];
     575     2114576 :         dc2+= src[-1+(i+4)*stride];
     576             :     }
     577      528644 :     dc0splat = PIXEL_SPLAT_X4((dc0 + 2)>>2);
     578      528644 :     dc2splat = PIXEL_SPLAT_X4((dc2 + 2)>>2);
     579             : 
     580     2643220 :     for(i=0; i<4; i++){
     581     2114576 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
     582     2114576 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc0splat);
     583             :     }
     584     2643220 :     for(i=4; i<8; i++){
     585     2114576 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc2splat);
     586     2114576 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc2splat);
     587             :     }
     588      528644 : }
     589             : 
     590       97770 : static void FUNCC(pred8x16_left_dc)(uint8_t *_src, ptrdiff_t stride)
     591             : {
     592       97770 :     FUNCC(pred8x8_left_dc)(_src, stride);
     593       97770 :     FUNCC(pred8x8_left_dc)(_src+8*stride, stride);
     594       97770 : }
     595             : 
     596       80626 : static void FUNCC(pred8x8_top_dc)(uint8_t *_src, ptrdiff_t stride)
     597             : {
     598             :     int i;
     599             :     int dc0, dc1;
     600             :     pixel4 dc0splat, dc1splat;
     601       80626 :     pixel *src = (pixel*)_src;
     602       80626 :     stride >>= sizeof(pixel)-1;
     603             : 
     604       80626 :     dc0=dc1=0;
     605      403130 :     for(i=0;i<4; i++){
     606      322504 :         dc0+= src[i-stride];
     607      322504 :         dc1+= src[4+i-stride];
     608             :     }
     609       80626 :     dc0splat = PIXEL_SPLAT_X4((dc0 + 2)>>2);
     610       80626 :     dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
     611             : 
     612      403130 :     for(i=0; i<4; i++){
     613      322504 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
     614      322504 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
     615             :     }
     616      403130 :     for(i=4; i<8; i++){
     617      322504 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
     618      322504 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
     619             :     }
     620       80626 : }
     621             : 
     622       13308 : static void FUNCC(pred8x16_top_dc)(uint8_t *_src, ptrdiff_t stride)
     623             : {
     624             :     int i;
     625             :     int dc0, dc1;
     626             :     pixel4 dc0splat, dc1splat;
     627       13308 :     pixel *src = (pixel*)_src;
     628       13308 :     stride >>= sizeof(pixel)-1;
     629             : 
     630       13308 :     dc0=dc1=0;
     631       66540 :     for(i=0;i<4; i++){
     632       53232 :         dc0+= src[i-stride];
     633       53232 :         dc1+= src[4+i-stride];
     634             :     }
     635       13308 :     dc0splat = PIXEL_SPLAT_X4((dc0 + 2)>>2);
     636       13308 :     dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
     637             : 
     638      226236 :     for(i=0; i<16; i++){
     639      212928 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
     640      212928 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
     641             :     }
     642       13308 : }
     643             : 
     644     2691324 : static void FUNCC(pred8x8_dc)(uint8_t *_src, ptrdiff_t stride)
     645             : {
     646             :     int i;
     647             :     int dc0, dc1, dc2;
     648             :     pixel4 dc0splat, dc1splat, dc2splat, dc3splat;
     649     2691324 :     pixel *src = (pixel*)_src;
     650     2691324 :     stride >>= sizeof(pixel)-1;
     651             : 
     652     2691324 :     dc0=dc1=dc2=0;
     653    13456620 :     for(i=0;i<4; i++){
     654    10765296 :         dc0+= src[-1+i*stride] + src[i-stride];
     655    10765296 :         dc1+= src[4+i-stride];
     656    10765296 :         dc2+= src[-1+(i+4)*stride];
     657             :     }
     658     2691324 :     dc0splat = PIXEL_SPLAT_X4((dc0 + 4)>>3);
     659     2691324 :     dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
     660     2691324 :     dc2splat = PIXEL_SPLAT_X4((dc2 + 2)>>2);
     661     2691324 :     dc3splat = PIXEL_SPLAT_X4((dc1 + dc2 + 4)>>3);
     662             : 
     663    13456620 :     for(i=0; i<4; i++){
     664    10765296 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
     665    10765296 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
     666             :     }
     667    13456620 :     for(i=4; i<8; i++){
     668    10765296 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc2splat);
     669    10765296 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc3splat);
     670             :     }
     671     2691324 : }
     672             : 
     673      797286 : static void FUNCC(pred8x16_dc)(uint8_t *_src, ptrdiff_t stride)
     674             : {
     675             :     int i;
     676             :     int dc0, dc1, dc2, dc3, dc4;
     677             :     pixel4 dc0splat, dc1splat, dc2splat, dc3splat, dc4splat, dc5splat, dc6splat, dc7splat;
     678      797286 :     pixel *src = (pixel*)_src;
     679      797286 :     stride >>= sizeof(pixel)-1;
     680             : 
     681      797286 :     dc0=dc1=dc2=dc3=dc4=0;
     682     3986430 :     for(i=0;i<4; i++){
     683     3189144 :         dc0+= src[-1+i*stride] + src[i-stride];
     684     3189144 :         dc1+= src[4+i-stride];
     685     3189144 :         dc2+= src[-1+(i+4)*stride];
     686     3189144 :         dc3+= src[-1+(i+8)*stride];
     687     3189144 :         dc4+= src[-1+(i+12)*stride];
     688             :     }
     689      797286 :     dc0splat = PIXEL_SPLAT_X4((dc0 + 4)>>3);
     690      797286 :     dc1splat = PIXEL_SPLAT_X4((dc1 + 2)>>2);
     691      797286 :     dc2splat = PIXEL_SPLAT_X4((dc2 + 2)>>2);
     692      797286 :     dc3splat = PIXEL_SPLAT_X4((dc1 + dc2 + 4)>>3);
     693      797286 :     dc4splat = PIXEL_SPLAT_X4((dc3 + 2)>>2);
     694      797286 :     dc5splat = PIXEL_SPLAT_X4((dc1 + dc3 + 4)>>3);
     695      797286 :     dc6splat = PIXEL_SPLAT_X4((dc4 + 2)>>2);
     696      797286 :     dc7splat = PIXEL_SPLAT_X4((dc1 + dc4 + 4)>>3);
     697             : 
     698     3986430 :     for(i=0; i<4; i++){
     699     3189144 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc0splat);
     700     3189144 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc1splat);
     701             :     }
     702     3986430 :     for(i=4; i<8; i++){
     703     3189144 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc2splat);
     704     3189144 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc3splat);
     705             :     }
     706     3986430 :     for(i=8; i<12; i++){
     707     3189144 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc4splat);
     708     3189144 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc5splat);
     709             :     }
     710     3986430 :     for(i=12; i<16; i++){
     711     3189144 :         AV_WN4PA(((pixel4*)(src+i*stride))+0, dc6splat);
     712     3189144 :         AV_WN4PA(((pixel4*)(src+i*stride))+1, dc7splat);
     713             :     }
     714      797286 : }
     715             : 
     716             : //the following 4 function should not be optimized!
     717          34 : static void FUNC(pred8x8_mad_cow_dc_l0t)(uint8_t *src, ptrdiff_t stride)
     718             : {
     719          34 :     FUNCC(pred8x8_top_dc)(src, stride);
     720          34 :     FUNCC(pred4x4_dc)(src, NULL, stride);
     721          34 : }
     722             : 
     723           6 : static void FUNC(pred8x16_mad_cow_dc_l0t)(uint8_t *src, ptrdiff_t stride)
     724             : {
     725           6 :     FUNCC(pred8x16_top_dc)(src, stride);
     726           6 :     FUNCC(pred4x4_dc)(src, NULL, stride);
     727           6 : }
     728             : 
     729          18 : static void FUNC(pred8x8_mad_cow_dc_0lt)(uint8_t *src, ptrdiff_t stride)
     730             : {
     731          18 :     FUNCC(pred8x8_dc)(src, stride);
     732          18 :     FUNCC(pred4x4_top_dc)(src, NULL, stride);
     733          18 : }
     734             : 
     735           6 : static void FUNC(pred8x16_mad_cow_dc_0lt)(uint8_t *src, ptrdiff_t stride)
     736             : {
     737           6 :     FUNCC(pred8x16_dc)(src, stride);
     738           6 :     FUNCC(pred4x4_top_dc)(src, NULL, stride);
     739           6 : }
     740             : 
     741          10 : static void FUNC(pred8x8_mad_cow_dc_l00)(uint8_t *src, ptrdiff_t stride)
     742             : {
     743          10 :     FUNCC(pred8x8_left_dc)(src, stride);
     744          10 :     FUNCC(pred4x4_128_dc)(src + 4*stride                  , NULL, stride);
     745          10 :     FUNCC(pred4x4_128_dc)(src + 4*stride + 4*sizeof(pixel), NULL, stride);
     746          10 : }
     747             : 
     748           6 : static void FUNC(pred8x16_mad_cow_dc_l00)(uint8_t *src, ptrdiff_t stride)
     749             : {
     750           6 :     FUNCC(pred8x16_left_dc)(src, stride);
     751           6 :     FUNCC(pred4x4_128_dc)(src + 4*stride                  , NULL, stride);
     752           6 :     FUNCC(pred4x4_128_dc)(src + 4*stride + 4*sizeof(pixel), NULL, stride);
     753           6 : }
     754             : 
     755          16 : static void FUNC(pred8x8_mad_cow_dc_0l0)(uint8_t *src, ptrdiff_t stride)
     756             : {
     757          16 :     FUNCC(pred8x8_left_dc)(src, stride);
     758          16 :     FUNCC(pred4x4_128_dc)(src                  , NULL, stride);
     759          16 :     FUNCC(pred4x4_128_dc)(src + 4*sizeof(pixel), NULL, stride);
     760          16 : }
     761             : 
     762           6 : static void FUNC(pred8x16_mad_cow_dc_0l0)(uint8_t *src, ptrdiff_t stride)
     763             : {
     764           6 :     FUNCC(pred8x16_left_dc)(src, stride);
     765           6 :     FUNCC(pred4x4_128_dc)(src                  , NULL, stride);
     766           6 :     FUNCC(pred4x4_128_dc)(src + 4*sizeof(pixel), NULL, stride);
     767           6 : }
     768             : 
     769      458198 : static void FUNCC(pred8x8_plane)(uint8_t *_src, ptrdiff_t _stride)
     770             : {
     771             :   int j, k;
     772             :   int a;
     773             :   INIT_CLIP
     774      458198 :   pixel *src = (pixel*)_src;
     775      458198 :   int stride = _stride>>(sizeof(pixel)-1);
     776      458198 :   const pixel * const src0 = src +3-stride;
     777      458198 :   const pixel *       src1 = src +4*stride-1;
     778      458198 :   const pixel *       src2 = src1-2*stride;    // == src+2*stride-1;
     779      458198 :   int H = src0[1] - src0[-1];
     780      458198 :   int V = src1[0] - src2[ 0];
     781     1832792 :   for(k=2; k<=4; ++k) {
     782     1374594 :     src1 += stride; src2 -= stride;
     783     1374594 :     H += k*(src0[k] - src0[-k]);
     784     1374594 :     V += k*(src1[0] - src2[ 0]);
     785             :   }
     786      458198 :   H = ( 17*H+16 ) >> 5;
     787      458198 :   V = ( 17*V+16 ) >> 5;
     788             : 
     789      458198 :   a = 16*(src1[0] + src2[8]+1) - 3*(V+H);
     790     4123782 :   for(j=8; j>0; --j) {
     791     3665584 :     int b = a;
     792     3665584 :     a += V;
     793     3665584 :     src[0] = CLIP((b    ) >> 5);
     794     3665584 :     src[1] = CLIP((b+  H) >> 5);
     795     3665584 :     src[2] = CLIP((b+2*H) >> 5);
     796     3665584 :     src[3] = CLIP((b+3*H) >> 5);
     797     3665584 :     src[4] = CLIP((b+4*H) >> 5);
     798     3665584 :     src[5] = CLIP((b+5*H) >> 5);
     799     3665584 :     src[6] = CLIP((b+6*H) >> 5);
     800     3665584 :     src[7] = CLIP((b+7*H) >> 5);
     801     3665584 :     src += stride;
     802             :   }
     803      458198 : }
     804             : 
     805      164288 : static void FUNCC(pred8x16_plane)(uint8_t *_src, ptrdiff_t _stride)
     806             : {
     807             :   int j, k;
     808             :   int a;
     809             :   INIT_CLIP
     810      164288 :   pixel *src = (pixel*)_src;
     811      164288 :   int stride = _stride>>(sizeof(pixel)-1);
     812      164288 :   const pixel * const src0 = src +3-stride;
     813      164288 :   const pixel *       src1 = src +8*stride-1;
     814      164288 :   const pixel *       src2 = src1-2*stride;    // == src+6*stride-1;
     815      164288 :   int H = src0[1] - src0[-1];
     816      164288 :   int V = src1[0] - src2[ 0];
     817             : 
     818      657152 :   for (k = 2; k <= 4; ++k) {
     819      492864 :       src1 += stride; src2 -= stride;
     820      492864 :       H += k*(src0[k] - src0[-k]);
     821      492864 :       V += k*(src1[0] - src2[ 0]);
     822             :   }
     823      821440 :   for (; k <= 8; ++k) {
     824      657152 :       src1 += stride; src2 -= stride;
     825      657152 :       V += k*(src1[0] - src2[0]);
     826             :   }
     827             : 
     828      164288 :   H = (17*H+16) >> 5;
     829      164288 :   V = (5*V+32) >> 6;
     830             : 
     831      164288 :   a = 16*(src1[0] + src2[8] + 1) - 7*V - 3*H;
     832     2792896 :   for(j=16; j>0; --j) {
     833     2628608 :     int b = a;
     834     2628608 :     a += V;
     835     2628608 :     src[0] = CLIP((b    ) >> 5);
     836     2628608 :     src[1] = CLIP((b+  H) >> 5);
     837     2628608 :     src[2] = CLIP((b+2*H) >> 5);
     838     2628608 :     src[3] = CLIP((b+3*H) >> 5);
     839     2628608 :     src[4] = CLIP((b+4*H) >> 5);
     840     2628608 :     src[5] = CLIP((b+5*H) >> 5);
     841     2628608 :     src[6] = CLIP((b+6*H) >> 5);
     842     2628608 :     src[7] = CLIP((b+7*H) >> 5);
     843     2628608 :     src += stride;
     844             :   }
     845      164288 : }
     846             : 
     847             : #define SRC(x,y) src[(x)+(y)*stride]
     848             : #define PL(y) \
     849             :     const int l##y = (SRC(-1,y-1) + 2*SRC(-1,y) + SRC(-1,y+1) + 2) >> 2;
     850             : #define PREDICT_8x8_LOAD_LEFT \
     851             :     const int l0 = ((has_topleft ? SRC(-1,-1) : SRC(-1,0)) \
     852             :                      + 2*SRC(-1,0) + SRC(-1,1) + 2) >> 2; \
     853             :     PL(1) PL(2) PL(3) PL(4) PL(5) PL(6) \
     854             :     const int l7 av_unused = (SRC(-1,6) + 3*SRC(-1,7) + 2) >> 2
     855             : 
     856             : #define PT(x) \
     857             :     const int t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
     858             : #define PREDICT_8x8_LOAD_TOP \
     859             :     const int t0 = ((has_topleft ? SRC(-1,-1) : SRC(0,-1)) \
     860             :                      + 2*SRC(0,-1) + SRC(1,-1) + 2) >> 2; \
     861             :     PT(1) PT(2) PT(3) PT(4) PT(5) PT(6) \
     862             :     const int t7 av_unused = ((has_topright ? SRC(8,-1) : SRC(7,-1)) \
     863             :                      + 2*SRC(7,-1) + SRC(6,-1) + 2) >> 2
     864             : 
     865             : #define PTR(x) \
     866             :     t##x = (SRC(x-1,-1) + 2*SRC(x,-1) + SRC(x+1,-1) + 2) >> 2;
     867             : #define PREDICT_8x8_LOAD_TOPRIGHT \
     868             :     int t8, t9, t10, t11, t12, t13, t14, t15; \
     869             :     if(has_topright) { \
     870             :         PTR(8) PTR(9) PTR(10) PTR(11) PTR(12) PTR(13) PTR(14) \
     871             :         t15 = (SRC(14,-1) + 3*SRC(15,-1) + 2) >> 2; \
     872             :     } else t8=t9=t10=t11=t12=t13=t14=t15= SRC(7,-1);
     873             : 
     874             : #define PREDICT_8x8_LOAD_TOPLEFT \
     875             :     const int lt = (SRC(-1,0) + 2*SRC(-1,-1) + SRC(0,-1) + 2) >> 2
     876             : 
     877             : #define PREDICT_8x8_DC(v) \
     878             :     int y; \
     879             :     for( y = 0; y < 8; y++ ) { \
     880             :         AV_WN4PA(((pixel4*)src)+0, v); \
     881             :         AV_WN4PA(((pixel4*)src)+1, v); \
     882             :         src += stride; \
     883             :     }
     884             : 
     885        1037 : static void FUNCC(pred8x8l_128_dc)(uint8_t *_src, int has_topleft,
     886             :                                    int has_topright, ptrdiff_t _stride)
     887             : {
     888        1037 :     pixel *src = (pixel*)_src;
     889        1037 :     int stride = _stride>>(sizeof(pixel)-1);
     890             : 
     891        1037 :     PREDICT_8x8_DC(PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1)));
     892        1037 : }
     893      125097 : static void FUNCC(pred8x8l_left_dc)(uint8_t *_src, int has_topleft,
     894             :                                     int has_topright, ptrdiff_t _stride)
     895             : {
     896      125097 :     pixel *src = (pixel*)_src;
     897      125097 :     int stride = _stride>>(sizeof(pixel)-1);
     898             : 
     899      125097 :     PREDICT_8x8_LOAD_LEFT;
     900      125097 :     const pixel4 dc = PIXEL_SPLAT_X4((l0+l1+l2+l3+l4+l5+l6+l7+4) >> 3);
     901      125097 :     PREDICT_8x8_DC(dc);
     902      125097 : }
     903       15066 : static void FUNCC(pred8x8l_top_dc)(uint8_t *_src, int has_topleft,
     904             :                                    int has_topright, ptrdiff_t _stride)
     905             : {
     906       15066 :     pixel *src = (pixel*)_src;
     907       15066 :     int stride = _stride>>(sizeof(pixel)-1);
     908             : 
     909       15066 :     PREDICT_8x8_LOAD_TOP;
     910       15066 :     const pixel4 dc = PIXEL_SPLAT_X4((t0+t1+t2+t3+t4+t5+t6+t7+4) >> 3);
     911       15066 :     PREDICT_8x8_DC(dc);
     912       15066 : }
     913     1630289 : static void FUNCC(pred8x8l_dc)(uint8_t *_src, int has_topleft,
     914             :                                int has_topright, ptrdiff_t _stride)
     915             : {
     916     1630289 :     pixel *src = (pixel*)_src;
     917     1630289 :     int stride = _stride>>(sizeof(pixel)-1);
     918             : 
     919     1630289 :     PREDICT_8x8_LOAD_LEFT;
     920     1630289 :     PREDICT_8x8_LOAD_TOP;
     921     1630289 :     const pixel4 dc = PIXEL_SPLAT_X4((l0+l1+l2+l3+l4+l5+l6+l7
     922             :                                      +t0+t1+t2+t3+t4+t5+t6+t7+8) >> 4);
     923     1630289 :     PREDICT_8x8_DC(dc);
     924     1630289 : }
     925     1618281 : static void FUNCC(pred8x8l_horizontal)(uint8_t *_src, int has_topleft,
     926             :                                        int has_topright, ptrdiff_t _stride)
     927             : {
     928     1618281 :     pixel *src = (pixel*)_src;
     929     1618281 :     int stride = _stride>>(sizeof(pixel)-1);
     930             :     pixel4 a;
     931             : 
     932     1618281 :     PREDICT_8x8_LOAD_LEFT;
     933             : #define ROW(y) a = PIXEL_SPLAT_X4(l##y); \
     934             :                AV_WN4PA(src+y*stride, a); \
     935             :                AV_WN4PA(src+y*stride+4, a);
     936     1618281 :     ROW(0); ROW(1); ROW(2); ROW(3); ROW(4); ROW(5); ROW(6); ROW(7);
     937             : #undef ROW
     938     1618281 : }
     939      429100 : static void FUNCC(pred8x8l_vertical)(uint8_t *_src, int has_topleft,
     940             :                                      int has_topright, ptrdiff_t _stride)
     941             : {
     942             :     int y;
     943      429100 :     pixel *src = (pixel*)_src;
     944      429100 :     int stride = _stride>>(sizeof(pixel)-1);
     945             :     pixel4 a, b;
     946             : 
     947      429100 :     PREDICT_8x8_LOAD_TOP;
     948      429100 :     src[0] = t0;
     949      429100 :     src[1] = t1;
     950      429100 :     src[2] = t2;
     951      429100 :     src[3] = t3;
     952      429100 :     src[4] = t4;
     953      429100 :     src[5] = t5;
     954      429100 :     src[6] = t6;
     955      429100 :     src[7] = t7;
     956      429100 :     a = AV_RN4PA(((pixel4*)src)+0);
     957      429100 :     b = AV_RN4PA(((pixel4*)src)+1);
     958     3432800 :     for( y = 1; y < 8; y++ ) {
     959     3003700 :         AV_WN4PA(((pixel4*)(src+y*stride))+0, a);
     960     3003700 :         AV_WN4PA(((pixel4*)(src+y*stride))+1, b);
     961             :     }
     962      429100 : }
     963      192099 : static void FUNCC(pred8x8l_down_left)(uint8_t *_src, int has_topleft,
     964             :                                       int has_topright, ptrdiff_t _stride)
     965             : {
     966      192099 :     pixel *src = (pixel*)_src;
     967      192099 :     int stride = _stride>>(sizeof(pixel)-1);
     968      192099 :     PREDICT_8x8_LOAD_TOP;
     969      192099 :     PREDICT_8x8_LOAD_TOPRIGHT;
     970      192099 :     SRC(0,0)= (t0 + 2*t1 + t2 + 2) >> 2;
     971      192099 :     SRC(0,1)=SRC(1,0)= (t1 + 2*t2 + t3 + 2) >> 2;
     972      192099 :     SRC(0,2)=SRC(1,1)=SRC(2,0)= (t2 + 2*t3 + t4 + 2) >> 2;
     973      192099 :     SRC(0,3)=SRC(1,2)=SRC(2,1)=SRC(3,0)= (t3 + 2*t4 + t5 + 2) >> 2;
     974      192099 :     SRC(0,4)=SRC(1,3)=SRC(2,2)=SRC(3,1)=SRC(4,0)= (t4 + 2*t5 + t6 + 2) >> 2;
     975      192099 :     SRC(0,5)=SRC(1,4)=SRC(2,3)=SRC(3,2)=SRC(4,1)=SRC(5,0)= (t5 + 2*t6 + t7 + 2) >> 2;
     976      192099 :     SRC(0,6)=SRC(1,5)=SRC(2,4)=SRC(3,3)=SRC(4,2)=SRC(5,1)=SRC(6,0)= (t6 + 2*t7 + t8 + 2) >> 2;
     977      192099 :     SRC(0,7)=SRC(1,6)=SRC(2,5)=SRC(3,4)=SRC(4,3)=SRC(5,2)=SRC(6,1)=SRC(7,0)= (t7 + 2*t8 + t9 + 2) >> 2;
     978      192099 :     SRC(1,7)=SRC(2,6)=SRC(3,5)=SRC(4,4)=SRC(5,3)=SRC(6,2)=SRC(7,1)= (t8 + 2*t9 + t10 + 2) >> 2;
     979      192099 :     SRC(2,7)=SRC(3,6)=SRC(4,5)=SRC(5,4)=SRC(6,3)=SRC(7,2)= (t9 + 2*t10 + t11 + 2) >> 2;
     980      192099 :     SRC(3,7)=SRC(4,6)=SRC(5,5)=SRC(6,4)=SRC(7,3)= (t10 + 2*t11 + t12 + 2) >> 2;
     981      192099 :     SRC(4,7)=SRC(5,6)=SRC(6,5)=SRC(7,4)= (t11 + 2*t12 + t13 + 2) >> 2;
     982      192099 :     SRC(5,7)=SRC(6,6)=SRC(7,5)= (t12 + 2*t13 + t14 + 2) >> 2;
     983      192099 :     SRC(6,7)=SRC(7,6)= (t13 + 2*t14 + t15 + 2) >> 2;
     984      192099 :     SRC(7,7)= (t14 + 3*t15 + 2) >> 2;
     985      192099 : }
     986      290738 : static void FUNCC(pred8x8l_down_right)(uint8_t *_src, int has_topleft,
     987             :                                        int has_topright, ptrdiff_t _stride)
     988             : {
     989      290738 :     pixel *src = (pixel*)_src;
     990      290738 :     int stride = _stride>>(sizeof(pixel)-1);
     991      290738 :     PREDICT_8x8_LOAD_TOP;
     992      290738 :     PREDICT_8x8_LOAD_LEFT;
     993      290738 :     PREDICT_8x8_LOAD_TOPLEFT;
     994      290738 :     SRC(0,7)= (l7 + 2*l6 + l5 + 2) >> 2;
     995      290738 :     SRC(0,6)=SRC(1,7)= (l6 + 2*l5 + l4 + 2) >> 2;
     996      290738 :     SRC(0,5)=SRC(1,6)=SRC(2,7)= (l5 + 2*l4 + l3 + 2) >> 2;
     997      290738 :     SRC(0,4)=SRC(1,5)=SRC(2,6)=SRC(3,7)= (l4 + 2*l3 + l2 + 2) >> 2;
     998      290738 :     SRC(0,3)=SRC(1,4)=SRC(2,5)=SRC(3,6)=SRC(4,7)= (l3 + 2*l2 + l1 + 2) >> 2;
     999      290738 :     SRC(0,2)=SRC(1,3)=SRC(2,4)=SRC(3,5)=SRC(4,6)=SRC(5,7)= (l2 + 2*l1 + l0 + 2) >> 2;
    1000      290738 :     SRC(0,1)=SRC(1,2)=SRC(2,3)=SRC(3,4)=SRC(4,5)=SRC(5,6)=SRC(6,7)= (l1 + 2*l0 + lt + 2) >> 2;
    1001      290738 :     SRC(0,0)=SRC(1,1)=SRC(2,2)=SRC(3,3)=SRC(4,4)=SRC(5,5)=SRC(6,6)=SRC(7,7)= (l0 + 2*lt + t0 + 2) >> 2;
    1002      290738 :     SRC(1,0)=SRC(2,1)=SRC(3,2)=SRC(4,3)=SRC(5,4)=SRC(6,5)=SRC(7,6)= (lt + 2*t0 + t1 + 2) >> 2;
    1003      290738 :     SRC(2,0)=SRC(3,1)=SRC(4,2)=SRC(5,3)=SRC(6,4)=SRC(7,5)= (t0 + 2*t1 + t2 + 2) >> 2;
    1004      290738 :     SRC(3,0)=SRC(4,1)=SRC(5,2)=SRC(6,3)=SRC(7,4)= (t1 + 2*t2 + t3 + 2) >> 2;
    1005      290738 :     SRC(4,0)=SRC(5,1)=SRC(6,2)=SRC(7,3)= (t2 + 2*t3 + t4 + 2) >> 2;
    1006      290738 :     SRC(5,0)=SRC(6,1)=SRC(7,2)= (t3 + 2*t4 + t5 + 2) >> 2;
    1007      290738 :     SRC(6,0)=SRC(7,1)= (t4 + 2*t5 + t6 + 2) >> 2;
    1008      290738 :     SRC(7,0)= (t5 + 2*t6 + t7 + 2) >> 2;
    1009      290738 : }
    1010      193840 : static void FUNCC(pred8x8l_vertical_right)(uint8_t *_src, int has_topleft,
    1011             :                                            int has_topright, ptrdiff_t _stride)
    1012             : {
    1013      193840 :     pixel *src = (pixel*)_src;
    1014      193840 :     int stride = _stride>>(sizeof(pixel)-1);
    1015      193840 :     PREDICT_8x8_LOAD_TOP;
    1016      193840 :     PREDICT_8x8_LOAD_LEFT;
    1017      193840 :     PREDICT_8x8_LOAD_TOPLEFT;
    1018      193840 :     SRC(0,6)= (l5 + 2*l4 + l3 + 2) >> 2;
    1019      193840 :     SRC(0,7)= (l6 + 2*l5 + l4 + 2) >> 2;
    1020      193840 :     SRC(0,4)=SRC(1,6)= (l3 + 2*l2 + l1 + 2) >> 2;
    1021      193840 :     SRC(0,5)=SRC(1,7)= (l4 + 2*l3 + l2 + 2) >> 2;
    1022      193840 :     SRC(0,2)=SRC(1,4)=SRC(2,6)= (l1 + 2*l0 + lt + 2) >> 2;
    1023      193840 :     SRC(0,3)=SRC(1,5)=SRC(2,7)= (l2 + 2*l1 + l0 + 2) >> 2;
    1024      193840 :     SRC(0,1)=SRC(1,3)=SRC(2,5)=SRC(3,7)= (l0 + 2*lt + t0 + 2) >> 2;
    1025      193840 :     SRC(0,0)=SRC(1,2)=SRC(2,4)=SRC(3,6)= (lt + t0 + 1) >> 1;
    1026      193840 :     SRC(1,1)=SRC(2,3)=SRC(3,5)=SRC(4,7)= (lt + 2*t0 + t1 + 2) >> 2;
    1027      193840 :     SRC(1,0)=SRC(2,2)=SRC(3,4)=SRC(4,6)= (t0 + t1 + 1) >> 1;
    1028      193840 :     SRC(2,1)=SRC(3,3)=SRC(4,5)=SRC(5,7)= (t0 + 2*t1 + t2 + 2) >> 2;
    1029      193840 :     SRC(2,0)=SRC(3,2)=SRC(4,4)=SRC(5,6)= (t1 + t2 + 1) >> 1;
    1030      193840 :     SRC(3,1)=SRC(4,3)=SRC(5,5)=SRC(6,7)= (t1 + 2*t2 + t3 + 2) >> 2;
    1031      193840 :     SRC(3,0)=SRC(4,2)=SRC(5,4)=SRC(6,6)= (t2 + t3 + 1) >> 1;
    1032      193840 :     SRC(4,1)=SRC(5,3)=SRC(6,5)=SRC(7,7)= (t2 + 2*t3 + t4 + 2) >> 2;
    1033      193840 :     SRC(4,0)=SRC(5,2)=SRC(6,4)=SRC(7,6)= (t3 + t4 + 1) >> 1;
    1034      193840 :     SRC(5,1)=SRC(6,3)=SRC(7,5)= (t3 + 2*t4 + t5 + 2) >> 2;
    1035      193840 :     SRC(5,0)=SRC(6,2)=SRC(7,4)= (t4 + t5 + 1) >> 1;
    1036      193840 :     SRC(6,1)=SRC(7,3)= (t4 + 2*t5 + t6 + 2) >> 2;
    1037      193840 :     SRC(6,0)=SRC(7,2)= (t5 + t6 + 1) >> 1;
    1038      193840 :     SRC(7,1)= (t5 + 2*t6 + t7 + 2) >> 2;
    1039      193840 :     SRC(7,0)= (t6 + t7 + 1) >> 1;
    1040      193840 : }
    1041      445522 : static void FUNCC(pred8x8l_horizontal_down)(uint8_t *_src, int has_topleft,
    1042             :                                             int has_topright, ptrdiff_t _stride)
    1043             : {
    1044      445522 :     pixel *src = (pixel*)_src;
    1045      445522 :     int stride = _stride>>(sizeof(pixel)-1);
    1046      445522 :     PREDICT_8x8_LOAD_TOP;
    1047      445522 :     PREDICT_8x8_LOAD_LEFT;
    1048      445522 :     PREDICT_8x8_LOAD_TOPLEFT;
    1049      445522 :     SRC(0,7)= (l6 + l7 + 1) >> 1;
    1050      445522 :     SRC(1,7)= (l5 + 2*l6 + l7 + 2) >> 2;
    1051      445522 :     SRC(0,6)=SRC(2,7)= (l5 + l6 + 1) >> 1;
    1052      445522 :     SRC(1,6)=SRC(3,7)= (l4 + 2*l5 + l6 + 2) >> 2;
    1053      445522 :     SRC(0,5)=SRC(2,6)=SRC(4,7)= (l4 + l5 + 1) >> 1;
    1054      445522 :     SRC(1,5)=SRC(3,6)=SRC(5,7)= (l3 + 2*l4 + l5 + 2) >> 2;
    1055      445522 :     SRC(0,4)=SRC(2,5)=SRC(4,6)=SRC(6,7)= (l3 + l4 + 1) >> 1;
    1056      445522 :     SRC(1,4)=SRC(3,5)=SRC(5,6)=SRC(7,7)= (l2 + 2*l3 + l4 + 2) >> 2;
    1057      445522 :     SRC(0,3)=SRC(2,4)=SRC(4,5)=SRC(6,6)= (l2 + l3 + 1) >> 1;
    1058      445522 :     SRC(1,3)=SRC(3,4)=SRC(5,5)=SRC(7,6)= (l1 + 2*l2 + l3 + 2) >> 2;
    1059      445522 :     SRC(0,2)=SRC(2,3)=SRC(4,4)=SRC(6,5)= (l1 + l2 + 1) >> 1;
    1060      445522 :     SRC(1,2)=SRC(3,3)=SRC(5,4)=SRC(7,5)= (l0 + 2*l1 + l2 + 2) >> 2;
    1061      445522 :     SRC(0,1)=SRC(2,2)=SRC(4,3)=SRC(6,4)= (l0 + l1 + 1) >> 1;
    1062      445522 :     SRC(1,1)=SRC(3,2)=SRC(5,3)=SRC(7,4)= (lt + 2*l0 + l1 + 2) >> 2;
    1063      445522 :     SRC(0,0)=SRC(2,1)=SRC(4,2)=SRC(6,3)= (lt + l0 + 1) >> 1;
    1064      445522 :     SRC(1,0)=SRC(3,1)=SRC(5,2)=SRC(7,3)= (l0 + 2*lt + t0 + 2) >> 2;
    1065      445522 :     SRC(2,0)=SRC(4,1)=SRC(6,2)= (t1 + 2*t0 + lt + 2) >> 2;
    1066      445522 :     SRC(3,0)=SRC(5,1)=SRC(7,2)= (t2 + 2*t1 + t0 + 2) >> 2;
    1067      445522 :     SRC(4,0)=SRC(6,1)= (t3 + 2*t2 + t1 + 2) >> 2;
    1068      445522 :     SRC(5,0)=SRC(7,1)= (t4 + 2*t3 + t2 + 2) >> 2;
    1069      445522 :     SRC(6,0)= (t5 + 2*t4 + t3 + 2) >> 2;
    1070      445522 :     SRC(7,0)= (t6 + 2*t5 + t4 + 2) >> 2;
    1071      445522 : }
    1072      195238 : static void FUNCC(pred8x8l_vertical_left)(uint8_t *_src, int has_topleft,
    1073             :                                           int has_topright, ptrdiff_t _stride)
    1074             : {
    1075      195238 :     pixel *src = (pixel*)_src;
    1076      195238 :     int stride = _stride>>(sizeof(pixel)-1);
    1077      195238 :     PREDICT_8x8_LOAD_TOP;
    1078      195238 :     PREDICT_8x8_LOAD_TOPRIGHT;
    1079      195238 :     SRC(0,0)= (t0 + t1 + 1) >> 1;
    1080      195238 :     SRC(0,1)= (t0 + 2*t1 + t2 + 2) >> 2;
    1081      195238 :     SRC(0,2)=SRC(1,0)= (t1 + t2 + 1) >> 1;
    1082      195238 :     SRC(0,3)=SRC(1,1)= (t1 + 2*t2 + t3 + 2) >> 2;
    1083      195238 :     SRC(0,4)=SRC(1,2)=SRC(2,0)= (t2 + t3 + 1) >> 1;
    1084      195238 :     SRC(0,5)=SRC(1,3)=SRC(2,1)= (t2 + 2*t3 + t4 + 2) >> 2;
    1085      195238 :     SRC(0,6)=SRC(1,4)=SRC(2,2)=SRC(3,0)= (t3 + t4 + 1) >> 1;
    1086      195238 :     SRC(0,7)=SRC(1,5)=SRC(2,3)=SRC(3,1)= (t3 + 2*t4 + t5 + 2) >> 2;
    1087      195238 :     SRC(1,6)=SRC(2,4)=SRC(3,2)=SRC(4,0)= (t4 + t5 + 1) >> 1;
    1088      195238 :     SRC(1,7)=SRC(2,5)=SRC(3,3)=SRC(4,1)= (t4 + 2*t5 + t6 + 2) >> 2;
    1089      195238 :     SRC(2,6)=SRC(3,4)=SRC(4,2)=SRC(5,0)= (t5 + t6 + 1) >> 1;
    1090      195238 :     SRC(2,7)=SRC(3,5)=SRC(4,3)=SRC(5,1)= (t5 + 2*t6 + t7 + 2) >> 2;
    1091      195238 :     SRC(3,6)=SRC(4,4)=SRC(5,2)=SRC(6,0)= (t6 + t7 + 1) >> 1;
    1092      195238 :     SRC(3,7)=SRC(4,5)=SRC(5,3)=SRC(6,1)= (t6 + 2*t7 + t8 + 2) >> 2;
    1093      195238 :     SRC(4,6)=SRC(5,4)=SRC(6,2)=SRC(7,0)= (t7 + t8 + 1) >> 1;
    1094      195238 :     SRC(4,7)=SRC(5,5)=SRC(6,3)=SRC(7,1)= (t7 + 2*t8 + t9 + 2) >> 2;
    1095      195238 :     SRC(5,6)=SRC(6,4)=SRC(7,2)= (t8 + t9 + 1) >> 1;
    1096      195238 :     SRC(5,7)=SRC(6,5)=SRC(7,3)= (t8 + 2*t9 + t10 + 2) >> 2;
    1097      195238 :     SRC(6,6)=SRC(7,4)= (t9 + t10 + 1) >> 1;
    1098      195238 :     SRC(6,7)=SRC(7,5)= (t9 + 2*t10 + t11 + 2) >> 2;
    1099      195238 :     SRC(7,6)= (t10 + t11 + 1) >> 1;
    1100      195238 :     SRC(7,7)= (t10 + 2*t11 + t12 + 2) >> 2;
    1101      195238 : }
    1102      545629 : static void FUNCC(pred8x8l_horizontal_up)(uint8_t *_src, int has_topleft,
    1103             :                                           int has_topright, ptrdiff_t _stride)
    1104             : {
    1105      545629 :     pixel *src = (pixel*)_src;
    1106      545629 :     int stride = _stride>>(sizeof(pixel)-1);
    1107      545629 :     PREDICT_8x8_LOAD_LEFT;
    1108      545629 :     SRC(0,0)= (l0 + l1 + 1) >> 1;
    1109      545629 :     SRC(1,0)= (l0 + 2*l1 + l2 + 2) >> 2;
    1110      545629 :     SRC(0,1)=SRC(2,0)= (l1 + l2 + 1) >> 1;
    1111      545629 :     SRC(1,1)=SRC(3,0)= (l1 + 2*l2 + l3 + 2) >> 2;
    1112      545629 :     SRC(0,2)=SRC(2,1)=SRC(4,0)= (l2 + l3 + 1) >> 1;
    1113      545629 :     SRC(1,2)=SRC(3,1)=SRC(5,0)= (l2 + 2*l3 + l4 + 2) >> 2;
    1114      545629 :     SRC(0,3)=SRC(2,2)=SRC(4,1)=SRC(6,0)= (l3 + l4 + 1) >> 1;
    1115      545629 :     SRC(1,3)=SRC(3,2)=SRC(5,1)=SRC(7,0)= (l3 + 2*l4 + l5 + 2) >> 2;
    1116      545629 :     SRC(0,4)=SRC(2,3)=SRC(4,2)=SRC(6,1)= (l4 + l5 + 1) >> 1;
    1117      545629 :     SRC(1,4)=SRC(3,3)=SRC(5,2)=SRC(7,1)= (l4 + 2*l5 + l6 + 2) >> 2;
    1118      545629 :     SRC(0,5)=SRC(2,4)=SRC(4,3)=SRC(6,2)= (l5 + l6 + 1) >> 1;
    1119      545629 :     SRC(1,5)=SRC(3,4)=SRC(5,3)=SRC(7,2)= (l5 + 2*l6 + l7 + 2) >> 2;
    1120      545629 :     SRC(0,6)=SRC(2,5)=SRC(4,4)=SRC(6,3)= (l6 + l7 + 1) >> 1;
    1121      545629 :     SRC(1,6)=SRC(3,5)=SRC(5,4)=SRC(7,3)= (l6 + 3*l7 + 2) >> 2;
    1122     1091258 :     SRC(0,7)=SRC(1,7)=SRC(2,6)=SRC(2,7)=SRC(3,6)=
    1123     1636887 :     SRC(3,7)=SRC(4,5)=SRC(4,6)=SRC(4,7)=SRC(5,5)=
    1124     1636887 :     SRC(5,6)=SRC(5,7)=SRC(6,4)=SRC(6,5)=SRC(6,6)=
    1125     1091258 :     SRC(6,7)=SRC(7,4)=SRC(7,5)=SRC(7,6)=SRC(7,7)= l7;
    1126      545629 : }
    1127             : 
    1128           0 : static void FUNCC(pred8x8l_vertical_filter_add)(uint8_t *_src, int16_t *_block, int has_topleft,
    1129             :                                      int has_topright, ptrdiff_t _stride)
    1130             : {
    1131             :     int i;
    1132           0 :     pixel *src = (pixel*)_src;
    1133           0 :     const dctcoef *block = (const dctcoef*)_block;
    1134             :     pixel pix[8];
    1135           0 :     int stride = _stride>>(sizeof(pixel)-1);
    1136           0 :     PREDICT_8x8_LOAD_TOP;
    1137             : 
    1138           0 :     pix[0] = t0;
    1139           0 :     pix[1] = t1;
    1140           0 :     pix[2] = t2;
    1141           0 :     pix[3] = t3;
    1142           0 :     pix[4] = t4;
    1143           0 :     pix[5] = t5;
    1144           0 :     pix[6] = t6;
    1145           0 :     pix[7] = t7;
    1146             : 
    1147           0 :     for(i=0; i<8; i++){
    1148           0 :         pixel v = pix[i];
    1149           0 :         src[0*stride]= v += block[0];
    1150           0 :         src[1*stride]= v += block[8];
    1151           0 :         src[2*stride]= v += block[16];
    1152           0 :         src[3*stride]= v += block[24];
    1153           0 :         src[4*stride]= v += block[32];
    1154           0 :         src[5*stride]= v += block[40];
    1155           0 :         src[6*stride]= v += block[48];
    1156           0 :         src[7*stride]= v +  block[56];
    1157           0 :         src++;
    1158           0 :         block++;
    1159             :     }
    1160             : 
    1161           0 :     memset(_block, 0, sizeof(dctcoef) * 64);
    1162           0 : }
    1163             : 
    1164           0 : static void FUNCC(pred8x8l_horizontal_filter_add)(uint8_t *_src, int16_t *_block, int has_topleft,
    1165             :                                int has_topright, ptrdiff_t _stride)
    1166             : {
    1167             :     int i;
    1168           0 :     pixel *src = (pixel*)_src;
    1169           0 :     const dctcoef *block = (const dctcoef*)_block;
    1170             :     pixel pix[8];
    1171           0 :     int stride = _stride>>(sizeof(pixel)-1);
    1172           0 :     PREDICT_8x8_LOAD_LEFT;
    1173             : 
    1174           0 :     pix[0] = l0;
    1175           0 :     pix[1] = l1;
    1176           0 :     pix[2] = l2;
    1177           0 :     pix[3] = l3;
    1178           0 :     pix[4] = l4;
    1179           0 :     pix[5] = l5;
    1180           0 :     pix[6] = l6;
    1181           0 :     pix[7] = l7;
    1182             : 
    1183           0 :     for(i=0; i<8; i++){
    1184           0 :         pixel v = pix[i];
    1185           0 :         src[0]= v += block[0];
    1186           0 :         src[1]= v += block[1];
    1187           0 :         src[2]= v += block[2];
    1188           0 :         src[3]= v += block[3];
    1189           0 :         src[4]= v += block[4];
    1190           0 :         src[5]= v += block[5];
    1191           0 :         src[6]= v += block[6];
    1192           0 :         src[7]= v +  block[7];
    1193           0 :         src+= stride;
    1194           0 :         block+= 8;
    1195             :     }
    1196             : 
    1197           0 :     memset(_block, 0, sizeof(dctcoef) * 64);
    1198           0 : }
    1199             : 
    1200             : #undef PREDICT_8x8_LOAD_LEFT
    1201             : #undef PREDICT_8x8_LOAD_TOP
    1202             : #undef PREDICT_8x8_LOAD_TOPLEFT
    1203             : #undef PREDICT_8x8_LOAD_TOPRIGHT
    1204             : #undef PREDICT_8x8_DC
    1205             : #undef PTR
    1206             : #undef PT
    1207             : #undef PL
    1208             : #undef SRC
    1209             : 
    1210       80320 : static void FUNCC(pred4x4_vertical_add)(uint8_t *_pix, int16_t *_block,
    1211             :                                         ptrdiff_t stride)
    1212             : {
    1213             :     int i;
    1214       80320 :     pixel *pix = (pixel*)_pix;
    1215       80320 :     const dctcoef *block = (const dctcoef*)_block;
    1216       80320 :     stride >>= sizeof(pixel)-1;
    1217       80320 :     pix -= stride;
    1218      401600 :     for(i=0; i<4; i++){
    1219      321280 :         pixel v = pix[0];
    1220      321280 :         pix[1*stride]= v += block[0];
    1221      321280 :         pix[2*stride]= v += block[4];
    1222      321280 :         pix[3*stride]= v += block[8];
    1223      321280 :         pix[4*stride]= v +  block[12];
    1224      321280 :         pix++;
    1225      321280 :         block++;
    1226             :     }
    1227             : 
    1228       80320 :     memset(_block, 0, sizeof(dctcoef) * 16);
    1229       80320 : }
    1230             : 
    1231      104227 : static void FUNCC(pred4x4_horizontal_add)(uint8_t *_pix, int16_t *_block,
    1232             :                                           ptrdiff_t stride)
    1233             : {
    1234             :     int i;
    1235      104227 :     pixel *pix = (pixel*)_pix;
    1236      104227 :     const dctcoef *block = (const dctcoef*)_block;
    1237      104227 :     stride >>= sizeof(pixel)-1;
    1238      521135 :     for(i=0; i<4; i++){
    1239      416908 :         pixel v = pix[-1];
    1240      416908 :         pix[0]= v += block[0];
    1241      416908 :         pix[1]= v += block[1];
    1242      416908 :         pix[2]= v += block[2];
    1243      416908 :         pix[3]= v +  block[3];
    1244      416908 :         pix+= stride;
    1245      416908 :         block+= 4;
    1246             :     }
    1247             : 
    1248      104227 :     memset(_block, 0, sizeof(dctcoef) * 16);
    1249      104227 : }
    1250             : 
    1251        1074 : static void FUNCC(pred8x8l_vertical_add)(uint8_t *_pix, int16_t *_block,
    1252             :                                          ptrdiff_t stride)
    1253             : {
    1254             :     int i;
    1255        1074 :     pixel *pix = (pixel*)_pix;
    1256        1074 :     const dctcoef *block = (const dctcoef*)_block;
    1257        1074 :     stride >>= sizeof(pixel)-1;
    1258        1074 :     pix -= stride;
    1259        9666 :     for(i=0; i<8; i++){
    1260        8592 :         pixel v = pix[0];
    1261        8592 :         pix[1*stride]= v += block[0];
    1262        8592 :         pix[2*stride]= v += block[8];
    1263        8592 :         pix[3*stride]= v += block[16];
    1264        8592 :         pix[4*stride]= v += block[24];
    1265        8592 :         pix[5*stride]= v += block[32];
    1266        8592 :         pix[6*stride]= v += block[40];
    1267        8592 :         pix[7*stride]= v += block[48];
    1268        8592 :         pix[8*stride]= v +  block[56];
    1269        8592 :         pix++;
    1270        8592 :         block++;
    1271             :     }
    1272             : 
    1273        1074 :     memset(_block, 0, sizeof(dctcoef) * 64);
    1274        1074 : }
    1275             : 
    1276        1414 : static void FUNCC(pred8x8l_horizontal_add)(uint8_t *_pix, int16_t *_block,
    1277             :                                            ptrdiff_t stride)
    1278             : {
    1279             :     int i;
    1280        1414 :     pixel *pix = (pixel*)_pix;
    1281        1414 :     const dctcoef *block = (const dctcoef*)_block;
    1282        1414 :     stride >>= sizeof(pixel)-1;
    1283       12726 :     for(i=0; i<8; i++){
    1284       11312 :         pixel v = pix[-1];
    1285       11312 :         pix[0]= v += block[0];
    1286       11312 :         pix[1]= v += block[1];
    1287       11312 :         pix[2]= v += block[2];
    1288       11312 :         pix[3]= v += block[3];
    1289       11312 :         pix[4]= v += block[4];
    1290       11312 :         pix[5]= v += block[5];
    1291       11312 :         pix[6]= v += block[6];
    1292       11312 :         pix[7]= v +  block[7];
    1293       11312 :         pix+= stride;
    1294       11312 :         block+= 8;
    1295             :     }
    1296             : 
    1297        1414 :     memset(_block, 0, sizeof(dctcoef) * 64);
    1298        1414 : }
    1299             : 
    1300         353 : static void FUNCC(pred16x16_vertical_add)(uint8_t *pix, const int *block_offset,
    1301             :                                           int16_t *block,
    1302             :                                           ptrdiff_t stride)
    1303             : {
    1304             :     int i;
    1305        6001 :     for(i=0; i<16; i++)
    1306        5648 :         FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
    1307         353 : }
    1308             : 
    1309         272 : static void FUNCC(pred16x16_horizontal_add)(uint8_t *pix,
    1310             :                                             const int *block_offset,
    1311             :                                             int16_t *block,
    1312             :                                             ptrdiff_t stride)
    1313             : {
    1314             :     int i;
    1315        4624 :     for(i=0; i<16; i++)
    1316        4352 :         FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
    1317         272 : }
    1318             : 
    1319        2258 : static void FUNCC(pred8x8_vertical_add)(uint8_t *pix, const int *block_offset,
    1320             :                                         int16_t *block, ptrdiff_t stride)
    1321             : {
    1322             :     int i;
    1323       11290 :     for(i=0; i<4; i++)
    1324        9032 :         FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
    1325        2258 : }
    1326             : 
    1327           0 : static void FUNCC(pred8x16_vertical_add)(uint8_t *pix, const int *block_offset,
    1328             :                                          int16_t *block, ptrdiff_t stride)
    1329             : {
    1330             :     int i;
    1331           0 :     for(i=0; i<4; i++)
    1332           0 :         FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
    1333           0 :     for(i=4; i<8; i++)
    1334           0 :         FUNCC(pred4x4_vertical_add)(pix + block_offset[i+4], block + i*16*sizeof(pixel), stride);
    1335           0 : }
    1336             : 
    1337        2888 : static void FUNCC(pred8x8_horizontal_add)(uint8_t *pix, const int *block_offset,
    1338             :                                           int16_t *block,
    1339             :                                           ptrdiff_t stride)
    1340             : {
    1341             :     int i;
    1342       14440 :     for(i=0; i<4; i++)
    1343       11552 :         FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
    1344        2888 : }
    1345             : 
    1346           0 : static void FUNCC(pred8x16_horizontal_add)(uint8_t *pix,
    1347             :                                            const int *block_offset,
    1348             :                                            int16_t *block, ptrdiff_t stride)
    1349             : {
    1350             :     int i;
    1351           0 :     for(i=0; i<4; i++)
    1352           0 :         FUNCC(pred4x4_horizontal_add)(pix + block_offset[i], block + i*16*sizeof(pixel), stride);
    1353           0 :     for(i=4; i<8; i++)
    1354           0 :         FUNCC(pred4x4_horizontal_add)(pix + block_offset[i+4], block + i*16*sizeof(pixel), stride);
    1355           0 : }

Generated by: LCOV version 1.13