1 /*
2 * Copyright © 2018, VideoLAN and dav1d authors
3 * Copyright © 2018, Two Orioles, LLC
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright notice, this
10 * list of conditions and the following disclaimer.
11 *
12 * 2. Redistributions in binary form must reproduce the above copyright notice,
13 * this list of conditions and the following disclaimer in the documentation
14 * and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
20 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #include "config.h"
29
30 #include <stdlib.h>
31
32 #include "common/intops.h"
33
34 #include "src/cdef.h"
35 #include "src/tables.h"
36
constrain(const int diff,const int threshold,const int shift)37 static inline int constrain(const int diff, const int threshold,
38 const int shift)
39 {
40 const int adiff = abs(diff);
41 return apply_sign(imin(adiff, imax(0, threshold - (adiff >> shift))), diff);
42 }
43
fill(int16_t * tmp,const ptrdiff_t stride,const int w,const int h)44 static inline void fill(int16_t *tmp, const ptrdiff_t stride,
45 const int w, const int h)
46 {
47 /* Use a value that's a large positive number when interpreted as unsigned,
48 * and a large negative number when interpreted as signed. */
49 for (int y = 0; y < h; y++) {
50 for (int x = 0; x < w; x++)
51 tmp[x] = INT16_MIN;
52 tmp += stride;
53 }
54 }
55
padding(int16_t * tmp,const ptrdiff_t tmp_stride,const pixel * src,const ptrdiff_t src_stride,const pixel (* left)[2],const pixel * top,const pixel * bottom,const int w,const int h,const enum CdefEdgeFlags edges)56 static void padding(int16_t *tmp, const ptrdiff_t tmp_stride,
57 const pixel *src, const ptrdiff_t src_stride,
58 const pixel (*left)[2],
59 const pixel *top, const pixel *bottom,
60 const int w, const int h, const enum CdefEdgeFlags edges)
61 {
62 // fill extended input buffer
63 int x_start = -2, x_end = w + 2, y_start = -2, y_end = h + 2;
64 if (!(edges & CDEF_HAVE_TOP)) {
65 fill(tmp - 2 - 2 * tmp_stride, tmp_stride, w + 4, 2);
66 y_start = 0;
67 }
68 if (!(edges & CDEF_HAVE_BOTTOM)) {
69 fill(tmp + h * tmp_stride - 2, tmp_stride, w + 4, 2);
70 y_end -= 2;
71 }
72 if (!(edges & CDEF_HAVE_LEFT)) {
73 fill(tmp + y_start * tmp_stride - 2, tmp_stride, 2, y_end - y_start);
74 x_start = 0;
75 }
76 if (!(edges & CDEF_HAVE_RIGHT)) {
77 fill(tmp + y_start * tmp_stride + w, tmp_stride, 2, y_end - y_start);
78 x_end -= 2;
79 }
80
81 for (int y = y_start; y < 0; y++) {
82 for (int x = x_start; x < x_end; x++)
83 tmp[x + y * tmp_stride] = top[x];
84 top += PXSTRIDE(src_stride);
85 }
86 for (int y = 0; y < h; y++)
87 for (int x = x_start; x < 0; x++)
88 tmp[x + y * tmp_stride] = left[y][2 + x];
89 for (int y = 0; y < h; y++) {
90 for (int x = (y < h) ? 0 : x_start; x < x_end; x++)
91 tmp[x] = src[x];
92 src += PXSTRIDE(src_stride);
93 tmp += tmp_stride;
94 }
95 for (int y = h; y < y_end; y++) {
96 for (int x = x_start; x < x_end; x++)
97 tmp[x] = bottom[x];
98 bottom += PXSTRIDE(src_stride);
99 tmp += tmp_stride;
100 }
101
102 }
103
104 static NOINLINE void
cdef_filter_block_c(pixel * dst,const ptrdiff_t dst_stride,const pixel (* left)[2],const pixel * const top,const pixel * const bottom,const int pri_strength,const int sec_strength,const int dir,const int damping,const int w,int h,const enum CdefEdgeFlags edges HIGHBD_DECL_SUFFIX)105 cdef_filter_block_c(pixel *dst, const ptrdiff_t dst_stride,
106 const pixel (*left)[2],
107 const pixel *const top, const pixel *const bottom,
108 const int pri_strength, const int sec_strength,
109 const int dir, const int damping, const int w, int h,
110 const enum CdefEdgeFlags edges HIGHBD_DECL_SUFFIX)
111 {
112 const ptrdiff_t tmp_stride = 12;
113 assert((w == 4 || w == 8) && (h == 4 || h == 8));
114 int16_t tmp_buf[144]; // 12*12 is the maximum value of tmp_stride * (h + 4)
115 int16_t *tmp = tmp_buf + 2 * tmp_stride + 2;
116
117 padding(tmp, tmp_stride, dst, dst_stride, left, top, bottom, w, h, edges);
118
119 if (pri_strength) {
120 const int bitdepth_min_8 = bitdepth_from_max(bitdepth_max) - 8;
121 const int pri_tap = 4 - ((pri_strength >> bitdepth_min_8) & 1);
122 const int pri_shift = imax(0, damping - ulog2(pri_strength));
123 if (sec_strength) {
124 const int sec_shift = damping - ulog2(sec_strength);
125 do {
126 for (int x = 0; x < w; x++) {
127 const int px = dst[x];
128 int sum = 0;
129 int max = px, min = px;
130 int pri_tap_k = pri_tap;
131 for (int k = 0; k < 2; k++) {
132 const int off1 = dav1d_cdef_directions[dir + 2][k]; // dir
133 const int p0 = tmp[x + off1];
134 const int p1 = tmp[x - off1];
135 sum += pri_tap_k * constrain(p0 - px, pri_strength, pri_shift);
136 sum += pri_tap_k * constrain(p1 - px, pri_strength, pri_shift);
137 // if pri_tap_k == 4 then it becomes 2 else it remains 3
138 pri_tap_k = (pri_tap_k & 3) | 2;
139 min = umin(p0, min);
140 max = imax(p0, max);
141 min = umin(p1, min);
142 max = imax(p1, max);
143 const int off2 = dav1d_cdef_directions[dir + 4][k]; // dir + 2
144 const int off3 = dav1d_cdef_directions[dir + 0][k]; // dir - 2
145 const int s0 = tmp[x + off2];
146 const int s1 = tmp[x - off2];
147 const int s2 = tmp[x + off3];
148 const int s3 = tmp[x - off3];
149 // sec_tap starts at 2 and becomes 1
150 const int sec_tap = 2 - k;
151 sum += sec_tap * constrain(s0 - px, sec_strength, sec_shift);
152 sum += sec_tap * constrain(s1 - px, sec_strength, sec_shift);
153 sum += sec_tap * constrain(s2 - px, sec_strength, sec_shift);
154 sum += sec_tap * constrain(s3 - px, sec_strength, sec_shift);
155 min = umin(s0, min);
156 max = imax(s0, max);
157 min = umin(s1, min);
158 max = imax(s1, max);
159 min = umin(s2, min);
160 max = imax(s2, max);
161 min = umin(s3, min);
162 max = imax(s3, max);
163 }
164 dst[x] = iclip(px + ((sum - (sum < 0) + 8) >> 4), min, max);
165 }
166 dst += PXSTRIDE(dst_stride);
167 tmp += tmp_stride;
168 } while (--h);
169 } else { // pri_strength only
170 do {
171 for (int x = 0; x < w; x++) {
172 const int px = dst[x];
173 int sum = 0;
174 int pri_tap_k = pri_tap;
175 for (int k = 0; k < 2; k++) {
176 const int off = dav1d_cdef_directions[dir + 2][k]; // dir
177 const int p0 = tmp[x + off];
178 const int p1 = tmp[x - off];
179 sum += pri_tap_k * constrain(p0 - px, pri_strength, pri_shift);
180 sum += pri_tap_k * constrain(p1 - px, pri_strength, pri_shift);
181 pri_tap_k = (pri_tap_k & 3) | 2;
182 }
183 dst[x] = px + ((sum - (sum < 0) + 8) >> 4);
184 }
185 dst += PXSTRIDE(dst_stride);
186 tmp += tmp_stride;
187 } while (--h);
188 }
189 } else { // sec_strength only
190 assert(sec_strength);
191 const int sec_shift = damping - ulog2(sec_strength);
192 do {
193 for (int x = 0; x < w; x++) {
194 const int px = dst[x];
195 int sum = 0;
196 for (int k = 0; k < 2; k++) {
197 const int off1 = dav1d_cdef_directions[dir + 4][k]; // dir + 2
198 const int off2 = dav1d_cdef_directions[dir + 0][k]; // dir - 2
199 const int s0 = tmp[x + off1];
200 const int s1 = tmp[x - off1];
201 const int s2 = tmp[x + off2];
202 const int s3 = tmp[x - off2];
203 const int sec_tap = 2 - k;
204 sum += sec_tap * constrain(s0 - px, sec_strength, sec_shift);
205 sum += sec_tap * constrain(s1 - px, sec_strength, sec_shift);
206 sum += sec_tap * constrain(s2 - px, sec_strength, sec_shift);
207 sum += sec_tap * constrain(s3 - px, sec_strength, sec_shift);
208 }
209 dst[x] = px + ((sum - (sum < 0) + 8) >> 4);
210 }
211 dst += PXSTRIDE(dst_stride);
212 tmp += tmp_stride;
213 } while (--h);
214 }
215 }
216
217 #define cdef_fn(w, h) \
218 static void cdef_filter_block_##w##x##h##_c(pixel *const dst, \
219 const ptrdiff_t stride, \
220 const pixel (*left)[2], \
221 const pixel *const top, \
222 const pixel *const bottom, \
223 const int pri_strength, \
224 const int sec_strength, \
225 const int dir, \
226 const int damping, \
227 const enum CdefEdgeFlags edges \
228 HIGHBD_DECL_SUFFIX) \
229 { \
230 cdef_filter_block_c(dst, stride, left, top, bottom, \
231 pri_strength, sec_strength, dir, damping, w, h, edges HIGHBD_TAIL_SUFFIX); \
232 }
233
234 cdef_fn(4, 4);
235 cdef_fn(4, 8);
236 cdef_fn(8, 8);
237
cdef_find_dir_c(const pixel * img,const ptrdiff_t stride,unsigned * const var HIGHBD_DECL_SUFFIX)238 static int cdef_find_dir_c(const pixel *img, const ptrdiff_t stride,
239 unsigned *const var HIGHBD_DECL_SUFFIX)
240 {
241 const int bitdepth_min_8 = bitdepth_from_max(bitdepth_max) - 8;
242 int partial_sum_hv[2][8] = { { 0 } };
243 int partial_sum_diag[2][15] = { { 0 } };
244 int partial_sum_alt[4][11] = { { 0 } };
245
246 for (int y = 0; y < 8; y++) {
247 for (int x = 0; x < 8; x++) {
248 const int px = (img[x] >> bitdepth_min_8) - 128;
249
250 partial_sum_diag[0][ y + x ] += px;
251 partial_sum_alt [0][ y + (x >> 1)] += px;
252 partial_sum_hv [0][ y ] += px;
253 partial_sum_alt [1][3 + y - (x >> 1)] += px;
254 partial_sum_diag[1][7 + y - x ] += px;
255 partial_sum_alt [2][3 - (y >> 1) + x ] += px;
256 partial_sum_hv [1][ x ] += px;
257 partial_sum_alt [3][ (y >> 1) + x ] += px;
258 }
259 img += PXSTRIDE(stride);
260 }
261
262 unsigned cost[8] = { 0 };
263 for (int n = 0; n < 8; n++) {
264 cost[2] += partial_sum_hv[0][n] * partial_sum_hv[0][n];
265 cost[6] += partial_sum_hv[1][n] * partial_sum_hv[1][n];
266 }
267 cost[2] *= 105;
268 cost[6] *= 105;
269
270 static const uint16_t div_table[7] = { 840, 420, 280, 210, 168, 140, 120 };
271 for (int n = 0; n < 7; n++) {
272 const int d = div_table[n];
273 cost[0] += (partial_sum_diag[0][n] * partial_sum_diag[0][n] +
274 partial_sum_diag[0][14 - n] * partial_sum_diag[0][14 - n]) * d;
275 cost[4] += (partial_sum_diag[1][n] * partial_sum_diag[1][n] +
276 partial_sum_diag[1][14 - n] * partial_sum_diag[1][14 - n]) * d;
277 }
278 cost[0] += partial_sum_diag[0][7] * partial_sum_diag[0][7] * 105;
279 cost[4] += partial_sum_diag[1][7] * partial_sum_diag[1][7] * 105;
280
281 for (int n = 0; n < 4; n++) {
282 unsigned *const cost_ptr = &cost[n * 2 + 1];
283 for (int m = 0; m < 5; m++)
284 *cost_ptr += partial_sum_alt[n][3 + m] * partial_sum_alt[n][3 + m];
285 *cost_ptr *= 105;
286 for (int m = 0; m < 3; m++) {
287 const int d = div_table[2 * m + 1];
288 *cost_ptr += (partial_sum_alt[n][m] * partial_sum_alt[n][m] +
289 partial_sum_alt[n][10 - m] * partial_sum_alt[n][10 - m]) * d;
290 }
291 }
292
293 int best_dir = 0;
294 unsigned best_cost = cost[0];
295 for (int n = 1; n < 8; n++) {
296 if (cost[n] > best_cost) {
297 best_cost = cost[n];
298 best_dir = n;
299 }
300 }
301
302 *var = (best_cost - (cost[best_dir ^ 4])) >> 10;
303 return best_dir;
304 }
305
306 #if HAVE_ASM
307 #if ARCH_AARCH64 || ARCH_ARM
308 #include "src/arm/cdef.h"
309 #elif ARCH_PPC64LE
310 #include "src/ppc/cdef.h"
311 #elif ARCH_RISCV
312 #include "src/riscv/cdef.h"
313 #elif ARCH_X86
314 #include "src/x86/cdef.h"
315 #elif ARCH_LOONGARCH64
316 #include "src/loongarch/cdef.h"
317 #endif
318 #endif
319
bitfn(dav1d_cdef_dsp_init)320 COLD void bitfn(dav1d_cdef_dsp_init)(Dav1dCdefDSPContext *const c) {
321 c->dir = cdef_find_dir_c;
322 c->fb[0] = cdef_filter_block_8x8_c;
323 c->fb[1] = cdef_filter_block_4x8_c;
324 c->fb[2] = cdef_filter_block_4x4_c;
325
326 #if HAVE_ASM
327 #if ARCH_AARCH64 || ARCH_ARM
328 cdef_dsp_init_arm(c);
329 #elif ARCH_PPC64LE
330 cdef_dsp_init_ppc(c);
331 #elif ARCH_RISCV
332 cdef_dsp_init_riscv(c);
333 #elif ARCH_X86
334 cdef_dsp_init_x86(c);
335 #elif ARCH_LOONGARCH64
336 cdef_dsp_init_loongarch(c);
337 #endif
338 #endif
339 }
340