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

1315 lines
48KB
Raw Blame History 

  1. /*

  2.  * HEVC video decoder

  3.  *

  4.  * Copyright (C) 2012 - 2013 Guillaume Martres

  5.  *

  6.  * This file is part of Libav.

  7.  *

  8.  * Libav 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.  * Libav 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 Libav; 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. 

  28. static void FUNC(put_pcm)(uint8_t *_dst, ptrdiff_t stride, int size,

  29.                           GetBitContext *gb, int pcm_bit_depth)

  30. {

  31.     int x, y;

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

  33. 

  34.     stride /= sizeof(pixel);

  35. 

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

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

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

  39.         dst += stride;

  40.     }

  41. }

  42. 

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

  44.                                                      ptrdiff_t stride, int size)

  45. {

  46.     int x, y;

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

  48. 

  49.     stride /= sizeof(pixel);

  50. 

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

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

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

  54.             coeffs++;

  55.         }

  56.         dst += stride;

  57.     }

  58. }

  59. 

  60. static void FUNC(transquant_bypass4x4)(uint8_t *_dst, int16_t *coeffs,

  61.                                        ptrdiff_t stride)

  62. {

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

  64. }

  65. 

  66. static void FUNC(transquant_bypass8x8)(uint8_t *_dst, int16_t *coeffs,

  67.                                        ptrdiff_t stride)

  68. {

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

  70. }

  71. 

  72. static void FUNC(transquant_bypass16x16)(uint8_t *_dst, int16_t *coeffs,

  73.                                          ptrdiff_t stride)

  74. {

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

  76. }

  77. 

  78. static void FUNC(transquant_bypass32x32)(uint8_t *_dst, int16_t *coeffs,

  79.                                          ptrdiff_t stride)

  80. {

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

  82. }

  83. 

  84. static void FUNC(transform_skip)(uint8_t *_dst, int16_t *coeffs,

  85.                                  ptrdiff_t stride)

  86. {

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

  88.     int shift  = 13 - BIT_DEPTH;

  89. #if BIT_DEPTH <= 13

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

  91. #else

  92.     int offset = 0;

  93. #endif

  94.     int x, y;

  95. 

  96.     stride /= sizeof(pixel);

  97. 

  98.     for (y = 0; y < 4 * 4; y += 4) {

  99.         for (x = 0; x < 4; x++)

  100.             dst[x] = av_clip_pixel(dst[x] + ((coeffs[y + x] + offset) >> shift));

  101.         dst += stride;

  102.     }

  103. }

  104. 

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

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

  107. #define ADD_AND_SCALE(dst, x)                                           \

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

  109. 

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

  111.     do {                                                                \

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

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

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

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

  116.                                                                         \

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

  118.                                     src[2 * step] +                     \

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

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

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

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

  123.     } while (0)

  124. 

  125. static void FUNC(transform_4x4_luma_add)(uint8_t *_dst, int16_t *coeffs,

  126.                                          ptrdiff_t stride)

  127. {

  128.     int i;

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

  130.     int shift    = 7;

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

  132.     int16_t *src = coeffs;

  133. 

  134.     stride /= sizeof(pixel);

  135. 

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

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

  138.         src++;

  139.     }

  140. 

  141.     shift = 20 - BIT_DEPTH;

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

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

  144.         TR_4x4_LUMA(dst, coeffs, 1, ADD_AND_SCALE);

  145.         coeffs += 4;

  146.         dst    += stride;

  147.     }

  148. }

  149. 

  150. #undef TR_4x4_LUMA

  151. 

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

  153.     do {                                                                \

  154.         const int e0 = transform[8 * 0][0] * src[0 * sstep] +           \

  155.                        transform[8 * 2][0] * src[2 * sstep];            \

  156.         const int e1 = transform[8 * 0][1] * src[0 * sstep] +           \

  157.                        transform[8 * 2][1] * src[2 * sstep];            \

  158.         const int o0 = transform[8 * 1][0] * src[1 * sstep] +           \

  159.                        transform[8 * 3][0] * src[3 * sstep];            \

  160.         const int o1 = transform[8 * 1][1] * src[1 * sstep] +           \

  161.                        transform[8 * 3][1] * src[3 * sstep];            \

  162.                                                                         \

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

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

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

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

  167.     } while (0)

  168. 

  169. static void FUNC(transform_4x4_add)(uint8_t *_dst, int16_t *coeffs,

  170.                                     ptrdiff_t stride)

  171. {

  172.     int i;

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

  174.     int shift    = 7;

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

  176.     int16_t *src = coeffs;

  177. 

  178.     stride /= sizeof(pixel);

  179. 

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

  181.         TR_4(src, src, 4, 4, SCALE);

  182.         src++;

  183.     }

  184. 

  185.     shift = 20 - BIT_DEPTH;

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

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

  188.         TR_4(dst, coeffs, 1, 1, ADD_AND_SCALE);

  189.         coeffs += 4;

  190.         dst    += stride;

  191.     }

  192. }

  193. 

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

  195.     do {                                                          \

  196.         int i, j;                                                 \

  197.         int e_8[4];                                               \

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

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

  200.             for (j = 1; j < 8; j += 2)                            \

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

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

  203.                                                                   \

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

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

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

  207.         }                                                         \

  208.     } while (0)

  209. 

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

  211.     do {                                                          \

  212.         int i, j;                                                 \

  213.         int e_16[8];                                              \

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

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

  216.             for (j = 1; j < 16; j += 2)                           \

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

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

  219.                                                                   \

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

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

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

  223.         }                                                         \

  224.     } while (0)

  225. 

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

  227.     do {                                                          \

  228.         int i, j;                                                 \

  229.         int e_32[16];                                             \

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

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

  232.             for (j = 1; j < 32; j += 2)                           \

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

  234.         TR_16(e_32, src, 1, 2 * sstep, SET);                      \

  235.                                                                   \

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

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

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

  239.         }                                                         \

  240.     } while (0)

  241. 

  242. 

  243. 

  244. static void FUNC(transform_8x8_add)(uint8_t *_dst, int16_t *coeffs,

  245.                                     ptrdiff_t stride)

  246. {

  247.     int i;

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

  249.     int shift    = 7;

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

  251.     int16_t *src = coeffs;

  252. 

  253.     stride /= sizeof(pixel);

  254. 

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

  256.         TR_8(src, src, 8, 8, SCALE);

  257.         src++;

  258.     }

  259. 

  260.     shift = 20 - BIT_DEPTH;

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

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

  263.         TR_8(dst, coeffs, 1, 1, ADD_AND_SCALE);

  264.         coeffs += 8;

  265.         dst    += stride;

  266.     }

  267. }

  268. 

  269. static void FUNC(transform_16x16_add)(uint8_t *_dst, int16_t *coeffs,

  270.                                       ptrdiff_t stride)

  271. {

  272.     int i;

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

  274.     int shift    = 7;

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

  276.     int16_t *src = coeffs;

  277. 

  278.     stride /= sizeof(pixel);

  279. 

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

  281.         TR_16(src, src, 16, 16, SCALE);

  282.         src++;

  283.     }

  284. 

  285.     shift = 20 - BIT_DEPTH;

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

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

  288.         TR_16(dst, coeffs, 1, 1, ADD_AND_SCALE);

  289.         coeffs += 16;

  290.         dst    += stride;

  291.     }

  292. }

  293. 

  294. static void FUNC(transform_32x32_add)(uint8_t *_dst, int16_t *coeffs,

  295.                                       ptrdiff_t stride)

  296. {

  297.     int i;

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

  299.     int shift    = 7;

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

  301.     int16_t *src = coeffs;

  302. 

  303.     stride /= sizeof(pixel);

  304. 

  305.     for (i = 0; i < 32; i++) {

  306.         TR_32(src, src, 32, 32, SCALE);

  307.         src++;

  308.     }

  309.     src   = coeffs;

  310.     shift = 20 - BIT_DEPTH;

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

  312.     for (i = 0; i < 32; i++) {

  313.         TR_32(dst, coeffs, 1, 1, ADD_AND_SCALE);

  314.         coeffs += 32;

  315.         dst    += stride;

  316.     }

  317. }

  318. 

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

  320.                                   ptrdiff_t stride, SAOParams *sao,

  321.                                   int *borders, int width, int height,

  322.                                   int c_idx, int class)

  323. {

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

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

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

  327.     int k, y, x;

  328.     int chroma = !!c_idx;

  329.     int shift  = BIT_DEPTH - 5;

  330.     int *sao_offset_val = sao->offset_val[c_idx];

  331.     int sao_left_class  = sao->band_position[c_idx];

  332.     int init_y = 0, init_x = 0;

  333. 

  334.     stride /= sizeof(pixel);

  335. 

  336.     switch (class) {

  337.     case 0:

  338.         if (!borders[2])

  339.             width -= (8 >> chroma) + 2;

  340.         if (!borders[3])

  341.             height -= (4 >> chroma) + 2;

  342.         break;

  343.     case 1:

  344.         init_y = -(4 >> chroma) - 2;

  345.         if (!borders[2])

  346.             width -= (8 >> chroma) + 2;

  347.         height = (4 >> chroma) + 2;

  348.         break;

  349.     case 2:

  350.         init_x = -(8 >> chroma) - 2;

  351.         width  =  (8 >> chroma) + 2;

  352.         if (!borders[3])

  353.             height -= (4 >> chroma) + 2;

  354.         break;

  355.     case 3:

  356.         init_y = -(4 >> chroma) - 2;

  357.         init_x = -(8 >> chroma) - 2;

  358.         width  =  (8 >> chroma) + 2;

  359.         height =  (4 >> chroma) + 2;

  360.         break;

  361.     }

  362. 

  363.     dst = dst + (init_y * stride + init_x);

  364.     src = src + (init_y * stride + init_x);

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

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

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

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

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

  370.         dst += stride;

  371.         src += stride;

  372.     }

  373. }

  374. 

  375. static void FUNC(sao_band_filter_0)(uint8_t *dst, uint8_t *src,

  376.                                     ptrdiff_t stride, SAOParams *sao,

  377.                                     int *borders, int width, int height,

  378.                                     int c_idx)

  379. {

  380.     FUNC(sao_band_filter)(dst, src, stride, sao, borders,

  381.                           width, height, c_idx, 0);

  382. }

  383. 

  384. static void FUNC(sao_band_filter_1)(uint8_t *dst, uint8_t *src,

  385.                                     ptrdiff_t stride, SAOParams *sao,

  386.                                     int *borders, int width, int height,

  387.                                     int c_idx)

  388. {

  389.     FUNC(sao_band_filter)(dst, src, stride, sao, borders,

  390.                           width, height, c_idx, 1);

  391. }

  392. 

  393. static void FUNC(sao_band_filter_2)(uint8_t *dst, uint8_t *src,

  394.                                     ptrdiff_t stride, SAOParams *sao,

  395.                                     int *borders, int width, int height,

  396.                                     int c_idx)

  397. {

  398.     FUNC(sao_band_filter)(dst, src, stride, sao, borders,

  399.                           width, height, c_idx, 2);

  400. }

  401. 

  402. static void FUNC(sao_band_filter_3)(uint8_t *_dst, uint8_t *_src,

  403.                                     ptrdiff_t stride, SAOParams *sao,

  404.                                     int *borders, int width, int height,

  405.                                     int c_idx)

  406. {

  407.     FUNC(sao_band_filter)(_dst, _src, stride, sao, borders,

  408.                           width, height, c_idx, 3);

  409. }

  410. 

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

  412.                                     ptrdiff_t stride, 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.     int chroma = !!c_idx;

  421.     int *sao_offset_val = sao->offset_val[c_idx];

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

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

  424. 

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

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

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

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

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

  430.     };

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

  432. 

  433. #define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))

  434. 

  435.     stride /= sizeof(pixel);

  436. 

  437.     if (!borders[2])

  438.         width -= (8 >> chroma) + 2;

  439.     if (!borders[3])

  440.         height -= (4 >> chroma) + 2;

  441. 

  442.     dst = dst + (init_y * stride + init_x);

  443.     src = src + (init_y * stride + init_x);

  444.     init_y = init_x = 0;

  445.     if (sao_eo_class != SAO_EO_VERT) {

  446.         if (borders[0]) {

  447.             int offset_val = sao_offset_val[0];

  448.             int y_stride   = 0;

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

  450.                 dst[y_stride] = av_clip_pixel(src[y_stride] + offset_val);

  451.                 y_stride     += stride;

  452.             }

  453.             init_x = 1;

  454.         }

  455.         if (borders[2]) {

  456.             int offset_val = sao_offset_val[0];

  457.             int x_stride   = width - 1;

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

  459.                 dst[x_stride] = av_clip_pixel(src[x_stride] + offset_val);

  460.                 x_stride     += stride;

  461.             }

  462.             width--;

  463.         }

  464.     }

  465.     if (sao_eo_class != SAO_EO_HORIZ) {

  466.         if (borders[1]) {

  467.             int offset_val = sao_offset_val[0];

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

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

  470.             init_y = 1;

  471.         }

  472.         if (borders[3]) {

  473.             int offset_val = sao_offset_val[0];

  474.             int y_stride   = stride * (height - 1);

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

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

  477.             height--;

  478.         }

  479.     }

  480.     {

  481.         int y_stride = init_y * stride;

  482.         int pos_0_0  = pos[sao_eo_class][0][0];

  483.         int pos_0_1  = pos[sao_eo_class][0][1];

  484.         int pos_1_0  = pos[sao_eo_class][1][0];

  485.         int pos_1_1  = pos[sao_eo_class][1][1];

  486. 

  487.         int y_stride_0_1 = (init_y + pos_0_1) * stride;

  488.         int y_stride_1_1 = (init_y + pos_1_1) * stride;

  489.         for (y = init_y; y < height; y++) {

  490.             for (x = init_x; x < width; x++) {

  491.                 int diff0         = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);

  492.                 int diff1         = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);

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

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

  495.             }

  496.             y_stride     += stride;

  497.             y_stride_0_1 += stride;

  498.             y_stride_1_1 += stride;

  499.         }

  500.     }

  501. 

  502.     {

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

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

  505.         if (vert_edge && sao_eo_class != SAO_EO_VERT)

  506.             for (y = init_y+save_upper_left; y< height; y++)

  507.                 dst[y*stride] = src[y*stride];

  508.         if(horiz_edge && sao_eo_class != SAO_EO_HORIZ)

  509.             for(x = init_x+save_upper_left; x<width; x++)

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

  511.         if(diag_edge && sao_eo_class == SAO_EO_135D)

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

  513.     }

  514. 

  515. #undef CMP

  516. }

  517. 

  518. static void FUNC(sao_edge_filter_1)(uint8_t *_dst, uint8_t *_src,

  519.                                     ptrdiff_t stride, SAOParams *sao,

  520.                                     int *borders, int _width, int _height,

  521.                                     int c_idx, uint8_t vert_edge,

  522.                                     uint8_t horiz_edge, uint8_t diag_edge)

  523. {

  524.     int x, y;

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

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

  527.     int chroma = !!c_idx;

  528.     int *sao_offset_val = sao->offset_val[c_idx];

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

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

  531. 

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

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

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

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

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

  537.     };

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

  539. 

  540. #define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))

  541. 

  542.     stride /= sizeof(pixel);

  543. 

  544.     init_y = -(4 >> chroma) - 2;

  545.     if (!borders[2])

  546.         width -= (8 >> chroma) + 2;

  547.     height = (4 >> chroma) + 2;

  548. 

  549.     dst = dst + (init_y * stride + init_x);

  550.     src = src + (init_y * stride + init_x);

  551.     init_y = init_x = 0;

  552.     if (sao_eo_class != SAO_EO_VERT) {

  553.         if (borders[0]) {

  554.             int offset_val = sao_offset_val[0];

  555.             int y_stride   = 0;

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

  557.                 dst[y_stride] = av_clip_pixel(src[y_stride] + offset_val);

  558.                 y_stride     += stride;

  559.             }

  560.             init_x = 1;

  561.         }

  562.         if (borders[2]) {

  563.             int offset_val = sao_offset_val[0];

  564.             int x_stride   = width - 1;

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

  566.                 dst[x_stride] = av_clip_pixel(src[x_stride] + offset_val);

  567.                 x_stride     += stride;

  568.             }

  569.             width--;

  570.         }

  571.     }

  572.     {

  573.         int y_stride = init_y * stride;

  574.         int pos_0_0  = pos[sao_eo_class][0][0];

  575.         int pos_0_1  = pos[sao_eo_class][0][1];

  576.         int pos_1_0  = pos[sao_eo_class][1][0];

  577.         int pos_1_1  = pos[sao_eo_class][1][1];

  578. 

  579.         int y_stride_0_1 = (init_y + pos_0_1) * stride;

  580.         int y_stride_1_1 = (init_y + pos_1_1) * stride;

  581.         for (y = init_y; y < height; y++) {

  582.             for (x = init_x; x < width; x++) {

  583.                 int diff0         = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);

  584.                 int diff1         = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);

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

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

  587.             }

  588.             y_stride     += stride;

  589.             y_stride_0_1 += stride;

  590.             y_stride_1_1 += stride;

  591.         }

  592.     }

  593. 

  594.     {

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

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

  597.         if(vert_edge && sao_eo_class != SAO_EO_VERT)

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

  599.                 dst[y*stride] = src[y*stride];

  600.         if(horiz_edge && sao_eo_class != SAO_EO_HORIZ)

  601.             for(x = init_x+save_lower_left; x<width; x++)

  602.                 dst[(height-1)*stride+x] = src[(height-1)*stride+x];

  603.         if(diag_edge && sao_eo_class == SAO_EO_45D)

  604.             dst[stride*(height-1)] = src[stride*(height-1)];

  605.     }

  606. 

  607. #undef CMP

  608. }

  609. 

  610. static void FUNC(sao_edge_filter_2)(uint8_t *_dst, uint8_t *_src,

  611.                                     ptrdiff_t stride, SAOParams *sao,

  612.                                     int *borders, int _width, int _height,

  613.                                     int c_idx, uint8_t vert_edge,

  614.                                     uint8_t horiz_edge, uint8_t diag_edge)

  615. {

  616.     int x, y;

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

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

  619.     int chroma = !!c_idx;

  620.     int *sao_offset_val = sao->offset_val[c_idx];

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

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

  623. 

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

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

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

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

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

  629.     };

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

  631. 

  632. #define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))

  633. 

  634.     stride /= sizeof(pixel);

  635. 

  636.     init_x = -(8 >> chroma) - 2;

  637.     width  =  (8 >> chroma) + 2;

  638.     if (!borders[3])

  639.         height -= (4 >> chroma) + 2;

  640. 

  641.     dst = dst + (init_y * stride + init_x);

  642.     src = src + (init_y * stride + init_x);

  643.     init_y = init_x = 0;

  644.     if (sao_eo_class != SAO_EO_HORIZ) {

  645.         if (borders[1]) {

  646.             int offset_val = sao_offset_val[0];

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

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

  649.             init_y = 1;

  650.         }

  651.         if (borders[3]) {

  652.             int offset_val = sao_offset_val[0];

  653.             int y_stride   = stride * (height - 1);

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

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

  656.             height--;

  657.         }

  658.     }

  659.     {

  660.         int y_stride = init_y * stride;

  661.         int pos_0_0  = pos[sao_eo_class][0][0];

  662.         int pos_0_1  = pos[sao_eo_class][0][1];

  663.         int pos_1_0  = pos[sao_eo_class][1][0];

  664.         int pos_1_1  = pos[sao_eo_class][1][1];

  665. 

  666.         int y_stride_0_1 = (init_y + pos_0_1) * stride;

  667.         int y_stride_1_1 = (init_y + pos_1_1) * stride;

  668.         for (y = init_y; y < height; y++) {

  669.             for (x = init_x; x < width; x++) {

  670.                 int diff0         = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);

  671.                 int diff1         = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);

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

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

  674.             }

  675.             y_stride     += stride;

  676.             y_stride_0_1 += stride;

  677.             y_stride_1_1 += stride;

  678.         }

  679.     }

  680. 

  681.     {

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

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

  684.         if(vert_edge && sao_eo_class != SAO_EO_VERT)

  685.             for(y = init_y+save_upper_right; y< height; y++)

  686.                 dst[y*stride+width-1] = src[y*stride+width-1];

  687.         if(horiz_edge && sao_eo_class != SAO_EO_HORIZ)

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

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

  690.         if(diag_edge && sao_eo_class == SAO_EO_45D)

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

  692.     }

  693. #undef CMP

  694. }

  695. 

  696. static void FUNC(sao_edge_filter_3)(uint8_t *_dst, uint8_t *_src,

  697.                                     ptrdiff_t stride, SAOParams *sao,

  698.                                     int *borders, int _width, int _height,

  699.                                     int c_idx, uint8_t vert_edge,

  700.                                     uint8_t horiz_edge, uint8_t diag_edge)

  701. {

  702.     int x, y;

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

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

  705.     int chroma = !!c_idx;

  706.     int *sao_offset_val = sao->offset_val[c_idx];

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

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

  709. 

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

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

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

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

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

  715.     };

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

  717. 

  718. #define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))

  719. 

  720.     stride /= sizeof(pixel);

  721. 

  722.     init_y = -(4 >> chroma) - 2;

  723.     init_x = -(8 >> chroma) - 2;

  724.     width  =  (8 >> chroma) + 2;

  725.     height =  (4 >> chroma) + 2;

  726. 

  727. 

  728.     dst    = dst + (init_y * stride + init_x);

  729.     src    = src + (init_y * stride + init_x);

  730.     init_y = init_x = 0;

  731. 

  732.     {

  733.         int y_stride = init_y * stride;

  734.         int pos_0_0  = pos[sao_eo_class][0][0];

  735.         int pos_0_1  = pos[sao_eo_class][0][1];

  736.         int pos_1_0  = pos[sao_eo_class][1][0];

  737.         int pos_1_1  = pos[sao_eo_class][1][1];

  738. 

  739.         int y_stride_0_1 = (init_y + pos_0_1) * stride;

  740.         int y_stride_1_1 = (init_y + pos_1_1) * stride;

  741. 

  742.         for (y = init_y; y < height; y++) {

  743.             for (x = init_x; x < width; x++) {

  744.                 int diff0         = CMP(src[x + y_stride], src[x + pos_0_0 + y_stride_0_1]);

  745.                 int diff1         = CMP(src[x + y_stride], src[x + pos_1_0 + y_stride_1_1]);

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

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

  748.             }

  749.             y_stride     += stride;

  750.             y_stride_0_1 += stride;

  751.             y_stride_1_1 += stride;

  752.         }

  753.     }

  754. 

  755.     {

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

  757.         int save_lower_right = !diag_edge && sao_eo_class == SAO_EO_135D;

  758.         if(vert_edge && sao_eo_class != SAO_EO_VERT)

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

  760.                 dst[y*stride+width-1] = src[y*stride+width-1];

  761.         if(horiz_edge && sao_eo_class != SAO_EO_HORIZ)

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

  763.                 dst[(height-1)*stride+x] = src[(height-1)*stride+x];

  764.         if(diag_edge && sao_eo_class == SAO_EO_135D)

  765.             dst[stride*(height-1)+width-1] = src[stride*(height-1)+width-1];

  766.     }

  767. #undef CMP

  768. }

  769. 

  770. #undef SET

  771. #undef SCALE

  772. #undef ADD_AND_SCALE

  773. #undef TR_4

  774. #undef TR_8

  775. #undef TR_16

  776. #undef TR_32

  777. 

  778. static void FUNC(put_hevc_qpel_pixels)(int16_t *dst, ptrdiff_t dststride,

  779.                                        uint8_t *_src, ptrdiff_t _srcstride,

  780.                                        int width, int height, int16_t* mcbuffer)

  781. {

  782.     int x, y;

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

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

  785. 

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

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

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

  789.         src += srcstride;

  790.         dst += dststride;

  791.     }

  792. }

  793. 

  794. #define QPEL_FILTER_1(src, stride)      \

  795.     (1 * -src[x - 3 * stride] +         \

  796.      4 *  src[x - 2 * stride] -         \

  797.     10 *  src[x -     stride] +         \

  798.     58 *  src[x]              +         \

  799.     17 *  src[x +     stride] -         \

  800.      5 *  src[x + 2 * stride] +         \

  801.      1 *  src[x + 3 * stride])

  802. 

  803. #define QPEL_FILTER_2(src, stride)      \

  804.     (1  * -src[x - 3 * stride] +        \

  805.      4  *  src[x - 2 * stride] -        \

  806.     11  *  src[x -     stride] +        \

  807.     40  *  src[x]              +        \

  808.     40  *  src[x +     stride] -        \

  809.     11  *  src[x + 2 * stride] +        \

  810.      4  *  src[x + 3 * stride] -        \

  811.      1  *  src[x + 4 * stride])

  812. 

  813. #define QPEL_FILTER_3(src, stride)      \

  814.     (1  * src[x - 2 * stride] -         \

  815.      5  * src[x -     stride] +         \

  816.     17  * src[x]              +         \

  817.     58  * src[x + stride]     -         \

  818.     10  * src[x + 2 * stride] +         \

  819.      4  * src[x + 3 * stride] -         \

  820.      1  * src[x + 4 * stride])

  821. 

  822. 

  823. #define PUT_HEVC_QPEL_H(H)                                                     \

  824. static void FUNC(put_hevc_qpel_h ## H)(int16_t *dst,  ptrdiff_t dststride,     \

  825.                                        uint8_t *_src, ptrdiff_t _srcstride,    \

  826.                                        int width, int height,                  \

  827.                                        int16_t* mcbuffer)                      \

  828. {                                                                              \

  829.     int x, y;                                                                  \

  830.     pixel *src = (pixel*)_src;                                                 \

  831.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);                          \

  832.                                                                                \

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

  834.         for (x = 0; x < width; x++)                                            \

  835.             dst[x] = QPEL_FILTER_ ## H(src, 1) >> (BIT_DEPTH - 8);             \

  836.         src += srcstride;                                                      \

  837.         dst += dststride;                                                      \

  838.     }                                                                          \

  839. }

  840. 

  841. #define PUT_HEVC_QPEL_V(V)                                                     \

  842. static void FUNC(put_hevc_qpel_v ## V)(int16_t *dst,  ptrdiff_t dststride,     \

  843.                                        uint8_t *_src, ptrdiff_t _srcstride,    \

  844.                                        int width, int height,                  \

  845.                                        int16_t* mcbuffer)                      \

  846. {                                                                              \

  847.     int x, y;                                                                  \

  848.     pixel *src = (pixel*)_src;                                                 \

  849.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);                          \

  850.                                                                                \

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

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

  853.             dst[x] = QPEL_FILTER_ ## V(src, srcstride) >> (BIT_DEPTH - 8);     \

  854.         src += srcstride;                                                      \

  855.         dst += dststride;                                                      \

  856.     }                                                                          \

  857. }

  858. 

  859. #define PUT_HEVC_QPEL_HV(H, V)                                                 \

  860. static void FUNC(put_hevc_qpel_h ## H ## v ## V)(int16_t *dst,                 \

  861.                                                  ptrdiff_t dststride,          \

  862.                                                  uint8_t *_src,                \

  863.                                                  ptrdiff_t _srcstride,         \

  864.                                                  int width, int height,        \

  865.                                                  int16_t* mcbuffer)            \

  866. {                                                                              \

  867.     int x, y;                                                                  \

  868.     pixel *src = (pixel*)_src;                                                 \

  869.     ptrdiff_t srcstride = _srcstride / sizeof(pixel);                          \

  870.                                                                                \

  871.     int16_t tmp_array[(MAX_PB_SIZE + 7) * MAX_PB_SIZE];                        \

  872.     int16_t *tmp = tmp_array;                                                  \

  873.                                                                                \

  874.     src -= ff_hevc_qpel_extra_before[V] * srcstride;                           \

  875.                                                                                \

  876.     for (y = 0; y < height + ff_hevc_qpel_extra[V]; y++) {                     \

  877.         for (x = 0; x < width; x++)                                            \

  878.             tmp[x] = QPEL_FILTER_ ## H(src, 1) >> (BIT_DEPTH - 8);             \

  879.         src += srcstride;                                                      \

  880.         tmp += MAX_PB_SIZE;                                                    \

  881.     }                                                                          \

  882.                                                                                \

  883.     tmp = tmp_array + ff_hevc_qpel_extra_before[V] * MAX_PB_SIZE;              \

  884.                                                                                \

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

  886.         for (x = 0; x < width; x++)                                            \

  887.             dst[x] = QPEL_FILTER_ ## V(tmp, MAX_PB_SIZE) >> 6;                 \

  888.         tmp += MAX_PB_SIZE;                                                    \

  889.         dst += dststride;                                                      \

  890.     }                                                                          \

  891. }

  892. 

  893. PUT_HEVC_QPEL_H(1)

  894. PUT_HEVC_QPEL_H(2)

  895. PUT_HEVC_QPEL_H(3)

  896. PUT_HEVC_QPEL_V(1)

  897. PUT_HEVC_QPEL_V(2)

  898. PUT_HEVC_QPEL_V(3)

  899. PUT_HEVC_QPEL_HV(1, 1)

  900. PUT_HEVC_QPEL_HV(1, 2)

  901. PUT_HEVC_QPEL_HV(1, 3)

  902. PUT_HEVC_QPEL_HV(2, 1)

  903. PUT_HEVC_QPEL_HV(2, 2)

  904. PUT_HEVC_QPEL_HV(2, 3)

  905. PUT_HEVC_QPEL_HV(3, 1)

  906. PUT_HEVC_QPEL_HV(3, 2)

  907. PUT_HEVC_QPEL_HV(3, 3)

  908. 

  909. static void FUNC(put_hevc_epel_pixels)(int16_t *dst, ptrdiff_t dststride,

  910.                                        uint8_t *_src, ptrdiff_t _srcstride,

  911.                                        int width, int height, int mx, int my,

  912.                                        int16_t* mcbuffer)

  913. {

  914.     int x, y;

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

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

  917. 

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

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

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

  921.         src += srcstride;

  922.         dst += dststride;

  923.     }

  924. }

  925. 

  926. #define EPEL_FILTER(src, stride)                \

  927.     (filter_0 * src[x - stride] +               \

  928.      filter_1 * src[x]          +               \

  929.      filter_2 * src[x + stride] +               \

  930.      filter_3 * src[x + 2 * stride])

  931. 

  932. static void FUNC(put_hevc_epel_h)(int16_t *dst, ptrdiff_t dststride,

  933.                                   uint8_t *_src, ptrdiff_t _srcstride,

  934.                                   int width, int height, int mx, int my,

  935.                                   int16_t* mcbuffer)

  936. {

  937.     int x, y;

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

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

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

  941.     int8_t filter_0 = filter[0];

  942.     int8_t filter_1 = filter[1];

  943.     int8_t filter_2 = filter[2];

  944.     int8_t filter_3 = filter[3];

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

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

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

  948.         src += srcstride;

  949.         dst += dststride;

  950.     }

  951. }

  952. 

  953. static void FUNC(put_hevc_epel_v)(int16_t *dst, ptrdiff_t dststride,

  954.                                   uint8_t *_src, ptrdiff_t _srcstride,

  955.                                   int width, int height, int mx, int my,

  956.                                   int16_t* mcbuffer)

  957. {

  958.     int x, y;

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

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

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

  962.     int8_t filter_0 = filter[0];

  963.     int8_t filter_1 = filter[1];

  964.     int8_t filter_2 = filter[2];

  965.     int8_t filter_3 = filter[3];

  966. 

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

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

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

  970.         src += srcstride;

  971.         dst += dststride;

  972.     }

  973. }

  974. 

  975. static void FUNC(put_hevc_epel_hv)(int16_t *dst, ptrdiff_t dststride,

  976.                                    uint8_t *_src, ptrdiff_t _srcstride,

  977.                                    int width, int height, int mx, int my,

  978.                                    int16_t* mcbuffer)

  979. {

  980.     int x, y;

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

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

  983.     const int8_t *filter_h = ff_hevc_epel_filters[mx - 1];

  984.     const int8_t *filter_v = ff_hevc_epel_filters[my - 1];

  985.     int8_t filter_0 = filter_h[0];

  986.     int8_t filter_1 = filter_h[1];

  987.     int8_t filter_2 = filter_h[2];

  988.     int8_t filter_3 = filter_h[3];

  989.     int16_t tmp_array[(MAX_PB_SIZE + 3) * MAX_PB_SIZE];

  990.     int16_t *tmp = tmp_array;

  991. 

  992.     src -= EPEL_EXTRA_BEFORE * srcstride;

  993. 

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

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

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

  997.         src += srcstride;

  998.         tmp += MAX_PB_SIZE;

  999.     }

  1000. 

  1001.     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;

  1002.     filter_0 = filter_v[0];

  1003.     filter_1 = filter_v[1];

  1004.     filter_2 = filter_v[2];

  1005.     filter_3 = filter_v[3];

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

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

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

  1009.         tmp += MAX_PB_SIZE;

  1010.         dst += dststride;

  1011.     }

  1012. }

  1013. 

  1014. static void FUNC(put_unweighted_pred)(uint8_t *_dst, ptrdiff_t _dststride,

  1015.                                       int16_t *src, ptrdiff_t srcstride,

  1016.                                       int width, int height)

  1017. {

  1018.     int x, y;

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

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

  1021. 

  1022.     int shift = 14 - BIT_DEPTH;

  1023. #if BIT_DEPTH < 14

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

  1025. #else

  1026.     int offset = 0;

  1027. #endif

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

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

  1030.             dst[x] = av_clip_pixel((src[x] + offset) >> shift);

  1031.         dst += dststride;

  1032.         src += srcstride;

  1033.     }

  1034. }

  1035. 

  1036. static void FUNC(put_weighted_pred_avg)(uint8_t *_dst, ptrdiff_t _dststride,

  1037.                                         int16_t *src1, int16_t *src2,

  1038.                                         ptrdiff_t srcstride,

  1039.                                         int width, int height)

  1040. {

  1041.     int x, y;

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

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

  1044. 

  1045.     int shift = 14 + 1 - BIT_DEPTH;

  1046. #if BIT_DEPTH < 14

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

  1048. #else

  1049.     int offset = 0;

  1050. #endif

  1051. 

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

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

  1054.             dst[x] = av_clip_pixel((src1[x] + src2[x] + offset) >> shift);

  1055.         dst  += dststride;

  1056.         src1 += srcstride;

  1057.         src2 += srcstride;

  1058.     }

  1059. }

  1060. 

  1061. static void FUNC(weighted_pred)(uint8_t denom, int16_t wlxFlag, int16_t olxFlag,

  1062.                                 uint8_t *_dst, ptrdiff_t _dststride,

  1063.                                 int16_t *src, ptrdiff_t srcstride,

  1064.                                 int width, int height)

  1065. {

  1066.     int shift, log2Wd, wx, ox, x, y, offset;

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

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

  1069. 

  1070.     shift  = 14 - BIT_DEPTH;

  1071.     log2Wd = denom + shift;

  1072.     offset = 1 << (log2Wd - 1);

  1073.     wx     = wlxFlag;

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

  1075. 

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

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

  1078.             if (log2Wd >= 1) {

  1079.                 dst[x] = av_clip_pixel(((src[x] * wx + offset) >> log2Wd) + ox);

  1080.             } else {

  1081.                 dst[x] = av_clip_pixel(src[x] * wx + ox);

  1082.             }

  1083.         }

  1084.         dst += dststride;

  1085.         src += srcstride;

  1086.     }

  1087. }

  1088. 

  1089. static void FUNC(weighted_pred_avg)(uint8_t denom,

  1090.                                     int16_t wl0Flag, int16_t wl1Flag,

  1091.                                     int16_t ol0Flag, int16_t ol1Flag,

  1092.                                     uint8_t *_dst, ptrdiff_t _dststride,

  1093.                                     int16_t *src1, int16_t *src2,

  1094.                                     ptrdiff_t srcstride,

  1095.                                     int width, int height)

  1096. {

  1097.     int shift, log2Wd, w0, w1, o0, o1, x, y;

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

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

  1100. 

  1101.     shift  = 14 - BIT_DEPTH;

  1102.     log2Wd = denom + shift;

  1103.     w0     = wl0Flag;

  1104.     w1     = wl1Flag;

  1105.     o0     = ol0Flag * (1 << (BIT_DEPTH - 8));

  1106.     o1     = ol1Flag * (1 << (BIT_DEPTH - 8));

  1107. 

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

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

  1110.             dst[x] = av_clip_pixel((src1[x] * w0 + src2[x] * w1 +

  1111.                                     ((o0 + o1 + 1) << log2Wd)) >> (log2Wd + 1));

  1112.         dst  += dststride;

  1113.         src1 += srcstride;

  1114.         src2 += srcstride;

  1115.     }

  1116. }

  1117. 

  1118. // line zero

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

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

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

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

  1123. #define Q0 pix[0 * xstride]

  1124. #define Q1 pix[1 * xstride]

  1125. #define Q2 pix[2 * xstride]

  1126. #define Q3 pix[3 * xstride]

  1127. 

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

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

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

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

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

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

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

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

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

  1137. 

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

  1139.                                         ptrdiff_t _xstride, ptrdiff_t _ystride,

  1140.                                         int beta, int *_tc,

  1141.                                         uint8_t *_no_p, uint8_t *_no_q)

  1142. {

  1143.     int d, j;

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

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

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

  1147. 

  1148.     beta <<= BIT_DEPTH - 8;

  1149. 

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

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

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

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

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

  1155.         const int d0   = dp0 + dq0;

  1156.         const int d3   = dp3 + dq3;

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

  1158.         const int no_p = _no_p[j];

  1159.         const int no_q = _no_q[j];

  1160. 

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

  1162.             pix += 4 * ystride;

  1163.             continue;

  1164.         } else {

  1165.             const int beta_3 = beta >> 3;

  1166.             const int beta_2 = beta >> 2;

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

  1168. 

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

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

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

  1172.                 // strong filtering

  1173.                 const int tc2 = tc << 1;

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

  1175.                     const int p3 = P3;

  1176.                     const int p2 = P2;

  1177.                     const int p1 = P1;

  1178.                     const int p0 = P0;

  1179.                     const int q0 = Q0;

  1180.                     const int q1 = Q1;

  1181.                     const int q2 = Q2;

  1182.                     const int q3 = Q3;

  1183.                     if (!no_p) {

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

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

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

  1187.                     }

  1188.                     if (!no_q) {

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

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

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

  1192.                     }

  1193.                     pix += ystride;

  1194.                 }

  1195.             } else { // normal filtering

  1196.                 int nd_p = 1;

  1197.                 int nd_q = 1;

  1198.                 const int tc_2 = tc >> 1;

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

  1200.                     nd_p = 2;

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

  1202.                     nd_q = 2;

  1203. 

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

  1205.                     const int p2 = P2;

  1206.                     const int p1 = P1;

  1207.                     const int p0 = P0;

  1208.                     const int q0 = Q0;

  1209.                     const int q1 = Q1;

  1210.                     const int q2 = Q2;

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

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

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

  1214.                         if (!no_p)

  1215.                             P0 = av_clip_pixel(p0 + delta0);

  1216.                         if (!no_q)

  1217.                             Q0 = av_clip_pixel(q0 - delta0);

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

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

  1220.                             P1 = av_clip_pixel(p1 + deltap1);

  1221.                         }

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

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

  1224.                             Q1 = av_clip_pixel(q1 + deltaq1);

  1225.                         }

  1226.                     }

  1227.                     pix += ystride;

  1228.                 }

  1229.             }

  1230.         }

  1231.     }

  1232. }

  1233. 

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

  1235.                                           ptrdiff_t _ystride, int *_tc,

  1236.                                           uint8_t *_no_p, uint8_t *_no_q)

  1237. {

  1238.     int d, j, no_p, no_q;

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

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

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

  1242. 

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

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

  1245.         if (tc <= 0) {

  1246.             pix += 4 * ystride;

  1247.             continue;

  1248.         }

  1249.         no_p = _no_p[j];

  1250.         no_q = _no_q[j];

  1251. 

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

  1253.             int delta0;

  1254.             const int p1 = P1;

  1255.             const int p0 = P0;

  1256.             const int q0 = Q0;

  1257.             const int q1 = Q1;

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

  1259.             if (!no_p)

  1260.                 P0 = av_clip_pixel(p0 + delta0);

  1261.             if (!no_q)

  1262.                 Q0 = av_clip_pixel(q0 - delta0);

  1263.             pix += ystride;

  1264.         }

  1265.     }

  1266. }

  1267. 

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

  1269.                                             int *tc, uint8_t *no_p,

  1270.                                             uint8_t *no_q)

  1271. {

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

  1273. }

  1274. 

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

  1276.                                             int *tc, uint8_t *no_p,

  1277.                                             uint8_t *no_q)

  1278. {

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

  1280. }

  1281. 

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

  1283.                                           int beta, int *tc, uint8_t *no_p,

  1284.                                           uint8_t *no_q)

  1285. {

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

  1287.                                 beta, tc, no_p, no_q);

  1288. }

  1289. 

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

  1291.                                           int beta, int *tc, uint8_t *no_p,

  1292.                                           uint8_t *no_q)

  1293. {

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

  1295.                                 beta, tc, no_p, no_q);

  1296. }

  1297. 

  1298. #undef P3

  1299. #undef P2

  1300. #undef P1

  1301. #undef P0

  1302. #undef Q0

  1303. #undef Q1

  1304. #undef Q2

  1305. #undef Q3

  1306. 

  1307. #undef TP3

  1308. #undef TP2

  1309. #undef TP1

  1310. #undef TP0

  1311. #undef TQ0

  1312. #undef TQ1

  1313. #undef TQ2

  1314. #undef TQ3