falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
89353 Commits
32 Branches
359MB
Tree: 0409d33311
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0409d33311'
${ noResults }
FFmpeg/libavcodec/hevcdsp_template.c

1693 lines
61KB
Raw Blame History 

  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. 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.     pixel *dst = (pixel *)_dst;

  34. 

  35.     stride /= sizeof(pixel);

  36. 

  37.     for (y = 0; y < height; y++) {

  38.         for (x = 0; x < width; x++)

  39.             dst[x] = get_bits(gb, pcm_bit_depth) << (BIT_DEPTH - pcm_bit_depth);

  40.         dst += stride;

  41.     }

  42. }

  43. 

  44. 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.     pixel *dst = (pixel *)_dst;

  49. 

  50.     stride /= sizeof(pixel);

  51. 

  52.     for (y = 0; y < size; y++) {

  53.         for (x = 0; x < size; x++) {

  54.             dst[x] = av_clip_pixel(dst[x] + *res);

  55.             res++;

  56.         }

  57.         dst += stride;

  58.     }

  59. }

  60. 

  61. static void FUNC(add_residual4x4)(uint8_t *_dst, int16_t *res,

  62.                                   ptrdiff_t stride)

  63. {

  64.     FUNC(add_residual)(_dst, res, stride, 4);

  65. }

  66. 

  67. static void FUNC(add_residual8x8)(uint8_t *_dst, int16_t *res,

  68.                                   ptrdiff_t stride)

  69. {

  70.     FUNC(add_residual)(_dst, res, stride, 8);

  71. }

  72. 

  73. static void FUNC(add_residual16x16)(uint8_t *_dst, int16_t *res,

  74.                                     ptrdiff_t stride)

  75. {

  76.     FUNC(add_residual)(_dst, res, stride, 16);

  77. }

  78. 

  79. static void FUNC(add_residual32x32)(uint8_t *_dst, int16_t *res,

  80.                                     ptrdiff_t stride)

  81. {

  82.     FUNC(add_residual)(_dst, res, stride, 32);

  83. }

  84. 

  85. static void FUNC(transform_rdpcm)(int16_t *_coeffs, int16_t log2_size, int mode)

  86. {

  87.     int16_t *coeffs = (int16_t *) _coeffs;

  88.     int x, y;

  89.     int size = 1 << log2_size;

  90. 

  91.     if (mode) {

  92.         coeffs += size;

  93.         for (y = 0; y < size - 1; y++) {

  94.             for (x = 0; x < size; x++)

  95.                 coeffs[x] += coeffs[x - size];

  96.             coeffs += size;

  97.         }

  98.     } else {

  99.         for (y = 0; y < size; y++) {

  100.             for (x = 1; x < size; x++)

  101.                 coeffs[x] += coeffs[x - 1];

  102.             coeffs += size;

  103.         }

  104.     }

  105. }

  106. 

  107. static void FUNC(dequant)(int16_t *coeffs, int16_t log2_size)

  108. {

  109.     int shift  = 15 - BIT_DEPTH - log2_size;

  110.     int x, y;

  111.     int size = 1 << log2_size;

  112. 

  113.     if (shift > 0) {

  114.         int offset = 1 << (shift - 1);

  115.         for (y = 0; y < size; y++) {

  116.             for (x = 0; x < size; x++) {

  117.                 *coeffs = (*coeffs + offset) >> shift;

  118.                 coeffs++;

  119.             }

  120.         }

  121.     } else {

  122.         for (y = 0; y < size; y++) {

  123.             for (x = 0; x < size; x++) {

  124.                 *coeffs = *coeffs << -shift;

  125.                 coeffs++;

  126.             }

  127.         }

  128.     }

  129. }

  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. static void FUNC(transform_4x4_luma)(int16_t *coeffs)

  150. {

  151.     int i;

  152.     int shift    = 7;

  153.     int add      = 1 << (shift - 1);

  154.     int16_t *src = coeffs;

  155. 

  156.     for (i = 0; i < 4; i++) {

  157.         TR_4x4_LUMA(src, src, 4, SCALE);

  158.         src++;

  159.     }

  160. 

  161.     shift = 20 - BIT_DEPTH;

  162.     add   = 1 << (shift - 1);

  163.     for (i = 0; i < 4; i++) {

  164.         TR_4x4_LUMA(coeffs, coeffs, 1, SCALE);

  165.         coeffs += 4;

  166.     }

  167. }

  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. IDCT( 4)

  281. IDCT( 8)

  282. IDCT(16)

  283. IDCT(32)

  284. 

  285. IDCT_DC( 4)

  286. IDCT_DC( 8)

  287. IDCT_DC(16)

  288. 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. 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.     pixel *dst = (pixel *)_dst;

  304.     pixel *src = (pixel *)_src;

  305.     int offset_table[32] = { 0 };

  306.     int k, y, x;

  307.     int shift  = BIT_DEPTH - 5;

  308. 

  309.     stride_dst /= sizeof(pixel);

  310.     stride_src /= sizeof(pixel);

  311. 

  312.     for (k = 0; k < 4; k++)

  313.         offset_table[(k + sao_left_class) & 31] = sao_offset_val[k + 1];

  314.     for (y = 0; y < height; y++) {

  315.         for (x = 0; x < width; x++)

  316.             dst[x] = av_clip_pixel(src[x] + offset_table[src[x] >> shift]);

  317.         dst += stride_dst;

  318.         src += stride_src;

  319.     }

  320. }

  321. 

  322. #define CMP(a, b) (((a) > (b)) - ((a) < (b)))

  323. 

  324. 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.     pixel *dst = (pixel *)_dst;

  335.     pixel *src = (pixel *)_src;

  336.     int a_stride, b_stride;

  337.     int x, y;

  338.     ptrdiff_t stride_src = (2*MAX_PB_SIZE + AV_INPUT_BUFFER_PADDING_SIZE) / sizeof(pixel);

  339.     stride_dst /= sizeof(pixel);

  340. 

  341.     a_stride = pos[eo][0][0] + pos[eo][0][1] * stride_src;

  342.     b_stride = pos[eo][1][0] + pos[eo][1][1] * stride_src;

  343.     for (y = 0; y < height; y++) {

  344.         for (x = 0; x < width; x++) {

  345.             int diff0 = CMP(src[x], src[x + a_stride]);

  346.             int diff1 = CMP(src[x], src[x + b_stride]);

  347.             int offset_val        = edge_idx[2 + diff0 + diff1];

  348.             dst[x] = av_clip_pixel(src[x] + sao_offset_val[offset_val]);

  349.         }

  350.         src += stride_src;

  351.         dst += stride_dst;

  352.     }

  353. }

  354. 

  355. 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.     pixel *dst = (pixel *)_dst;

  363.     pixel *src = (pixel *)_src;

  364.     int16_t *sao_offset_val = sao->offset_val[c_idx];

  365.     int sao_eo_class    = sao->eo_class[c_idx];

  366.     int init_x = 0, width = _width, height = _height;

  367. 

  368.     stride_dst /= sizeof(pixel);

  369.     stride_src /= sizeof(pixel);

  370. 

  371.     if (sao_eo_class != SAO_EO_VERT) {

  372.         if (borders[0]) {

  373.             int offset_val = sao_offset_val[0];

  374.             for (y = 0; y < height; y++) {

  375.                 dst[y * stride_dst] = av_clip_pixel(src[y * stride_src] + offset_val);

  376.             }

  377.             init_x = 1;

  378.         }

  379.         if (borders[2]) {

  380.             int offset_val = sao_offset_val[0];

  381.             int offset     = width - 1;

  382.             for (x = 0; x < height; x++) {

  383.                 dst[x * stride_dst + offset] = av_clip_pixel(src[x * stride_src + offset] + offset_val);

  384.             }

  385.             width--;

  386.         }

  387.     }

  388.     if (sao_eo_class != SAO_EO_HORIZ) {

  389.         if (borders[1]) {

  390.             int offset_val = sao_offset_val[0];

  391.             for (x = init_x; x < width; x++)

  392.                 dst[x] = av_clip_pixel(src[x] + offset_val);

  393.         }

  394.         if (borders[3]) {

  395.             int offset_val   = sao_offset_val[0];

  396.             ptrdiff_t y_stride_dst = stride_dst * (height - 1);

  397.             ptrdiff_t y_stride_src = stride_src * (height - 1);

  398.             for (x = init_x; x < width; x++)

  399.                 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);

  400.             height--;

  401.         }

  402.     }

  403. }

  404. 

  405. 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.     pixel *dst = (pixel *)_dst;

  413.     pixel *src = (pixel *)_src;

  414.     int16_t *sao_offset_val = sao->offset_val[c_idx];

  415.     int sao_eo_class    = sao->eo_class[c_idx];

  416.     int init_x = 0, init_y = 0, width = _width, height = _height;

  417. 

  418.     stride_dst /= sizeof(pixel);

  419.     stride_src /= sizeof(pixel);

  420. 

  421.     if (sao_eo_class != SAO_EO_VERT) {

  422.         if (borders[0]) {

  423.             int offset_val = sao_offset_val[0];

  424.             for (y = 0; y < height; y++) {

  425.                 dst[y * stride_dst] = av_clip_pixel(src[y * stride_src] + offset_val);

  426.             }

  427.             init_x = 1;

  428.         }

  429.         if (borders[2]) {

  430.             int offset_val = sao_offset_val[0];

  431.             int offset     = width - 1;

  432.             for (x = 0; x < height; x++) {

  433.                 dst[x * stride_dst + offset] = av_clip_pixel(src[x * stride_src + offset] + offset_val);

  434.             }

  435.             width--;

  436.         }

  437.     }

  438.     if (sao_eo_class != SAO_EO_HORIZ) {

  439.         if (borders[1]) {

  440.             int offset_val = sao_offset_val[0];

  441.             for (x = init_x; x < width; x++)

  442.                 dst[x] = av_clip_pixel(src[x] + offset_val);

  443.             init_y = 1;

  444.         }

  445.         if (borders[3]) {

  446.             int offset_val   = sao_offset_val[0];

  447.             ptrdiff_t y_stride_dst = stride_dst * (height - 1);

  448.             ptrdiff_t y_stride_src = stride_src * (height - 1);

  449.             for (x = init_x; x < width; x++)

  450.                 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);

  451.             height--;

  452.         }

  453.     }

  454. 

  455.     {

  456.         int save_upper_left  = !diag_edge[0] && sao_eo_class == SAO_EO_135D && !borders[0] && !borders[1];

  457.         int save_upper_right = !diag_edge[1] && sao_eo_class == SAO_EO_45D  && !borders[1] && !borders[2];

  458.         int save_lower_right = !diag_edge[2] && sao_eo_class == SAO_EO_135D && !borders[2] && !borders[3];

  459.         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.         if(vert_edge[0] && sao_eo_class != SAO_EO_VERT) {

  463.             for(y = init_y+save_upper_left; y< height-save_lower_left; y++)

  464.                 dst[y*stride_dst] = src[y*stride_src];

  465.         }

  466.         if(vert_edge[1] && sao_eo_class != SAO_EO_VERT) {

  467.             for(y = init_y+save_upper_right; y< height-save_lower_right; y++)

  468.                 dst[y*stride_dst+width-1] = src[y*stride_src+width-1];

  469.         }

  470. 

  471.         if(horiz_edge[0] && sao_eo_class != SAO_EO_HORIZ) {

  472.             for(x = init_x+save_upper_left; x < width-save_upper_right; x++)

  473.                 dst[x] = src[x];

  474.         }

  475.         if(horiz_edge[1] && sao_eo_class != SAO_EO_HORIZ) {

  476.             for(x = init_x+save_lower_left; x < width-save_lower_right; x++)

  477.                 dst[(height-1)*stride_dst+x] = src[(height-1)*stride_src+x];

  478.         }

  479.         if(diag_edge[0] && sao_eo_class == SAO_EO_135D)

  480.             dst[0] = src[0];

  481.         if(diag_edge[1] && sao_eo_class == SAO_EO_45D)

  482.             dst[width-1] = src[width-1];

  483.         if(diag_edge[2] && sao_eo_class == SAO_EO_135D)

  484.             dst[stride_dst*(height-1)+width-1] = src[stride_src*(height-1)+width-1];

  485.         if(diag_edge[3] && sao_eo_class == SAO_EO_45D)

  486.             dst[stride_dst*(height-1)] = src[stride_src*(height-1)];

  487. 

  488.     }

  489. }

  490. 

  491. #undef CMP

  492. 

  493. ////////////////////////////////////////////////////////////////////////////////

  494. //

  495. ////////////////////////////////////////////////////////////////////////////////

  496. 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.     pixel *src          = (pixel *)_src;

  502.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  503. 

  504.     for (y = 0; y < height; y++) {

  505.         for (x = 0; x < width; x++)

  506.             dst[x] = src[x] << (14 - BIT_DEPTH);

  507.         src += srcstride;

  508.         dst += MAX_PB_SIZE;

  509.     }

  510. }

  511. 

  512. 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.     pixel *src          = (pixel *)_src;

  517.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  518.     pixel *dst          = (pixel *)_dst;

  519.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  520. 

  521.     for (y = 0; y < height; y++) {

  522.         memcpy(dst, src, width * sizeof(pixel));

  523.         src += srcstride;

  524.         dst += dststride;

  525.     }

  526. }

  527. 

  528. 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.     pixel *src          = (pixel *)_src;

  534.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  535.     pixel *dst          = (pixel *)_dst;

  536.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  537. 

  538.     int shift = 14  + 1 - BIT_DEPTH;

  539. #if BIT_DEPTH < 14

  540.     int offset = 1 << (shift - 1);

  541. #else

  542.     int offset = 0;

  543. #endif

  544. 

  545.     for (y = 0; y < height; y++) {

  546.         for (x = 0; x < width; x++)

  547.             dst[x] = av_clip_pixel(((src[x] << (14 - BIT_DEPTH)) + src2[x] + offset) >> shift);

  548.         src  += srcstride;

  549.         dst  += dststride;

  550.         src2 += MAX_PB_SIZE;

  551.     }

  552. }

  553. 

  554. 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.     pixel *src          = (pixel *)_src;

  559.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  560.     pixel *dst          = (pixel *)_dst;

  561.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  562.     int shift = denom + 14 - BIT_DEPTH;

  563. #if BIT_DEPTH < 14

  564.     int offset = 1 << (shift - 1);

  565. #else

  566.     int offset = 0;

  567. #endif

  568. 

  569.     ox     = ox * (1 << (BIT_DEPTH - 8));

  570.     for (y = 0; y < height; y++) {

  571.         for (x = 0; x < width; x++)

  572.             dst[x] = av_clip_pixel((((src[x] << (14 - BIT_DEPTH)) * wx + offset) >> shift) + ox);

  573.         src += srcstride;

  574.         dst += dststride;

  575.     }

  576. }

  577. 

  578. 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.     pixel *src          = (pixel *)_src;

  585.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  586.     pixel *dst          = (pixel *)_dst;

  587.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  588. 

  589.     int shift = 14  + 1 - BIT_DEPTH;

  590.     int log2Wd = denom + shift - 1;

  591. 

  592.     ox0     = ox0 * (1 << (BIT_DEPTH - 8));

  593.     ox1     = ox1 * (1 << (BIT_DEPTH - 8));

  594.     for (y = 0; y < height; y++) {

  595.         for (x = 0; x < width; x++) {

  596.             dst[x] = av_clip_pixel(( (src[x] << (14 - BIT_DEPTH)) * wx1 + src2[x] * wx0 + (ox0 + ox1 + 1) * (1 << log2Wd)) >> (log2Wd + 1));

  597.         }

  598.         src  += srcstride;

  599.         dst  += dststride;

  600.         src2 += MAX_PB_SIZE;

  601.     }

  602. }

  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. 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.     pixel        *src       = (pixel*)_src;

  623.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  624.     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];

  625.     for (y = 0; y < height; y++) {

  626.         for (x = 0; x < width; x++)

  627.             dst[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  628.         src += srcstride;

  629.         dst += MAX_PB_SIZE;

  630.     }

  631. }

  632. 

  633. 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.     pixel        *src       = (pixel*)_src;

  639.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  640.     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];

  641.     for (y = 0; y < height; y++)  {

  642.         for (x = 0; x < width; x++)

  643.             dst[x] = QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8);

  644.         src += srcstride;

  645.         dst += MAX_PB_SIZE;

  646.     }

  647. }

  648. 

  649. 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.     pixel *src = (pixel*)_src;

  658.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  659.     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

  660.     int16_t *tmp = tmp_array;

  661. 

  662.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  663.     filter = ff_hevc_qpel_filters[mx - 1];

  664.     for (y = 0; y < height + QPEL_EXTRA; y++) {

  665.         for (x = 0; x < width; x++)

  666.             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  667.         src += srcstride;

  668.         tmp += MAX_PB_SIZE;

  669.     }

  670. 

  671.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  672.     filter = ff_hevc_qpel_filters[my - 1];

  673.     for (y = 0; y < height; y++) {

  674.         for (x = 0; x < width; x++)

  675.             dst[x] = QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6;

  676.         tmp += MAX_PB_SIZE;

  677.         dst += MAX_PB_SIZE;

  678.     }

  679. }

  680. 

  681. 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.     pixel        *src       = (pixel*)_src;

  687.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  688.     pixel *dst          = (pixel *)_dst;

  689.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  690.     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];

  691.     int shift = 14 - BIT_DEPTH;

  692. 

  693. #if BIT_DEPTH < 14

  694.     int offset = 1 << (shift - 1);

  695. #else

  696.     int offset = 0;

  697. #endif

  698. 

  699.     for (y = 0; y < height; y++) {

  700.         for (x = 0; x < width; x++)

  701.             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);

  702.         src += srcstride;

  703.         dst += dststride;

  704.     }

  705. }

  706. 

  707. 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.     pixel        *src       = (pixel*)_src;

  713.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  714.     pixel *dst          = (pixel *)_dst;

  715.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  716. 

  717.     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];

  718. 

  719.     int shift = 14  + 1 - BIT_DEPTH;

  720. #if BIT_DEPTH < 14

  721.     int offset = 1 << (shift - 1);

  722. #else

  723.     int offset = 0;

  724. #endif

  725. 

  726.     for (y = 0; y < height; y++) {

  727.         for (x = 0; x < width; x++)

  728.             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);

  729.         src  += srcstride;

  730.         dst  += dststride;

  731.         src2 += MAX_PB_SIZE;

  732.     }

  733. }

  734. 

  735. 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.     pixel        *src       = (pixel*)_src;

  741.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  742.     pixel *dst          = (pixel *)_dst;

  743.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  744.     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];

  745.     int shift = 14 - BIT_DEPTH;

  746. 

  747. #if BIT_DEPTH < 14

  748.     int offset = 1 << (shift - 1);

  749. #else

  750.     int offset = 0;

  751. #endif

  752. 

  753.     for (y = 0; y < height; y++) {

  754.         for (x = 0; x < width; x++)

  755.             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + offset) >> shift);

  756.         src += srcstride;

  757.         dst += dststride;

  758.     }

  759. }

  760. 

  761. 

  762. 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.     pixel        *src       = (pixel*)_src;

  768.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  769.     pixel *dst          = (pixel *)_dst;

  770.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  771. 

  772.     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];

  773. 

  774.     int shift = 14 + 1 - BIT_DEPTH;

  775. #if BIT_DEPTH < 14

  776.     int offset = 1 << (shift - 1);

  777. #else

  778.     int offset = 0;

  779. #endif

  780. 

  781.     for (y = 0; y < height; y++) {

  782.         for (x = 0; x < width; x++)

  783.             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);

  784.         src  += srcstride;

  785.         dst  += dststride;

  786.         src2 += MAX_PB_SIZE;

  787.     }

  788. }

  789. 

  790. 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.     pixel *src = (pixel*)_src;

  797.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  798.     pixel *dst          = (pixel *)_dst;

  799.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  800.     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

  801.     int16_t *tmp = tmp_array;

  802.     int shift =  14 - BIT_DEPTH;

  803. 

  804. #if BIT_DEPTH < 14

  805.     int offset = 1 << (shift - 1);

  806. #else

  807.     int offset = 0;

  808. #endif

  809. 

  810.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  811.     filter = ff_hevc_qpel_filters[mx - 1];

  812.     for (y = 0; y < height + QPEL_EXTRA; y++) {

  813.         for (x = 0; x < width; x++)

  814.             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  815.         src += srcstride;

  816.         tmp += MAX_PB_SIZE;

  817.     }

  818. 

  819.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  820.     filter = ff_hevc_qpel_filters[my - 1];

  821. 

  822.     for (y = 0; y < height; y++) {

  823.         for (x = 0; x < width; x++)

  824.             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);

  825.         tmp += MAX_PB_SIZE;

  826.         dst += dststride;

  827.     }

  828. }

  829. 

  830. 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.     pixel *src = (pixel*)_src;

  837.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  838.     pixel *dst          = (pixel *)_dst;

  839.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  840.     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

  841.     int16_t *tmp = tmp_array;

  842.     int shift = 14 + 1 - BIT_DEPTH;

  843. #if BIT_DEPTH < 14

  844.     int offset = 1 << (shift - 1);

  845. #else

  846.     int offset = 0;

  847. #endif

  848. 

  849.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  850.     filter = ff_hevc_qpel_filters[mx - 1];

  851.     for (y = 0; y < height + QPEL_EXTRA; y++) {

  852.         for (x = 0; x < width; x++)

  853.             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  854.         src += srcstride;

  855.         tmp += MAX_PB_SIZE;

  856.     }

  857. 

  858.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  859.     filter = ff_hevc_qpel_filters[my - 1];

  860. 

  861.     for (y = 0; y < height; y++) {

  862.         for (x = 0; x < width; x++)

  863.             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + src2[x] + offset) >> shift);

  864.         tmp  += MAX_PB_SIZE;

  865.         dst  += dststride;

  866.         src2 += MAX_PB_SIZE;

  867.     }

  868. }

  869. 

  870. 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.     pixel        *src       = (pixel*)_src;

  877.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  878.     pixel *dst          = (pixel *)_dst;

  879.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  880.     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];

  881.     int shift = denom + 14 - BIT_DEPTH;

  882. #if BIT_DEPTH < 14

  883.     int offset = 1 << (shift - 1);

  884. #else

  885.     int offset = 0;

  886. #endif

  887. 

  888.     ox = ox * (1 << (BIT_DEPTH - 8));

  889.     for (y = 0; y < height; y++) {

  890.         for (x = 0; x < width; x++)

  891.             dst[x] = av_clip_pixel((((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);

  892.         src += srcstride;

  893.         dst += dststride;

  894.     }

  895. }

  896. 

  897. 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.     pixel        *src       = (pixel*)_src;

  904.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  905.     pixel *dst          = (pixel *)_dst;

  906.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  907. 

  908.     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];

  909. 

  910.     int shift = 14  + 1 - BIT_DEPTH;

  911.     int log2Wd = denom + shift - 1;

  912. 

  913.     ox0     = ox0 * (1 << (BIT_DEPTH - 8));

  914.     ox1     = ox1 * (1 << (BIT_DEPTH - 8));

  915.     for (y = 0; y < height; y++) {

  916.         for (x = 0; x < width; x++)

  917.             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +

  918.                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

  919.         src  += srcstride;

  920.         dst  += dststride;

  921.         src2 += MAX_PB_SIZE;

  922.     }

  923. }

  924. 

  925. 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.     pixel        *src       = (pixel*)_src;

  932.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  933.     pixel *dst          = (pixel *)_dst;

  934.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  935.     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];

  936.     int shift = denom + 14 - BIT_DEPTH;

  937. #if BIT_DEPTH < 14

  938.     int offset = 1 << (shift - 1);

  939. #else

  940.     int offset = 0;

  941. #endif

  942. 

  943.     ox = ox * (1 << (BIT_DEPTH - 8));

  944.     for (y = 0; y < height; y++) {

  945.         for (x = 0; x < width; x++)

  946.             dst[x] = av_clip_pixel((((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);

  947.         src += srcstride;

  948.         dst += dststride;

  949.     }

  950. }

  951. 

  952. 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.     pixel        *src       = (pixel*)_src;

  959.     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);

  960.     pixel *dst          = (pixel *)_dst;

  961.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  962. 

  963.     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];

  964. 

  965.     int shift = 14 + 1 - BIT_DEPTH;

  966.     int log2Wd = denom + shift - 1;

  967. 

  968.     ox0     = ox0 * (1 << (BIT_DEPTH - 8));

  969.     ox1     = ox1 * (1 << (BIT_DEPTH - 8));

  970.     for (y = 0; y < height; y++) {

  971.         for (x = 0; x < width; x++)

  972.             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +

  973.                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

  974.         src  += srcstride;

  975.         dst  += dststride;

  976.         src2 += MAX_PB_SIZE;

  977.     }

  978. }

  979. 

  980. 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.     pixel *src = (pixel*)_src;

  988.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  989.     pixel *dst          = (pixel *)_dst;

  990.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  991.     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

  992.     int16_t *tmp = tmp_array;

  993.     int shift = denom + 14 - BIT_DEPTH;

  994. #if BIT_DEPTH < 14

  995.     int offset = 1 << (shift - 1);

  996. #else

  997.     int offset = 0;

  998. #endif

  999. 

  1000.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  1001.     filter = ff_hevc_qpel_filters[mx - 1];

  1002.     for (y = 0; y < height + QPEL_EXTRA; y++) {

  1003.         for (x = 0; x < width; x++)

  1004.             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  1005.         src += srcstride;

  1006.         tmp += MAX_PB_SIZE;

  1007.     }

  1008. 

  1009.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1010.     filter = ff_hevc_qpel_filters[my - 1];

  1011. 

  1012.     ox = ox * (1 << (BIT_DEPTH - 8));

  1013.     for (y = 0; y < height; y++) {

  1014.         for (x = 0; x < width; x++)

  1015.             dst[x] = av_clip_pixel((((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);

  1016.         tmp += MAX_PB_SIZE;

  1017.         dst += dststride;

  1018.     }

  1019. }

  1020. 

  1021. 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.     pixel *src = (pixel*)_src;

  1029.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  1030.     pixel *dst          = (pixel *)_dst;

  1031.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1032.     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];

  1033.     int16_t *tmp = tmp_array;

  1034.     int shift = 14 + 1 - BIT_DEPTH;

  1035.     int log2Wd = denom + shift - 1;

  1036. 

  1037.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  1038.     filter = ff_hevc_qpel_filters[mx - 1];

  1039.     for (y = 0; y < height + QPEL_EXTRA; y++) {

  1040.         for (x = 0; x < width; x++)

  1041.             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  1042.         src += srcstride;

  1043.         tmp += MAX_PB_SIZE;

  1044.     }

  1045. 

  1046.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1047.     filter = ff_hevc_qpel_filters[my - 1];

  1048. 

  1049.     ox0     = ox0 * (1 << (BIT_DEPTH - 8));

  1050.     ox1     = ox1 * (1 << (BIT_DEPTH - 8));

  1051.     for (y = 0; y < height; y++) {

  1052.         for (x = 0; x < width; x++)

  1053.             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +

  1054.                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));

  1055.         tmp  += MAX_PB_SIZE;

  1056.         dst  += dststride;

  1057.         src2 += MAX_PB_SIZE;

  1058.     }

  1059. }

  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. 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.     pixel *src = (pixel *)_src;

  1076.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1077.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1078.     for (y = 0; y < height; y++) {

  1079.         for (x = 0; x < width; x++)

  1080.             dst[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  1081.         src += srcstride;

  1082.         dst += MAX_PB_SIZE;

  1083.     }

  1084. }

  1085. 

  1086. 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.     pixel *src = (pixel *)_src;

  1092.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  1093.     const int8_t *filter = ff_hevc_epel_filters[my - 1];

  1094. 

  1095.     for (y = 0; y < height; y++) {

  1096.         for (x = 0; x < width; x++)

  1097.             dst[x] = EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8);

  1098.         src += srcstride;

  1099.         dst += MAX_PB_SIZE;

  1100.     }

  1101. }

  1102. 

  1103. 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.     pixel *src = (pixel *)_src;

  1109.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  1110.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1111.     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

  1112.     int16_t *tmp = tmp_array;

  1113. 

  1114.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1115. 

  1116.     for (y = 0; y < height + EPEL_EXTRA; y++) {

  1117.         for (x = 0; x < width; x++)

  1118.             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  1119.         src += srcstride;

  1120.         tmp += MAX_PB_SIZE;

  1121.     }

  1122. 

  1123.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1124.     filter = ff_hevc_epel_filters[my - 1];

  1125. 

  1126.     for (y = 0; y < height; y++) {

  1127.         for (x = 0; x < width; x++)

  1128.             dst[x] = EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6;

  1129.         tmp += MAX_PB_SIZE;

  1130.         dst += MAX_PB_SIZE;

  1131.     }

  1132. }

  1133. 

  1134. 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.     pixel *src = (pixel *)_src;

  1139.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1140.     pixel *dst          = (pixel *)_dst;

  1141.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1142.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1143.     int shift = 14 - BIT_DEPTH;

  1144. #if BIT_DEPTH < 14

  1145.     int offset = 1 << (shift - 1);

  1146. #else

  1147.     int offset = 0;

  1148. #endif

  1149. 

  1150.     for (y = 0; y < height; y++) {

  1151.         for (x = 0; x < width; x++)

  1152.             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);

  1153.         src += srcstride;

  1154.         dst += dststride;

  1155.     }

  1156. }

  1157. 

  1158. 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.     pixel *src = (pixel *)_src;

  1164.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1165.     pixel *dst          = (pixel *)_dst;

  1166.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1167.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1168.     int shift = 14 + 1 - BIT_DEPTH;

  1169. #if BIT_DEPTH < 14

  1170.     int offset = 1 << (shift - 1);

  1171. #else

  1172.     int offset = 0;

  1173. #endif

  1174. 

  1175.     for (y = 0; y < height; y++) {

  1176.         for (x = 0; x < width; x++) {

  1177.             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);

  1178.         }

  1179.         dst  += dststride;

  1180.         src  += srcstride;

  1181.         src2 += MAX_PB_SIZE;

  1182.     }

  1183. }

  1184. 

  1185. 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.     pixel *src = (pixel *)_src;

  1190.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1191.     pixel *dst          = (pixel *)_dst;

  1192.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1193.     const int8_t *filter = ff_hevc_epel_filters[my - 1];

  1194.     int shift = 14 - BIT_DEPTH;

  1195. #if BIT_DEPTH < 14

  1196.     int offset = 1 << (shift - 1);

  1197. #else

  1198.     int offset = 0;

  1199. #endif

  1200. 

  1201.     for (y = 0; y < height; y++) {

  1202.         for (x = 0; x < width; x++)

  1203.             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + offset) >> shift);

  1204.         src += srcstride;

  1205.         dst += dststride;

  1206.     }

  1207. }

  1208. 

  1209. 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.     pixel *src = (pixel *)_src;

  1215.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1216.     const int8_t *filter = ff_hevc_epel_filters[my - 1];

  1217.     pixel *dst          = (pixel *)_dst;

  1218.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1219.     int shift = 14 + 1 - BIT_DEPTH;

  1220. #if BIT_DEPTH < 14

  1221.     int offset = 1 << (shift - 1);

  1222. #else

  1223.     int offset = 0;

  1224. #endif

  1225. 

  1226.     for (y = 0; y < height; y++) {

  1227.         for (x = 0; x < width; x++)

  1228.             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);

  1229.         dst  += dststride;

  1230.         src  += srcstride;

  1231.         src2 += MAX_PB_SIZE;

  1232.     }

  1233. }

  1234. 

  1235. 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.     pixel *src = (pixel *)_src;

  1240.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  1241.     pixel *dst          = (pixel *)_dst;

  1242.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1243.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1244.     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

  1245.     int16_t *tmp = tmp_array;

  1246.     int shift = 14 - BIT_DEPTH;

  1247. #if BIT_DEPTH < 14

  1248.     int offset = 1 << (shift - 1);

  1249. #else

  1250.     int offset = 0;

  1251. #endif

  1252. 

  1253.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1254. 

  1255.     for (y = 0; y < height + EPEL_EXTRA; y++) {

  1256.         for (x = 0; x < width; x++)

  1257.             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  1258.         src += srcstride;

  1259.         tmp += MAX_PB_SIZE;

  1260.     }

  1261. 

  1262.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1263.     filter = ff_hevc_epel_filters[my - 1];

  1264. 

  1265.     for (y = 0; y < height; y++) {

  1266.         for (x = 0; x < width; x++)

  1267.             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);

  1268.         tmp += MAX_PB_SIZE;

  1269.         dst += dststride;

  1270.     }

  1271. }

  1272. 

  1273. 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.     pixel *src = (pixel *)_src;

  1279.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  1280.     pixel *dst          = (pixel *)_dst;

  1281.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1282.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1283.     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

  1284.     int16_t *tmp = tmp_array;

  1285.     int shift = 14 + 1 - BIT_DEPTH;

  1286. #if BIT_DEPTH < 14

  1287.     int offset = 1 << (shift - 1);

  1288. #else

  1289.     int offset = 0;

  1290. #endif

  1291. 

  1292.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1293. 

  1294.     for (y = 0; y < height + EPEL_EXTRA; y++) {

  1295.         for (x = 0; x < width; x++)

  1296.             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  1297.         src += srcstride;

  1298.         tmp += MAX_PB_SIZE;

  1299.     }

  1300. 

  1301.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1302.     filter = ff_hevc_epel_filters[my - 1];

  1303. 

  1304.     for (y = 0; y < height; y++) {

  1305.         for (x = 0; x < width; x++)

  1306.             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + src2[x] + offset) >> shift);

  1307.         tmp  += MAX_PB_SIZE;

  1308.         dst  += dststride;

  1309.         src2 += MAX_PB_SIZE;

  1310.     }

  1311. }

  1312. 

  1313. 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.     pixel *src = (pixel *)_src;

  1318.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1319.     pixel *dst          = (pixel *)_dst;

  1320.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1321.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1322.     int shift = denom + 14 - BIT_DEPTH;

  1323. #if BIT_DEPTH < 14

  1324.     int offset = 1 << (shift - 1);

  1325. #else

  1326.     int offset = 0;

  1327. #endif

  1328. 

  1329.     ox     = ox * (1 << (BIT_DEPTH - 8));

  1330.     for (y = 0; y < height; y++) {

  1331.         for (x = 0; x < width; x++) {

  1332.             dst[x] = av_clip_pixel((((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);

  1333.         }

  1334.         dst += dststride;

  1335.         src += srcstride;

  1336.     }

  1337. }

  1338. 

  1339. 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.     pixel *src = (pixel *)_src;

  1346.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1347.     pixel *dst          = (pixel *)_dst;

  1348.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1349.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1350.     int shift = 14 + 1 - BIT_DEPTH;

  1351.     int log2Wd = denom + shift - 1;

  1352. 

  1353.     ox0     = ox0 * (1 << (BIT_DEPTH - 8));

  1354.     ox1     = ox1 * (1 << (BIT_DEPTH - 8));

  1355.     for (y = 0; y < height; y++) {

  1356.         for (x = 0; x < width; x++)

  1357.             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.         src  += srcstride;

  1360.         dst  += dststride;

  1361.         src2 += MAX_PB_SIZE;

  1362.     }

  1363. }

  1364. 

  1365. 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.     pixel *src = (pixel *)_src;

  1370.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1371.     pixel *dst          = (pixel *)_dst;

  1372.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1373.     const int8_t *filter = ff_hevc_epel_filters[my - 1];

  1374.     int shift = denom + 14 - BIT_DEPTH;

  1375. #if BIT_DEPTH < 14

  1376.     int offset = 1 << (shift - 1);

  1377. #else

  1378.     int offset = 0;

  1379. #endif

  1380. 

  1381.     ox     = ox * (1 << (BIT_DEPTH - 8));

  1382.     for (y = 0; y < height; y++) {

  1383.         for (x = 0; x < width; x++) {

  1384.             dst[x] = av_clip_pixel((((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);

  1385.         }

  1386.         dst += dststride;

  1387.         src += srcstride;

  1388.     }

  1389. }

  1390. 

  1391. 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.     pixel *src = (pixel *)_src;

  1398.     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);

  1399.     const int8_t *filter = ff_hevc_epel_filters[my - 1];

  1400.     pixel *dst          = (pixel *)_dst;

  1401.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1402.     int shift = 14 + 1 - BIT_DEPTH;

  1403.     int log2Wd = denom + shift - 1;

  1404. 

  1405.     ox0     = ox0 * (1 << (BIT_DEPTH - 8));

  1406.     ox1     = ox1 * (1 << (BIT_DEPTH - 8));

  1407.     for (y = 0; y < height; y++) {

  1408.         for (x = 0; x < width; x++)

  1409.             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.         src  += srcstride;

  1412.         dst  += dststride;

  1413.         src2 += MAX_PB_SIZE;

  1414.     }

  1415. }

  1416. 

  1417. 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.     pixel *src = (pixel *)_src;

  1422.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  1423.     pixel *dst          = (pixel *)_dst;

  1424.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1425.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1426.     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

  1427.     int16_t *tmp = tmp_array;

  1428.     int shift = denom + 14 - BIT_DEPTH;

  1429. #if BIT_DEPTH < 14

  1430.     int offset = 1 << (shift - 1);

  1431. #else

  1432.     int offset = 0;

  1433. #endif

  1434. 

  1435.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1436. 

  1437.     for (y = 0; y < height + EPEL_EXTRA; y++) {

  1438.         for (x = 0; x < width; x++)

  1439.             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  1440.         src += srcstride;

  1441.         tmp += MAX_PB_SIZE;

  1442.     }

  1443. 

  1444.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1445.     filter = ff_hevc_epel_filters[my - 1];

  1446. 

  1447.     ox     = ox * (1 << (BIT_DEPTH - 8));

  1448.     for (y = 0; y < height; y++) {

  1449.         for (x = 0; x < width; x++)

  1450.             dst[x] = av_clip_pixel((((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);

  1451.         tmp += MAX_PB_SIZE;

  1452.         dst += dststride;

  1453.     }

  1454. }

  1455. 

  1456. 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.     pixel *src = (pixel *)_src;

  1463.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);

  1464.     pixel *dst          = (pixel *)_dst;

  1465.     ptrdiff_t dststride = _dststride / sizeof(pixel);

  1466.     const int8_t *filter = ff_hevc_epel_filters[mx - 1];

  1467.     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];

  1468.     int16_t *tmp = tmp_array;

  1469.     int shift = 14 + 1 - BIT_DEPTH;

  1470.     int log2Wd = denom + shift - 1;

  1471. 

  1472.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1473. 

  1474.     for (y = 0; y < height + EPEL_EXTRA; y++) {

  1475.         for (x = 0; x < width; x++)

  1476.             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);

  1477.         src += srcstride;

  1478.         tmp += MAX_PB_SIZE;

  1479.     }

  1480. 

  1481.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1482.     filter = ff_hevc_epel_filters[my - 1];

  1483. 

  1484.     ox0     = ox0 * (1 << (BIT_DEPTH - 8));

  1485.     ox1     = ox1 * (1 << (BIT_DEPTH - 8));

  1486.     for (y = 0; y < height; y++) {

  1487.         for (x = 0; x < width; x++)

  1488.             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.         tmp  += MAX_PB_SIZE;

  1491.         dst  += dststride;

  1492.         src2 += MAX_PB_SIZE;

  1493.     }

  1494. }

  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. 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.     pixel *pix        = (pixel *)_pix;

  1523.     ptrdiff_t xstride = _xstride / sizeof(pixel);

  1524.     ptrdiff_t ystride = _ystride / sizeof(pixel);

  1525. 

  1526.     beta <<= BIT_DEPTH - 8;

  1527. 

  1528.     for (j = 0; j < 2; j++) {

  1529.         const int dp0  = abs(P2  - 2 * P1  + P0);

  1530.         const int dq0  = abs(Q2  - 2 * Q1  + Q0);

  1531.         const int dp3  = abs(TP2 - 2 * TP1 + TP0);

  1532.         const int dq3  = abs(TQ2 - 2 * TQ1 + TQ0);

  1533.         const int d0   = dp0 + dq0;

  1534.         const int d3   = dp3 + dq3;

  1535.         const int tc   = _tc[j]   << (BIT_DEPTH - 8);

  1536.         const int no_p = _no_p[j];

  1537.         const int no_q = _no_q[j];

  1538. 

  1539.         if (d0 + d3 >= beta) {

  1540.             pix += 4 * ystride;

  1541.             continue;

  1542.         } else {

  1543.             const int beta_3 = beta >> 3;

  1544.             const int beta_2 = beta >> 2;

  1545.             const int tc25   = ((tc * 5 + 1) >> 1);

  1546. 

  1547.             if (abs(P3  -  P0) + abs(Q3  -  Q0) < beta_3 && abs(P0  -  Q0) < tc25 &&

  1548.                 abs(TP3 - TP0) + abs(TQ3 - TQ0) < beta_3 && abs(TP0 - TQ0) < tc25 &&

  1549.                                       (d0 << 1) < beta_2 &&      (d3 << 1) < beta_2) {

  1550.                 // strong filtering

  1551.                 const int tc2 = tc << 1;

  1552.                 for (d = 0; d < 4; d++) {

  1553.                     const int p3 = P3;

  1554.                     const int p2 = P2;

  1555.                     const int p1 = P1;

  1556.                     const int p0 = P0;

  1557.                     const int q0 = Q0;

  1558.                     const int q1 = Q1;

  1559.                     const int q2 = Q2;

  1560.                     const int q3 = Q3;

  1561.                     if (!no_p) {

  1562.                         P0 = p0 + av_clip(((p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3) - p0, -tc2, tc2);

  1563.                         P1 = p1 + av_clip(((p2 + p1 + p0 + q0 + 2) >> 2) - p1, -tc2, tc2);

  1564.                         P2 = p2 + av_clip(((2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3) - p2, -tc2, tc2);

  1565.                     }

  1566.                     if (!no_q) {

  1567.                         Q0 = q0 + av_clip(((p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3) - q0, -tc2, tc2);

  1568.                         Q1 = q1 + av_clip(((p0 + q0 + q1 + q2 + 2) >> 2) - q1, -tc2, tc2);

  1569.                         Q2 = q2 + av_clip(((2 * q3 + 3 * q2 + q1 + q0 + p0 + 4) >> 3) - q2, -tc2, tc2);

  1570.                     }

  1571.                     pix += ystride;

  1572.                 }

  1573.             } else { // normal filtering

  1574.                 int nd_p = 1;

  1575.                 int nd_q = 1;

  1576.                 const int tc_2 = tc >> 1;

  1577.                 if (dp0 + dp3 < ((beta + (beta >> 1)) >> 3))

  1578.                     nd_p = 2;

  1579.                 if (dq0 + dq3 < ((beta + (beta >> 1)) >> 3))

  1580.                     nd_q = 2;

  1581. 

  1582.                 for (d = 0; d < 4; d++) {

  1583.                     const int p2 = P2;

  1584.                     const int p1 = P1;

  1585.                     const int p0 = P0;

  1586.                     const int q0 = Q0;

  1587.                     const int q1 = Q1;

  1588.                     const int q2 = Q2;

  1589.                     int delta0   = (9 * (q0 - p0) - 3 * (q1 - p1) + 8) >> 4;

  1590.                     if (abs(delta0) < 10 * tc) {

  1591.                         delta0 = av_clip(delta0, -tc, tc);

  1592.                         if (!no_p)

  1593.                             P0 = av_clip_pixel(p0 + delta0);

  1594.                         if (!no_q)

  1595.                             Q0 = av_clip_pixel(q0 - delta0);

  1596.                         if (!no_p && nd_p > 1) {

  1597.                             const int deltap1 = av_clip((((p2 + p0 + 1) >> 1) - p1 + delta0) >> 1, -tc_2, tc_2);

  1598.                             P1 = av_clip_pixel(p1 + deltap1);

  1599.                         }

  1600.                         if (!no_q && nd_q > 1) {

  1601.                             const int deltaq1 = av_clip((((q2 + q0 + 1) >> 1) - q1 - delta0) >> 1, -tc_2, tc_2);

  1602.                             Q1 = av_clip_pixel(q1 + deltaq1);

  1603.                         }

  1604.                     }

  1605.                     pix += ystride;

  1606.                 }

  1607.             }

  1608.         }

  1609.     }

  1610. }

  1611. 

  1612. 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.     pixel *pix        = (pixel *)_pix;

  1618.     ptrdiff_t xstride = _xstride / sizeof(pixel);

  1619.     ptrdiff_t ystride = _ystride / sizeof(pixel);

  1620. 

  1621.     for (j = 0; j < 2; j++) {

  1622.         const int tc = _tc[j] << (BIT_DEPTH - 8);

  1623.         if (tc <= 0) {

  1624.             pix += 4 * ystride;

  1625.             continue;

  1626.         }

  1627.         no_p = _no_p[j];

  1628.         no_q = _no_q[j];

  1629. 

  1630.         for (d = 0; d < 4; d++) {

  1631.             int delta0;

  1632.             const int p1 = P1;

  1633.             const int p0 = P0;

  1634.             const int q0 = Q0;

  1635.             const int q1 = Q1;

  1636.             delta0 = av_clip((((q0 - p0) * 4) + p1 - q1 + 4) >> 3, -tc, tc);

  1637.             if (!no_p)

  1638.                 P0 = av_clip_pixel(p0 + delta0);

  1639.             if (!no_q)

  1640.                 Q0 = av_clip_pixel(q0 - delta0);

  1641.             pix += ystride;

  1642.         }

  1643.     }

  1644. }

  1645. 

  1646. 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.     FUNC(hevc_loop_filter_chroma)(pix, stride, sizeof(pixel), tc, no_p, no_q);

  1651. }

  1652. 

  1653. 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.     FUNC(hevc_loop_filter_chroma)(pix, sizeof(pixel), stride, tc, no_p, no_q);

  1658. }

  1659. 

  1660. 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.     FUNC(hevc_loop_filter_luma)(pix, stride, sizeof(pixel),

  1665.                                 beta, tc, no_p, no_q);

  1666. }

  1667. 

  1668. 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.     FUNC(hevc_loop_filter_luma)(pix, sizeof(pixel), stride,

  1673.                                 beta, tc, no_p, no_q);

  1674. }

  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