hevcdsp: remove an unneeded variable in the loop filter
[ffmpeg.git] / libavcodec / hevcdsp_template.c
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 void FUNC(transform_add4x4)(uint8_t *_dst, int16_t *coeffs,
46                                        ptrdiff_t stride)
47 {
48     int x, y;
49     pixel *dst = (pixel *)_dst;
50
51     stride /= sizeof(pixel);
52
53     for (y = 0; y < 4; y++) {
54         for (x = 0; x < 4; x++) {
55             dst[x] = av_clip_pixel(dst[x] + *coeffs);
56             coeffs++;
57         }
58         dst += stride;
59     }
60 }
61
62 static void FUNC(transform_add8x8)(uint8_t *_dst, int16_t *coeffs,
63                                        ptrdiff_t stride)
64 {
65     int x, y;
66     pixel *dst = (pixel *)_dst;
67
68     stride /= sizeof(pixel);
69
70     for (y = 0; y < 8; y++) {
71         for (x = 0; x < 8; x++) {
72             dst[x] = av_clip_pixel(dst[x] + *coeffs);
73             coeffs++;
74         }
75         dst += stride;
76     }
77 }
78
79 static void FUNC(transform_add16x16)(uint8_t *_dst, int16_t *coeffs,
80                                          ptrdiff_t stride)
81 {
82     int x, y;
83     pixel *dst = (pixel *)_dst;
84
85     stride /= sizeof(pixel);
86
87     for (y = 0; y < 16; y++) {
88         for (x = 0; x < 16; x++) {
89             dst[x] = av_clip_pixel(dst[x] + *coeffs);
90             coeffs++;
91         }
92         dst += stride;
93     }
94 }
95
96 static void FUNC(transform_add32x32)(uint8_t *_dst, int16_t *coeffs,
97                                          ptrdiff_t stride)
98 {
99     int x, y;
100     pixel *dst = (pixel *)_dst;
101
102     stride /= sizeof(pixel);
103
104     for (y = 0; y < 32; y++) {
105         for (x = 0; x < 32; x++) {
106             dst[x] = av_clip_pixel(dst[x] + *coeffs);
107             coeffs++;
108         }
109         dst += stride;
110     }
111 }
112
113
114 static void FUNC(transform_rdpcm)(int16_t *_coeffs, int16_t log2_size, int mode)
115 {
116     int16_t *coeffs = (int16_t *) _coeffs;
117     int x, y;
118     int size = 1 << log2_size;
119
120     if (mode) {
121         coeffs += size;
122         for (y = 0; y < size - 1; y++) {
123             for (x = 0; x < size; x++)
124                 coeffs[x] += coeffs[x - size];
125             coeffs += size;
126         }
127     } else {
128         for (y = 0; y < size; y++) {
129             for (x = 1; x < size; x++)
130                 coeffs[x] += coeffs[x - 1];
131             coeffs += size;
132         }
133     }
134 }
135
136 static void FUNC(transform_skip)(int16_t *_coeffs, int16_t log2_size)
137 {
138     int shift  = 15 - BIT_DEPTH - log2_size;
139     int x, y;
140     int size = 1 << log2_size;
141     int16_t *coeffs = _coeffs;
142
143
144     if (shift > 0) {
145         int offset = 1 << (shift - 1);
146         for (y = 0; y < size; y++) {
147             for (x = 0; x < size; x++) {
148                 *coeffs = (*coeffs + offset) >> shift;
149                 coeffs++;
150             }
151         }
152     } else {
153         for (y = 0; y < size; y++) {
154             for (x = 0; x < size; x++) {
155                 *coeffs = *coeffs << -shift;
156                 coeffs++;
157             }
158         }
159     }
160 }
161
162 #define SET(dst, x)   (dst) = (x)
163 #define SCALE(dst, x) (dst) = av_clip_int16(((x) + add) >> shift)
164 #define ADD_AND_SCALE(dst, x)                                           \
165     (dst) = av_clip_pixel((dst) + av_clip_int16(((x) + add) >> shift))
166
167 #define TR_4x4_LUMA(dst, src, step, assign)                             \
168     do {                                                                \
169         int c0 = src[0 * step] + src[2 * step];                         \
170         int c1 = src[2 * step] + src[3 * step];                         \
171         int c2 = src[0 * step] - src[3 * step];                         \
172         int c3 = 74 * src[1 * step];                                    \
173                                                                         \
174         assign(dst[2 * step], 74 * (src[0 * step] -                     \
175                                     src[2 * step] +                     \
176                                     src[3 * step]));                    \
177         assign(dst[0 * step], 29 * c0 + 55 * c1 + c3);                  \
178         assign(dst[1 * step], 55 * c2 - 29 * c1 + c3);                  \
179         assign(dst[3 * step], 55 * c0 + 29 * c2 - c3);                  \
180     } while (0)
181
182 static void FUNC(transform_4x4_luma)(int16_t *coeffs)
183 {
184     int i;
185     int shift    = 7;
186     int add      = 1 << (shift - 1);
187     int16_t *src = coeffs;
188
189     for (i = 0; i < 4; i++) {
190         TR_4x4_LUMA(src, src, 4, SCALE);
191         src++;
192     }
193
194     shift = 20 - BIT_DEPTH;
195     add   = 1 << (shift - 1);
196     for (i = 0; i < 4; i++) {
197         TR_4x4_LUMA(coeffs, coeffs, 1, SCALE);
198         coeffs += 4;
199     }
200 }
201
202 #undef TR_4x4_LUMA
203
204 #define TR_4(dst, src, dstep, sstep, assign, end)                              \
205     do {                                                                       \
206         const int e0 = 64 * src[0 * sstep] + 64 * src[2 * sstep];              \
207         const int e1 = 64 * src[0 * sstep] - 64 * src[2 * sstep];              \
208         const int o0 = 83 * src[1 * sstep] + 36 * src[3 * sstep];              \
209         const int o1 = 36 * src[1 * sstep] - 83 * src[3 * sstep];              \
210                                                                                \
211         assign(dst[0 * dstep], e0 + o0);                                       \
212         assign(dst[1 * dstep], e1 + o1);                                       \
213         assign(dst[2 * dstep], e1 - o1);                                       \
214         assign(dst[3 * dstep], e0 - o0);                                       \
215     } while (0)
216
217 #define TR_8(dst, src, dstep, sstep, assign, end)                              \
218     do {                                                                       \
219         int i, j;                                                              \
220         int e_8[4];                                                            \
221         int o_8[4] = { 0 };                                                    \
222         for (i = 0; i < 4; i++)                                                \
223             for (j = 1; j < end; j += 2)                                       \
224                 o_8[i] += transform[4 * j][i] * src[j * sstep];                \
225         TR_4(e_8, src, 1, 2 * sstep, SET, 4);                                  \
226                                                                                \
227         for (i = 0; i < 4; i++) {                                              \
228             assign(dst[i * dstep], e_8[i] + o_8[i]);                           \
229             assign(dst[(7 - i) * dstep], e_8[i] - o_8[i]);                     \
230         }                                                                      \
231     } while (0)
232
233 #define TR_16(dst, src, dstep, sstep, assign, end)                             \
234     do {                                                                       \
235         int i, j;                                                              \
236         int e_16[8];                                                           \
237         int o_16[8] = { 0 };                                                   \
238         for (i = 0; i < 8; i++)                                                \
239             for (j = 1; j < end; j += 2)                                       \
240                 o_16[i] += transform[2 * j][i] * src[j * sstep];               \
241         TR_8(e_16, src, 1, 2 * sstep, SET, 8);                                 \
242                                                                                \
243         for (i = 0; i < 8; i++) {                                              \
244             assign(dst[i * dstep], e_16[i] + o_16[i]);                         \
245             assign(dst[(15 - i) * dstep], e_16[i] - o_16[i]);                  \
246         }                                                                      \
247     } while (0)
248
249 #define TR_32(dst, src, dstep, sstep, assign, end)                             \
250     do {                                                                       \
251         int i, j;                                                              \
252         int e_32[16];                                                          \
253         int o_32[16] = { 0 };                                                  \
254         for (i = 0; i < 16; i++)                                               \
255             for (j = 1; j < end; j += 2)                                       \
256                 o_32[i] += transform[j][i] * src[j * sstep];                   \
257         TR_16(e_32, src, 1, 2 * sstep, SET, end/2);                            \
258                                                                                \
259         for (i = 0; i < 16; i++) {                                             \
260             assign(dst[i * dstep], e_32[i] + o_32[i]);                         \
261             assign(dst[(31 - i) * dstep], e_32[i] - o_32[i]);                  \
262         }                                                                      \
263     } while (0)
264
265 #define IDCT_VAR4(H)                                                          \
266     int      limit2   = FFMIN(col_limit + 4, H)
267 #define IDCT_VAR8(H)                                                          \
268         int      limit   = FFMIN(col_limit, H);                               \
269         int      limit2   = FFMIN(col_limit + 4, H)
270 #define IDCT_VAR16(H)   IDCT_VAR8(H)
271 #define IDCT_VAR32(H)   IDCT_VAR8(H)
272
273 #define IDCT(H)                                                              \
274 static void FUNC(idct_##H ##x ##H )(                                         \
275                    int16_t *coeffs, int col_limit) {                         \
276     int i;                                                                   \
277     int      shift   = 7;                                                    \
278     int      add     = 1 << (shift - 1);                                     \
279     int16_t *src     = coeffs;                                               \
280     IDCT_VAR ##H(H);                                                         \
281                                                                              \
282     for (i = 0; i < H; i++) {                                                \
283         TR_ ## H(src, src, H, H, SCALE, limit2);                             \
284         if (limit2 < H && i%4 == 0 && !!i)                                   \
285             limit2 -= 4;                                                     \
286         src++;                                                               \
287     }                                                                        \
288                                                                              \
289     shift   = 20 - BIT_DEPTH;                                                \
290     add     = 1 << (shift - 1);                                              \
291     for (i = 0; i < H; i++) {                                                \
292         TR_ ## H(coeffs, coeffs, 1, 1, SCALE, limit);                        \
293         coeffs += H;                                                         \
294     }                                                                        \
295 }
296
297 #define IDCT_DC(H)                                                           \
298 static void FUNC(idct_##H ##x ##H ##_dc)(                                    \
299                    int16_t *coeffs) {                                        \
300     int i, j;                                                                \
301     int      shift   = 14 - BIT_DEPTH;                                       \
302     int      add     = 1 << (shift - 1);                                     \
303     int      coeff   = (((coeffs[0] + 1) >> 1) + add) >> shift;              \
304                                                                              \
305     for (j = 0; j < H; j++) {                                                \
306         for (i = 0; i < H; i++) {                                            \
307             coeffs[i+j*H] = coeff;                                           \
308         }                                                                    \
309     }                                                                        \
310 }
311
312 IDCT( 4)
313 IDCT( 8)
314 IDCT(16)
315 IDCT(32)
316
317 IDCT_DC( 4)
318 IDCT_DC( 8)
319 IDCT_DC(16)
320 IDCT_DC(32)
321
322 #undef TR_4
323 #undef TR_8
324 #undef TR_16
325 #undef TR_32
326
327 #undef SET
328 #undef SCALE
329 #undef ADD_AND_SCALE
330
331 static void FUNC(sao_band_filter_0)(uint8_t *_dst, uint8_t *_src,
332                                   ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,
333                                   int *borders, int width, int height,
334                                   int c_idx)
335 {
336     pixel *dst = (pixel *)_dst;
337     pixel *src = (pixel *)_src;
338     int offset_table[32] = { 0 };
339     int k, y, x;
340     int shift  = BIT_DEPTH - 5;
341     int *sao_offset_val = sao->offset_val[c_idx];
342     int sao_left_class  = sao->band_position[c_idx];
343
344     stride_dst /= sizeof(pixel);
345     stride_src /= sizeof(pixel);
346
347     for (k = 0; k < 4; k++)
348         offset_table[(k + sao_left_class) & 31] = sao_offset_val[k + 1];
349     for (y = 0; y < height; y++) {
350         for (x = 0; x < width; x++)
351             dst[x] = av_clip_pixel(src[x] + offset_table[src[x] >> shift]);
352         dst += stride_dst;
353         src += stride_src;
354     }
355 }
356
357 #define CMP(a, b) ((a) > (b) ? 1 : ((a) == (b) ? 0 : -1))
358
359 static void FUNC(sao_edge_filter)(uint8_t *_dst, uint8_t *_src,
360                                   ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,
361                                   int width, int height,
362                                   int c_idx, int init_x, int init_y) {
363
364     static const uint8_t edge_idx[] = { 1, 2, 0, 3, 4 };
365     static const int8_t pos[4][2][2] = {
366         { { -1,  0 }, {  1, 0 } }, // horizontal
367         { {  0, -1 }, {  0, 1 } }, // vertical
368         { { -1, -1 }, {  1, 1 } }, // 45 degree
369         { {  1, -1 }, { -1, 1 } }, // 135 degree
370     };
371     int *sao_offset_val = sao->offset_val[c_idx];
372     int sao_eo_class    = sao->eo_class[c_idx];
373     pixel *dst = (pixel *)_dst;
374     pixel *src = (pixel *)_src;
375
376     int y_stride_src = init_y * stride_src;
377     int y_stride_dst = init_y * stride_dst;
378     int pos_0_0  = pos[sao_eo_class][0][0];
379     int pos_0_1  = pos[sao_eo_class][0][1];
380     int pos_1_0  = pos[sao_eo_class][1][0];
381     int pos_1_1  = pos[sao_eo_class][1][1];
382     int x, y;
383
384     int y_stride_0_1 = (init_y + pos_0_1) * stride_src;
385     int y_stride_1_1 = (init_y + pos_1_1) * stride_src;
386     for (y = init_y; y < height; y++) {
387         for (x = init_x; x < width; x++) {
388             int diff0             = CMP(src[x + y_stride_src], src[x + pos_0_0 + y_stride_0_1]);
389             int diff1             = CMP(src[x + y_stride_src], src[x + pos_1_0 + y_stride_1_1]);
390             int offset_val        = edge_idx[2 + diff0 + diff1];
391             dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + sao_offset_val[offset_val]);
392         }
393         y_stride_src += stride_src;
394         y_stride_dst += stride_dst;
395         y_stride_0_1 += stride_src;
396         y_stride_1_1 += stride_src;
397     }
398 }
399
400 static void FUNC(sao_edge_filter_0)(uint8_t *_dst, uint8_t *_src,
401                                     ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,
402                                     int *borders, int _width, int _height,
403                                     int c_idx, uint8_t *vert_edge,
404                                     uint8_t *horiz_edge, uint8_t *diag_edge)
405 {
406     int x, y;
407     pixel *dst = (pixel *)_dst;
408     pixel *src = (pixel *)_src;
409     int *sao_offset_val = sao->offset_val[c_idx];
410     int sao_eo_class    = sao->eo_class[c_idx];
411     int init_x = 0, init_y = 0, width = _width, height = _height;
412
413     stride_dst /= sizeof(pixel);
414     stride_src /= sizeof(pixel);
415
416     if (sao_eo_class != SAO_EO_VERT) {
417         if (borders[0]) {
418             int offset_val = sao_offset_val[0];
419             for (y = 0; y < height; y++) {
420                 dst[y * stride_dst] = av_clip_pixel(src[y * stride_src] + offset_val);
421             }
422             init_x = 1;
423         }
424         if (borders[2]) {
425             int offset_val = sao_offset_val[0];
426             int offset     = width - 1;
427             for (x = 0; x < height; x++) {
428                 dst[x * stride_dst + offset] = av_clip_pixel(src[x * stride_src + offset] + offset_val);
429             }
430             width--;
431         }
432     }
433     if (sao_eo_class != SAO_EO_HORIZ) {
434         if (borders[1]) {
435             int offset_val = sao_offset_val[0];
436             for (x = init_x; x < width; x++)
437                 dst[x] = av_clip_pixel(src[x] + offset_val);
438             init_y = 1;
439         }
440         if (borders[3]) {
441             int offset_val   = sao_offset_val[0];
442             int y_stride_dst = stride_dst * (height - 1);
443             int y_stride_src = stride_src * (height - 1);
444             for (x = init_x; x < width; x++)
445                 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);
446             height--;
447         }
448     }
449
450     FUNC(sao_edge_filter)((uint8_t *)dst, (uint8_t *)src, stride_dst, stride_src, sao, width, height, c_idx, init_x, init_y);
451 }
452
453 static void FUNC(sao_edge_filter_1)(uint8_t *_dst, uint8_t *_src,
454                                     ptrdiff_t stride_dst, ptrdiff_t stride_src, SAOParams *sao,
455                                     int *borders, int _width, int _height,
456                                     int c_idx, uint8_t *vert_edge,
457                                     uint8_t *horiz_edge, uint8_t *diag_edge)
458 {
459     int x, y;
460     pixel *dst = (pixel *)_dst;
461     pixel *src = (pixel *)_src;
462     int *sao_offset_val = sao->offset_val[c_idx];
463     int sao_eo_class    = sao->eo_class[c_idx];
464     int init_x = 0, init_y = 0, width = _width, height = _height;
465
466     stride_dst /= sizeof(pixel);
467     stride_src /= sizeof(pixel);
468
469     if (sao_eo_class != SAO_EO_VERT) {
470         if (borders[0]) {
471             int offset_val = sao_offset_val[0];
472             for (y = 0; y < height; y++) {
473                 dst[y * stride_dst] = av_clip_pixel(src[y * stride_src] + offset_val);
474             }
475             init_x = 1;
476         }
477         if (borders[2]) {
478             int offset_val = sao_offset_val[0];
479             int offset     = width - 1;
480             for (x = 0; x < height; x++) {
481                 dst[x * stride_dst + offset] = av_clip_pixel(src[x * stride_src + offset] + offset_val);
482             }
483             width--;
484         }
485     }
486     if (sao_eo_class != SAO_EO_HORIZ) {
487         if (borders[1]) {
488             int offset_val = sao_offset_val[0];
489             for (x = init_x; x < width; x++)
490                 dst[x] = av_clip_pixel(src[x] + offset_val);
491             init_y = 1;
492         }
493         if (borders[3]) {
494             int offset_val   = sao_offset_val[0];
495             int y_stride_dst = stride_dst * (height - 1);
496             int y_stride_src = stride_src * (height - 1);
497             for (x = init_x; x < width; x++)
498                 dst[x + y_stride_dst] = av_clip_pixel(src[x + y_stride_src] + offset_val);
499             height--;
500         }
501     }
502
503     FUNC(sao_edge_filter)((uint8_t *)dst, (uint8_t *)src, stride_dst, stride_src, sao, width, height, c_idx, init_x, init_y);
504
505     {
506         int save_upper_left  = !diag_edge[0] && sao_eo_class == SAO_EO_135D && !borders[0] && !borders[1];
507         int save_upper_right = !diag_edge[1] && sao_eo_class == SAO_EO_45D  && !borders[1] && !borders[2];
508         int save_lower_right = !diag_edge[2] && sao_eo_class == SAO_EO_135D && !borders[2] && !borders[3];
509         int save_lower_left  = !diag_edge[3] && sao_eo_class == SAO_EO_45D  && !borders[0] && !borders[3];
510
511         // Restore pixels that can't be modified
512         if(vert_edge[0] && sao_eo_class != SAO_EO_VERT) {
513             for(y = init_y+save_upper_left; y< height-save_lower_left; y++)
514                 dst[y*stride_dst] = src[y*stride_src];
515         }
516         if(vert_edge[1] && sao_eo_class != SAO_EO_VERT) {
517             for(y = init_y+save_upper_right; y< height-save_lower_right; y++)
518                 dst[y*stride_dst+width-1] = src[y*stride_src+width-1];
519         }
520
521         if(horiz_edge[0] && sao_eo_class != SAO_EO_HORIZ) {
522             for(x = init_x+save_upper_left; x < width-save_upper_right; x++)
523                 dst[x] = src[x];
524         }
525         if(horiz_edge[1] && sao_eo_class != SAO_EO_HORIZ) {
526             for(x = init_x+save_lower_left; x < width-save_lower_right; x++)
527                 dst[(height-1)*stride_dst+x] = src[(height-1)*stride_src+x];
528         }
529         if(diag_edge[0] && sao_eo_class == SAO_EO_135D)
530             dst[0] = src[0];
531         if(diag_edge[1] && sao_eo_class == SAO_EO_45D)
532             dst[width-1] = src[width-1];
533         if(diag_edge[2] && sao_eo_class == SAO_EO_135D)
534             dst[stride_dst*(height-1)+width-1] = src[stride_src*(height-1)+width-1];
535         if(diag_edge[3] && sao_eo_class == SAO_EO_45D)
536             dst[stride_dst*(height-1)] = src[stride_src*(height-1)];
537
538     }
539 }
540
541 #undef CMP
542
543 ////////////////////////////////////////////////////////////////////////////////
544 //
545 ////////////////////////////////////////////////////////////////////////////////
546 static void FUNC(put_hevc_pel_pixels)(int16_t *dst, ptrdiff_t dststride,
547                                       uint8_t *_src, ptrdiff_t _srcstride,
548                                       int height, intptr_t mx, intptr_t my, int width)
549 {
550     int x, y;
551     pixel *src          = (pixel *)_src;
552     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
553
554     for (y = 0; y < height; y++) {
555         for (x = 0; x < width; x++)
556             dst[x] = src[x] << (14 - BIT_DEPTH);
557         src += srcstride;
558         dst += dststride;
559     }
560 }
561
562 static void FUNC(put_hevc_pel_uni_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
563                                           int height, intptr_t mx, intptr_t my, int width)
564 {
565     int y;
566     pixel *src          = (pixel *)_src;
567     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
568     pixel *dst          = (pixel *)_dst;
569     ptrdiff_t dststride = _dststride / sizeof(pixel);
570
571     for (y = 0; y < height; y++) {
572         memcpy(dst, src, width * sizeof(pixel));
573         src += srcstride;
574         dst += dststride;
575     }
576 }
577
578 static void FUNC(put_hevc_pel_bi_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
579                                          int16_t *src2, ptrdiff_t src2stride,
580                                          int height, intptr_t mx, intptr_t my, int width)
581 {
582     int x, y;
583     pixel *src          = (pixel *)_src;
584     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
585     pixel *dst          = (pixel *)_dst;
586     ptrdiff_t dststride = _dststride / sizeof(pixel);
587
588     int shift = 14  + 1 - BIT_DEPTH;
589 #if BIT_DEPTH < 14
590     int offset = 1 << (shift - 1);
591 #else
592     int offset = 0;
593 #endif
594
595     for (y = 0; y < height; y++) {
596         for (x = 0; x < width; x++)
597             dst[x] = av_clip_pixel(((src[x] << (14 - BIT_DEPTH)) + src2[x] + offset) >> shift);
598         src  += srcstride;
599         dst  += dststride;
600         src2 += src2stride;
601     }
602 }
603
604 static void FUNC(put_hevc_pel_uni_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
605                                             int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
606 {
607     int x, y;
608     pixel *src          = (pixel *)_src;
609     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
610     pixel *dst          = (pixel *)_dst;
611     ptrdiff_t dststride = _dststride / sizeof(pixel);
612     int shift = denom + 14 - BIT_DEPTH;
613 #if BIT_DEPTH < 14
614     int offset = 1 << (shift - 1);
615 #else
616     int offset = 0;
617 #endif
618
619     ox     = ox * (1 << (BIT_DEPTH - 8));
620     for (y = 0; y < height; y++) {
621         for (x = 0; x < width; x++)
622             dst[x] = av_clip_pixel((((src[x] << (14 - BIT_DEPTH)) * wx + offset) >> shift) + ox);
623         src += srcstride;
624         dst += dststride;
625     }
626 }
627
628 static void FUNC(put_hevc_pel_bi_w_pixels)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
629                                            int16_t *src2, ptrdiff_t src2stride,
630                                            int height, int denom, int wx0, int wx1,
631                                            int ox0, int ox1, intptr_t mx, intptr_t my, int width)
632 {
633     int x, y;
634     pixel *src          = (pixel *)_src;
635     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
636     pixel *dst          = (pixel *)_dst;
637     ptrdiff_t dststride = _dststride / sizeof(pixel);
638
639     int shift = 14  + 1 - BIT_DEPTH;
640     int log2Wd = denom + shift - 1;
641
642     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
643     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
644     for (y = 0; y < height; y++) {
645         for (x = 0; x < width; x++) {
646             dst[x] = av_clip_pixel(( (src[x] << (14 - BIT_DEPTH)) * wx1 + src2[x] * wx0 + ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
647         }
648         src  += srcstride;
649         dst  += dststride;
650         src2 += src2stride;
651     }
652 }
653
654 ////////////////////////////////////////////////////////////////////////////////
655 //
656 ////////////////////////////////////////////////////////////////////////////////
657 #define QPEL_FILTER(src, stride)                                               \
658     (filter[0] * src[x - 3 * stride] +                                         \
659      filter[1] * src[x - 2 * stride] +                                         \
660      filter[2] * src[x -     stride] +                                         \
661      filter[3] * src[x             ] +                                         \
662      filter[4] * src[x +     stride] +                                         \
663      filter[5] * src[x + 2 * stride] +                                         \
664      filter[6] * src[x + 3 * stride] +                                         \
665      filter[7] * src[x + 4 * stride])
666
667 static void FUNC(put_hevc_qpel_h)(int16_t *dst,  ptrdiff_t dststride,
668                                   uint8_t *_src, ptrdiff_t _srcstride,
669                                   int height, intptr_t mx, intptr_t my, int width)
670 {
671     int x, y;
672     pixel        *src       = (pixel*)_src;
673     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
674     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
675     for (y = 0; y < height; y++) {
676         for (x = 0; x < width; x++)
677             dst[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
678         src += srcstride;
679         dst += dststride;
680     }
681 }
682
683 static void FUNC(put_hevc_qpel_v)(int16_t *dst,  ptrdiff_t dststride,
684                                   uint8_t *_src, ptrdiff_t _srcstride,
685                                   int height, intptr_t mx, intptr_t my, int width)
686 {
687     int x, y;
688     pixel        *src       = (pixel*)_src;
689     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
690     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
691     for (y = 0; y < height; y++)  {
692         for (x = 0; x < width; x++)
693             dst[x] = QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8);
694         src += srcstride;
695         dst += dststride;
696     }
697 }
698
699 static void FUNC(put_hevc_qpel_hv)(int16_t *dst,
700                                    ptrdiff_t dststride,
701                                    uint8_t *_src,
702                                    ptrdiff_t _srcstride,
703                                    int height, intptr_t mx,
704                                    intptr_t my, int width)
705 {
706     int x, y;
707     const int8_t *filter;
708     pixel *src = (pixel*)_src;
709     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
710     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
711     int16_t *tmp = tmp_array;
712
713     src   -= QPEL_EXTRA_BEFORE * srcstride;
714     filter = ff_hevc_qpel_filters[mx - 1];
715     for (y = 0; y < height + QPEL_EXTRA; y++) {
716         for (x = 0; x < width; x++)
717             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
718         src += srcstride;
719         tmp += MAX_PB_SIZE;
720     }
721
722     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
723     filter = ff_hevc_qpel_filters[my - 1];
724     for (y = 0; y < height; y++) {
725         for (x = 0; x < width; x++)
726             dst[x] = QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6;
727         tmp += MAX_PB_SIZE;
728         dst += dststride;
729     }
730 }
731
732 static void FUNC(put_hevc_qpel_uni_h)(uint8_t *_dst,  ptrdiff_t _dststride,
733                                       uint8_t *_src, ptrdiff_t _srcstride,
734                                       int height, intptr_t mx, intptr_t my, int width)
735 {
736     int x, y;
737     pixel        *src       = (pixel*)_src;
738     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
739     pixel *dst          = (pixel *)_dst;
740     ptrdiff_t dststride = _dststride / sizeof(pixel);
741     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
742     int shift = 14 - BIT_DEPTH;
743
744 #if BIT_DEPTH < 14
745     int offset = 1 << (shift - 1);
746 #else
747     int offset = 0;
748 #endif
749
750     for (y = 0; y < height; y++) {
751         for (x = 0; x < width; x++)
752             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
753         src += srcstride;
754         dst += dststride;
755     }
756 }
757
758 static void FUNC(put_hevc_qpel_bi_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
759                                      int16_t *src2, ptrdiff_t src2stride,
760                                      int height, intptr_t mx, intptr_t my, int width)
761 {
762     int x, y;
763     pixel        *src       = (pixel*)_src;
764     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
765     pixel *dst          = (pixel *)_dst;
766     ptrdiff_t dststride = _dststride / sizeof(pixel);
767
768     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
769
770     int shift = 14  + 1 - BIT_DEPTH;
771 #if BIT_DEPTH < 14
772     int offset = 1 << (shift - 1);
773 #else
774     int offset = 0;
775 #endif
776
777     for (y = 0; y < height; y++) {
778         for (x = 0; x < width; x++)
779             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);
780         src  += srcstride;
781         dst  += dststride;
782         src2 += src2stride;
783     }
784 }
785
786 static void FUNC(put_hevc_qpel_uni_v)(uint8_t *_dst,  ptrdiff_t _dststride,
787                                      uint8_t *_src, ptrdiff_t _srcstride,
788                                      int height, intptr_t mx, intptr_t my, int width)
789 {
790     int x, y;
791     pixel        *src       = (pixel*)_src;
792     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
793     pixel *dst          = (pixel *)_dst;
794     ptrdiff_t dststride = _dststride / sizeof(pixel);
795     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
796     int shift = 14 - BIT_DEPTH;
797
798 #if BIT_DEPTH < 14
799     int offset = 1 << (shift - 1);
800 #else
801     int offset = 0;
802 #endif
803
804     for (y = 0; y < height; y++) {
805         for (x = 0; x < width; x++)
806             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + offset) >> shift);
807         src += srcstride;
808         dst += dststride;
809     }
810 }
811
812
813 static void FUNC(put_hevc_qpel_bi_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
814                                      int16_t *src2, ptrdiff_t src2stride,
815                                      int height, intptr_t mx, intptr_t my, int width)
816 {
817     int x, y;
818     pixel        *src       = (pixel*)_src;
819     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
820     pixel *dst          = (pixel *)_dst;
821     ptrdiff_t dststride = _dststride / sizeof(pixel);
822
823     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
824
825     int shift = 14 + 1 - BIT_DEPTH;
826 #if BIT_DEPTH < 14
827     int offset = 1 << (shift - 1);
828 #else
829     int offset = 0;
830 #endif
831
832     for (y = 0; y < height; y++) {
833         for (x = 0; x < width; x++)
834             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);
835         src  += srcstride;
836         dst  += dststride;
837         src2 += src2stride;
838     }
839 }
840
841 static void FUNC(put_hevc_qpel_uni_hv)(uint8_t *_dst,  ptrdiff_t _dststride,
842                                        uint8_t *_src, ptrdiff_t _srcstride,
843                                        int height, intptr_t mx, intptr_t my, int width)
844 {
845     int x, y;
846     const int8_t *filter;
847     pixel *src = (pixel*)_src;
848     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
849     pixel *dst          = (pixel *)_dst;
850     ptrdiff_t dststride = _dststride / sizeof(pixel);
851     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
852     int16_t *tmp = tmp_array;
853     int shift =  14 - BIT_DEPTH;
854
855 #if BIT_DEPTH < 14
856     int offset = 1 << (shift - 1);
857 #else
858     int offset = 0;
859 #endif
860
861     src   -= QPEL_EXTRA_BEFORE * srcstride;
862     filter = ff_hevc_qpel_filters[mx - 1];
863     for (y = 0; y < height + QPEL_EXTRA; y++) {
864         for (x = 0; x < width; x++)
865             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
866         src += srcstride;
867         tmp += MAX_PB_SIZE;
868     }
869
870     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
871     filter = ff_hevc_qpel_filters[my - 1];
872
873     for (y = 0; y < height; y++) {
874         for (x = 0; x < width; x++)
875             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
876         tmp += MAX_PB_SIZE;
877         dst += dststride;
878     }
879 }
880
881 static void FUNC(put_hevc_qpel_bi_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
882                                       int16_t *src2, ptrdiff_t src2stride,
883                                       int height, intptr_t mx, intptr_t my, int width)
884 {
885     int x, y;
886     const int8_t *filter;
887     pixel *src = (pixel*)_src;
888     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
889     pixel *dst          = (pixel *)_dst;
890     ptrdiff_t dststride = _dststride / sizeof(pixel);
891     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
892     int16_t *tmp = tmp_array;
893     int shift = 14 + 1 - BIT_DEPTH;
894 #if BIT_DEPTH < 14
895     int offset = 1 << (shift - 1);
896 #else
897     int offset = 0;
898 #endif
899
900     src   -= QPEL_EXTRA_BEFORE * srcstride;
901     filter = ff_hevc_qpel_filters[mx - 1];
902     for (y = 0; y < height + QPEL_EXTRA; y++) {
903         for (x = 0; x < width; x++)
904             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
905         src += srcstride;
906         tmp += MAX_PB_SIZE;
907     }
908
909     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
910     filter = ff_hevc_qpel_filters[my - 1];
911
912     for (y = 0; y < height; y++) {
913         for (x = 0; x < width; x++)
914             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + src2[x] + offset) >> shift);
915         tmp  += MAX_PB_SIZE;
916         dst  += dststride;
917         src2 += src2stride;
918     }
919 }
920
921 static void FUNC(put_hevc_qpel_uni_w_h)(uint8_t *_dst,  ptrdiff_t _dststride,
922                                         uint8_t *_src, ptrdiff_t _srcstride,
923                                         int height, int denom, int wx, int ox,
924                                         intptr_t mx, intptr_t my, int width)
925 {
926     int x, y;
927     pixel        *src       = (pixel*)_src;
928     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
929     pixel *dst          = (pixel *)_dst;
930     ptrdiff_t dststride = _dststride / sizeof(pixel);
931     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
932     int shift = denom + 14 - BIT_DEPTH;
933 #if BIT_DEPTH < 14
934     int offset = 1 << (shift - 1);
935 #else
936     int offset = 0;
937 #endif
938
939     ox = ox * (1 << (BIT_DEPTH - 8));
940     for (y = 0; y < height; y++) {
941         for (x = 0; x < width; x++)
942             dst[x] = av_clip_pixel((((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
943         src += srcstride;
944         dst += dststride;
945     }
946 }
947
948 static void FUNC(put_hevc_qpel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
949                                        int16_t *src2, ptrdiff_t src2stride,
950                                        int height, int denom, int wx0, int wx1,
951                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)
952 {
953     int x, y;
954     pixel        *src       = (pixel*)_src;
955     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
956     pixel *dst          = (pixel *)_dst;
957     ptrdiff_t dststride = _dststride / sizeof(pixel);
958
959     const int8_t *filter    = ff_hevc_qpel_filters[mx - 1];
960
961     int shift = 14  + 1 - BIT_DEPTH;
962     int log2Wd = denom + shift - 1;
963
964     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
965     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
966     for (y = 0; y < height; y++) {
967         for (x = 0; x < width; x++)
968             dst[x] = av_clip_pixel(((QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
969                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
970         src  += srcstride;
971         dst  += dststride;
972         src2 += src2stride;
973     }
974 }
975
976 static void FUNC(put_hevc_qpel_uni_w_v)(uint8_t *_dst,  ptrdiff_t _dststride,
977                                         uint8_t *_src, ptrdiff_t _srcstride,
978                                         int height, int denom, int wx, int ox,
979                                         intptr_t mx, intptr_t my, int width)
980 {
981     int x, y;
982     pixel        *src       = (pixel*)_src;
983     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
984     pixel *dst          = (pixel *)_dst;
985     ptrdiff_t dststride = _dststride / sizeof(pixel);
986     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
987     int shift = denom + 14 - BIT_DEPTH;
988 #if BIT_DEPTH < 14
989     int offset = 1 << (shift - 1);
990 #else
991     int offset = 0;
992 #endif
993
994     ox = ox * (1 << (BIT_DEPTH - 8));
995     for (y = 0; y < height; y++) {
996         for (x = 0; x < width; x++)
997             dst[x] = av_clip_pixel((((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
998         src += srcstride;
999         dst += dststride;
1000     }
1001 }
1002
1003 static void FUNC(put_hevc_qpel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1004                                        int16_t *src2, ptrdiff_t src2stride,
1005                                        int height, int denom, int wx0, int wx1,
1006                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)
1007 {
1008     int x, y;
1009     pixel        *src       = (pixel*)_src;
1010     ptrdiff_t     srcstride = _srcstride / sizeof(pixel);
1011     pixel *dst          = (pixel *)_dst;
1012     ptrdiff_t dststride = _dststride / sizeof(pixel);
1013
1014     const int8_t *filter    = ff_hevc_qpel_filters[my - 1];
1015
1016     int shift = 14 + 1 - BIT_DEPTH;
1017     int log2Wd = denom + shift - 1;
1018
1019     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
1020     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
1021     for (y = 0; y < height; y++) {
1022         for (x = 0; x < width; x++)
1023             dst[x] = av_clip_pixel(((QPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
1024                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
1025         src  += srcstride;
1026         dst  += dststride;
1027         src2 += src2stride;
1028     }
1029 }
1030
1031 static void FUNC(put_hevc_qpel_uni_w_hv)(uint8_t *_dst,  ptrdiff_t _dststride,
1032                                          uint8_t *_src, ptrdiff_t _srcstride,
1033                                          int height, int denom, int wx, int ox,
1034                                          intptr_t mx, intptr_t my, int width)
1035 {
1036     int x, y;
1037     const int8_t *filter;
1038     pixel *src = (pixel*)_src;
1039     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
1040     pixel *dst          = (pixel *)_dst;
1041     ptrdiff_t dststride = _dststride / sizeof(pixel);
1042     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
1043     int16_t *tmp = tmp_array;
1044     int shift = denom + 14 - BIT_DEPTH;
1045 #if BIT_DEPTH < 14
1046     int offset = 1 << (shift - 1);
1047 #else
1048     int offset = 0;
1049 #endif
1050
1051     src   -= QPEL_EXTRA_BEFORE * srcstride;
1052     filter = ff_hevc_qpel_filters[mx - 1];
1053     for (y = 0; y < height + QPEL_EXTRA; y++) {
1054         for (x = 0; x < width; x++)
1055             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
1056         src += srcstride;
1057         tmp += MAX_PB_SIZE;
1058     }
1059
1060     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
1061     filter = ff_hevc_qpel_filters[my - 1];
1062
1063     ox = ox * (1 << (BIT_DEPTH - 8));
1064     for (y = 0; y < height; y++) {
1065         for (x = 0; x < width; x++)
1066             dst[x] = av_clip_pixel((((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
1067         tmp += MAX_PB_SIZE;
1068         dst += dststride;
1069     }
1070 }
1071
1072 static void FUNC(put_hevc_qpel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1073                                         int16_t *src2, ptrdiff_t src2stride,
1074                                         int height, int denom, int wx0, int wx1,
1075                                         int ox0, int ox1, intptr_t mx, intptr_t my, int width)
1076 {
1077     int x, y;
1078     const int8_t *filter;
1079     pixel *src = (pixel*)_src;
1080     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
1081     pixel *dst          = (pixel *)_dst;
1082     ptrdiff_t dststride = _dststride / sizeof(pixel);
1083     int16_t tmp_array[(MAX_PB_SIZE + QPEL_EXTRA) * MAX_PB_SIZE];
1084     int16_t *tmp = tmp_array;
1085     int shift = 14 + 1 - BIT_DEPTH;
1086     int log2Wd = denom + shift - 1;
1087
1088     src   -= QPEL_EXTRA_BEFORE * srcstride;
1089     filter = ff_hevc_qpel_filters[mx - 1];
1090     for (y = 0; y < height + QPEL_EXTRA; y++) {
1091         for (x = 0; x < width; x++)
1092             tmp[x] = QPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
1093         src += srcstride;
1094         tmp += MAX_PB_SIZE;
1095     }
1096
1097     tmp    = tmp_array + QPEL_EXTRA_BEFORE * MAX_PB_SIZE;
1098     filter = ff_hevc_qpel_filters[my - 1];
1099
1100     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
1101     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
1102     for (y = 0; y < height; y++) {
1103         for (x = 0; x < width; x++)
1104             dst[x] = av_clip_pixel(((QPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +
1105                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
1106         tmp  += MAX_PB_SIZE;
1107         dst  += dststride;
1108         src2 += src2stride;
1109     }
1110 }
1111
1112 ////////////////////////////////////////////////////////////////////////////////
1113 //
1114 ////////////////////////////////////////////////////////////////////////////////
1115 #define EPEL_FILTER(src, stride)                                               \
1116     (filter[0] * src[x - stride] +                                             \
1117      filter[1] * src[x]          +                                             \
1118      filter[2] * src[x + stride] +                                             \
1119      filter[3] * src[x + 2 * stride])
1120
1121 static void FUNC(put_hevc_epel_h)(int16_t *dst, ptrdiff_t dststride,
1122                                   uint8_t *_src, ptrdiff_t _srcstride,
1123                                   int height, intptr_t mx, intptr_t my, int width)
1124 {
1125     int x, y;
1126     pixel *src = (pixel *)_src;
1127     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1128     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1129     for (y = 0; y < height; y++) {
1130         for (x = 0; x < width; x++)
1131             dst[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
1132         src += srcstride;
1133         dst += dststride;
1134     }
1135 }
1136
1137 static void FUNC(put_hevc_epel_v)(int16_t *dst, ptrdiff_t dststride,
1138                                   uint8_t *_src, ptrdiff_t _srcstride,
1139                                   int height, intptr_t mx, intptr_t my, int width)
1140 {
1141     int x, y;
1142     pixel *src = (pixel *)_src;
1143     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
1144     const int8_t *filter = ff_hevc_epel_filters[my - 1];
1145
1146     for (y = 0; y < height; y++) {
1147         for (x = 0; x < width; x++)
1148             dst[x] = EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8);
1149         src += srcstride;
1150         dst += dststride;
1151     }
1152 }
1153
1154 static void FUNC(put_hevc_epel_hv)(int16_t *dst, ptrdiff_t dststride,
1155                                    uint8_t *_src, ptrdiff_t _srcstride,
1156                                    int height, intptr_t mx, intptr_t my, int width)
1157 {
1158     int x, y;
1159     pixel *src = (pixel *)_src;
1160     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
1161     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1162     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
1163     int16_t *tmp = tmp_array;
1164
1165     src -= EPEL_EXTRA_BEFORE * srcstride;
1166
1167     for (y = 0; y < height + EPEL_EXTRA; y++) {
1168         for (x = 0; x < width; x++)
1169             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
1170         src += srcstride;
1171         tmp += MAX_PB_SIZE;
1172     }
1173
1174     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
1175     filter = ff_hevc_epel_filters[my - 1];
1176
1177     for (y = 0; y < height; y++) {
1178         for (x = 0; x < width; x++)
1179             dst[x] = EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6;
1180         tmp += MAX_PB_SIZE;
1181         dst += dststride;
1182     }
1183 }
1184
1185 static void FUNC(put_hevc_epel_uni_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1186                                       int height, intptr_t mx, intptr_t my, int width)
1187 {
1188     int x, y;
1189     pixel *src = (pixel *)_src;
1190     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1191     pixel *dst          = (pixel *)_dst;
1192     ptrdiff_t dststride = _dststride / sizeof(pixel);
1193     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1194     int shift = 14 - BIT_DEPTH;
1195 #if BIT_DEPTH < 14
1196     int offset = 1 << (shift - 1);
1197 #else
1198     int offset = 0;
1199 #endif
1200
1201     for (y = 0; y < height; y++) {
1202         for (x = 0; x < width; x++)
1203             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + offset) >> shift);
1204         src += srcstride;
1205         dst += dststride;
1206     }
1207 }
1208
1209 static void FUNC(put_hevc_epel_bi_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1210                                      int16_t *src2, ptrdiff_t src2stride,
1211                                      int height, intptr_t mx, intptr_t my, int width)
1212 {
1213     int x, y;
1214     pixel *src = (pixel *)_src;
1215     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1216     pixel *dst          = (pixel *)_dst;
1217     ptrdiff_t dststride = _dststride / sizeof(pixel);
1218     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1219     int shift = 14 + 1 - BIT_DEPTH;
1220 #if BIT_DEPTH < 14
1221     int offset = 1 << (shift - 1);
1222 #else
1223     int offset = 0;
1224 #endif
1225
1226     for (y = 0; y < height; y++) {
1227         for (x = 0; x < width; x++) {
1228             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);
1229         }
1230         dst  += dststride;
1231         src  += srcstride;
1232         src2 += src2stride;
1233     }
1234 }
1235
1236 static void FUNC(put_hevc_epel_uni_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1237                                       int height, intptr_t mx, intptr_t my, int width)
1238 {
1239     int x, y;
1240     pixel *src = (pixel *)_src;
1241     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1242     pixel *dst          = (pixel *)_dst;
1243     ptrdiff_t dststride = _dststride / sizeof(pixel);
1244     const int8_t *filter = ff_hevc_epel_filters[my - 1];
1245     int shift = 14 - BIT_DEPTH;
1246 #if BIT_DEPTH < 14
1247     int offset = 1 << (shift - 1);
1248 #else
1249     int offset = 0;
1250 #endif
1251
1252     for (y = 0; y < height; y++) {
1253         for (x = 0; x < width; x++)
1254             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + offset) >> shift);
1255         src += srcstride;
1256         dst += dststride;
1257     }
1258 }
1259
1260 static void FUNC(put_hevc_epel_bi_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1261                                      int16_t *src2, ptrdiff_t src2stride,
1262                                      int height, intptr_t mx, intptr_t my, int width)
1263 {
1264     int x, y;
1265     pixel *src = (pixel *)_src;
1266     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1267     const int8_t *filter = ff_hevc_epel_filters[my - 1];
1268     pixel *dst          = (pixel *)_dst;
1269     ptrdiff_t dststride = _dststride / sizeof(pixel);
1270     int shift = 14 + 1 - BIT_DEPTH;
1271 #if BIT_DEPTH < 14
1272     int offset = 1 << (shift - 1);
1273 #else
1274     int offset = 0;
1275 #endif
1276
1277     for (y = 0; y < height; y++) {
1278         for (x = 0; x < width; x++)
1279             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) + src2[x] + offset) >> shift);
1280         dst  += dststride;
1281         src  += srcstride;
1282         src2 += src2stride;
1283     }
1284 }
1285
1286 static void FUNC(put_hevc_epel_uni_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1287                                        int height, intptr_t mx, intptr_t my, int width)
1288 {
1289     int x, y;
1290     pixel *src = (pixel *)_src;
1291     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
1292     pixel *dst          = (pixel *)_dst;
1293     ptrdiff_t dststride = _dststride / sizeof(pixel);
1294     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1295     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
1296     int16_t *tmp = tmp_array;
1297     int shift = 14 - BIT_DEPTH;
1298 #if BIT_DEPTH < 14
1299     int offset = 1 << (shift - 1);
1300 #else
1301     int offset = 0;
1302 #endif
1303
1304     src -= EPEL_EXTRA_BEFORE * srcstride;
1305
1306     for (y = 0; y < height + EPEL_EXTRA; y++) {
1307         for (x = 0; x < width; x++)
1308             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
1309         src += srcstride;
1310         tmp += MAX_PB_SIZE;
1311     }
1312
1313     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
1314     filter = ff_hevc_epel_filters[my - 1];
1315
1316     for (y = 0; y < height; y++) {
1317         for (x = 0; x < width; x++)
1318             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + offset) >> shift);
1319         tmp += MAX_PB_SIZE;
1320         dst += dststride;
1321     }
1322 }
1323
1324 static void FUNC(put_hevc_epel_bi_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1325                                       int16_t *src2, ptrdiff_t src2stride,
1326                                       int height, intptr_t mx, intptr_t my, int width)
1327 {
1328     int x, y;
1329     pixel *src = (pixel *)_src;
1330     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
1331     pixel *dst          = (pixel *)_dst;
1332     ptrdiff_t dststride = _dststride / sizeof(pixel);
1333     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1334     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
1335     int16_t *tmp = tmp_array;
1336     int shift = 14 + 1 - BIT_DEPTH;
1337 #if BIT_DEPTH < 14
1338     int offset = 1 << (shift - 1);
1339 #else
1340     int offset = 0;
1341 #endif
1342
1343     src -= EPEL_EXTRA_BEFORE * srcstride;
1344
1345     for (y = 0; y < height + EPEL_EXTRA; y++) {
1346         for (x = 0; x < width; x++)
1347             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
1348         src += srcstride;
1349         tmp += MAX_PB_SIZE;
1350     }
1351
1352     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
1353     filter = ff_hevc_epel_filters[my - 1];
1354
1355     for (y = 0; y < height; y++) {
1356         for (x = 0; x < width; x++)
1357             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) + src2[x] + offset) >> shift);
1358         tmp  += MAX_PB_SIZE;
1359         dst  += dststride;
1360         src2 += src2stride;
1361     }
1362 }
1363
1364 static void FUNC(put_hevc_epel_uni_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1365                                         int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
1366 {
1367     int x, y;
1368     pixel *src = (pixel *)_src;
1369     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1370     pixel *dst          = (pixel *)_dst;
1371     ptrdiff_t dststride = _dststride / sizeof(pixel);
1372     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1373     int shift = denom + 14 - BIT_DEPTH;
1374 #if BIT_DEPTH < 14
1375     int offset = 1 << (shift - 1);
1376 #else
1377     int offset = 0;
1378 #endif
1379
1380     ox     = ox * (1 << (BIT_DEPTH - 8));
1381     for (y = 0; y < height; y++) {
1382         for (x = 0; x < width; x++) {
1383             dst[x] = av_clip_pixel((((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
1384         }
1385         dst += dststride;
1386         src += srcstride;
1387     }
1388 }
1389
1390 static void FUNC(put_hevc_epel_bi_w_h)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1391                                        int16_t *src2, ptrdiff_t src2stride,
1392                                        int height, int denom, int wx0, int wx1,
1393                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)
1394 {
1395     int x, y;
1396     pixel *src = (pixel *)_src;
1397     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1398     pixel *dst          = (pixel *)_dst;
1399     ptrdiff_t dststride = _dststride / sizeof(pixel);
1400     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1401     int shift = 14 + 1 - BIT_DEPTH;
1402     int log2Wd = denom + shift - 1;
1403
1404     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
1405     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
1406     for (y = 0; y < height; y++) {
1407         for (x = 0; x < width; x++)
1408             dst[x] = av_clip_pixel(((EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
1409                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
1410         src  += srcstride;
1411         dst  += dststride;
1412         src2 += src2stride;
1413     }
1414 }
1415
1416 static void FUNC(put_hevc_epel_uni_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1417                                         int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
1418 {
1419     int x, y;
1420     pixel *src = (pixel *)_src;
1421     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1422     pixel *dst          = (pixel *)_dst;
1423     ptrdiff_t dststride = _dststride / sizeof(pixel);
1424     const int8_t *filter = ff_hevc_epel_filters[my - 1];
1425     int shift = denom + 14 - BIT_DEPTH;
1426 #if BIT_DEPTH < 14
1427     int offset = 1 << (shift - 1);
1428 #else
1429     int offset = 0;
1430 #endif
1431
1432     ox     = ox * (1 << (BIT_DEPTH - 8));
1433     for (y = 0; y < height; y++) {
1434         for (x = 0; x < width; x++) {
1435             dst[x] = av_clip_pixel((((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx + offset) >> shift) + ox);
1436         }
1437         dst += dststride;
1438         src += srcstride;
1439     }
1440 }
1441
1442 static void FUNC(put_hevc_epel_bi_w_v)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1443                                        int16_t *src2, ptrdiff_t src2stride,
1444                                        int height, int denom, int wx0, int wx1,
1445                                        int ox0, int ox1, intptr_t mx, intptr_t my, int width)
1446 {
1447     int x, y;
1448     pixel *src = (pixel *)_src;
1449     ptrdiff_t srcstride  = _srcstride / sizeof(pixel);
1450     const int8_t *filter = ff_hevc_epel_filters[my - 1];
1451     pixel *dst          = (pixel *)_dst;
1452     ptrdiff_t dststride = _dststride / sizeof(pixel);
1453     int shift = 14 + 1 - BIT_DEPTH;
1454     int log2Wd = denom + shift - 1;
1455
1456     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
1457     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
1458     for (y = 0; y < height; y++) {
1459         for (x = 0; x < width; x++)
1460             dst[x] = av_clip_pixel(((EPEL_FILTER(src, srcstride) >> (BIT_DEPTH - 8)) * wx1 + src2[x] * wx0 +
1461                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
1462         src  += srcstride;
1463         dst  += dststride;
1464         src2 += src2stride;
1465     }
1466 }
1467
1468 static void FUNC(put_hevc_epel_uni_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1469                                          int height, int denom, int wx, int ox, intptr_t mx, intptr_t my, int width)
1470 {
1471     int x, y;
1472     pixel *src = (pixel *)_src;
1473     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
1474     pixel *dst          = (pixel *)_dst;
1475     ptrdiff_t dststride = _dststride / sizeof(pixel);
1476     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1477     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
1478     int16_t *tmp = tmp_array;
1479     int shift = denom + 14 - BIT_DEPTH;
1480 #if BIT_DEPTH < 14
1481     int offset = 1 << (shift - 1);
1482 #else
1483     int offset = 0;
1484 #endif
1485
1486     src -= EPEL_EXTRA_BEFORE * srcstride;
1487
1488     for (y = 0; y < height + EPEL_EXTRA; y++) {
1489         for (x = 0; x < width; x++)
1490             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
1491         src += srcstride;
1492         tmp += MAX_PB_SIZE;
1493     }
1494
1495     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
1496     filter = ff_hevc_epel_filters[my - 1];
1497
1498     ox     = ox * (1 << (BIT_DEPTH - 8));
1499     for (y = 0; y < height; y++) {
1500         for (x = 0; x < width; x++)
1501             dst[x] = av_clip_pixel((((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx + offset) >> shift) + ox);
1502         tmp += MAX_PB_SIZE;
1503         dst += dststride;
1504     }
1505 }
1506
1507 static void FUNC(put_hevc_epel_bi_w_hv)(uint8_t *_dst, ptrdiff_t _dststride, uint8_t *_src, ptrdiff_t _srcstride,
1508                                         int16_t *src2, ptrdiff_t src2stride,
1509                                         int height, int denom, int wx0, int wx1,
1510                                         int ox0, int ox1, intptr_t mx, intptr_t my, int width)
1511 {
1512     int x, y;
1513     pixel *src = (pixel *)_src;
1514     ptrdiff_t srcstride = _srcstride / sizeof(pixel);
1515     pixel *dst          = (pixel *)_dst;
1516     ptrdiff_t dststride = _dststride / sizeof(pixel);
1517     const int8_t *filter = ff_hevc_epel_filters[mx - 1];
1518     int16_t tmp_array[(MAX_PB_SIZE + EPEL_EXTRA) * MAX_PB_SIZE];
1519     int16_t *tmp = tmp_array;
1520     int shift = 14 + 1 - BIT_DEPTH;
1521     int log2Wd = denom + shift - 1;
1522
1523     src -= EPEL_EXTRA_BEFORE * srcstride;
1524
1525     for (y = 0; y < height + EPEL_EXTRA; y++) {
1526         for (x = 0; x < width; x++)
1527             tmp[x] = EPEL_FILTER(src, 1) >> (BIT_DEPTH - 8);
1528         src += srcstride;
1529         tmp += MAX_PB_SIZE;
1530     }
1531
1532     tmp      = tmp_array + EPEL_EXTRA_BEFORE * MAX_PB_SIZE;
1533     filter = ff_hevc_epel_filters[my - 1];
1534
1535     ox0     = ox0 * (1 << (BIT_DEPTH - 8));
1536     ox1     = ox1 * (1 << (BIT_DEPTH - 8));
1537     for (y = 0; y < height; y++) {
1538         for (x = 0; x < width; x++)
1539             dst[x] = av_clip_pixel(((EPEL_FILTER(tmp, MAX_PB_SIZE) >> 6) * wx1 + src2[x] * wx0 +
1540                                     ((ox0 + ox1 + 1) << log2Wd)) >> (log2Wd + 1));
1541         tmp  += MAX_PB_SIZE;
1542         dst  += dststride;
1543         src2 += src2stride;
1544     }
1545 }// line zero
1546 #define P3 pix[-4 * xstride]
1547 #define P2 pix[-3 * xstride]
1548 #define P1 pix[-2 * xstride]
1549 #define P0 pix[-1 * xstride]
1550 #define Q0 pix[0 * xstride]
1551 #define Q1 pix[1 * xstride]
1552 #define Q2 pix[2 * xstride]
1553 #define Q3 pix[3 * xstride]
1554
1555 // line three. used only for deblocking decision
1556 #define TP3 pix[-4 * xstride + 3 * ystride]
1557 #define TP2 pix[-3 * xstride + 3 * ystride]
1558 #define TP1 pix[-2 * xstride + 3 * ystride]
1559 #define TP0 pix[-1 * xstride + 3 * ystride]
1560 #define TQ0 pix[0  * xstride + 3 * ystride]
1561 #define TQ1 pix[1  * xstride + 3 * ystride]
1562 #define TQ2 pix[2  * xstride + 3 * ystride]
1563 #define TQ3 pix[3  * xstride + 3 * ystride]
1564
1565 static void FUNC(hevc_loop_filter_luma)(uint8_t *_pix,
1566                                         ptrdiff_t _xstride, ptrdiff_t _ystride,
1567                                         int beta, int *_tc,
1568                                         uint8_t *_no_p, uint8_t *_no_q)
1569 {
1570     int d, j;
1571     pixel *pix        = (pixel *)_pix;
1572     ptrdiff_t xstride = _xstride / sizeof(pixel);
1573     ptrdiff_t ystride = _ystride / sizeof(pixel);
1574
1575     beta <<= BIT_DEPTH - 8;
1576
1577     for (j = 0; j < 2; j++) {
1578         const int dp0  = abs(P2  - 2 * P1  + P0);
1579         const int dq0  = abs(Q2  - 2 * Q1  + Q0);
1580         const int dp3  = abs(TP2 - 2 * TP1 + TP0);
1581         const int dq3  = abs(TQ2 - 2 * TQ1 + TQ0);
1582         const int d0   = dp0 + dq0;
1583         const int d3   = dp3 + dq3;
1584         const int tc   = _tc[j]   << (BIT_DEPTH - 8);
1585         const int no_p = _no_p[j];
1586         const int no_q = _no_q[j];
1587
1588         if (d0 + d3 >= beta) {
1589             pix += 4 * ystride;
1590             continue;
1591         } else {
1592             const int beta_3 = beta >> 3;
1593             const int beta_2 = beta >> 2;
1594             const int tc25   = ((tc * 5 + 1) >> 1);
1595
1596             if (abs(P3  -  P0) + abs(Q3  -  Q0) < beta_3 && abs(P0  -  Q0) < tc25 &&
1597                 abs(TP3 - TP0) + abs(TQ3 - TQ0) < beta_3 && abs(TP0 - TQ0) < tc25 &&
1598                                       (d0 << 1) < beta_2 &&      (d3 << 1) < beta_2) {
1599                 // strong filtering
1600                 const int tc2 = tc << 1;
1601                 for (d = 0; d < 4; d++) {
1602                     const int p3 = P3;
1603                     const int p2 = P2;
1604                     const int p1 = P1;
1605                     const int p0 = P0;
1606                     const int q0 = Q0;
1607                     const int q1 = Q1;
1608                     const int q2 = Q2;
1609                     const int q3 = Q3;
1610                     if (!no_p) {
1611                         P0 = p0 + av_clip(((p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3) - p0, -tc2, tc2);
1612                         P1 = p1 + av_clip(((p2 + p1 + p0 + q0 + 2) >> 2) - p1, -tc2, tc2);
1613                         P2 = p2 + av_clip(((2 * p3 + 3 * p2 + p1 + p0 + q0 + 4) >> 3) - p2, -tc2, tc2);
1614                     }
1615                     if (!no_q) {
1616                         Q0 = q0 + av_clip(((p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3) - q0, -tc2, tc2);
1617                         Q1 = q1 + av_clip(((p0 + q0 + q1 + q2 + 2) >> 2) - q1, -tc2, tc2);
1618                         Q2 = q2 + av_clip(((2 * q3 + 3 * q2 + q1 + q0 + p0 + 4) >> 3) - q2, -tc2, tc2);
1619                     }
1620                     pix += ystride;
1621                 }
1622             } else { // normal filtering
1623                 int nd_p = 1;
1624                 int nd_q = 1;
1625                 const int tc_2 = tc >> 1;
1626                 if (dp0 + dp3 < ((beta + (beta >> 1)) >> 3))
1627                     nd_p = 2;
1628                 if (dq0 + dq3 < ((beta + (beta >> 1)) >> 3))
1629                     nd_q = 2;
1630
1631                 for (d = 0; d < 4; d++) {
1632                     const int p2 = P2;
1633                     const int p1 = P1;
1634                     const int p0 = P0;
1635                     const int q0 = Q0;
1636                     const int q1 = Q1;
1637                     const int q2 = Q2;
1638                     int delta0   = (9 * (q0 - p0) - 3 * (q1 - p1) + 8) >> 4;
1639                     if (abs(delta0) < 10 * tc) {
1640                         delta0 = av_clip(delta0, -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                         if (!no_p && nd_p > 1) {
1646                             const int deltap1 = av_clip((((p2 + p0 + 1) >> 1) - p1 + delta0) >> 1, -tc_2, tc_2);
1647                             P1 = av_clip_pixel(p1 + deltap1);
1648                         }
1649                         if (!no_q && nd_q > 1) {
1650                             const int deltaq1 = av_clip((((q2 + q0 + 1) >> 1) - q1 - delta0) >> 1, -tc_2, tc_2);
1651                             Q1 = av_clip_pixel(q1 + deltaq1);
1652                         }
1653                     }
1654                     pix += ystride;
1655                 }
1656             }
1657         }
1658     }
1659 }
1660
1661 static void FUNC(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,
1662                                           ptrdiff_t _ystride, int *_tc,
1663                                           uint8_t *_no_p, uint8_t *_no_q)
1664 {
1665     int d, j, no_p, no_q;
1666     pixel *pix        = (pixel *)_pix;
1667     ptrdiff_t xstride = _xstride / sizeof(pixel);
1668     ptrdiff_t ystride = _ystride / sizeof(pixel);
1669
1670     for (j = 0; j < 2; j++) {
1671         const int tc = _tc[j] << (BIT_DEPTH - 8);
1672         if (tc <= 0) {
1673             pix += 4 * ystride;
1674             continue;
1675         }
1676         no_p = _no_p[j];
1677         no_q = _no_q[j];
1678
1679         for (d = 0; d < 4; d++) {
1680             int delta0;
1681             const int p1 = P1;
1682             const int p0 = P0;
1683             const int q0 = Q0;
1684             const int q1 = Q1;
1685             delta0 = av_clip((((q0 - p0) * 4) + p1 - q1 + 4) >> 3, -tc, tc);
1686             if (!no_p)
1687                 P0 = av_clip_pixel(p0 + delta0);
1688             if (!no_q)
1689                 Q0 = av_clip_pixel(q0 - delta0);
1690             pix += ystride;
1691         }
1692     }
1693 }
1694
1695 static void FUNC(hevc_h_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride,
1696                                             int *tc, uint8_t *no_p,
1697                                             uint8_t *no_q)
1698 {
1699     FUNC(hevc_loop_filter_chroma)(pix, stride, sizeof(pixel), tc, no_p, no_q);
1700 }
1701
1702 static void FUNC(hevc_v_loop_filter_chroma)(uint8_t *pix, ptrdiff_t stride,
1703                                             int *tc, uint8_t *no_p,
1704                                             uint8_t *no_q)
1705 {
1706     FUNC(hevc_loop_filter_chroma)(pix, sizeof(pixel), stride, tc, no_p, no_q);
1707 }
1708
1709 static void FUNC(hevc_h_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,
1710                                           int beta, int *tc, uint8_t *no_p,
1711                                           uint8_t *no_q)
1712 {
1713     FUNC(hevc_loop_filter_luma)(pix, stride, sizeof(pixel),
1714                                 beta, tc, no_p, no_q);
1715 }
1716
1717 static void FUNC(hevc_v_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,
1718                                           int beta, int *tc, uint8_t *no_p,
1719                                           uint8_t *no_q)
1720 {
1721     FUNC(hevc_loop_filter_luma)(pix, sizeof(pixel), stride,
1722                                 beta, tc, no_p, no_q);
1723 }
1724
1725 #undef P3
1726 #undef P2
1727 #undef P1
1728 #undef P0
1729 #undef Q0
1730 #undef Q1
1731 #undef Q2
1732 #undef Q3
1733
1734 #undef TP3
1735 #undef TP2
1736 #undef TP1
1737 #undef TP0
1738 #undef TQ0
1739 #undef TQ1
1740 #undef TQ2
1741 #undef TQ3