LCOV - code coverage report
Current view: top level - libavcodec - hevcdsp_template.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 886 886 100.0 %
Date: 2017-12-12 11:08:38 Functions: 183 248 73.8 %

          Line data    Source code
       1             : /*
       2             :  * HEVC video decoder
       3             :  *
       4             :  * Copyright (C) 2012 - 2013 Guillaume Martres
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : #include "get_bits.h"
      24             : #include "hevcdec.h"
      25             : 
      26             : #include "bit_depth_template.c"
      27             : #include "hevcdsp.h"
      28             : 
      29       37299 : static void FUNC(put_pcm)(uint8_t *_dst, ptrdiff_t stride, int width, int height,
      30             :                           GetBitContext *gb, int pcm_bit_depth)
      31             : {
      32             :     int x, y;
      33       37299 :     pixel *dst = (pixel *)_dst;
      34             : 
      35       37299 :     stride /= sizeof(pixel);
      36             : 
      37      364723 :     for (y = 0; y < height; y++) {
      38     4709504 :         for (x = 0; x < width; x++)
      39     4382080 :             dst[x] = get_bits(gb, pcm_bit_depth) << (BIT_DEPTH - pcm_bit_depth);
      40      327424 :         dst += stride;
      41             :     }
      42       37299 : }
      43             : 
      44    13520410 : static av_always_inline void FUNC(add_residual)(uint8_t *_dst, int16_t *res,
      45             :                                                 ptrdiff_t stride, int size)
      46             : {
      47             :     int x, y;
      48    13520410 :     pixel *dst = (pixel *)_dst;
      49             : 
      50    13520410 :     stride /= sizeof(pixel);
      51             : 
      52   116253122 :     for (y = 0; y < size; y++) {
      53  1430868584 :         for (x = 0; x < size; x++) {
      54  1328135872 :             dst[x] = av_clip_pixel(dst[x] + *res);
      55  1328135872 :             res++;
      56             :         }
      57   102732712 :         dst += stride;
      58             :     }
      59    13520410 : }
      60             : 
      61     7884576 : static void FUNC(add_residual4x4)(uint8_t *_dst, int16_t *res,
      62             :                                   ptrdiff_t stride)
      63             : {
      64     7884576 :     FUNC(add_residual)(_dst, res, stride, 4);
      65     7884576 : }
      66             : 
      67     3490615 : static void FUNC(add_residual8x8)(uint8_t *_dst, int16_t *res,
      68             :                                   ptrdiff_t stride)
      69             : {
      70     3490615 :     FUNC(add_residual)(_dst, res, stride, 8);
      71     3490615 : }
      72             : 
      73     1586095 : static void FUNC(add_residual16x16)(uint8_t *_dst, int16_t *res,
      74             :                                     ptrdiff_t stride)
      75             : {
      76     1586095 :     FUNC(add_residual)(_dst, res, stride, 16);
      77     1586095 : }
      78             : 
      79      559124 : static void FUNC(add_residual32x32)(uint8_t *_dst, int16_t *res,
      80             :                                     ptrdiff_t stride)
      81             : {
      82      559124 :     FUNC(add_residual)(_dst, res, stride, 32);
      83      559124 : }
      84             : 
      85       18976 : static void FUNC(transform_rdpcm)(int16_t *_coeffs, int16_t log2_size, int mode)
      86             : {
      87       18976 :     int16_t *coeffs = (int16_t *) _coeffs;
      88             :     int x, y;
      89       18976 :     int size = 1 << log2_size;
      90             : 
      91       18976 :     if (mode) {
      92        7839 :         coeffs += size;
      93       57324 :         for (y = 0; y < size - 1; y++) {
      94      542673 :             for (x = 0; x < size; x++)
      95      493188 :                 coeffs[x] += coeffs[x - size];
      96       49485 :             coeffs += size;
      97             :         }
      98             :     } else {
      99       98049 :         for (y = 0; y < size; y++) {
     100      914368 :             for (x = 1; x < size; x++)
     101      827456 :                 coeffs[x] += coeffs[x - 1];
     102       86912 :             coeffs += size;
     103             :         }
     104             :     }
     105       18976 : }
     106             : 
     107      415305 : static void FUNC(dequant)(int16_t *coeffs, int16_t log2_size)
     108             : {
     109      415305 :     int shift  = 15 - BIT_DEPTH - log2_size;
     110             :     int x, y;
     111      415305 :     int size = 1 << log2_size;
     112             : 
     113      415305 :     if (shift > 0) {
     114      410662 :         int offset = 1 << (shift - 1);
     115     2127022 :         for (y = 0; y < size; y++) {
     116     9604744 :             for (x = 0; x < size; x++) {
     117     7888384 :                 *coeffs = (*coeffs + offset) >> shift;
     118     7888384 :                 coeffs++;
     119             :             }
     120             :         }
     121             :     } else {
     122       42139 :         for (y = 0; y < size; y++) {
     123      344248 :             for (x = 0; x < size; x++) {
     124      306752 :                 *coeffs = *coeffs << -shift;
     125      306752 :                 coeffs++;
     126             :             }
     127             :         }
     128             :     }
     129      415305 : }
     130             : 
     131             : #define SET(dst, x)   (dst) = (x)
     132             : #define SCALE(dst, x) (dst) = av_clip_int16(((x) + add) >> shift)
     133             : 
     134             : #define TR_4x4_LUMA(dst, src, step, assign)                             \
     135             :     do {                                                                \
     136             :         int c0 = src[0 * step] + src[2 * step];                         \
     137             :         int c1 = src[2 * step] + src[3 * step];                         \
     138             :         int c2 = src[0 * step] - src[3 * step];                         \
     139             :         int c3 = 74 * src[1 * step];                                    \
     140             :                                                                         \
     141             :         assign(dst[2 * step], 74 * (src[0 * step] -                     \
     142             :                                     src[2 * step] +                     \
     143             :                                     src[3 * step]));                    \
     144             :         assign(dst[0 * step], 29 * c0 + 55 * c1 + c3);                  \
     145             :         assign(dst[1 * step], 55 * c2 - 29 * c1 + c3);                  \
     146             :         assign(dst[3 * step], 55 * c0 + 29 * c2 - c3);                  \
     147             :     } while (0)
     148             : 
     149     3490771 : static void FUNC(transform_4x4_luma)(int16_t *coeffs)
     150             : {
     151             :     int i;
     152     3490771 :     int shift    = 7;
     153     3490771 :     int add      = 1 << (shift - 1);
     154     3490771 :     int16_t *src = coeffs;
     155             : 
     156    17453855 :     for (i = 0; i < 4; i++) {
     157    13963084 :         TR_4x4_LUMA(src, src, 4, SCALE);
     158    13963084 :         src++;
     159             :     }
     160             : 
     161     3490771 :     shift = 20 - BIT_DEPTH;
     162     3490771 :     add   = 1 << (shift - 1);
     163    17453855 :     for (i = 0; i < 4; i++) {
     164    13963084 :         TR_4x4_LUMA(coeffs, coeffs, 1, SCALE);
     165    13963084 :         coeffs += 4;
     166             :     }
     167     3490771 : }
     168             : 
     169             : #undef TR_4x4_LUMA
     170             : 
     171             : #define TR_4(dst, src, dstep, sstep, assign, end)                 \
     172             :     do {                                                          \
     173             :         const int e0 = 64 * src[0 * sstep] + 64 * src[2 * sstep]; \
     174             :         const int e1 = 64 * src[0 * sstep] - 64 * src[2 * sstep]; \
     175             :         const int o0 = 83 * src[1 * sstep] + 36 * src[3 * sstep]; \
     176             :         const int o1 = 36 * src[1 * sstep] - 83 * src[3 * sstep]; \
     177             :                                                                   \
     178             :         assign(dst[0 * dstep], e0 + o0);                          \
     179             :         assign(dst[1 * dstep], e1 + o1);                          \
     180             :         assign(dst[2 * dstep], e1 - o1);                          \
     181             :         assign(dst[3 * dstep], e0 - o0);                          \
     182             :     } while (0)
     183             : 
     184             : #define TR_8(dst, src, dstep, sstep, assign, end)                 \
     185             :     do {                                                          \
     186             :         int i, j;                                                 \
     187             :         int e_8[4];                                               \
     188             :         int o_8[4] = { 0 };                                       \
     189             :         for (i = 0; i < 4; i++)                                   \
     190             :             for (j = 1; j < end; j += 2)                          \
     191             :                 o_8[i] += transform[4 * j][i] * src[j * sstep];   \
     192             :         TR_4(e_8, src, 1, 2 * sstep, SET, 4);                     \
     193             :                                                                   \
     194             :         for (i = 0; i < 4; i++) {                                 \
     195             :             assign(dst[i * dstep], e_8[i] + o_8[i]);              \
     196             :             assign(dst[(7 - i) * dstep], e_8[i] - o_8[i]);        \
     197             :         }                                                         \
     198             :     } while (0)
     199             : 
     200             : #define TR_16(dst, src, dstep, sstep, assign, end)                \
     201             :     do {                                                          \
     202             :         int i, j;                                                 \
     203             :         int e_16[8];                                              \
     204             :         int o_16[8] = { 0 };                                      \
     205             :         for (i = 0; i < 8; i++)                                   \
     206             :             for (j = 1; j < end; j += 2)                          \
     207             :                 o_16[i] += transform[2 * j][i] * src[j * sstep];  \
     208             :         TR_8(e_16, src, 1, 2 * sstep, SET, 8);                    \
     209             :                                                                   \
     210             :         for (i = 0; i < 8; i++) {                                 \
     211             :             assign(dst[i * dstep], e_16[i] + o_16[i]);            \
     212             :             assign(dst[(15 - i) * dstep], e_16[i] - o_16[i]);     \
     213             :         }                                                         \
     214             :     } while (0)
     215             : 
     216             : #define TR_32(dst, src, dstep, sstep, assign, end)                \
     217             :     do {                                                          \
     218             :         int i, j;                                                 \
     219             :         int e_32[16];                                             \
     220             :         int o_32[16] = { 0 };                                     \
     221             :         for (i = 0; i < 16; i++)                                  \
     222             :             for (j = 1; j < end; j += 2)                          \
     223             :                 o_32[i] += transform[j][i] * src[j * sstep];      \
     224             :         TR_16(e_32, src, 1, 2 * sstep, SET, end / 2);             \
     225             :                                                                   \
     226             :         for (i = 0; i < 16; i++) {                                \
     227             :             assign(dst[i * dstep], e_32[i] + o_32[i]);            \
     228             :             assign(dst[(31 - i) * dstep], e_32[i] - o_32[i]);     \
     229             :         }                                                         \
     230             :     } while (0)
     231             : 
     232             : #define IDCT_VAR4(H)                                              \
     233             :     int limit2 = FFMIN(col_limit + 4, H)
     234             : #define IDCT_VAR8(H)                                              \
     235             :     int limit  = FFMIN(col_limit, H);                             \
     236             :     int limit2 = FFMIN(col_limit + 4, H)
     237             : #define IDCT_VAR16(H)   IDCT_VAR8(H)
     238             : #define IDCT_VAR32(H)   IDCT_VAR8(H)
     239             : 
     240             : #define IDCT(H)                                                   \
     241             : static void FUNC(idct_ ## H ## x ## H )(int16_t *coeffs,          \
     242             :                                         int col_limit)            \
     243             : {                                                                 \
     244             :     int i;                                                        \
     245             :     int      shift = 7;                                           \
     246             :     int      add   = 1 << (shift - 1);                            \
     247             :     int16_t *src   = coeffs;                                      \
     248             :     IDCT_VAR ## H(H);                                             \
     249             :                                                                   \
     250             :     for (i = 0; i < H; i++) {                                     \
     251             :         TR_ ## H(src, src, H, H, SCALE, limit2);                  \
     252             :         if (limit2 < H && i%4 == 0 && !!i)                        \
     253             :             limit2 -= 4;                                          \
     254             :         src++;                                                    \
     255             :     }                                                             \
     256             :                                                                   \
     257             :     shift = 20 - BIT_DEPTH;                                       \
     258             :     add   = 1 << (shift - 1);                                     \
     259             :     for (i = 0; i < H; i++) {                                     \
     260             :         TR_ ## H(coeffs, coeffs, 1, 1, SCALE, limit);             \
     261             :         coeffs += H;                                              \
     262             :     }                                                             \
     263             : }
     264             : 
     265             : #define IDCT_DC(H)                                                \
     266             : static void FUNC(idct_ ## H ## x ## H ## _dc)(int16_t *coeffs)    \
     267             : {                                                                 \
     268             :     int i, j;                                                     \
     269             :     int shift = 14 - BIT_DEPTH;                                   \
     270             :     int add   = 1 << (shift - 1);                                 \
     271             :     int coeff = (((coeffs[0] + 1) >> 1) + add) >> shift;          \
     272             :                                                                   \
     273             :     for (j = 0; j < H; j++) {                                     \
     274             :         for (i = 0; i < H; i++) {                                 \
     275             :             coeffs[i + j * H] = coeff;                            \
     276             :         }                                                         \
     277             :     }                                                             \
     278             : }
     279             : 
     280     2505139 : IDCT( 4)
     281     2701428 : IDCT( 8)
     282     1322010 : IDCT(16)
     283      479365 : IDCT(32)
     284             : 
     285     1034070 : IDCT_DC( 4)
     286      724309 : IDCT_DC( 8)
     287      249167 : IDCT_DC(16)
     288       77114 : IDCT_DC(32)
     289             : 
     290             : #undef TR_4
     291             : #undef TR_8
     292             : #undef TR_16
     293             : #undef TR_32
     294             : 
     295             : #undef SET
     296             : #undef SCALE
     297             : 
     298      108245 : static void FUNC(sao_band_filter)(uint8_t *_dst, uint8_t *_src,
     299             :                                   ptrdiff_t stride_dst, ptrdiff_t stride_src,
     300             :                                   int16_t *sao_offset_val, int sao_left_class,
     301             :                                   int width, int height)
     302             : {
     303      108245 :     pixel *dst = (pixel *)_dst;
     304      108245 :     pixel *src = (pixel *)_src;
     305      108245 :     int offset_table[32] = { 0 };
     306             :     int k, y, x;
     307      108245 :     int shift  = BIT_DEPTH - 5;
     308             : 
     309      108245 :     stride_dst /= sizeof(pixel);
     310      108245 :     stride_src /= sizeof(pixel);
     311             : 
     312      541225 :     for (k = 0; k < 4; k++)
     313      432980 :         offset_table[(k + sao_left_class) & 31] = sao_offset_val[k + 1];
     314     4127653 :     for (y = 0; y < height; y++) {
     315   199195856 :         for (x = 0; x < width; x++)
     316   195176448 :             dst[x] = av_clip_pixel(src[x] + offset_table[src[x] >> shift]);
     317     4019408 :         dst += stride_dst;
     318     4019408 :         src += stride_src;
     319             :     }
     320      108245 : }
     321             : 
     322             : #define CMP(a, b) (((a) > (b)) - ((a) < (b)))
     323             : 
     324      364389 : static void FUNC(sao_edge_filter)(uint8_t *_dst, uint8_t *_src, ptrdiff_t stride_dst, int16_t *sao_offset_val,
     325             :                                   int eo, int width, int height) {
     326             : 
     327             :     static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };
     328             :     static const int8_t pos[4][2][2] = {
     329             :         { { -1,  0 }, {  1, 0 } }, // horizontal
     330             :         { {  0, -1 }, {  0, 1 } }, // vertical
     331             :         { { -1, -1 }, {  1, 1 } }, // 45 degree
     332             :         { {  1, -1 }, { -1, 1 } }, // 135 degree
     333             :     };
     334      364389 :     pixel *dst = (pixel *)_dst;
     335      364389 :     pixel *src = (pixel *)_src;
     336             :     int a_stride, b_stride;
     337             :     int x, y;
     338      364389 :     ptrdiff_t stride_src = (2*MAX_PB_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) / sizeof(pixel);
     339      364389 :     stride_dst /= sizeof(pixel);
     340             : 
     341      364389 :     a_stride = pos[eo][0][0] + pos[eo][0][1] * stride_src;
     342      364389 :     b_stride = pos[eo][1][0] + pos[eo][1][1] * stride_src;
     343    19071989 :     for (y = 0; y < height; y++) {
     344  1046044432 :         for (x = 0; x < width; x++) {
     345  1027336832 :             int diff0 = CMP(src[x], src[x + a_stride]);
     346  1027336832 :             int diff1 = CMP(src[x], src[x + b_stride]);
     347  1027336832 :             int offset_val        = edge_idx[2 + diff0 + diff1];
     348  1027336832 :             dst[x] = av_clip_pixel(src[x] + sao_offset_val[offset_val]);
     349             :         }
     350    18707600 :         src += stride_src;
     351    18707600 :         dst += stride_dst;
     352             :     }
     353      364389 : }
     354             : 
     355      353166 : static void FUNC(sao_edge_restore_0)(uint8_t *_dst, uint8_t *_src,
     356             :                                     ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,
     357             :                                     int *borders, int _width, int _height,
     358             :                                     int c_idx, uint8_t *vert_edge,
     359             :                                     uint8_t *horiz_edge, uint8_t *diag_edge)
     360             : {
     361             :     int x, y;
     362      353166 :     pixel *dst = (pixel *)_dst;
     363      353166 :     pixel *src = (pixel *)_src;
     364      353166 :     int16_t *sao_offset_val = sao->offset_val[c_idx];
     365      353166 :     int sao_eo_class    = sao->eo_class[c_idx];
     366      353166 :     int init_x = 0, width = _width, height = _height;
     367             : 
     368      353166 :     stride_dst /= sizeof(pixel);
     369      353166 :     stride_src /= sizeof(pixel);
     370             : 
     371      353166 :     if (sao_eo_class != SAO_EO_VERT) {
     372      277440 :         if (borders[0]) {
     373       13065 :             int offset_val = sao_offset_val[0];
     374      661097 :             for (y = 0; y < height; y++) {
     375      648032 :                 dst[y * stride_dst] = av_clip_pixel(src[y * stride_src] + offset_val);
     376             :             }
     377       13065 :             init_x = 1;
     378             :         }
     379      277440 :         if (borders[2]) {
     380       13382 :             int offset_val = sao_offset_val[0];
     381       13382 :             int offset     = width - 1;
     382      664422 :             for (x = 0; x < height; x++) {
     383      651040 :                 dst[x * stride_dst + offset] = av_clip_pixel(src[x * stride_src + offset] + offset_val);
     384             :             }
     385       13382 :             width--;
     386             :         }
     387             :     }
     388      353166 :     if (sao_eo_class != SAO_EO_HORIZ) {
     389      291556 :         if (borders[1]) {
     390       18173 :             int offset_val = sao_offset_val[0];
     391      912744 :             for (x = init_x; x < width; x++)
     392      894571 :                 dst[x] = av_clip_pixel(src[x] + offset_val);
     393             :         }
     394      291556 :         if (borders[3]) {
     395       23070 :             int offset_val   = sao_offset_val[0];
     396       23070 :             ptrdiff_t y_stride_dst = stride_dst * (height - 1);
     397       23070 :             ptrdiff_t y_stride_src = stride_src * (height - 1);
     398     1123559 :             for (x = init_x; x < width; x++)
     399     1100489 :                 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);
     400       23070 :             height--;
     401             :         }
     402             :     }
     403      353166 : }
     404             : 
     405       11961 : static void FUNC(sao_edge_restore_1)(uint8_t *_dst, uint8_t *_src,
     406             :                                     ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,
     407             :                                     int *borders, int _width, int _height,
     408             :                                     int c_idx, uint8_t *vert_edge,
     409             :                                     uint8_t *horiz_edge, uint8_t *diag_edge)
     410             : {
     411             :     int x, y;
     412       11961 :     pixel *dst = (pixel *)_dst;
     413       11961 :     pixel *src = (pixel *)_src;
     414       11961 :     int16_t *sao_offset_val = sao->offset_val[c_idx];
     415       11961 :     int sao_eo_class    = sao->eo_class[c_idx];
     416       11961 :     int init_x = 0, init_y = 0, width = _width, height = _height;
     417             : 
     418       11961 :     stride_dst /= sizeof(pixel);
     419       11961 :     stride_src /= sizeof(pixel);
     420             : 
     421       11961 :     if (sao_eo_class != SAO_EO_VERT) {
     422        8493 :         if (borders[0]) {
     423        1072 :             int offset_val = sao_offset_val[0];
     424       51104 :             for (y = 0; y < height; y++) {
     425       50032 :                 dst[y * stride_dst] = av_clip_pixel(src[y * stride_src] + offset_val);
     426             :             }
     427        1072 :             init_x = 1;
     428             :         }
     429        8493 :         if (borders[2]) {
     430         678 :             int offset_val = sao_offset_val[0];
     431         678 :             int offset     = width - 1;
     432       30518 :             for (x = 0; x < height; x++) {
     433       29840 :                 dst[x * stride_dst + offset] = av_clip_pixel(src[x * stride_src + offset] + offset_val);
     434             :             }
     435         678 :             width--;
     436             :         }
     437             :     }
     438       11961 :     if (sao_eo_class != SAO_EO_HORIZ) {
     439        9454 :         if (borders[1]) {
     440        1844 :             int offset_val = sao_offset_val[0];
     441       88593 :             for (x = init_x; x < width; x++)
     442       86749 :                 dst[x] = av_clip_pixel(src[x] + offset_val);
     443        1844 :             init_y = 1;
     444             :         }
     445        9454 :         if (borders[3]) {
     446        1459 :             int offset_val   = sao_offset_val[0];
     447        1459 :             ptrdiff_t y_stride_dst = stride_dst * (height - 1);
     448        1459 :             ptrdiff_t y_stride_src = stride_src * (height - 1);
     449       66897 :             for (x = init_x; x < width; x++)
     450       65438 :                 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);
     451        1459 :             height--;
     452             :         }
     453             :     }
     454             : 
     455             :     {
     456       11961 :         int save_upper_left  = !diag_edge[0] && sao_eo_class == SAO_EO_135D && !borders[0] && !borders[1];
     457       11961 :         int save_upper_right = !diag_edge[1] && sao_eo_class == SAO_EO_45D  && !borders[1] && !borders[2];
     458       11961 :         int save_lower_right = !diag_edge[2] && sao_eo_class == SAO_EO_135D && !borders[2] && !borders[3];
     459       11961 :         int save_lower_left  = !diag_edge[3] && sao_eo_class == SAO_EO_45D  && !borders[0] && !borders[3];
     460             : 
     461             :         // Restore pixels that can't be modified
     462       11961 :         if(vert_edge[0] && sao_eo_class != SAO_EO_VERT) {
     463        1254 :             for(y = init_y+save_upper_left; y< height-save_lower_left; y++)
     464        1216 :                 dst[y*stride_dst] = src[y*stride_src];
     465             :         }
     466       11961 :         if(vert_edge[1] && sao_eo_class != SAO_EO_VERT) {
     467        2904 :             for(y = init_y+save_upper_right; y< height-save_lower_right; y++)
     468        2812 :                 dst[y*stride_dst+width-1] = src[y*stride_src+width-1];
     469             :         }
     470             : 
     471       11961 :         if(horiz_edge[0] && sao_eo_class != SAO_EO_HORIZ) {
     472        3816 :             for(x = init_x+save_upper_left; x < width-save_upper_right; x++)
     473        3700 :                 dst[x] = src[x];
     474             :         }
     475       11961 :         if(horiz_edge[1] && sao_eo_class != SAO_EO_HORIZ) {
     476        5922 :             for(x = init_x+save_lower_left; x < width-save_lower_right; x++)
     477        5742 :                 dst[(height-1)*stride_dst+x] = src[(height-1)*stride_src+x];
     478             :         }
     479       11961 :         if(diag_edge[0] && sao_eo_class == SAO_EO_135D)
     480          56 :             dst[0] = src[0];
     481       11961 :         if(diag_edge[1] && sao_eo_class == SAO_EO_45D)
     482         106 :             dst[width-1] = src[width-1];
     483       11961 :         if(diag_edge[2] && sao_eo_class == SAO_EO_135D)
     484         108 :             dst[stride_dst*(height-1)+width-1] = src[stride_src*(height-1)+width-1];
     485       11961 :         if(diag_edge[3] && sao_eo_class == SAO_EO_45D)
     486          84 :             dst[stride_dst*(height-1)] = src[stride_src*(height-1)];
     487             : 
     488             :     }
     489       11961 : }
     490             : 
     491             : #undef CMP
     492             : 
     493             : ////////////////////////////////////////////////////////////////////////////////
     494             : //
     495             : ////////////////////////////////////////////////////////////////////////////////
     496     2375628 : static void FUNC(put_hevc_pel_pixels)(int16_t *dst,
     497             :                                       uint8_t *_src, ptrdiff_t _srcstride,
     498             :                                       int height, intptr_t mx, intptr_t my, int width)
     499             : {
     500             :     int x, y;
     501     2375628 :     pixel *src          = (pixel *)_src;
     502     2375628 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     503             : 
     504    37687780 :     for (y = 0; y < height; y++) {
     505   933614360 :         for (x = 0; x < width; x++)
     506   898302208 :             dst[x] = src[x] << (14 - BIT_DEPTH);
     507    35312152 :         src += srcstride;
     508    35312152 :         dst += MAX_PB_SIZE;
     509             :     }
     510     2375628 : }
     511             : 
     512     2152468 : static void FUNC(put_hevc_pel_uni_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     513             :                                           int height, intptr_t mx, intptr_t my, int width)
     514             : {
     515             :     int y;
     516     2152468 :     pixel *src          = (pixel *)_src;
     517     2152468 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     518     2152468 :     pixel *dst          = (pixel *)_dst;
     519     2152468 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     520             : 
     521    24259048 :     for (y = 0; y < height; y++) {
     522    22106580 :         memcpy(dst, src, width * sizeof(pixel));
     523    22106580 :         src += srcstride;
     524    22106580 :         dst += dststride;
     525             :     }
     526     2152468 : }
     527             : 
     528     2599012 : static void FUNC(put_hevc_pel_bi_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     529             :                                          int16_t *src2,
     530             :                                          int height, intptr_t mx, intptr_t my, int width)
     531             : {
     532             :     int x, y;
     533     2599012 :     pixel *src          = (pixel *)_src;
     534     2599012 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     535     2599012 :     pixel *dst          = (pixel *)_dst;
     536     2599012 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     537             : 
     538     2599012 :     int shift = 14  + 1 - BIT_DEPTH;
     539             : #if BIT_DEPTH < 14
     540     2599012 :     int offset = 1 << (shift - 1);
     541             : #else
     542             :     int offset = 0;
     543             : #endif
     544             : 
     545    40997588 :     for (y = 0; y < height; y++) {
     546  1005907952 :         for (x = 0; x < width; x++)
     547   967509376 :             dst[x] = av_clip_pixel(((src[x] << (14 - BIT_DEPTH)) + src2[x] + offset) >> shift);
     548    38398576 :         src  += srcstride;
     549    38398576 :         dst  += dststride;
     550    38398576 :         src2 += MAX_PB_SIZE;
     551             :     }
     552     2599012 : }
     553             : 
     554       70871 : static void FUNC(put_hevc_pel_uni_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     555             :                                             int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
     556             : {
     557             :     int x, y;
     558       70871 :     pixel *src          = (pixel *)_src;
     559       70871 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     560       70871 :     pixel *dst          = (pixel *)_dst;
     561       70871 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     562       70871 :     int shift = denom + 14 - BIT_DEPTH;
     563             : #if BIT_DEPTH < 14
     564       70871 :     int offset = 1 << (shift - 1);
     565             : #else
     566             :     int offset = 0;
     567             : #endif
     568             : 
     569       70871 :     ox     = ox * (1 << (BIT_DEPTH - 8));
     570     1661123 :     for (y = 0; y < height; y++) {
     571    55504828 :         for (x = 0; x < width; x++)
     572    53914576 :             dst[x] = av_clip_pixel((((src[x] << (14 - BIT_DEPTH)) * wx + offset) >> shift) + ox);
     573     1590252 :         src += srcstride;
     574     1590252 :         dst += dststride;
     575             :     }
     576       70871 : }
     577             : 
     578       29971 : static void FUNC(put_hevc_pel_bi_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     579             :                                            int16_t *src2,
     580             :                                            int height, int denom, int wx0, int wx1,
     581             :                                            int ox0, int ox1, intptr_t mx, intptr_t my, int width)
     582             : {
     583             :     int x, y;
     584       29971 :     pixel *src          = (pixel *)_src;
     585       29971 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     586       29971 :     pixel *dst          = (pixel *)_dst;
     587       29971 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     588             : 
     589       29971 :     int shift = 14  + 1 - BIT_DEPTH;
     590       29971 :     int log2Wd = denom + shift - 1;
     591             : 
     592       29971 :     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
     593       29971 :     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
     594      650895 :     for (y = 0; y < height; y++) {
     595    20518908 :         for (x = 0; x < width; x++) {
     596    19897984 :             dst[x] = av_clip_pixel(( (src[x] << (14 - BIT_DEPTH)) * wx1 + src2[x] * wx0 + (ox0 + ox1 + 1) * (1 << log2Wd)) >> (log2Wd + 1));
     597             :         }
     598      620924 :         src  += srcstride;
     599      620924 :         dst  += dststride;
     600      620924 :         src2 += MAX_PB_SIZE;
     601             :     }
     602       29971 : }
     603             : 
     604             : ////////////////////////////////////////////////////////////////////////////////
     605             : //
     606             : ////////////////////////////////////////////////////////////////////////////////
     607             : #define QPEL_FILTER(src, stride)                                               \
     608             :     (filter[0] * src[x - 3 * stride] +                                         \
     609             :      filter[1] * src[x - 2 * stride] +                                         \
     610             :      filter[2] * src[x -     stride] +                                         \
     611             :      filter[3] * src[x             ] +                                         \
     612             :      filter[4] * src[x +     stride] +                                         \
     613             :      filter[5] * src[x + 2 * stride] +                                         \
     614             :      filter[6] * src[x + 3 * stride] +                                         \
     615             :      filter[7] * src[x + 4 * stride])
     616             : 
     617      683483 : static void FUNC(put_hevc_qpel_h)(int16_t *dst,
     618             :                                   uint8_t *_src, ptrdiff_t _srcstride,
     619             :                                   int height, intptr_t mx, intptr_t my, int width)
     620             : {
     621             :     int x, y;
     622      683483 :     pixel        *src       = (pixel*)_src;
     623      683483 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     624      683483 :     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
     625    15473715 :     for (y = 0; y < height; y++) {
     626   501522264 :         for (x = 0; x < width; x++)
     627   486732032 :             dst[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
     628    14790232 :         src += srcstride;
     629    14790232 :         dst += MAX_PB_SIZE;
     630             :     }
     631      683483 : }
     632             : 
     633      535342 : static void FUNC(put_hevc_qpel_v)(int16_t *dst,
     634             :                                   uint8_t *_src, ptrdiff_t _srcstride,
     635             :                                   int height, intptr_t mx, intptr_t my, int width)
     636             : {
     637             :     int x, y;
     638      535342 :     pixel        *src       = (pixel*)_src;
     639      535342 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     640      535342 :     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
     641    12083210 :     for (y = 0; y < height; y++)  {
     642   390787164 :         for (x = 0; x < width; x++)
     643   379239296 :             dst[x] = QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8);
     644    11547868 :         src += srcstride;
     645    11547868 :         dst += MAX_PB_SIZE;
     646             :     }
     647      535342 : }
     648             : 
     649     1671381 : static void FUNC(put_hevc_qpel_hv)(int16_t *dst,
     650             :                                    uint8_t *_src,
     651             :                                    ptrdiff_t _srcstride,
     652             :                                    int height, intptr_t mx,
     653             :                                    intptr_t my, int width)
     654             : {
     655             :     int x, y;
     656             :     const int8_t *filter;
     657     1671381 :     pixel *src = (pixel*)_src;
     658     1671381 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     659             :     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
     660     1671381 :     int16_t *tmp = tmp_array;
     661             : 
     662     1671381 :     src   -= QPEL_EXTRA_BEFORE * srcstride;
     663     1671381 :     filter = ff_hevc_qpel_filters[mx - 1];
     664    48554356 :     for (y = 0; y < height + QPEL_EXTRA; y++) {
     665  1395937023 :         for (x = 0; x < width; x++)
     666  1349054048 :             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
     667    46882975 :         src += srcstride;
     668    46882975 :         tmp += MAX_PB_SIZE;
     669             :     }
     670             : 
     671     1671381 :     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
     672     1671381 :     filter = ff_hevc_qpel_filters[my - 1];
     673    36854689 :     for (y = 0; y < height; y++) {
     674  1140876364 :         for (x = 0; x < width; x++)
     675  1105693056 :             dst[x] = QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6;
     676    35183308 :         tmp += MAX_PB_SIZE;
     677    35183308 :         dst += MAX_PB_SIZE;
     678             :     }
     679     1671381 : }
     680             : 
     681      774689 : static void FUNC(put_hevc_qpel_uni_h)(uint8_t *_dst,  ptrdiff_t _dststride,
     682             :                                       uint8_t *_src, ptrdiff_t _srcstride,
     683             :                                       int height, intptr_t mx, intptr_t my, int width)
     684             : {
     685             :     int x, y;
     686      774689 :     pixel        *src       = (pixel*)_src;
     687      774689 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     688      774689 :     pixel *dst          = (pixel *)_dst;
     689      774689 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     690      774689 :     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
     691      774689 :     int shift = 14 - BIT_DEPTH;
     692             : 
     693             : #if BIT_DEPTH < 14
     694      774689 :     int offset = 1 << (shift - 1);
     695             : #else
     696             :     int offset = 0;
     697             : #endif
     698             : 
     699    11997421 :     for (y = 0; y < height; y++) {
     700   256167244 :         for (x = 0; x < width; x++)
     701   244944512 :             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
     702    11222732 :         src += srcstride;
     703    11222732 :         dst += dststride;
     704             :     }
     705      774689 : }
     706             : 
     707      643560 : static void FUNC(put_hevc_qpel_bi_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     708             :                                      int16_t *src2,
     709             :                                      int height, intptr_t mx, intptr_t my, int width)
     710             : {
     711             :     int x, y;
     712      643560 :     pixel        *src       = (pixel*)_src;
     713      643560 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     714      643560 :     pixel *dst          = (pixel *)_dst;
     715      643560 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     716             : 
     717      643560 :     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
     718             : 
     719      643560 :     int shift = 14  + 1 - BIT_DEPTH;
     720             : #if BIT_DEPTH < 14
     721      643560 :     int offset = 1 << (shift - 1);
     722             : #else
     723             :     int offset = 0;
     724             : #endif
     725             : 
     726    14577344 :     for (y = 0; y < height; y++) {
     727   471552280 :         for (x = 0; x < width; x++)
     728   457618496 :             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);
     729    13933784 :         src  += srcstride;
     730    13933784 :         dst  += dststride;
     731    13933784 :         src2 += MAX_PB_SIZE;
     732             :     }
     733      643560 : }
     734             : 
     735      680401 : static void FUNC(put_hevc_qpel_uni_v)(uint8_t *_dst,  ptrdiff_t _dststride,
     736             :                                      uint8_t *_src, ptrdiff_t _srcstride,
     737             :                                      int height, intptr_t mx, intptr_t my, int width)
     738             : {
     739             :     int x, y;
     740      680401 :     pixel        *src       = (pixel*)_src;
     741      680401 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     742      680401 :     pixel *dst          = (pixel *)_dst;
     743      680401 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     744      680401 :     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
     745      680401 :     int shift = 14 - BIT_DEPTH;
     746             : 
     747             : #if BIT_DEPTH < 14
     748      680401 :     int offset = 1 << (shift - 1);
     749             : #else
     750             :     int offset = 0;
     751             : #endif
     752             : 
     753    10811745 :     for (y = 0; y < height; y++) {
     754   246168176 :         for (x = 0; x < width; x++)
     755   236036832 :             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + offset) >> shift);
     756    10131344 :         src += srcstride;
     757    10131344 :         dst += dststride;
     758             :     }
     759      680401 : }
     760             : 
     761             : 
     762      512322 : static void FUNC(put_hevc_qpel_bi_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     763             :                                      int16_t *src2,
     764             :                                      int height, intptr_t mx, intptr_t my, int width)
     765             : {
     766             :     int x, y;
     767      512322 :     pixel        *src       = (pixel*)_src;
     768      512322 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     769      512322 :     pixel *dst          = (pixel *)_dst;
     770      512322 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     771             : 
     772      512322 :     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
     773             : 
     774      512322 :     int shift = 14 + 1 - BIT_DEPTH;
     775             : #if BIT_DEPTH < 14
     776      512322 :     int offset = 1 << (shift - 1);
     777             : #else
     778             :     int offset = 0;
     779             : #endif
     780             : 
     781    11374010 :     for (y = 0; y < height; y++) {
     782   359538040 :         for (x = 0; x < width; x++)
     783   348676352 :             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);
     784    10861688 :         src  += srcstride;
     785    10861688 :         dst  += dststride;
     786    10861688 :         src2 += MAX_PB_SIZE;
     787             :     }
     788      512322 : }
     789             : 
     790     2148454 : static void FUNC(put_hevc_qpel_uni_hv)(uint8_t *_dst,  ptrdiff_t _dststride,
     791             :                                        uint8_t *_src, ptrdiff_t _srcstride,
     792             :                                        int height, intptr_t mx, intptr_t my, int width)
     793             : {
     794             :     int x, y;
     795             :     const int8_t *filter;
     796     2148454 :     pixel *src = (pixel*)_src;
     797     2148454 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     798     2148454 :     pixel *dst          = (pixel *)_dst;
     799     2148454 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     800             :     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
     801     2148454 :     int16_t *tmp = tmp_array;
     802     2148454 :     int shift =  14 - BIT_DEPTH;
     803             : 
     804             : #if BIT_DEPTH < 14
     805     2148454 :     int offset = 1 << (shift - 1);
     806             : #else
     807             :     int offset = 0;
     808             : #endif
     809             : 
     810     2148454 :     src   -= QPEL_EXTRA_BEFORE * srcstride;
     811     2148454 :     filter = ff_hevc_qpel_filters[mx - 1];
     812    48209576 :     for (y = 0; y < height + QPEL_EXTRA; y++) {
     813   913292098 :         for (x = 0; x < width; x++)
     814   867230976 :             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
     815    46061122 :         src += srcstride;
     816    46061122 :         tmp += MAX_PB_SIZE;
     817             :     }
     818             : 
     819     2148454 :     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
     820     2148454 :     filter = ff_hevc_qpel_filters[my - 1];
     821             : 
     822    33170398 :     for (y = 0; y < height; y++) {
     823   686212056 :         for (x = 0; x < width; x++)
     824   655190112 :             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
     825    31021944 :         tmp += MAX_PB_SIZE;
     826    31021944 :         dst += dststride;
     827             :     }
     828     2148454 : }
     829             : 
     830     1597727 : static void FUNC(put_hevc_qpel_bi_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     831             :                                       int16_t *src2,
     832             :                                       int height, intptr_t mx, intptr_t my, int width)
     833             : {
     834             :     int x, y;
     835             :     const int8_t *filter;
     836     1597727 :     pixel *src = (pixel*)_src;
     837     1597727 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     838     1597727 :     pixel *dst          = (pixel *)_dst;
     839     1597727 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     840             :     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
     841     1597727 :     int16_t *tmp = tmp_array;
     842     1597727 :     int shift = 14 + 1 - BIT_DEPTH;
     843             : #if BIT_DEPTH < 14
     844     1597727 :     int offset = 1 << (shift - 1);
     845             : #else
     846             :     int offset = 0;
     847             : #endif
     848             : 
     849     1597727 :     src   -= QPEL_EXTRA_BEFORE * srcstride;
     850     1597727 :     filter = ff_hevc_qpel_filters[mx - 1];
     851    46544252 :     for (y = 0; y < height + QPEL_EXTRA; y++) {
     852  1349255961 :         for (x = 0; x < width; x++)
     853  1304309436 :             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
     854    44946525 :         src += srcstride;
     855    44946525 :         tmp += MAX_PB_SIZE;
     856             :     }
     857             : 
     858     1597727 :     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
     859     1597727 :     filter = ff_hevc_qpel_filters[my - 1];
     860             : 
     861    35360163 :     for (y = 0; y < height; y++) {
     862  1104377348 :         for (x = 0; x < width; x++)
     863  1070614912 :             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + src2[x] + offset) >> shift);
     864    33762436 :         tmp  += MAX_PB_SIZE;
     865    33762436 :         dst  += dststride;
     866    33762436 :         src2 += MAX_PB_SIZE;
     867             :     }
     868     1597727 : }
     869             : 
     870       16063 : static void FUNC(put_hevc_qpel_uni_w_h)(uint8_t *_dst,  ptrdiff_t _dststride,
     871             :                                         uint8_t *_src, ptrdiff_t _srcstride,
     872             :                                         int height, int denom, int wx, int ox,
     873             :                                         intptr_t mx, intptr_t my, int width)
     874             : {
     875             :     int x, y;
     876       16063 :     pixel        *src       = (pixel*)_src;
     877       16063 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     878       16063 :     pixel *dst          = (pixel *)_dst;
     879       16063 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     880       16063 :     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
     881       16063 :     int shift = denom + 14 - BIT_DEPTH;
     882             : #if BIT_DEPTH < 14
     883       16063 :     int offset = 1 << (shift - 1);
     884             : #else
     885             :     int offset = 0;
     886             : #endif
     887             : 
     888       16063 :     ox = ox * (1 << (BIT_DEPTH - 8));
     889      347927 :     for (y = 0; y < height; y++) {
     890    10789080 :         for (x = 0; x < width; x++)
     891    10457216 :             dst[x] = av_clip_pixel((((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
     892      331864 :         src += srcstride;
     893      331864 :         dst += dststride;
     894             :     }
     895       16063 : }
     896             : 
     897        9353 : static void FUNC(put_hevc_qpel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     898             :                                        int16_t *src2,
     899             :                                        int height, int denom, int wx0, int wx1,
     900             :                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)
     901             : {
     902             :     int x, y;
     903        9353 :     pixel        *src       = (pixel*)_src;
     904        9353 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     905        9353 :     pixel *dst          = (pixel *)_dst;
     906        9353 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     907             : 
     908        9353 :     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
     909             : 
     910        9353 :     int shift = 14  + 1 - BIT_DEPTH;
     911        9353 :     int log2Wd = denom + shift - 1;
     912             : 
     913        9353 :     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
     914        9353 :     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
     915      238201 :     for (y = 0; y < height; y++) {
     916     8107248 :         for (x = 0; x < width; x++)
     917     7878400 :             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
     918             :                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
     919      228848 :         src  += srcstride;
     920      228848 :         dst  += dststride;
     921      228848 :         src2 += MAX_PB_SIZE;
     922             :     }
     923        9353 : }
     924             : 
     925       14423 : static void FUNC(put_hevc_qpel_uni_w_v)(uint8_t *_dst,  ptrdiff_t _dststride,
     926             :                                         uint8_t *_src, ptrdiff_t _srcstride,
     927             :                                         int height, int denom, int wx, int ox,
     928             :                                         intptr_t mx, intptr_t my, int width)
     929             : {
     930             :     int x, y;
     931       14423 :     pixel        *src       = (pixel*)_src;
     932       14423 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     933       14423 :     pixel *dst          = (pixel *)_dst;
     934       14423 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     935       14423 :     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
     936       14423 :     int shift = denom + 14 - BIT_DEPTH;
     937             : #if BIT_DEPTH < 14
     938       14423 :     int offset = 1 << (shift - 1);
     939             : #else
     940             :     int offset = 0;
     941             : #endif
     942             : 
     943       14423 :     ox = ox * (1 << (BIT_DEPTH - 8));
     944      283555 :     for (y = 0; y < height; y++) {
     945     7745580 :         for (x = 0; x < width; x++)
     946     7476448 :             dst[x] = av_clip_pixel((((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
     947      269132 :         src += srcstride;
     948      269132 :         dst += dststride;
     949             :     }
     950       14423 : }
     951             : 
     952        8172 : static void FUNC(put_hevc_qpel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
     953             :                                        int16_t *src2,
     954             :                                        int height, int denom, int wx0, int wx1,
     955             :                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)
     956             : {
     957             :     int x, y;
     958        8172 :     pixel        *src       = (pixel*)_src;
     959        8172 :     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
     960        8172 :     pixel *dst          = (pixel *)_dst;
     961        8172 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     962             : 
     963        8172 :     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
     964             : 
     965        8172 :     int shift = 14 + 1 - BIT_DEPTH;
     966        8172 :     int log2Wd = denom + shift - 1;
     967             : 
     968        8172 :     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
     969        8172 :     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
     970      194744 :     for (y = 0; y < height; y++) {
     971     6137804 :         for (x = 0; x < width; x++)
     972     5951232 :             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
     973             :                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
     974      186572 :         src  += srcstride;
     975      186572 :         dst  += dststride;
     976      186572 :         src2 += MAX_PB_SIZE;
     977             :     }
     978        8172 : }
     979             : 
     980       49387 : static void FUNC(put_hevc_qpel_uni_w_hv)(uint8_t *_dst,  ptrdiff_t _dststride,
     981             :                                          uint8_t *_src, ptrdiff_t _srcstride,
     982             :                                          int height, int denom, int wx, int ox,
     983             :                                          intptr_t mx, intptr_t my, int width)
     984             : {
     985             :     int x, y;
     986             :     const int8_t *filter;
     987       49387 :     pixel *src = (pixel*)_src;
     988       49387 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
     989       49387 :     pixel *dst          = (pixel *)_dst;
     990       49387 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
     991             :     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
     992       49387 :     int16_t *tmp = tmp_array;
     993       49387 :     int shift = denom + 14 - BIT_DEPTH;
     994             : #if BIT_DEPTH < 14
     995       49387 :     int offset = 1 << (shift - 1);
     996             : #else
     997             :     int offset = 0;
     998             : #endif
     999             : 
    1000       49387 :     src   -= QPEL_EXTRA_BEFORE * srcstride;
    1001       49387 :     filter = ff_hevc_qpel_filters[mx - 1];
    1002     1357804 :     for (y = 0; y < height + QPEL_EXTRA; y++) {
    1003    36457197 :         for (x = 0; x < width; x++)
    1004    35148780 :             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
    1005     1308417 :         src += srcstride;
    1006     1308417 :         tmp += MAX_PB_SIZE;
    1007             :     }
    1008             : 
    1009       49387 :     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
    1010       49387 :     filter = ff_hevc_qpel_filters[my - 1];
    1011             : 
    1012       49387 :     ox = ox * (1 << (BIT_DEPTH - 8));
    1013     1012095 :     for (y = 0; y < height; y++) {
    1014    29689940 :         for (x = 0; x < width; x++)
    1015    28727232 :             dst[x] = av_clip_pixel((((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
    1016      962708 :         tmp += MAX_PB_SIZE;
    1017      962708 :         dst += dststride;
    1018             :     }
    1019       49387 : }
    1020             : 
    1021       33469 : static void FUNC(put_hevc_qpel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1022             :                                         int16_t *src2,
    1023             :                                         int height, int denom, int wx0, int wx1,
    1024             :                                         int ox0, int ox1, intptr_t mx, intptr_t my, int width)
    1025             : {
    1026             :     int x, y;
    1027             :     const int8_t *filter;
    1028       33469 :     pixel *src = (pixel*)_src;
    1029       33469 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
    1030       33469 :     pixel *dst          = (pixel *)_dst;
    1031       33469 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1032             :     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
    1033       33469 :     int16_t *tmp = tmp_array;
    1034       33469 :     int shift = 14 + 1 - BIT_DEPTH;
    1035       33469 :     int log2Wd = denom + shift - 1;
    1036             : 
    1037       33469 :     src   -= QPEL_EXTRA_BEFORE * srcstride;
    1038       33469 :     filter = ff_hevc_qpel_filters[mx - 1];
    1039     1100560 :     for (y = 0; y < height + QPEL_EXTRA; y++) {
    1040    35684099 :         for (x = 0; x < width; x++)
    1041    34617008 :             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
    1042     1067091 :         src += srcstride;
    1043     1067091 :         tmp += MAX_PB_SIZE;
    1044             :     }
    1045             : 
    1046       33469 :     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
    1047       33469 :     filter = ff_hevc_qpel_filters[my - 1];
    1048             : 
    1049       33469 :     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
    1050       33469 :     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
    1051      866277 :     for (y = 0; y < height; y++) {
    1052    29826856 :         for (x = 0; x < width; x++)
    1053    28994048 :             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +
    1054             :                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
    1055      832808 :         tmp  += MAX_PB_SIZE;
    1056      832808 :         dst  += dststride;
    1057      832808 :         src2 += MAX_PB_SIZE;
    1058             :     }
    1059       33469 : }
    1060             : 
    1061             : ////////////////////////////////////////////////////////////////////////////////
    1062             : //
    1063             : ////////////////////////////////////////////////////////////////////////////////
    1064             : #define EPEL_FILTER(src, stride)                                               \
    1065             :     (filter[0] * src[x - stride] +                                             \
    1066             :      filter[1] * src[x]          +                                             \
    1067             :      filter[2] * src[x + stride] +                                             \
    1068             :      filter[3] * src[x + 2 * stride])
    1069             : 
    1070     1074184 : static void FUNC(put_hevc_epel_h)(int16_t *dst,
    1071             :                                   uint8_t *_src, ptrdiff_t _srcstride,
    1072             :                                   int height, intptr_t mx, intptr_t my, int width)
    1073             : {
    1074             :     int x, y;
    1075     1074184 :     pixel *src = (pixel *)_src;
    1076     1074184 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1077     1074184 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1078    13529692 :     for (y = 0; y < height; y++) {
    1079   213501108 :         for (x = 0; x < width; x++)
    1080   201045600 :             dst[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
    1081    12455508 :         src += srcstride;
    1082    12455508 :         dst += MAX_PB_SIZE;
    1083             :     }
    1084     1074184 : }
    1085             : 
    1086      745866 : static void FUNC(put_hevc_epel_v)(int16_t *dst,
    1087             :                                   uint8_t *_src, ptrdiff_t _srcstride,
    1088             :                                   int height, intptr_t mx, intptr_t my, int width)
    1089             : {
    1090             :     int x, y;
    1091      745866 :     pixel *src = (pixel *)_src;
    1092      745866 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
    1093      745866 :     const int8_t *filter = ff_hevc_epel_filters[my - 1];
    1094             : 
    1095     9840826 :     for (y = 0; y < height; y++) {
    1096   163088048 :         for (x = 0; x < width; x++)
    1097   153993088 :             dst[x] = EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8);
    1098     9094960 :         src += srcstride;
    1099     9094960 :         dst += MAX_PB_SIZE;
    1100             :     }
    1101      745866 : }
    1102             : 
    1103     4255598 : static void FUNC(put_hevc_epel_hv)(int16_t *dst,
    1104             :                                    uint8_t *_src, ptrdiff_t _srcstride,
    1105             :                                    int height, intptr_t mx, intptr_t my, int width)
    1106             : {
    1107             :     int x, y;
    1108     4255598 :     pixel *src = (pixel *)_src;
    1109     4255598 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
    1110     4255598 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1111             :     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
    1112     4255598 :     int16_t *tmp = tmp_array;
    1113             : 
    1114     4255598 :     src -= EPEL_EXTRA_BEFORE * srcstride;
    1115             : 
    1116    64934296 :     for (y = 0; y < height + EPEL_EXTRA; y++) {
    1117   946651522 :         for (x = 0; x < width; x++)
    1118   885972824 :             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
    1119    60678698 :         src += srcstride;
    1120    60678698 :         tmp += MAX_PB_SIZE;
    1121             :     }
    1122             : 
    1123     4255598 :     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
    1124     4255598 :     filter = ff_hevc_epel_filters[my - 1];
    1125             : 
    1126    52167502 :     for (y = 0; y < height; y++) {
    1127   799368064 :         for (x = 0; x < width; x++)
    1128   751456160 :             dst[x] = EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6;
    1129    47911904 :         tmp += MAX_PB_SIZE;
    1130    47911904 :         dst += MAX_PB_SIZE;
    1131             :     }
    1132     4255598 : }
    1133             : 
    1134     1262490 : static void FUNC(put_hevc_epel_uni_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1135             :                                       int height, intptr_t mx, intptr_t my, int width)
    1136             : {
    1137             :     int x, y;
    1138     1262490 :     pixel *src = (pixel *)_src;
    1139     1262490 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1140     1262490 :     pixel *dst          = (pixel *)_dst;
    1141     1262490 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1142     1262490 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1143     1262490 :     int shift = 14 - BIT_DEPTH;
    1144             : #if BIT_DEPTH < 14
    1145     1262490 :     int offset = 1 << (shift - 1);
    1146             : #else
    1147             :     int offset = 0;
    1148             : #endif
    1149             : 
    1150    10355770 :     for (y = 0; y < height; y++) {
    1151   105706544 :         for (x = 0; x < width; x++)
    1152    96613264 :             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
    1153     9093280 :         src += srcstride;
    1154     9093280 :         dst += dststride;
    1155             :     }
    1156     1262490 : }
    1157             : 
    1158     1010218 : static void FUNC(put_hevc_epel_bi_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1159             :                                      int16_t *src2,
    1160             :                                      int height, intptr_t mx, intptr_t my, int width)
    1161             : {
    1162             :     int x, y;
    1163     1010218 :     pixel *src = (pixel *)_src;
    1164     1010218 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1165     1010218 :     pixel *dst          = (pixel *)_dst;
    1166     1010218 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1167     1010218 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1168     1010218 :     int shift = 14 + 1 - BIT_DEPTH;
    1169             : #if BIT_DEPTH < 14
    1170     1010218 :     int offset = 1 << (shift - 1);
    1171             : #else
    1172             :     int offset = 0;
    1173             : #endif
    1174             : 
    1175    12531354 :     for (y = 0; y < height; y++) {
    1176   198089776 :         for (x = 0; x < width; x++) {
    1177   186568640 :             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);
    1178             :         }
    1179    11521136 :         dst  += dststride;
    1180    11521136 :         src  += srcstride;
    1181    11521136 :         src2 += MAX_PB_SIZE;
    1182             :     }
    1183     1010218 : }
    1184             : 
    1185     1037492 : static void FUNC(put_hevc_epel_uni_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1186             :                                       int height, intptr_t mx, intptr_t my, int width)
    1187             : {
    1188             :     int x, y;
    1189     1037492 :     pixel *src = (pixel *)_src;
    1190     1037492 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1191     1037492 :     pixel *dst          = (pixel *)_dst;
    1192     1037492 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1193     1037492 :     const int8_t *filter = ff_hevc_epel_filters[my - 1];
    1194     1037492 :     int shift = 14 - BIT_DEPTH;
    1195             : #if BIT_DEPTH < 14
    1196     1037492 :     int offset = 1 << (shift - 1);
    1197             : #else
    1198             :     int offset = 0;
    1199             : #endif
    1200             : 
    1201     8782964 :     for (y = 0; y < height; y++) {
    1202    96413216 :         for (x = 0; x < width; x++)
    1203    88667744 :             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + offset) >> shift);
    1204     7745472 :         src += srcstride;
    1205     7745472 :         dst += dststride;
    1206             :     }
    1207     1037492 : }
    1208             : 
    1209      723918 : static void FUNC(put_hevc_epel_bi_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1210             :                                      int16_t *src2,
    1211             :                                      int height, intptr_t mx, intptr_t my, int width)
    1212             : {
    1213             :     int x, y;
    1214      723918 :     pixel *src = (pixel *)_src;
    1215      723918 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1216      723918 :     const int8_t *filter = ff_hevc_epel_filters[my - 1];
    1217      723918 :     pixel *dst          = (pixel *)_dst;
    1218      723918 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1219      723918 :     int shift = 14 + 1 - BIT_DEPTH;
    1220             : #if BIT_DEPTH < 14
    1221      723918 :     int offset = 1 << (shift - 1);
    1222             : #else
    1223             :     int offset = 0;
    1224             : #endif
    1225             : 
    1226     9404738 :     for (y = 0; y < height; y++) {
    1227   149934676 :         for (x = 0; x < width; x++)
    1228   141253856 :             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);
    1229     8680820 :         dst  += dststride;
    1230     8680820 :         src  += srcstride;
    1231     8680820 :         src2 += MAX_PB_SIZE;
    1232             :     }
    1233      723918 : }
    1234             : 
    1235     5682758 : static void FUNC(put_hevc_epel_uni_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1236             :                                        int height, intptr_t mx, intptr_t my, int width)
    1237             : {
    1238             :     int x, y;
    1239     5682758 :     pixel *src = (pixel *)_src;
    1240     5682758 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
    1241     5682758 :     pixel *dst          = (pixel *)_dst;
    1242     5682758 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1243     5682758 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1244             :     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
    1245     5682758 :     int16_t *tmp = tmp_array;
    1246     5682758 :     int shift = 14 - BIT_DEPTH;
    1247             : #if BIT_DEPTH < 14
    1248     5682758 :     int offset = 1 << (shift - 1);
    1249             : #else
    1250             :     int offset = 0;
    1251             : #endif
    1252             : 
    1253     5682758 :     src -= EPEL_EXTRA_BEFORE * srcstride;
    1254             : 
    1255    64137428 :     for (y = 0; y < height + EPEL_EXTRA; y++) {
    1256   619679070 :         for (x = 0; x < width; x++)
    1257   561224400 :             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
    1258    58454670 :         src += srcstride;
    1259    58454670 :         tmp += MAX_PB_SIZE;
    1260             :     }
    1261             : 
    1262     5682758 :     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
    1263     5682758 :     filter = ff_hevc_epel_filters[my - 1];
    1264             : 
    1265    47089154 :     for (y = 0; y < height; y++) {
    1266   482229996 :         for (x = 0; x < width; x++)
    1267   440823600 :             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
    1268    41406396 :         tmp += MAX_PB_SIZE;
    1269    41406396 :         dst += dststride;
    1270             :     }
    1271     5682758 : }
    1272             : 
    1273     4067804 : static void FUNC(put_hevc_epel_bi_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1274             :                                       int16_t *src2,
    1275             :                                       int height, intptr_t mx, intptr_t my, int width)
    1276             : {
    1277             :     int x, y;
    1278     4067804 :     pixel *src = (pixel *)_src;
    1279     4067804 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
    1280     4067804 :     pixel *dst          = (pixel *)_dst;
    1281     4067804 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1282     4067804 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1283             :     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
    1284     4067804 :     int16_t *tmp = tmp_array;
    1285     4067804 :     int shift = 14 + 1 - BIT_DEPTH;
    1286             : #if BIT_DEPTH < 14
    1287     4067804 :     int offset = 1 << (shift - 1);
    1288             : #else
    1289             :     int offset = 0;
    1290             : #endif
    1291             : 
    1292     4067804 :     src -= EPEL_EXTRA_BEFORE * srcstride;
    1293             : 
    1294    62249500 :     for (y = 0; y < height + EPEL_EXTRA; y++) {
    1295   906168660 :         for (x = 0; x < width; x++)
    1296   847986964 :             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
    1297    58181696 :         src += srcstride;
    1298    58181696 :         tmp += MAX_PB_SIZE;
    1299             :     }
    1300             : 
    1301     4067804 :     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
    1302     4067804 :     filter = ff_hevc_epel_filters[my - 1];
    1303             : 
    1304    50046088 :     for (y = 0; y < height; y++) {
    1305   765445260 :         for (x = 0; x < width; x++)
    1306   719466976 :             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + src2[x] + offset) >> shift);
    1307    45978284 :         tmp  += MAX_PB_SIZE;
    1308    45978284 :         dst  += dststride;
    1309    45978284 :         src2 += MAX_PB_SIZE;
    1310             :     }
    1311     4067804 : }
    1312             : 
    1313       24682 : static void FUNC(put_hevc_epel_uni_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1314             :                                         int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
    1315             : {
    1316             :     int x, y;
    1317       24682 :     pixel *src = (pixel *)_src;
    1318       24682 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1319       24682 :     pixel *dst          = (pixel *)_dst;
    1320       24682 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1321       24682 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1322       24682 :     int shift = denom + 14 - BIT_DEPTH;
    1323             : #if BIT_DEPTH < 14
    1324       24682 :     int offset = 1 << (shift - 1);
    1325             : #else
    1326             :     int offset = 0;
    1327             : #endif
    1328             : 
    1329       24682 :     ox     = ox * (1 << (BIT_DEPTH - 8));
    1330      298314 :     for (y = 0; y < height; y++) {
    1331     4844752 :         for (x = 0; x < width; x++) {
    1332     4571120 :             dst[x] = av_clip_pixel((((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
    1333             :         }
    1334      273632 :         dst += dststride;
    1335      273632 :         src += srcstride;
    1336             :     }
    1337       24682 : }
    1338             : 
    1339       14434 : static void FUNC(put_hevc_epel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1340             :                                        int16_t *src2,
    1341             :                                        int height, int denom, int wx0, int wx1,
    1342             :                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)
    1343             : {
    1344             :     int x, y;
    1345       14434 :     pixel *src = (pixel *)_src;
    1346       14434 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1347       14434 :     pixel *dst          = (pixel *)_dst;
    1348       14434 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1349       14434 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1350       14434 :     int shift = 14 + 1 - BIT_DEPTH;
    1351       14434 :     int log2Wd = denom + shift - 1;
    1352             : 
    1353       14434 :     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
    1354       14434 :     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
    1355      198150 :     for (y = 0; y < height; y++) {
    1356     3497124 :         for (x = 0; x < width; x++)
    1357     3313408 :             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
    1358             :                                     ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));
    1359      183716 :         src  += srcstride;
    1360      183716 :         dst  += dststride;
    1361      183716 :         src2 += MAX_PB_SIZE;
    1362             :     }
    1363       14434 : }
    1364             : 
    1365       18894 : static void FUNC(put_hevc_epel_uni_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1366             :                                         int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
    1367             : {
    1368             :     int x, y;
    1369       18894 :     pixel *src = (pixel *)_src;
    1370       18894 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1371       18894 :     pixel *dst          = (pixel *)_dst;
    1372       18894 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1373       18894 :     const int8_t *filter = ff_hevc_epel_filters[my - 1];
    1374       18894 :     int shift = denom + 14 - BIT_DEPTH;
    1375             : #if BIT_DEPTH < 14
    1376       18894 :     int offset = 1 << (shift - 1);
    1377             : #else
    1378             :     int offset = 0;
    1379             : #endif
    1380             : 
    1381       18894 :     ox     = ox * (1 << (BIT_DEPTH - 8));
    1382      205630 :     for (y = 0; y < height; y++) {
    1383     2958400 :         for (x = 0; x < width; x++) {
    1384     2771664 :             dst[x] = av_clip_pixel((((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
    1385             :         }
    1386      186736 :         dst += dststride;
    1387      186736 :         src += srcstride;
    1388             :     }
    1389       18894 : }
    1390             : 
    1391       10170 : static void FUNC(put_hevc_epel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1392             :                                        int16_t *src2,
    1393             :                                        int height, int denom, int wx0, int wx1,
    1394             :                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)
    1395             : {
    1396             :     int x, y;
    1397       10170 :     pixel *src = (pixel *)_src;
    1398       10170 :     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
    1399       10170 :     const int8_t *filter = ff_hevc_epel_filters[my - 1];
    1400       10170 :     pixel *dst          = (pixel *)_dst;
    1401       10170 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1402       10170 :     int shift = 14 + 1 - BIT_DEPTH;
    1403       10170 :     int log2Wd = denom + shift - 1;
    1404             : 
    1405       10170 :     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
    1406       10170 :     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
    1407      128050 :     for (y = 0; y < height; y++) {
    1408     2047832 :         for (x = 0; x < width; x++)
    1409     1929952 :             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
    1410             :                                     ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));
    1411      117880 :         src  += srcstride;
    1412      117880 :         dst  += dststride;
    1413      117880 :         src2 += MAX_PB_SIZE;
    1414             :     }
    1415       10170 : }
    1416             : 
    1417      123494 : static void FUNC(put_hevc_epel_uni_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1418             :                                          int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
    1419             : {
    1420             :     int x, y;
    1421      123494 :     pixel *src = (pixel *)_src;
    1422      123494 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
    1423      123494 :     pixel *dst          = (pixel *)_dst;
    1424      123494 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1425      123494 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1426             :     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
    1427      123494 :     int16_t *tmp = tmp_array;
    1428      123494 :     int shift = denom + 14 - BIT_DEPTH;
    1429             : #if BIT_DEPTH < 14
    1430      123494 :     int offset = 1 << (shift - 1);
    1431             : #else
    1432             :     int offset = 0;
    1433             : #endif
    1434             : 
    1435      123494 :     src -= EPEL_EXTRA_BEFORE * srcstride;
    1436             : 
    1437     1664300 :     for (y = 0; y < height + EPEL_EXTRA; y++) {
    1438    21798522 :         for (x = 0; x < width; x++)
    1439    20257716 :             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
    1440     1540806 :         src += srcstride;
    1441     1540806 :         tmp += MAX_PB_SIZE;
    1442             :     }
    1443             : 
    1444      123494 :     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
    1445      123494 :     filter = ff_hevc_epel_filters[my - 1];
    1446             : 
    1447      123494 :     ox     = ox * (1 << (BIT_DEPTH - 8));
    1448     1293818 :     for (y = 0; y < height; y++) {
    1449    18088356 :         for (x = 0; x < width; x++)
    1450    16918032 :             dst[x] = av_clip_pixel((((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
    1451     1170324 :         tmp += MAX_PB_SIZE;
    1452     1170324 :         dst += dststride;
    1453             :     }
    1454      123494 : }
    1455             : 
    1456       81352 : static void FUNC(put_hevc_epel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
    1457             :                                         int16_t *src2,
    1458             :                                         int height, int denom, int wx0, int wx1,
    1459             :                                         int ox0, int ox1, intptr_t mx, intptr_t my, int width)
    1460             : {
    1461             :     int x, y;
    1462       81352 :     pixel *src = (pixel *)_src;
    1463       81352 :     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
    1464       81352 :     pixel *dst          = (pixel *)_dst;
    1465       81352 :     ptrdiff_t dststride = _dststride / sizeof(pixel);
    1466       81352 :     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
    1467             :     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
    1468       81352 :     int16_t *tmp = tmp_array;
    1469       81352 :     int shift = 14 + 1 - BIT_DEPTH;
    1470       81352 :     int log2Wd = denom + shift - 1;
    1471             : 
    1472       81352 :     src -= EPEL_EXTRA_BEFORE * srcstride;
    1473             : 
    1474     1313868 :     for (y = 0; y < height + EPEL_EXTRA; y++) {
    1475    20871764 :         for (x = 0; x < width; x++)
    1476    19639248 :             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
    1477     1232516 :         src += srcstride;
    1478     1232516 :         tmp += MAX_PB_SIZE;
    1479             :     }
    1480             : 
    1481       81352 :     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
    1482       81352 :     filter = ff_hevc_epel_filters[my - 1];
    1483             : 
    1484       81352 :     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
    1485       81352 :     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
    1486     1069812 :     for (y = 0; y < height; y++) {
    1487    17776268 :         for (x = 0; x < width; x++)
    1488    16787808 :             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +
    1489             :                                     ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));
    1490      988460 :         tmp  += MAX_PB_SIZE;
    1491      988460 :         dst  += dststride;
    1492      988460 :         src2 += MAX_PB_SIZE;
    1493             :     }
    1494       81352 : }
    1495             : 
    1496             : // line zero
    1497             : #define P3 pix[-4 * xstride]
    1498             : #define P2 pix[-3 * xstride]
    1499             : #define P1 pix[-2 * xstride]
    1500             : #define P0 pix[-1 * xstride]
    1501             : #define Q0 pix[0 * xstride]
    1502             : #define Q1 pix[1 * xstride]
    1503             : #define Q2 pix[2 * xstride]
    1504             : #define Q3 pix[3 * xstride]
    1505             : 
    1506             : // line three. used only for deblocking decision
    1507             : #define TP3 pix[-4 * xstride + 3 * ystride]
    1508             : #define TP2 pix[-3 * xstride + 3 * ystride]
    1509             : #define TP1 pix[-2 * xstride + 3 * ystride]
    1510             : #define TP0 pix[-1 * xstride + 3 * ystride]
    1511             : #define TQ0 pix[0  * xstride + 3 * ystride]
    1512             : #define TQ1 pix[1  * xstride + 3 * ystride]
    1513             : #define TQ2 pix[2  * xstride + 3 * ystride]
    1514             : #define TQ3 pix[3  * xstride + 3 * ystride]
    1515             : 
    1516    34042750 : static void FUNC(hevc_loop_filter_luma)(uint8_t *_pix,
    1517             :                                         ptrdiff_t _xstride, ptrdiff_t _ystride,
    1518             :                                         int beta, int *_tc,
    1519             :                                         uint8_t *_no_p, uint8_t *_no_q)
    1520             : {
    1521             :     int d, j;
    1522    34042750 :     pixel *pix        = (pixel *)_pix;
    1523    34042750 :     ptrdiff_t xstride = _xstride / sizeof(pixel);
    1524    34042750 :     ptrdiff_t ystride = _ystride / sizeof(pixel);
    1525             : 
    1526    34042750 :     beta <<= BIT_DEPTH - 8;
    1527             : 
    1528   102128250 :     for (j = 0; j < 2; j++) {
    1529    68085500 :         const int dp0  = abs(P2  - 2 * P1  + P0);
    1530    68085500 :         const int dq0  = abs(Q2  - 2 * Q1  + Q0);
    1531    68085500 :         const int dp3  = abs(TP2 - 2 * TP1 + TP0);
    1532    68085500 :         const int dq3  = abs(TQ2 - 2 * TQ1 + TQ0);
    1533    68085500 :         const int d0   = dp0 + dq0;
    1534    68085500 :         const int d3   = dp3 + dq3;
    1535    68085500 :         const int tc   = _tc[j]   << (BIT_DEPTH - 8);
    1536    68085500 :         const int no_p = _no_p[j];
    1537    68085500 :         const int no_q = _no_q[j];
    1538             : 
    1539    68085500 :         if (d0 + d3 >= beta) {
    1540    17191654 :             pix += 4 * ystride;
    1541    17191654 :             continue;
    1542             :         } else {
    1543    50893846 :             const int beta_3 = beta >> 3;
    1544    50893846 :             const int beta_2 = beta >> 2;
    1545    50893846 :             const int tc25   = ((tc * 5 + 1) >> 1);
    1546             : 
    1547    64818699 :             if (abs(P3  -  P0) + abs(Q3  -  Q0) < beta_3 && abs(P0  -  Q0) < tc25 &&
    1548    34672158 :                 abs(TP3 - TP0) + abs(TQ3 - TQ0) < beta_3 && abs(TP0 - TQ0) < tc25 &&
    1549    30061408 :                                       (d0 << 1) < beta_2 &&      (d3 << 1) < beta_2) {
    1550             :                 // strong filtering
    1551     9760039 :                 const int tc2 = tc << 1;
    1552    48800195 :                 for (d = 0; d < 4; d++) {
    1553    39040156 :                     const int p3 = P3;
    1554    39040156 :                     const int p2 = P2;
    1555    39040156 :                     const int p1 = P1;
    1556    39040156 :                     const int p0 = P0;
    1557    39040156 :                     const int q0 = Q0;
    1558    39040156 :                     const int q1 = Q1;
    1559    39040156 :                     const int q2 = Q2;
    1560    39040156 :                     const int q3 = Q3;
    1561    39040156 :                     if (!no_p) {
    1562    39034612 :                         P0 = p0 + av_clip(((p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3) - p0, -tc2, tc2);
    1563    39034612 :                         P1 = p1 + av_clip(((p2 + p1 + p0 + q0 + 2) >> 2) - p1, -tc2, tc2);
    1564    39034612 :                         P2 = p2 + av_clip(((2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3) - p2, -tc2, tc2);
    1565             :                     }
    1566    39040156 :                     if (!no_q) {
    1567    39034484 :                         Q0 = q0 + av_clip(((p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3) - q0, -tc2, tc2);
    1568    39034484 :                         Q1 = q1 + av_clip(((p0 + q0 + q1 + q2 + 2) >> 2) - q1, -tc2, tc2);
    1569    39034484 :                         Q2 = q2 + av_clip(((2 * q3 + 3 * q2 + q1 + q0 + p0 + 4) >> 3) - q2, -tc2, tc2);
    1570             :                     }
    1571    39040156 :                     pix += ystride;
    1572             :                 }
    1573             :             } else { // normal filtering
    1574    41133807 :                 int nd_p = 1;
    1575    41133807 :                 int nd_q = 1;
    1576    41133807 :                 const int tc_2 = tc >> 1;
    1577    41133807 :                 if (dp0 + dp3 < ((beta + (beta >> 1)) >> 3))
    1578    28931373 :                     nd_p = 2;
    1579    41133807 :                 if (dq0 + dq3 < ((beta + (beta >> 1)) >> 3))
    1580    28173011 :                     nd_q = 2;
    1581             : 
    1582   205669035 :                 for (d = 0; d < 4; d++) {
    1583   164535228 :                     const int p2 = P2;
    1584   164535228 :                     const int p1 = P1;
    1585   164535228 :                     const int p0 = P0;
    1586   164535228 :                     const int q0 = Q0;
    1587   164535228 :                     const int q1 = Q1;
    1588   164535228 :                     const int q2 = Q2;
    1589   164535228 :                     int delta0   = (9 * (q0 - p0) - 3 * (q1 - p1) + 8) >> 4;
    1590   164535228 :                     if (abs(delta0) < 10 * tc) {
    1591   162699181 :                         delta0 = av_clip(delta0, -tc, tc);
    1592   162699181 :                         if (!no_p)
    1593   162383864 :                             P0 = av_clip_pixel(p0 + delta0);
    1594   162699181 :                         if (!no_q)
    1595   162381933 :                             Q0 = av_clip_pixel(q0 - delta0);
    1596   162699181 :                         if (!no_p && nd_p > 1) {
    1597   114530938 :                             const int deltap1 = av_clip((((p2 + p0 + 1) >> 1) - p1 + delta0) >> 1, -tc_2, tc_2);
    1598   114530938 :                             P1 = av_clip_pixel(p1 + deltap1);
    1599             :                         }
    1600   162699181 :                         if (!no_q && nd_q > 1) {
    1601   111519012 :                             const int deltaq1 = av_clip((((q2 + q0 + 1) >> 1) - q1 - delta0) >> 1, -tc_2, tc_2);
    1602   111519012 :                             Q1 = av_clip_pixel(q1 + deltaq1);
    1603             :                         }
    1604             :                     }
    1605   164535228 :                     pix += ystride;
    1606             :                 }
    1607             :             }
    1608             :         }
    1609             :     }
    1610    34042750 : }
    1611             : 
    1612    10446678 : static void FUNC(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,
    1613             :                                           ptrdiff_t _ystride, int *_tc,
    1614             :                                           uint8_t *_no_p, uint8_t *_no_q)
    1615             : {
    1616             :     int d, j, no_p, no_q;
    1617    10446678 :     pixel *pix        = (pixel *)_pix;
    1618    10446678 :     ptrdiff_t xstride = _xstride / sizeof(pixel);
    1619    10446678 :     ptrdiff_t ystride = _ystride / sizeof(pixel);
    1620             : 
    1621    31340034 :     for (j = 0; j < 2; j++) {
    1622    20893356 :         const int tc = _tc[j] << (BIT_DEPTH - 8);
    1623    20893356 :         if (tc <= 0) {
    1624     1651873 :             pix += 4 * ystride;
    1625     1651873 :             continue;
    1626             :         }
    1627    19241483 :         no_p = _no_p[j];
    1628    19241483 :         no_q = _no_q[j];
    1629             : 
    1630    96207415 :         for (d = 0; d < 4; d++) {
    1631             :             int delta0;
    1632    76965932 :             const int p1 = P1;
    1633    76965932 :             const int p0 = P0;
    1634    76965932 :             const int q0 = Q0;
    1635    76965932 :             const int q1 = Q1;
    1636    76965932 :             delta0 = av_clip((((q0 - p0) * 4) + p1 - q1 + 4) >> 3, -tc, tc);
    1637    76965932 :             if (!no_p)
    1638    76703340 :                 P0 = av_clip_pixel(p0 + delta0);
    1639    76965932 :             if (!no_q)
    1640    76699484 :                 Q0 = av_clip_pixel(q0 - delta0);
    1641    76965932 :             pix += ystride;
    1642             :         }
    1643             :     }
    1644    10446678 : }
    1645             : 
    1646     5111466 : static void FUNC(hevc_h_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride,
    1647             :                                             int32_t *tc, uint8_t *no_p,
    1648             :                                             uint8_t *no_q)
    1649             : {
    1650     5111466 :     FUNC(hevc_loop_filter_chroma)(pix, stride, sizeof(pixel), tc, no_p, no_q);
    1651     5111466 : }
    1652             : 
    1653     5335212 : static void FUNC(hevc_v_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride,
    1654             :                                             int32_t *tc, uint8_t *no_p,
    1655             :                                             uint8_t *no_q)
    1656             : {
    1657     5335212 :     FUNC(hevc_loop_filter_chroma)(pix, sizeof(pixel), stride, tc, no_p, no_q);
    1658     5335212 : }
    1659             : 
    1660    17186146 : static void FUNC(hevc_h_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,
    1661             :                                           int beta, int32_t *tc, uint8_t *no_p,
    1662             :                                           uint8_t *no_q)
    1663             : {
    1664    17186146 :     FUNC(hevc_loop_filter_luma)(pix, stride, sizeof(pixel),
    1665             :                                 beta, tc, no_p, no_q);
    1666    17186146 : }
    1667             : 
    1668    16856604 : static void FUNC(hevc_v_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,
    1669             :                                           int beta, int32_t *tc, uint8_t *no_p,
    1670             :                                           uint8_t *no_q)
    1671             : {
    1672    16856604 :     FUNC(hevc_loop_filter_luma)(pix, sizeof(pixel), stride,
    1673             :                                 beta, tc, no_p, no_q);
    1674    16856604 : }
    1675             : 
    1676             : #undef P3
    1677             : #undef P2
    1678             : #undef P1
    1679             : #undef P0
    1680             : #undef Q0
    1681             : #undef Q1
    1682             : #undef Q2
    1683             : #undef Q3
    1684             : 
    1685             : #undef TP3
    1686             : #undef TP2
    1687             : #undef TP1
    1688             : #undef TP0
    1689             : #undef TQ0
    1690             : #undef TQ1
    1691             : #undef TQ2
    1692             : #undef TQ3

Generated by: LCOV version 1.13