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