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.
82782 Commits
32 Branches
303MB
Tree: 954c2b07b6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '954c2b07b6'
${ noResults }
FFmpeg/libavcodec/hevcdsp_template.c

1697 lines
63KB
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 "hevc.h"

  25. 

  26. #include "bit_depth_template.c"

  27. #include "hevcdsp.h"

  28. 

  29. 

  30. static void FUNC(put_pcm)(uint8_t *_dst, ptrdiff_t stride, int width, int height,

  31.                           GetBitContext *gb, int pcm_bit_depth)

  32. {

  33.     int x, y;

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

  35. 

  36.     stride /= sizeof(pixel);

  37. 

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

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

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

  41.         dst += stride;

  42.     }

  43. }

  44. 

  45. static av_always_inline void FUNC(transquant_bypass)(uint8_t *_dst, int16_t *coeffs,

  46.                                                      ptrdiff_t stride, int size)

  47. {

  48.     int x, y;

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

  50. 

  51.     stride /= sizeof(pixel);

  52. 

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

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

  55.             dst[x] = av_clip_pixel(dst[x] + *coeffs);

  56.             coeffs++;

  57.         }

  58.         dst += stride;

  59.     }

  60. }

  61. 

  62. static void FUNC(transform_add4x4)(uint8_t *_dst, int16_t *coeffs,

  63.                                        ptrdiff_t stride)

  64. {

  65.     FUNC(transquant_bypass)(_dst, coeffs, stride, 4);

  66. }

  67. 

  68. static void FUNC(transform_add8x8)(uint8_t *_dst, int16_t *coeffs,

  69.                                        ptrdiff_t stride)

  70. {

  71.     FUNC(transquant_bypass)(_dst, coeffs, stride, 8);

  72. }

  73. 

  74. static void FUNC(transform_add16x16)(uint8_t *_dst, int16_t *coeffs,

  75.                                          ptrdiff_t stride)

  76. {

  77.     FUNC(transquant_bypass)(_dst, coeffs, stride, 16);

  78. }

  79. 

  80. static void FUNC(transform_add32x32)(uint8_t *_dst, int16_t *coeffs,

  81.                                          ptrdiff_t stride)

  82. {

  83.     FUNC(transquant_bypass)(_dst, coeffs, stride, 32);

  84. }

  85. 

  86. 

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

  88. {

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

  90.     int x, y;

  91.     int size = 1 << log2_size;

  92. 

  93.     if (mode) {

  94.         coeffs += size;

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

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

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

  98.             coeffs += size;

  99.         }

  100.     } else {

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

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

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

  104.             coeffs += size;

  105.         }

  106.     }

  107. }

  108. 

  109. static void FUNC(transform_skip)(int16_t *_coeffs, int16_t log2_size)

  110. {

  111.     int shift  = 15 - BIT_DEPTH - log2_size;

  112.     int x, y;

  113.     int size = 1 << log2_size;

  114.     int16_t *coeffs = _coeffs;

  115. 

  116. 

  117.     if (shift > 0) {

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

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

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

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

  122.                 coeffs++;

  123.             }

  124.         }

  125.     } else {

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

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

  128.                 *coeffs = *(uint16_t*)coeffs << -shift;

  129.                 coeffs++;

  130.             }

  131.         }

  132.     }

  133. }

  134. 

  135. #define SET(dst, x)   (dst) = (x)

  136. #define SCALE(dst, x) (dst) = av_clip_int16(((x) + add) >> shift)

  137. #define ADD_AND_SCALE(dst, x)                                           \

  138.     (dst) = av_clip_pixel((dst) + av_clip_int16(((x) + add) >> shift))

  139. 

  140. #define TR_4x4_LUMA(dst, src, step, assign)                             \

  141.     do {                                                                \

  142.         int c0 = src[0 * step] + src[2 * step];                         \

  143.         int c1 = src[2 * step] + src[3 * step];                         \

  144.         int c2 = src[0 * step] - src[3 * step];                         \

  145.         int c3 = 74 * src[1 * step];                                    \

  146.                                                                         \

  147.         assign(dst[2 * step], 74 * (src[0 * step] -                     \

  148.                                     src[2 * step] +                     \

  149.                                     src[3 * step]));                    \

  150.         assign(dst[0 * step], 29 * c0 + 55 * c1 + c3);                  \

  151.         assign(dst[1 * step], 55 * c2 - 29 * c1 + c3);                  \

  152.         assign(dst[3 * step], 55 * c0 + 29 * c2 - c3);                  \

  153.     } while (0)

  154. 

  155. static void FUNC(transform_4x4_luma)(int16_t *coeffs)

  156. {

  157.     int i;

  158.     int shift    = 7;

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

  160.     int16_t *src = coeffs;

  161. 

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

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

  164.         src++;

  165.     }

  166. 

  167.     shift = 20 - BIT_DEPTH;

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

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

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

  171.         coeffs += 4;

  172.     }

  173. }

  174. 

  175. #undef TR_4x4_LUMA

  176. 

  177. #define TR_4(dst, src, dstep, sstep, assign, end)                              \

  178.     do {                                                                       \

  179.         const int e0 = 64 * src[0 * sstep] + 64 * src[2 * sstep];              \

  180.         const int e1 = 64 * src[0 * sstep] - 64 * src[2 * sstep];              \

  181.         const int o0 = 83 * src[1 * sstep] + 36 * src[3 * sstep];              \

  182.         const int o1 = 36 * src[1 * sstep] - 83 * src[3 * sstep];              \

  183.                                                                                \

  184.         assign(dst[0 * dstep], e0 + o0);                                       \

  185.         assign(dst[1 * dstep], e1 + o1);                                       \

  186.         assign(dst[2 * dstep], e1 - o1);                                       \

  187.         assign(dst[3 * dstep], e0 - o0);                                       \

  188.     } while (0)

  189. 

  190. #define TR_8(dst, src, dstep, sstep, assign, end)                              \

  191.     do {                                                                       \

  192.         int i, j;                                                              \

  193.         int e_8[4];                                                            \

  194.         int o_8[4] = { 0 };                                                    \

  195.         for (i = 0; i < 4; i++)                                                \

  196.             for (j = 1; j < end; j += 2)                                       \

  197.                 o_8[i] += transform[4 * j][i] * src[j * sstep];                \

  198.         TR_4(e_8, src, 1, 2 * sstep, SET, 4);                                  \

  199.                                                                                \

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

  201.             assign(dst[i * dstep], e_8[i] + o_8[i]);                           \

  202.             assign(dst[(7 - i) * dstep], e_8[i] - o_8[i]);                     \

  203.         }                                                                      \

  204.     } while (0)

  205. 

  206. #define TR_16(dst, src, dstep, sstep, assign, end)                             \

  207.     do {                                                                       \

  208.         int i, j;                                                              \

  209.         int e_16[8];                                                           \

  210.         int o_16[8] = { 0 };                                                   \

  211.         for (i = 0; i < 8; i++)                                                \

  212.             for (j = 1; j < end; j += 2)                                       \

  213.                 o_16[i] += transform[2 * j][i] * src[j * sstep];               \

  214.         TR_8(e_16, src, 1, 2 * sstep, SET, 8);                                 \

  215.                                                                                \

  216.         for (i = 0; i < 8; i++) {                                              \

  217.             assign(dst[i * dstep], e_16[i] + o_16[i]);                         \

  218.             assign(dst[(15 - i) * dstep], e_16[i] - o_16[i]);                  \

  219.         }                                                                      \

  220.     } while (0)

  221. 

  222. #define TR_32(dst, src, dstep, sstep, assign, end)                             \

  223.     do {                                                                       \

  224.         int i, j;                                                              \

  225.         int e_32[16];                                                          \

  226.         int o_32[16] = { 0 };                                                  \

  227.         for (i = 0; i < 16; i++)                                               \

  228.             for (j = 1; j < end; j += 2)                                       \

  229.                 o_32[i] += transform[j][i] * src[j * sstep];                   \

  230.         TR_16(e_32, src, 1, 2 * sstep, SET, end/2);                            \

  231.                                                                                \

  232.         for (i = 0; i < 16; i++) {                                             \

  233.             assign(dst[i * dstep], e_32[i] + o_32[i]);                         \

  234.             assign(dst[(31 - i) * dstep], e_32[i] - o_32[i]);                  \

  235.         }                                                                      \

  236.     } while (0)

  237. 

  238. #define IDCT_VAR4(H)                                                          \

  239.     int      limit2   = FFMIN(col_limit + 4, H)

  240. #define IDCT_VAR8(H)                                                          \

  241.         int      limit   = FFMIN(col_limit, H);                               \

  242.         int      limit2   = FFMIN(col_limit + 4, H)

  243. #define IDCT_VAR16(H)   IDCT_VAR8(H)

  244. #define IDCT_VAR32(H)   IDCT_VAR8(H)

  245. 

  246. #define IDCT(H)                                                              \

  247. static void FUNC(idct_##H ##x ##H )(                                         \

  248.                    int16_t *coeffs, int col_limit) {                         \

  249.     int i;                                                                   \

  250.     int      shift   = 7;                                                    \

  251.     int      add     = 1 << (shift - 1);                                     \

  252.     int16_t *src     = coeffs;                                               \

  253.     IDCT_VAR ##H(H);                                                         \

  254.                                                                              \

  255.     for (i = 0; i < H; i++) {                                                \

  256.         TR_ ## H(src, src, H, H, SCALE, limit2);                             \

  257.         if (limit2 < H && i%4 == 0 && !!i)                                   \

  258.             limit2 -= 4;                                                     \

  259.         src++;                                                               \

  260.     }                                                                        \

  261.                                                                              \

  262.     shift   = 20 - BIT_DEPTH;                                                \

  263.     add     = 1 << (shift - 1);                                              \

  264.     for (i = 0; i < H; i++) {                                                \

  265.         TR_ ## H(coeffs, coeffs, 1, 1, SCALE, limit);                        \

  266.         coeffs += H;                                                         \

  267.     }                                                                        \

  268. }

  269. 

  270. #define IDCT_DC(H)                                                           \

  271. static void FUNC(idct_##H ##x ##H ##_dc)(                                    \

  272.                    int16_t *coeffs) {                                        \

  273.     int i, j;                                                                \

  274.     int      shift   = 14 - BIT_DEPTH;                                       \

  275.     int      add     = 1 << (shift - 1);                                     \

  276.     int      coeff   = (((coeffs[0] + 1) >> 1) + add) >> shift;              \

  277.                                                                              \

  278.     for (j = 0; j < H; j++) {                                                \

  279.         for (i = 0; i < H; i++) {                                            \

  280.             coeffs[i+j*H] = coeff;                                           \

  281.         }                                                                    \

  282.     }                                                                        \

  283. }

  284. 

  285. IDCT( 4)

  286. IDCT( 8)

  287. IDCT(16)

  288. IDCT(32)

  289. 

  290. IDCT_DC( 4)

  291. IDCT_DC( 8)

  292. IDCT_DC(16)

  293. IDCT_DC(32)

  294. 

  295. #undef TR_4

  296. #undef TR_8

  297. #undef TR_16

  298. #undef TR_32

  299. 

  300. #undef SET

  301. #undef SCALE

  302. #undef ADD_AND_SCALE

  303. 

  304. static void FUNC(sao_band_filter)(uint8_t *_dst, uint8_t *_src,

  305.                                   ptrdiff_t stride_dst, ptrdiff_t stride_src,

  306.                                   int16_t *sao_offset_val, int sao_left_class,

  307.                                   int width, int height)

  308. {

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

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

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

  312.     int k, y, x;

  313.     int shift  = BIT_DEPTH - 5;

  314. 

  315.     stride_dst /= sizeof(pixel);

  316.     stride_src /= sizeof(pixel);

  317. 

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

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

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

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

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

  323.         dst += stride_dst;

  324.         src += stride_src;

  325.     }

  326. }

  327. 

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

  329. 

  330. static void FUNC(sao_edge_filter)(uint8_t *_dst, uint8_t *_src, ptrdiff_t stride_dst, int16_t *sao_offset_val,

  331.                                   int eo, int width, int height) {

  332. 

  333.     static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };

  334.     static const int8_t pos[4][2][2] = {

  335.         { { -1,  0 }, {  1, 0 } }, // horizontal

  336.         { {  0, -1 }, {  0, 1 } }, // vertical

  337.         { { -1, -1 }, {  1, 1 } }, // 45 degree

  338.         { {  1, -1 }, { -1, 1 } }, // 135 degree

  339.     };

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

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

  342.     int a_stride, b_stride;

  343.     int x, y;

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

  345.     stride_dst /= sizeof(pixel);

  346. 

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

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

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

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

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

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

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

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

  355.         }

  356.         src += stride_src;

  357.         dst += stride_dst;

  358.     }

  359. }

  360. 

  361. static void FUNC(sao_edge_restore_0)(uint8_t *_dst, uint8_t *_src,

  362.                                     ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,

  363.                                     int *borders, int _width, int _height,

  364.                                     int c_idx, uint8_t *vert_edge,

  365.                                     uint8_t *horiz_edge, uint8_t *diag_edge)

  366. {

  367.     int x, y;

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

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

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

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

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

  373. 

  374.     stride_dst /= sizeof(pixel);

  375.     stride_src /= sizeof(pixel);

  376. 

  377.     if (sao_eo_class != SAO_EO_VERT) {

  378.         if (borders[0]) {

  379.             int offset_val = sao_offset_val[0];

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

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

  382.             }

  383.             init_x = 1;

  384.         }

  385.         if (borders[2]) {

  386.             int offset_val = sao_offset_val[0];

  387.             int offset     = width - 1;

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

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

  390.             }

  391.             width--;

  392.         }

  393.     }

  394.     if (sao_eo_class != SAO_EO_HORIZ) {

  395.         if (borders[1]) {

  396.             int offset_val = sao_offset_val[0];

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

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

  399.         }

  400.         if (borders[3]) {

  401.             int offset_val   = sao_offset_val[0];

  402.             int y_stride_dst = stride_dst * (height - 1);

  403.             int y_stride_src = stride_src * (height - 1);

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

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

  406.             height--;

  407.         }

  408.     }

  409. }

  410. 

  411. static void FUNC(sao_edge_restore_1)(uint8_t *_dst, uint8_t *_src,

  412.                                     ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,

  413.                                     int *borders, int _width, int _height,

  414.                                     int c_idx, uint8_t *vert_edge,

  415.                                     uint8_t *horiz_edge, uint8_t *diag_edge)

  416. {

  417.     int x, y;

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

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

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

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

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

  423. 

  424.     stride_dst /= sizeof(pixel);

  425.     stride_src /= sizeof(pixel);

  426. 

  427.     if (sao_eo_class != SAO_EO_VERT) {

  428.         if (borders[0]) {

  429.             int offset_val = sao_offset_val[0];

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

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

  432.             }

  433.             init_x = 1;

  434.         }

  435.         if (borders[2]) {

  436.             int offset_val = sao_offset_val[0];

  437.             int offset     = width - 1;

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

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

  440.             }

  441.             width--;

  442.         }

  443.     }

  444.     if (sao_eo_class != SAO_EO_HORIZ) {

  445.         if (borders[1]) {

  446.             int offset_val = sao_offset_val[0];

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

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

  449.             init_y = 1;

  450.         }

  451.         if (borders[3]) {

  452.             int offset_val   = sao_offset_val[0];

  453.             int y_stride_dst = stride_dst * (height - 1);

  454.             int y_stride_src = stride_src * (height - 1);

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

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

  457.             height--;

  458.         }

  459.     }

  460. 

  461.     {

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

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

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

  465.         int save_lower_left  = !diag_edge[3] && sao_eo_class == SAO_EO_45D  && !borders[0] && !borders[3];

  466. 

  467.         // Restore pixels that can't be modified

  468.         if(vert_edge[0] && sao_eo_class != SAO_EO_VERT) {

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

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

  471.         }

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

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

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

  475.         }

  476. 

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

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

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

  480.         }

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

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

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

  484.         }

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

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

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

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

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

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

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

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

  493. 

  494.     }

  495. }

  496. 

  497. #undef CMP

  498. 

  499. ////////////////////////////////////////////////////////////////////////////////

  500. //

  501. ////////////////////////////////////////////////////////////////////////////////

  502. static void FUNC(put_hevc_pel_pixels)(int16_t *dst,

  503.                                       uint8_t *_src, ptrdiff_t _srcstride,

  504.                                       int height, intptr_t mx, intptr_t my, int width)

  505. {

  506.     int x, y;

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

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

  509. 

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

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

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

  513.         src += srcstride;

  514.         dst += MAX_PB_SIZE;

  515.     }

  516. }

  517. 

  518. static void FUNC(put_hevc_pel_uni_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  519.                                           int height, intptr_t mx, intptr_t my, int width)

  520. {

  521.     int y;

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

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

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

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

  526. 

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

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

  529.         src += srcstride;

  530.         dst += dststride;

  531.     }

  532. }

  533. 

  534. static void FUNC(put_hevc_pel_bi_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  535.                                          int16_t *src2,

  536.                                          int height, intptr_t mx, intptr_t my, int width)

  537. {

  538.     int x, y;

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

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

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

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

  543. 

  544.     int shift = 14  + 1 - BIT_DEPTH;

  545. #if BIT_DEPTH < 14

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

  547. #else

  548.     int offset = 0;

  549. #endif

  550. 

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

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

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

  554.         src  += srcstride;

  555.         dst  += dststride;

  556.         src2 += MAX_PB_SIZE;

  557.     }

  558. }

  559. 

  560. static void FUNC(put_hevc_pel_uni_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  561.                                             int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)

  562. {

  563.     int x, y;

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

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

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

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

  568.     int shift = denom + 14 - BIT_DEPTH;

  569. #if BIT_DEPTH < 14

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

  571. #else

  572.     int offset = 0;

  573. #endif

  574. 

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

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

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

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

  579.         src += srcstride;

  580.         dst += dststride;

  581.     }

  582. }

  583. 

  584. static void FUNC(put_hevc_pel_bi_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  585.                                            int16_t *src2,

  586.                                            int height, int denom, int wx0, int wx1,

  587.                                            int ox0, int ox1, intptr_t mx, intptr_t my, int width)

  588. {

  589.     int x, y;

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

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

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

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

  594. 

  595.     int shift = 14  + 1 - BIT_DEPTH;

  596.     int log2Wd = denom + shift - 1;

  597. 

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

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

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

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

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

  603.         }

  604.         src  += srcstride;

  605.         dst  += dststride;

  606.         src2 += MAX_PB_SIZE;

  607.     }

  608. }

  609. 

  610. ////////////////////////////////////////////////////////////////////////////////

  611. //

  612. ////////////////////////////////////////////////////////////////////////////////

  613. #define QPEL_FILTER(src, stride)                                               \

  614.     (filter[0] * src[x - 3 * stride] +                                         \

  615.      filter[1] * src[x - 2 * stride] +                                         \

  616.      filter[2] * src[x -     stride] +                                         \

  617.      filter[3] * src[x             ] +                                         \

  618.      filter[4] * src[x +     stride] +                                         \

  619.      filter[5] * src[x + 2 * stride] +                                         \

  620.      filter[6] * src[x + 3 * stride] +                                         \

  621.      filter[7] * src[x + 4 * stride])

  622. 

  623. static void FUNC(put_hevc_qpel_h)(int16_t *dst,

  624.                                   uint8_t *_src, ptrdiff_t _srcstride,

  625.                                   int height, intptr_t mx, intptr_t my, int width)

  626. {

  627.     int x, y;

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

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

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

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

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

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

  634.         src += srcstride;

  635.         dst += MAX_PB_SIZE;

  636.     }

  637. }

  638. 

  639. static void FUNC(put_hevc_qpel_v)(int16_t *dst,

  640.                                   uint8_t *_src, ptrdiff_t _srcstride,

  641.                                   int height, intptr_t mx, intptr_t my, int width)

  642. {

  643.     int x, y;

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

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

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

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

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

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

  650.         src += srcstride;

  651.         dst += MAX_PB_SIZE;

  652.     }

  653. }

  654. 

  655. static void FUNC(put_hevc_qpel_hv)(int16_t *dst,

  656.                                    uint8_t *_src,

  657.                                    ptrdiff_t _srcstride,

  658.                                    int height, intptr_t mx,

  659.                                    intptr_t my, int width)

  660. {

  661.     int x, y;

  662.     const int8_t *filter;

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

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

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

  666.     int16_t *tmp = tmp_array;

  667. 

  668.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  669.     filter = ff_hevc_qpel_filters[mx - 1];

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

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

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

  673.         src += srcstride;

  674.         tmp += MAX_PB_SIZE;

  675.     }

  676. 

  677.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  678.     filter = ff_hevc_qpel_filters[my - 1];

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

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

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

  682.         tmp += MAX_PB_SIZE;

  683.         dst += MAX_PB_SIZE;

  684.     }

  685. }

  686. 

  687. static void FUNC(put_hevc_qpel_uni_h)(uint8_t *_dst,  ptrdiff_t _dststride,

  688.                                       uint8_t *_src, ptrdiff_t _srcstride,

  689.                                       int height, intptr_t mx, intptr_t my, int width)

  690. {

  691.     int x, y;

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

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

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

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

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

  697.     int shift = 14 - BIT_DEPTH;

  698. 

  699. #if BIT_DEPTH < 14

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

  701. #else

  702.     int offset = 0;

  703. #endif

  704. 

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

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

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

  708.         src += srcstride;

  709.         dst += dststride;

  710.     }

  711. }

  712. 

  713. static void FUNC(put_hevc_qpel_bi_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  714.                                      int16_t *src2,

  715.                                      int height, intptr_t mx, intptr_t my, int width)

  716. {

  717.     int x, y;

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

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

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

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

  722. 

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

  724. 

  725.     int shift = 14  + 1 - BIT_DEPTH;

  726. #if BIT_DEPTH < 14

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

  728. #else

  729.     int offset = 0;

  730. #endif

  731. 

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

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

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

  735.         src  += srcstride;

  736.         dst  += dststride;

  737.         src2 += MAX_PB_SIZE;

  738.     }

  739. }

  740. 

  741. static void FUNC(put_hevc_qpel_uni_v)(uint8_t *_dst,  ptrdiff_t _dststride,

  742.                                      uint8_t *_src, ptrdiff_t _srcstride,

  743.                                      int height, intptr_t mx, intptr_t my, int width)

  744. {

  745.     int x, y;

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

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

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

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

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

  751.     int shift = 14 - BIT_DEPTH;

  752. 

  753. #if BIT_DEPTH < 14

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

  755. #else

  756.     int offset = 0;

  757. #endif

  758. 

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

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

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

  762.         src += srcstride;

  763.         dst += dststride;

  764.     }

  765. }

  766. 

  767. 

  768. static void FUNC(put_hevc_qpel_bi_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  769.                                      int16_t *src2,

  770.                                      int height, intptr_t mx, intptr_t my, int width)

  771. {

  772.     int x, y;

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

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

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

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

  777. 

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

  779. 

  780.     int shift = 14 + 1 - BIT_DEPTH;

  781. #if BIT_DEPTH < 14

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

  783. #else

  784.     int offset = 0;

  785. #endif

  786. 

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

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

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

  790.         src  += srcstride;

  791.         dst  += dststride;

  792.         src2 += MAX_PB_SIZE;

  793.     }

  794. }

  795. 

  796. static void FUNC(put_hevc_qpel_uni_hv)(uint8_t *_dst,  ptrdiff_t _dststride,

  797.                                        uint8_t *_src, ptrdiff_t _srcstride,

  798.                                        int height, intptr_t mx, intptr_t my, int width)

  799. {

  800.     int x, y;

  801.     const int8_t *filter;

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

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

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

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

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

  807.     int16_t *tmp = tmp_array;

  808.     int shift =  14 - BIT_DEPTH;

  809. 

  810. #if BIT_DEPTH < 14

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

  812. #else

  813.     int offset = 0;

  814. #endif

  815. 

  816.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  817.     filter = ff_hevc_qpel_filters[mx - 1];

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

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

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

  821.         src += srcstride;

  822.         tmp += MAX_PB_SIZE;

  823.     }

  824. 

  825.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  826.     filter = ff_hevc_qpel_filters[my - 1];

  827. 

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

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

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

  831.         tmp += MAX_PB_SIZE;

  832.         dst += dststride;

  833.     }

  834. }

  835. 

  836. static void FUNC(put_hevc_qpel_bi_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  837.                                       int16_t *src2,

  838.                                       int height, intptr_t mx, intptr_t my, int width)

  839. {

  840.     int x, y;

  841.     const int8_t *filter;

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

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

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

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

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

  847.     int16_t *tmp = tmp_array;

  848.     int shift = 14 + 1 - BIT_DEPTH;

  849. #if BIT_DEPTH < 14

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

  851. #else

  852.     int offset = 0;

  853. #endif

  854. 

  855.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  856.     filter = ff_hevc_qpel_filters[mx - 1];

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

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

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

  860.         src += srcstride;

  861.         tmp += MAX_PB_SIZE;

  862.     }

  863. 

  864.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  865.     filter = ff_hevc_qpel_filters[my - 1];

  866. 

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

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

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

  870.         tmp  += MAX_PB_SIZE;

  871.         dst  += dststride;

  872.         src2 += MAX_PB_SIZE;

  873.     }

  874. }

  875. 

  876. static void FUNC(put_hevc_qpel_uni_w_h)(uint8_t *_dst,  ptrdiff_t _dststride,

  877.                                         uint8_t *_src, ptrdiff_t _srcstride,

  878.                                         int height, int denom, int wx, int ox,

  879.                                         intptr_t mx, intptr_t my, int width)

  880. {

  881.     int x, y;

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

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

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

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

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

  887.     int shift = denom + 14 - BIT_DEPTH;

  888. #if BIT_DEPTH < 14

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

  890. #else

  891.     int offset = 0;

  892. #endif

  893. 

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

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

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

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

  898.         src += srcstride;

  899.         dst += dststride;

  900.     }

  901. }

  902. 

  903. static void FUNC(put_hevc_qpel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  904.                                        int16_t *src2,

  905.                                        int height, int denom, int wx0, int wx1,

  906.                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)

  907. {

  908.     int x, y;

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

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

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

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

  913. 

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

  915. 

  916.     int shift = 14  + 1 - BIT_DEPTH;

  917.     int log2Wd = denom + shift - 1;

  918. 

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

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

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

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

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

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

  925.         src  += srcstride;

  926.         dst  += dststride;

  927.         src2 += MAX_PB_SIZE;

  928.     }

  929. }

  930. 

  931. static void FUNC(put_hevc_qpel_uni_w_v)(uint8_t *_dst,  ptrdiff_t _dststride,

  932.                                         uint8_t *_src, ptrdiff_t _srcstride,

  933.                                         int height, int denom, int wx, int ox,

  934.                                         intptr_t mx, intptr_t my, int width)

  935. {

  936.     int x, y;

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

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

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

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

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

  942.     int shift = denom + 14 - BIT_DEPTH;

  943. #if BIT_DEPTH < 14

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

  945. #else

  946.     int offset = 0;

  947. #endif

  948. 

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

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

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

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

  953.         src += srcstride;

  954.         dst += dststride;

  955.     }

  956. }

  957. 

  958. static void FUNC(put_hevc_qpel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  959.                                        int16_t *src2,

  960.                                        int height, int denom, int wx0, int wx1,

  961.                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)

  962. {

  963.     int x, y;

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

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

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

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

  968. 

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

  970. 

  971.     int shift = 14 + 1 - BIT_DEPTH;

  972.     int log2Wd = denom + shift - 1;

  973. 

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

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

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

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

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

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

  980.         src  += srcstride;

  981.         dst  += dststride;

  982.         src2 += MAX_PB_SIZE;

  983.     }

  984. }

  985. 

  986. static void FUNC(put_hevc_qpel_uni_w_hv)(uint8_t *_dst,  ptrdiff_t _dststride,

  987.                                          uint8_t *_src, ptrdiff_t _srcstride,

  988.                                          int height, int denom, int wx, int ox,

  989.                                          intptr_t mx, intptr_t my, int width)

  990. {

  991.     int x, y;

  992.     const int8_t *filter;

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

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

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

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

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

  998.     int16_t *tmp = tmp_array;

  999.     int shift = denom + 14 - BIT_DEPTH;

  1000. #if BIT_DEPTH < 14

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

  1002. #else

  1003.     int offset = 0;

  1004. #endif

  1005. 

  1006.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  1007.     filter = ff_hevc_qpel_filters[mx - 1];

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

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

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

  1011.         src += srcstride;

  1012.         tmp += MAX_PB_SIZE;

  1013.     }

  1014. 

  1015.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1016.     filter = ff_hevc_qpel_filters[my - 1];

  1017. 

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

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

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

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

  1022.         tmp += MAX_PB_SIZE;

  1023.         dst += dststride;

  1024.     }

  1025. }

  1026. 

  1027. static void FUNC(put_hevc_qpel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1028.                                         int16_t *src2,

  1029.                                         int height, int denom, int wx0, int wx1,

  1030.                                         int ox0, int ox1, intptr_t mx, intptr_t my, int width)

  1031. {

  1032.     int x, y;

  1033.     const int8_t *filter;

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

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

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

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

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

  1039.     int16_t *tmp = tmp_array;

  1040.     int shift = 14 + 1 - BIT_DEPTH;

  1041.     int log2Wd = denom + shift - 1;

  1042. 

  1043.     src   -= QPEL_EXTRA_BEFORE * srcstride;

  1044.     filter = ff_hevc_qpel_filters[mx - 1];

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

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

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

  1048.         src += srcstride;

  1049.         tmp += MAX_PB_SIZE;

  1050.     }

  1051. 

  1052.     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1053.     filter = ff_hevc_qpel_filters[my - 1];

  1054. 

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

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

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

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

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

  1060.                                     ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));

  1061.         tmp  += MAX_PB_SIZE;

  1062.         dst  += dststride;

  1063.         src2 += MAX_PB_SIZE;

  1064.     }

  1065. }

  1066. 

  1067. ////////////////////////////////////////////////////////////////////////////////

  1068. //

  1069. ////////////////////////////////////////////////////////////////////////////////

  1070. #define EPEL_FILTER(src, stride)                                               \

  1071.     (filter[0] * src[x - stride] +                                             \

  1072.      filter[1] * src[x]          +                                             \

  1073.      filter[2] * src[x + stride] +                                             \

  1074.      filter[3] * src[x + 2 * stride])

  1075. 

  1076. static void FUNC(put_hevc_epel_h)(int16_t *dst,

  1077.                                   uint8_t *_src, ptrdiff_t _srcstride,

  1078.                                   int height, intptr_t mx, intptr_t my, int width)

  1079. {

  1080.     int x, y;

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

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

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

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

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

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

  1087.         src += srcstride;

  1088.         dst += MAX_PB_SIZE;

  1089.     }

  1090. }

  1091. 

  1092. static void FUNC(put_hevc_epel_v)(int16_t *dst,

  1093.                                   uint8_t *_src, ptrdiff_t _srcstride,

  1094.                                   int height, intptr_t mx, intptr_t my, int width)

  1095. {

  1096.     int x, y;

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

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

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

  1100. 

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

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

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

  1104.         src += srcstride;

  1105.         dst += MAX_PB_SIZE;

  1106.     }

  1107. }

  1108. 

  1109. static void FUNC(put_hevc_epel_hv)(int16_t *dst,

  1110.                                    uint8_t *_src, ptrdiff_t _srcstride,

  1111.                                    int height, intptr_t mx, intptr_t my, int width)

  1112. {

  1113.     int x, y;

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

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

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

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

  1118.     int16_t *tmp = tmp_array;

  1119. 

  1120.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1121. 

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

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

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

  1125.         src += srcstride;

  1126.         tmp += MAX_PB_SIZE;

  1127.     }

  1128. 

  1129.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1130.     filter = ff_hevc_epel_filters[my - 1];

  1131. 

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

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

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

  1135.         tmp += MAX_PB_SIZE;

  1136.         dst += MAX_PB_SIZE;

  1137.     }

  1138. }

  1139. 

  1140. static void FUNC(put_hevc_epel_uni_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1141.                                       int height, intptr_t mx, intptr_t my, int width)

  1142. {

  1143.     int x, y;

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

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

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

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

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

  1149.     int shift = 14 - BIT_DEPTH;

  1150. #if BIT_DEPTH < 14

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

  1152. #else

  1153.     int offset = 0;

  1154. #endif

  1155. 

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

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

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

  1159.         src += srcstride;

  1160.         dst += dststride;

  1161.     }

  1162. }

  1163. 

  1164. static void FUNC(put_hevc_epel_bi_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1165.                                      int16_t *src2,

  1166.                                      int height, intptr_t mx, intptr_t my, int width)

  1167. {

  1168.     int x, y;

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

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

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

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

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

  1174.     int shift = 14 + 1 - BIT_DEPTH;

  1175. #if BIT_DEPTH < 14

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

  1177. #else

  1178.     int offset = 0;

  1179. #endif

  1180. 

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

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

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

  1184.         }

  1185.         dst  += dststride;

  1186.         src  += srcstride;

  1187.         src2 += MAX_PB_SIZE;

  1188.     }

  1189. }

  1190. 

  1191. static void FUNC(put_hevc_epel_uni_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1192.                                       int height, intptr_t mx, intptr_t my, int width)

  1193. {

  1194.     int x, y;

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

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

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

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

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

  1200.     int shift = 14 - BIT_DEPTH;

  1201. #if BIT_DEPTH < 14

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

  1203. #else

  1204.     int offset = 0;

  1205. #endif

  1206. 

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

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

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

  1210.         src += srcstride;

  1211.         dst += dststride;

  1212.     }

  1213. }

  1214. 

  1215. static void FUNC(put_hevc_epel_bi_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1216.                                      int16_t *src2,

  1217.                                      int height, intptr_t mx, intptr_t my, int width)

  1218. {

  1219.     int x, y;

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

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

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

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

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

  1225.     int shift = 14 + 1 - BIT_DEPTH;

  1226. #if BIT_DEPTH < 14

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

  1228. #else

  1229.     int offset = 0;

  1230. #endif

  1231. 

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

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

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

  1235.         dst  += dststride;

  1236.         src  += srcstride;

  1237.         src2 += MAX_PB_SIZE;

  1238.     }

  1239. }

  1240. 

  1241. static void FUNC(put_hevc_epel_uni_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1242.                                        int height, intptr_t mx, intptr_t my, int width)

  1243. {

  1244.     int x, y;

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

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

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

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

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

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

  1251.     int16_t *tmp = tmp_array;

  1252.     int shift = 14 - BIT_DEPTH;

  1253. #if BIT_DEPTH < 14

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

  1255. #else

  1256.     int offset = 0;

  1257. #endif

  1258. 

  1259.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1260. 

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

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

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

  1264.         src += srcstride;

  1265.         tmp += MAX_PB_SIZE;

  1266.     }

  1267. 

  1268.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1269.     filter = ff_hevc_epel_filters[my - 1];

  1270. 

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

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

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

  1274.         tmp += MAX_PB_SIZE;

  1275.         dst += dststride;

  1276.     }

  1277. }

  1278. 

  1279. static void FUNC(put_hevc_epel_bi_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1280.                                       int16_t *src2,

  1281.                                       int height, intptr_t mx, intptr_t my, int width)

  1282. {

  1283.     int x, y;

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

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

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

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

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

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

  1290.     int16_t *tmp = tmp_array;

  1291.     int shift = 14 + 1 - BIT_DEPTH;

  1292. #if BIT_DEPTH < 14

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

  1294. #else

  1295.     int offset = 0;

  1296. #endif

  1297. 

  1298.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1299. 

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

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

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

  1303.         src += srcstride;

  1304.         tmp += MAX_PB_SIZE;

  1305.     }

  1306. 

  1307.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1308.     filter = ff_hevc_epel_filters[my - 1];

  1309. 

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

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

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

  1313.         tmp  += MAX_PB_SIZE;

  1314.         dst  += dststride;

  1315.         src2 += MAX_PB_SIZE;

  1316.     }

  1317. }

  1318. 

  1319. static void FUNC(put_hevc_epel_uni_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1320.                                         int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)

  1321. {

  1322.     int x, y;

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

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

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

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

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

  1328.     int shift = denom + 14 - BIT_DEPTH;

  1329. #if BIT_DEPTH < 14

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

  1331. #else

  1332.     int offset = 0;

  1333. #endif

  1334. 

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

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

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

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

  1339.         }

  1340.         dst += dststride;

  1341.         src += srcstride;

  1342.     }

  1343. }

  1344. 

  1345. static void FUNC(put_hevc_epel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1346.                                        int16_t *src2,

  1347.                                        int height, int denom, int wx0, int wx1,

  1348.                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)

  1349. {

  1350.     int x, y;

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

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

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

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

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

  1356.     int shift = 14 + 1 - BIT_DEPTH;

  1357.     int log2Wd = denom + shift - 1;

  1358. 

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

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

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

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

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

  1364.                                     ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));

  1365.         src  += srcstride;

  1366.         dst  += dststride;

  1367.         src2 += MAX_PB_SIZE;

  1368.     }

  1369. }

  1370. 

  1371. static void FUNC(put_hevc_epel_uni_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1372.                                         int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)

  1373. {

  1374.     int x, y;

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

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

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

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

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

  1380.     int shift = denom + 14 - BIT_DEPTH;

  1381. #if BIT_DEPTH < 14

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

  1383. #else

  1384.     int offset = 0;

  1385. #endif

  1386. 

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

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

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

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

  1391.         }

  1392.         dst += dststride;

  1393.         src += srcstride;

  1394.     }

  1395. }

  1396. 

  1397. static void FUNC(put_hevc_epel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1398.                                        int16_t *src2,

  1399.                                        int height, int denom, int wx0, int wx1,

  1400.                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)

  1401. {

  1402.     int x, y;

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

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

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

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

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

  1408.     int shift = 14 + 1 - BIT_DEPTH;

  1409.     int log2Wd = denom + shift - 1;

  1410. 

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

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

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

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

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

  1416.                                     ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));

  1417.         src  += srcstride;

  1418.         dst  += dststride;

  1419.         src2 += MAX_PB_SIZE;

  1420.     }

  1421. }

  1422. 

  1423. static void FUNC(put_hevc_epel_uni_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1424.                                          int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)

  1425. {

  1426.     int x, y;

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

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

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

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

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

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

  1433.     int16_t *tmp = tmp_array;

  1434.     int shift = denom + 14 - BIT_DEPTH;

  1435. #if BIT_DEPTH < 14

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

  1437. #else

  1438.     int offset = 0;

  1439. #endif

  1440. 

  1441.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1442. 

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

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

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

  1446.         src += srcstride;

  1447.         tmp += MAX_PB_SIZE;

  1448.     }

  1449. 

  1450.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1451.     filter = ff_hevc_epel_filters[my - 1];

  1452. 

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

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

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

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

  1457.         tmp += MAX_PB_SIZE;

  1458.         dst += dststride;

  1459.     }

  1460. }

  1461. 

  1462. static void FUNC(put_hevc_epel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,

  1463.                                         int16_t *src2,

  1464.                                         int height, int denom, int wx0, int wx1,

  1465.                                         int ox0, int ox1, intptr_t mx, intptr_t my, int width)

  1466. {

  1467.     int x, y;

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

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

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

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

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

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

  1474.     int16_t *tmp = tmp_array;

  1475.     int shift = 14 + 1 - BIT_DEPTH;

  1476.     int log2Wd = denom + shift - 1;

  1477. 

  1478.     src -= EPEL_EXTRA_BEFORE * srcstride;

  1479. 

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

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

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

  1483.         src += srcstride;

  1484.         tmp += MAX_PB_SIZE;

  1485.     }

  1486. 

  1487.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1488.     filter = ff_hevc_epel_filters[my - 1];

  1489. 

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

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

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

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

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

  1495.                                     ((ox0 + ox1 + 1) * (1 << log2Wd))) >> (log2Wd + 1));

  1496.         tmp  += MAX_PB_SIZE;

  1497.         dst  += dststride;

  1498.         src2 += MAX_PB_SIZE;

  1499.     }

  1500. }// line zero

  1501. #define P3 pix[-4 * xstride]

  1502. #define P2 pix[-3 * xstride]

  1503. #define P1 pix[-2 * xstride]

  1504. #define P0 pix[-1 * xstride]

  1505. #define Q0 pix[0 * xstride]

  1506. #define Q1 pix[1 * xstride]

  1507. #define Q2 pix[2 * xstride]

  1508. #define Q3 pix[3 * xstride]

  1509. 

  1510. // line three. used only for deblocking decision

  1511. #define TP3 pix[-4 * xstride + 3 * ystride]

  1512. #define TP2 pix[-3 * xstride + 3 * ystride]

  1513. #define TP1 pix[-2 * xstride + 3 * ystride]

  1514. #define TP0 pix[-1 * xstride + 3 * ystride]

  1515. #define TQ0 pix[0  * xstride + 3 * ystride]

  1516. #define TQ1 pix[1  * xstride + 3 * ystride]

  1517. #define TQ2 pix[2  * xstride + 3 * ystride]

  1518. #define TQ3 pix[3  * xstride + 3 * ystride]

  1519. 

  1520. static void FUNC(hevc_loop_filter_luma)(uint8_t *_pix,

  1521.                                         ptrdiff_t _xstride, ptrdiff_t _ystride,

  1522.                                         int beta, int *_tc,

  1523.                                         uint8_t *_no_p, uint8_t *_no_q)

  1524. {

  1525.     int d, j;

  1526.     pixel *pix        = (pixel *)_pix;

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

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

  1529. 

  1530.     beta <<= BIT_DEPTH - 8;

  1531. 

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

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

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

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

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

  1537.         const int d0   = dp0 + dq0;

  1538.         const int d3   = dp3 + dq3;

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

  1540.         const int no_p = _no_p[j];

  1541.         const int no_q = _no_q[j];

  1542. 

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

  1544.             pix += 4 * ystride;

  1545.             continue;

  1546.         } else {

  1547.             const int beta_3 = beta >> 3;

  1548.             const int beta_2 = beta >> 2;

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

  1550. 

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

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

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

  1554.                 // strong filtering

  1555.                 const int tc2 = tc << 1;

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

  1557.                     const int p3 = P3;

  1558.                     const int p2 = P2;

  1559.                     const int p1 = P1;

  1560.                     const int p0 = P0;

  1561.                     const int q0 = Q0;

  1562.                     const int q1 = Q1;

  1563.                     const int q2 = Q2;

  1564.                     const int q3 = Q3;

  1565.                     if (!no_p) {

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

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

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

  1569.                     }

  1570.                     if (!no_q) {

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

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

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

  1574.                     }

  1575.                     pix += ystride;

  1576.                 }

  1577.             } else { // normal filtering

  1578.                 int nd_p = 1;

  1579.                 int nd_q = 1;

  1580.                 const int tc_2 = tc >> 1;

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

  1582.                     nd_p = 2;

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

  1584.                     nd_q = 2;

  1585. 

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

  1587.                     const int p2 = P2;

  1588.                     const int p1 = P1;

  1589.                     const int p0 = P0;

  1590.                     const int q0 = Q0;

  1591.                     const int q1 = Q1;

  1592.                     const int q2 = Q2;

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

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

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

  1596.                         if (!no_p)

  1597.                             P0 = av_clip_pixel(p0 + delta0);

  1598.                         if (!no_q)

  1599.                             Q0 = av_clip_pixel(q0 - delta0);

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

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

  1602.                             P1 = av_clip_pixel(p1 + deltap1);

  1603.                         }

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

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

  1606.                             Q1 = av_clip_pixel(q1 + deltaq1);

  1607.                         }

  1608.                     }

  1609.                     pix += ystride;

  1610.                 }

  1611.             }

  1612.         }

  1613.     }

  1614. }

  1615. 

  1616. static void FUNC(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,

  1617.                                           ptrdiff_t _ystride, int *_tc,

  1618.                                           uint8_t *_no_p, uint8_t *_no_q)

  1619. {

  1620.     int d, j, no_p, no_q;

  1621.     pixel *pix        = (pixel *)_pix;

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

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

  1624. 

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

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

  1627.         if (tc <= 0) {

  1628.             pix += 4 * ystride;

  1629.             continue;

  1630.         }

  1631.         no_p = _no_p[j];

  1632.         no_q = _no_q[j];

  1633. 

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

  1635.             int delta0;

  1636.             const int p1 = P1;

  1637.             const int p0 = P0;

  1638.             const int q0 = Q0;

  1639.             const int q1 = Q1;

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

  1641.             if (!no_p)

  1642.                 P0 = av_clip_pixel(p0 + delta0);

  1643.             if (!no_q)

  1644.                 Q0 = av_clip_pixel(q0 - delta0);

  1645.             pix += ystride;

  1646.         }

  1647.     }

  1648. }

  1649. 

  1650. static void FUNC(hevc_h_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride,

  1651.                                             int32_t *tc, uint8_t *no_p,

  1652.                                             uint8_t *no_q)

  1653. {

  1654.     FUNC(hevc_loop_filter_chroma)(pix, stride, sizeof(pixel), tc, no_p, no_q);

  1655. }

  1656. 

  1657. static void FUNC(hevc_v_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride,

  1658.                                             int32_t *tc, uint8_t *no_p,

  1659.                                             uint8_t *no_q)

  1660. {

  1661.     FUNC(hevc_loop_filter_chroma)(pix, sizeof(pixel), stride, tc, no_p, no_q);

  1662. }

  1663. 

  1664. static void FUNC(hevc_h_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,

  1665.                                           int beta, int32_t *tc, uint8_t *no_p,

  1666.                                           uint8_t *no_q)

  1667. {

  1668.     FUNC(hevc_loop_filter_luma)(pix, stride, sizeof(pixel),

  1669.                                 beta, tc, no_p, no_q);

  1670. }

  1671. 

  1672. static void FUNC(hevc_v_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,

  1673.                                           int beta, int32_t *tc, uint8_t *no_p,

  1674.                                           uint8_t *no_q)

  1675. {

  1676.     FUNC(hevc_loop_filter_luma)(pix, sizeof(pixel), stride,

  1677.                                 beta, tc, no_p, no_q);

  1678. }

  1679. 

  1680. #undef P3

  1681. #undef P2

  1682. #undef P1

  1683. #undef P0

  1684. #undef Q0

  1685. #undef Q1

  1686. #undef Q2

  1687. #undef Q3

  1688. 

  1689. #undef TP3

  1690. #undef TP2

  1691. #undef TP1

  1692. #undef TP0

  1693. #undef TQ0

  1694. #undef TQ1

  1695. #undef TQ2

  1696. #undef TQ3