/src/aom/av1/common/cdef.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright (c) 2016, Alliance for Open Media. All rights reserved. |
3 | | * |
4 | | * This source code is subject to the terms of the BSD 2 Clause License and |
5 | | * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License |
6 | | * was not distributed with this source code in the LICENSE file, you can |
7 | | * obtain it at www.aomedia.org/license/software. If the Alliance for Open |
8 | | * Media Patent License 1.0 was not distributed with this source code in the |
9 | | * PATENTS file, you can obtain it at www.aomedia.org/license/patent. |
10 | | */ |
11 | | |
12 | | #include <assert.h> |
13 | | #include <stddef.h> |
14 | | #include <string.h> |
15 | | |
16 | | #include "config/aom_scale_rtcd.h" |
17 | | |
18 | | #include "aom/aom_integer.h" |
19 | | #include "aom_util/aom_pthread.h" |
20 | | #include "av1/common/av1_common_int.h" |
21 | | #include "av1/common/cdef.h" |
22 | | #include "av1/common/cdef_block.h" |
23 | | #include "av1/common/common.h" |
24 | | #include "av1/common/common_data.h" |
25 | | #include "av1/common/enums.h" |
26 | | #include "av1/common/reconinter.h" |
27 | | #include "av1/common/thread_common.h" |
28 | | |
29 | | static int is_8x8_block_skip(MB_MODE_INFO **grid, int mi_row, int mi_col, |
30 | 36.6M | int mi_stride) { |
31 | 36.6M | MB_MODE_INFO **mbmi = grid + mi_row * mi_stride + mi_col; |
32 | 55.4M | for (int r = 0; r < mi_size_high[BLOCK_8X8]; ++r, mbmi += mi_stride) { |
33 | 83.7M | for (int c = 0; c < mi_size_wide[BLOCK_8X8]; ++c) { |
34 | 64.9M | if (!mbmi[c]->skip_txfm) return 0; |
35 | 64.9M | } |
36 | 46.0M | } |
37 | | |
38 | 9.41M | return 1; |
39 | 36.6M | } |
40 | | |
41 | | int av1_cdef_compute_sb_list(const CommonModeInfoParams *const mi_params, |
42 | | int mi_row, int mi_col, cdef_list *dlist, |
43 | 639k | BLOCK_SIZE bs) { |
44 | 639k | MB_MODE_INFO **grid = mi_params->mi_grid_base; |
45 | 639k | int maxc = mi_params->mi_cols - mi_col; |
46 | 639k | int maxr = mi_params->mi_rows - mi_row; |
47 | | |
48 | 639k | if (bs == BLOCK_128X128 || bs == BLOCK_128X64) |
49 | 0 | maxc = AOMMIN(maxc, MI_SIZE_128X128); |
50 | 639k | else |
51 | 639k | maxc = AOMMIN(maxc, MI_SIZE_64X64); |
52 | 639k | if (bs == BLOCK_128X128 || bs == BLOCK_64X128) |
53 | 0 | maxr = AOMMIN(maxr, MI_SIZE_128X128); |
54 | 639k | else |
55 | 639k | maxr = AOMMIN(maxr, MI_SIZE_64X64); |
56 | | |
57 | 639k | const int r_step = 2; // mi_size_high[BLOCK_8X8] |
58 | 639k | const int c_step = 2; // mi_size_wide[BLOCK_8X8] |
59 | 639k | const int r_shift = 1; |
60 | 639k | const int c_shift = 1; |
61 | 639k | int count = 0; |
62 | 5.44M | for (int r = 0; r < maxr; r += r_step) { |
63 | 41.4M | for (int c = 0; c < maxc; c += c_step) { |
64 | 36.6M | if (!is_8x8_block_skip(grid, mi_row + r, mi_col + c, |
65 | 36.6M | mi_params->mi_stride)) { |
66 | 27.2M | dlist[count].by = r >> r_shift; |
67 | 27.2M | dlist[count].bx = c >> c_shift; |
68 | 27.2M | count++; |
69 | 27.2M | } |
70 | 36.6M | } |
71 | 4.80M | } |
72 | 639k | return count; |
73 | 639k | } |
74 | | |
75 | | void cdef_copy_rect8_8bit_to_16bit_c(uint16_t *dst, int dstride, |
76 | | const uint8_t *src, int sstride, int width, |
77 | 0 | int height) { |
78 | 0 | for (int i = 0; i < height; i++) { |
79 | 0 | for (int j = 0; j < width; j++) { |
80 | 0 | dst[i * dstride + j] = src[i * sstride + j]; |
81 | 0 | } |
82 | 0 | } |
83 | 0 | } |
84 | | |
85 | | #if CONFIG_AV1_HIGHBITDEPTH |
86 | | void cdef_copy_rect8_16bit_to_16bit_c(uint16_t *dst, int dstride, |
87 | | const uint16_t *src, int sstride, |
88 | 0 | int width, int height) { |
89 | 0 | for (int i = 0; i < height; i++) { |
90 | 0 | for (int j = 0; j < width; j++) { |
91 | 0 | dst[i * dstride + j] = src[i * sstride + j]; |
92 | 0 | } |
93 | 0 | } |
94 | 0 | } |
95 | | #endif // CONFIG_AV1_HIGHBITDEPTH |
96 | | |
97 | | void av1_cdef_copy_sb8_16_lowbd(uint16_t *const dst, int dstride, |
98 | | const uint8_t *src, int src_voffset, |
99 | | int src_hoffset, int sstride, int vsize, |
100 | 868k | int hsize) { |
101 | 868k | const uint8_t *base = &src[src_voffset * (ptrdiff_t)sstride + src_hoffset]; |
102 | 868k | cdef_copy_rect8_8bit_to_16bit(dst, dstride, base, sstride, hsize, vsize); |
103 | 868k | } |
104 | | |
105 | | #if CONFIG_AV1_HIGHBITDEPTH |
106 | | void av1_cdef_copy_sb8_16_highbd(uint16_t *const dst, int dstride, |
107 | | const uint8_t *src, int src_voffset, |
108 | | int src_hoffset, int sstride, int vsize, |
109 | 809k | int hsize) { |
110 | 809k | const uint16_t *base = |
111 | 809k | &CONVERT_TO_SHORTPTR(src)[src_voffset * (ptrdiff_t)sstride + src_hoffset]; |
112 | 809k | cdef_copy_rect8_16bit_to_16bit(dst, dstride, base, sstride, hsize, vsize); |
113 | 809k | } |
114 | | #endif // CONFIG_AV1_HIGHBITDEPTH |
115 | | |
116 | | void av1_cdef_copy_sb8_16(const AV1_COMMON *const cm, uint16_t *const dst, |
117 | | int dstride, const uint8_t *src, int src_voffset, |
118 | 1.67M | int src_hoffset, int sstride, int vsize, int hsize) { |
119 | 1.67M | #if CONFIG_AV1_HIGHBITDEPTH |
120 | 1.67M | if (cm->seq_params->use_highbitdepth) { |
121 | 809k | av1_cdef_copy_sb8_16_highbd(dst, dstride, src, src_voffset, src_hoffset, |
122 | 809k | sstride, vsize, hsize); |
123 | 809k | return; |
124 | 809k | } |
125 | | #else |
126 | | (void)cm; |
127 | | #endif // CONFIG_AV1_HIGHBITDEPTH |
128 | 868k | av1_cdef_copy_sb8_16_lowbd(dst, dstride, src, src_voffset, src_hoffset, |
129 | 868k | sstride, vsize, hsize); |
130 | 868k | } |
131 | | |
132 | | static inline void copy_rect(uint16_t *dst, int dstride, const uint16_t *src, |
133 | 9.36M | int sstride, int v, int h) { |
134 | 140M | for (int i = 0; i < v; i++) { |
135 | 1.34G | for (int j = 0; j < h; j++) { |
136 | 1.21G | dst[i * dstride + j] = src[i * sstride + j]; |
137 | 1.21G | } |
138 | 131M | } |
139 | 9.36M | } |
140 | | |
141 | | // Prepares intermediate input buffer for CDEF. |
142 | | // Inputs: |
143 | | // cm: Pointer to common structure. |
144 | | // fb_info: Pointer to the CDEF block-level parameter structure. |
145 | | // colbuf: Left column buffer for CDEF. |
146 | | // cdef_left: Left block is filtered or not. |
147 | | // fbc, fbr: col and row index of a block. |
148 | | // plane: plane index Y/CB/CR. |
149 | | // Returns: |
150 | | // Nothing will be returned. |
151 | | static void cdef_prepare_fb(const AV1_COMMON *const cm, CdefBlockInfo *fb_info, |
152 | | uint16_t **const colbuf, const int cdef_left, |
153 | 1.32M | int fbc, int fbr, int plane) { |
154 | 1.32M | const CommonModeInfoParams *const mi_params = &cm->mi_params; |
155 | 1.32M | uint16_t *src = fb_info->src; |
156 | 1.32M | const int luma_stride = |
157 | 1.32M | ALIGN_POWER_OF_TWO(mi_params->mi_cols << MI_SIZE_LOG2, 4); |
158 | 1.32M | const int nvfb = (mi_params->mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; |
159 | 1.32M | const int nhfb = (mi_params->mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; |
160 | 1.32M | int cstart = 0; |
161 | 1.32M | if (!cdef_left) cstart = -CDEF_HBORDER; |
162 | 1.32M | int rend, cend; |
163 | 1.32M | const int nhb = |
164 | 1.32M | AOMMIN(MI_SIZE_64X64, mi_params->mi_cols - MI_SIZE_64X64 * fbc); |
165 | 1.32M | const int nvb = |
166 | 1.32M | AOMMIN(MI_SIZE_64X64, mi_params->mi_rows - MI_SIZE_64X64 * fbr); |
167 | 1.32M | const int hsize = nhb << fb_info->mi_wide_l2; |
168 | 1.32M | const int vsize = nvb << fb_info->mi_high_l2; |
169 | 1.32M | const uint16_t *top_linebuf = fb_info->top_linebuf[plane]; |
170 | 1.32M | const uint16_t *bot_linebuf = fb_info->bot_linebuf[plane]; |
171 | 1.32M | const int bot_offset = (vsize + CDEF_VBORDER) * CDEF_BSTRIDE; |
172 | 1.32M | const int stride = |
173 | 1.32M | luma_stride >> (plane == AOM_PLANE_Y ? 0 : cm->seq_params->subsampling_x); |
174 | | |
175 | 1.32M | if (fbc == nhfb - 1) |
176 | 149k | cend = hsize; |
177 | 1.17M | else |
178 | 1.17M | cend = hsize + CDEF_HBORDER; |
179 | | |
180 | 1.32M | if (fbr == nvfb - 1) |
181 | 143k | rend = vsize; |
182 | 1.18M | else |
183 | 1.18M | rend = vsize + CDEF_VBORDER; |
184 | | |
185 | | /* Copy in the pixels we need from the current superblock for |
186 | | deringing.*/ |
187 | 1.32M | av1_cdef_copy_sb8_16( |
188 | 1.32M | cm, &src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER + cstart], |
189 | 1.32M | CDEF_BSTRIDE, fb_info->dst, fb_info->roffset, fb_info->coffset + cstart, |
190 | 1.32M | fb_info->dst_stride, vsize, cend - cstart); |
191 | | |
192 | | /* Copy in the pixels we need for the current superblock from bottom buffer.*/ |
193 | 1.32M | if (fbr < nvfb - 1) { |
194 | 1.18M | copy_rect(&src[bot_offset + CDEF_HBORDER], CDEF_BSTRIDE, |
195 | 1.18M | &bot_linebuf[fb_info->coffset], stride, CDEF_VBORDER, hsize); |
196 | 1.18M | } else { |
197 | 143k | fill_rect(&src[bot_offset + CDEF_HBORDER], CDEF_BSTRIDE, CDEF_VBORDER, |
198 | 143k | hsize, CDEF_VERY_LARGE); |
199 | 143k | } |
200 | 1.32M | if (fbr < nvfb - 1 && fbc > 0) { |
201 | 1.08M | copy_rect(&src[bot_offset], CDEF_BSTRIDE, |
202 | 1.08M | &bot_linebuf[fb_info->coffset - CDEF_HBORDER], stride, |
203 | 1.08M | CDEF_VBORDER, CDEF_HBORDER); |
204 | 1.08M | } else { |
205 | 244k | fill_rect(&src[bot_offset], CDEF_BSTRIDE, CDEF_VBORDER, CDEF_HBORDER, |
206 | 244k | CDEF_VERY_LARGE); |
207 | 244k | } |
208 | 1.32M | if (fbr < nvfb - 1 && fbc < nhfb - 1) { |
209 | 1.08M | copy_rect(&src[bot_offset + hsize + CDEF_HBORDER], CDEF_BSTRIDE, |
210 | 1.08M | &bot_linebuf[fb_info->coffset + hsize], stride, CDEF_VBORDER, |
211 | 1.08M | CDEF_HBORDER); |
212 | 1.08M | } else { |
213 | 244k | fill_rect(&src[bot_offset + hsize + CDEF_HBORDER], CDEF_BSTRIDE, |
214 | 244k | CDEF_VBORDER, CDEF_HBORDER, CDEF_VERY_LARGE); |
215 | 244k | } |
216 | | |
217 | | /* Copy in the pixels we need from the current superblock from top buffer.*/ |
218 | 1.32M | if (fbr > 0) { |
219 | 1.20M | copy_rect(&src[CDEF_HBORDER], CDEF_BSTRIDE, &top_linebuf[fb_info->coffset], |
220 | 1.20M | stride, CDEF_VBORDER, hsize); |
221 | 1.20M | } else { |
222 | 125k | fill_rect(&src[CDEF_HBORDER], CDEF_BSTRIDE, CDEF_VBORDER, hsize, |
223 | 125k | CDEF_VERY_LARGE); |
224 | 125k | } |
225 | 1.32M | if (fbr > 0 && fbc > 0) { |
226 | 1.09M | copy_rect(src, CDEF_BSTRIDE, &top_linebuf[fb_info->coffset - CDEF_HBORDER], |
227 | 1.09M | stride, CDEF_VBORDER, CDEF_HBORDER); |
228 | 1.09M | } else { |
229 | 229k | fill_rect(src, CDEF_BSTRIDE, CDEF_VBORDER, CDEF_HBORDER, CDEF_VERY_LARGE); |
230 | 229k | } |
231 | 1.32M | if (fbr > 0 && fbc < nhfb - 1) { |
232 | 1.09M | copy_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, |
233 | 1.09M | &top_linebuf[fb_info->coffset + hsize], stride, CDEF_VBORDER, |
234 | 1.09M | CDEF_HBORDER); |
235 | 1.09M | } else { |
236 | 230k | fill_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, CDEF_VBORDER, |
237 | 230k | CDEF_HBORDER, CDEF_VERY_LARGE); |
238 | 230k | } |
239 | 1.32M | if (cdef_left) { |
240 | | /* If we deringed the superblock on the left then we need to copy in |
241 | | saved pixels. */ |
242 | 1.30M | copy_rect(src, CDEF_BSTRIDE, colbuf[plane], CDEF_HBORDER, |
243 | 1.30M | rend + CDEF_VBORDER, CDEF_HBORDER); |
244 | 1.30M | } |
245 | | /* Saving pixels in case we need to dering the superblock on the |
246 | | right. */ |
247 | 1.32M | copy_rect(colbuf[plane], CDEF_HBORDER, src + hsize, CDEF_BSTRIDE, |
248 | 1.32M | rend + CDEF_VBORDER, CDEF_HBORDER); |
249 | | |
250 | 1.32M | if (fb_info->frame_boundary[LEFT]) { |
251 | 149k | fill_rect(src, CDEF_BSTRIDE, vsize + 2 * CDEF_VBORDER, CDEF_HBORDER, |
252 | 149k | CDEF_VERY_LARGE); |
253 | 149k | } |
254 | 1.32M | if (fb_info->frame_boundary[RIGHT]) { |
255 | 149k | fill_rect(&src[hsize + CDEF_HBORDER], CDEF_BSTRIDE, |
256 | 149k | vsize + 2 * CDEF_VBORDER, CDEF_HBORDER, CDEF_VERY_LARGE); |
257 | 149k | } |
258 | 1.32M | } |
259 | | |
260 | | static inline void cdef_filter_fb(CdefBlockInfo *const fb_info, int plane, |
261 | 1.33M | uint8_t use_highbitdepth) { |
262 | 1.33M | ptrdiff_t offset = |
263 | 1.33M | (ptrdiff_t)fb_info->dst_stride * fb_info->roffset + fb_info->coffset; |
264 | 1.33M | if (use_highbitdepth) { |
265 | 658k | av1_cdef_filter_fb( |
266 | 658k | NULL, CONVERT_TO_SHORTPTR(fb_info->dst + offset), fb_info->dst_stride, |
267 | 658k | &fb_info->src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER], |
268 | 658k | fb_info->xdec, fb_info->ydec, fb_info->dir, NULL, fb_info->var, plane, |
269 | 658k | fb_info->dlist, fb_info->cdef_count, fb_info->level, |
270 | 658k | fb_info->sec_strength, fb_info->damping, fb_info->coeff_shift); |
271 | 672k | } else { |
272 | 672k | av1_cdef_filter_fb( |
273 | 672k | fb_info->dst + offset, NULL, fb_info->dst_stride, |
274 | 672k | &fb_info->src[CDEF_VBORDER * CDEF_BSTRIDE + CDEF_HBORDER], |
275 | 672k | fb_info->xdec, fb_info->ydec, fb_info->dir, NULL, fb_info->var, plane, |
276 | 672k | fb_info->dlist, fb_info->cdef_count, fb_info->level, |
277 | 672k | fb_info->sec_strength, fb_info->damping, fb_info->coeff_shift); |
278 | 672k | } |
279 | 1.33M | } |
280 | | |
281 | | // Initializes block-level parameters for CDEF. |
282 | | static inline void cdef_init_fb_col(const MACROBLOCKD *const xd, |
283 | | CdefBlockInfo *const fb_info, int *level, |
284 | | int *sec_strength, int fbc, int fbr, |
285 | 1.32M | int plane) { |
286 | 1.32M | const PLANE_TYPE plane_type = get_plane_type(plane); |
287 | 1.32M | fb_info->level = level[plane_type]; |
288 | 1.32M | fb_info->sec_strength = sec_strength[plane_type]; |
289 | 1.32M | fb_info->dst = xd->plane[plane].dst.buf; |
290 | 1.32M | fb_info->dst_stride = xd->plane[plane].dst.stride; |
291 | | |
292 | 1.32M | fb_info->xdec = xd->plane[plane].subsampling_x; |
293 | 1.32M | fb_info->ydec = xd->plane[plane].subsampling_y; |
294 | 1.32M | fb_info->mi_wide_l2 = MI_SIZE_LOG2 - xd->plane[plane].subsampling_x; |
295 | 1.32M | fb_info->mi_high_l2 = MI_SIZE_LOG2 - xd->plane[plane].subsampling_y; |
296 | 1.32M | fb_info->roffset = MI_SIZE_64X64 * fbr << fb_info->mi_high_l2; |
297 | 1.32M | fb_info->coffset = MI_SIZE_64X64 * fbc << fb_info->mi_wide_l2; |
298 | 1.32M | } |
299 | | |
300 | | static void cdef_fb_col(const AV1_COMMON *const cm, const MACROBLOCKD *const xd, |
301 | | CdefBlockInfo *const fb_info, uint16_t **const colbuf, |
302 | 647k | int *cdef_left, int fbc, int fbr) { |
303 | 647k | const CommonModeInfoParams *const mi_params = &cm->mi_params; |
304 | 647k | const int mbmi_cdef_strength = |
305 | 647k | mi_params |
306 | 647k | ->mi_grid_base[MI_SIZE_64X64 * fbr * mi_params->mi_stride + |
307 | 647k | MI_SIZE_64X64 * fbc] |
308 | 647k | ->cdef_strength; |
309 | 647k | const int num_planes = av1_num_planes(cm); |
310 | 647k | int is_zero_level[PLANE_TYPES] = { 1, 1 }; |
311 | 647k | int level[PLANE_TYPES] = { 0 }; |
312 | 647k | int sec_strength[PLANE_TYPES] = { 0 }; |
313 | 647k | const CdefInfo *const cdef_info = &cm->cdef_info; |
314 | | |
315 | 647k | if (mi_params->mi_grid_base[MI_SIZE_64X64 * fbr * mi_params->mi_stride + |
316 | 647k | MI_SIZE_64X64 * fbc] == NULL || |
317 | 647k | mbmi_cdef_strength == -1) { |
318 | 0 | av1_zero_array(cdef_left, num_planes); |
319 | 0 | return; |
320 | 0 | } |
321 | | |
322 | | // Compute level and secondary strength for planes |
323 | 647k | level[PLANE_TYPE_Y] = |
324 | 647k | cdef_info->cdef_strengths[mbmi_cdef_strength] / CDEF_SEC_STRENGTHS; |
325 | 647k | sec_strength[PLANE_TYPE_Y] = |
326 | 647k | cdef_info->cdef_strengths[mbmi_cdef_strength] % CDEF_SEC_STRENGTHS; |
327 | 647k | sec_strength[PLANE_TYPE_Y] += sec_strength[PLANE_TYPE_Y] == 3; |
328 | 647k | is_zero_level[PLANE_TYPE_Y] = |
329 | 647k | (level[PLANE_TYPE_Y] == 0) && (sec_strength[PLANE_TYPE_Y] == 0); |
330 | | |
331 | 647k | if (num_planes > 1) { |
332 | 618k | level[PLANE_TYPE_UV] = |
333 | 618k | cdef_info->cdef_uv_strengths[mbmi_cdef_strength] / CDEF_SEC_STRENGTHS; |
334 | 618k | sec_strength[PLANE_TYPE_UV] = |
335 | 618k | cdef_info->cdef_uv_strengths[mbmi_cdef_strength] % CDEF_SEC_STRENGTHS; |
336 | 618k | sec_strength[PLANE_TYPE_UV] += sec_strength[PLANE_TYPE_UV] == 3; |
337 | 618k | is_zero_level[PLANE_TYPE_UV] = |
338 | 618k | (level[PLANE_TYPE_UV] == 0) && (sec_strength[PLANE_TYPE_UV] == 0); |
339 | 618k | } |
340 | | |
341 | 647k | if (is_zero_level[PLANE_TYPE_Y] && is_zero_level[PLANE_TYPE_UV]) { |
342 | 7.93k | av1_zero_array(cdef_left, num_planes); |
343 | 7.93k | return; |
344 | 7.93k | } |
345 | | |
346 | 639k | fb_info->cdef_count = av1_cdef_compute_sb_list(mi_params, fbr * MI_SIZE_64X64, |
347 | 639k | fbc * MI_SIZE_64X64, |
348 | 639k | fb_info->dlist, BLOCK_64X64); |
349 | 639k | if (!fb_info->cdef_count) { |
350 | 182k | av1_zero_array(cdef_left, num_planes); |
351 | 182k | return; |
352 | 182k | } |
353 | | |
354 | 1.79M | for (int plane = 0; plane < num_planes; plane++) { |
355 | | // Do not skip cdef filtering for luma plane as filter direction is |
356 | | // computed based on luma. |
357 | 1.33M | if (plane && is_zero_level[get_plane_type(plane)]) { |
358 | 7.15k | cdef_left[plane] = 0; |
359 | 7.15k | continue; |
360 | 7.15k | } |
361 | 1.32M | cdef_init_fb_col(xd, fb_info, level, sec_strength, fbc, fbr, plane); |
362 | 1.32M | cdef_prepare_fb(cm, fb_info, colbuf, cdef_left[plane], fbc, fbr, plane); |
363 | 1.32M | cdef_filter_fb(fb_info, plane, cm->seq_params->use_highbitdepth); |
364 | 1.32M | cdef_left[plane] = 1; |
365 | 1.32M | } |
366 | 456k | } |
367 | | |
368 | | // Initializes row-level parameters for CDEF frame. |
369 | | void av1_cdef_init_fb_row(const AV1_COMMON *const cm, |
370 | | const MACROBLOCKD *const xd, |
371 | | CdefBlockInfo *const fb_info, |
372 | | uint16_t **const linebuf, uint16_t *const src, |
373 | 19.1k | struct AV1CdefSyncData *const cdef_sync, int fbr) { |
374 | 19.1k | (void)cdef_sync; |
375 | 19.1k | const int num_planes = av1_num_planes(cm); |
376 | 19.1k | const int nvfb = (cm->mi_params.mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; |
377 | 19.1k | const int luma_stride = |
378 | 19.1k | ALIGN_POWER_OF_TWO(cm->mi_params.mi_cols << MI_SIZE_LOG2, 4); |
379 | 19.1k | const bool ping_pong = fbr & 1; |
380 | | // for the current filter block, it's top left corner mi structure (mi_tl) |
381 | | // is first accessed to check whether the top and left boundaries are |
382 | | // frame boundaries. Then bottom-left and top-right mi structures are |
383 | | // accessed to check whether the bottom and right boundaries |
384 | | // (respectively) are frame boundaries. |
385 | | // |
386 | | // Note that we can't just check the bottom-right mi structure - eg. if |
387 | | // we're at the right-hand edge of the frame but not the bottom, then |
388 | | // the bottom-right mi is NULL but the bottom-left is not. |
389 | 19.1k | fb_info->frame_boundary[TOP] = (MI_SIZE_64X64 * fbr == 0) ? 1 : 0; |
390 | 19.1k | if (fbr != nvfb - 1) |
391 | 13.1k | fb_info->frame_boundary[BOTTOM] = |
392 | 13.1k | (MI_SIZE_64X64 * (fbr + 1) == cm->mi_params.mi_rows) ? 1 : 0; |
393 | 6.00k | else |
394 | 6.00k | fb_info->frame_boundary[BOTTOM] = 1; |
395 | | |
396 | 19.1k | fb_info->src = src; |
397 | 19.1k | fb_info->damping = cm->cdef_info.cdef_damping; |
398 | 19.1k | fb_info->coeff_shift = AOMMAX(cm->seq_params->bit_depth - 8, 0); |
399 | 19.1k | av1_zero(fb_info->dir); |
400 | 19.1k | av1_zero(fb_info->var); |
401 | | |
402 | 64.2k | for (int plane = 0; plane < num_planes; plane++) { |
403 | 45.1k | const int mi_high_l2 = MI_SIZE_LOG2 - xd->plane[plane].subsampling_y; |
404 | 45.1k | const int offset = MI_SIZE_64X64 * (fbr + 1) << mi_high_l2; |
405 | 45.1k | const int stride = luma_stride >> xd->plane[plane].subsampling_x; |
406 | | // here ping-pong buffers are maintained for top linebuf |
407 | | // to avoid linebuf over-write by consecutive row. |
408 | 45.1k | uint16_t *const top_linebuf = |
409 | 45.1k | &linebuf[plane][ping_pong * CDEF_VBORDER * stride]; |
410 | 45.1k | fb_info->bot_linebuf[plane] = &linebuf[plane][(CDEF_VBORDER << 1) * stride]; |
411 | | |
412 | 45.1k | if (fbr != nvfb - 1) // top line buffer copy |
413 | 32.2k | av1_cdef_copy_sb8_16(cm, top_linebuf, stride, xd->plane[plane].dst.buf, |
414 | 32.2k | offset - CDEF_VBORDER, 0, |
415 | 32.2k | xd->plane[plane].dst.stride, CDEF_VBORDER, stride); |
416 | 45.1k | fb_info->top_linebuf[plane] = |
417 | 45.1k | &linebuf[plane][(!ping_pong) * CDEF_VBORDER * stride]; |
418 | | |
419 | 45.1k | if (fbr != nvfb - 1) // bottom line buffer copy |
420 | 32.2k | av1_cdef_copy_sb8_16(cm, fb_info->bot_linebuf[plane], stride, |
421 | 32.2k | xd->plane[plane].dst.buf, offset, 0, |
422 | 32.2k | xd->plane[plane].dst.stride, CDEF_VBORDER, stride); |
423 | 45.1k | } |
424 | 19.1k | } |
425 | | |
426 | | void av1_cdef_fb_row(const AV1_COMMON *const cm, MACROBLOCKD *xd, |
427 | | uint16_t **const linebuf, uint16_t **const colbuf, |
428 | | uint16_t *const src, int fbr, |
429 | | cdef_init_fb_row_t cdef_init_fb_row_fn, |
430 | | struct AV1CdefSyncData *const cdef_sync, |
431 | 88.5k | struct aom_internal_error_info *error_info) { |
432 | | // TODO(aomedia:3276): Pass error_info to the low-level functions as required |
433 | | // in future to handle error propagation. |
434 | 88.5k | (void)error_info; |
435 | 88.5k | CdefBlockInfo fb_info; |
436 | 88.5k | int cdef_left[MAX_MB_PLANE] = { 1, 1, 1 }; |
437 | 88.5k | const int nhfb = (cm->mi_params.mi_cols + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; |
438 | | |
439 | 88.5k | cdef_init_fb_row_fn(cm, xd, &fb_info, linebuf, src, cdef_sync, fbr); |
440 | 88.5k | #if CONFIG_MULTITHREAD |
441 | 88.5k | if (cdef_sync && cm->cdef_info.allocated_num_workers > 1) { |
442 | 69.3k | pthread_mutex_lock(cdef_sync->mutex_); |
443 | 69.3k | const bool cdef_mt_exit = cdef_sync->cdef_mt_exit; |
444 | 69.3k | pthread_mutex_unlock(cdef_sync->mutex_); |
445 | | // Exit in case any worker has encountered an error. |
446 | 69.3k | if (cdef_mt_exit) return; |
447 | 69.3k | } |
448 | 88.5k | #endif |
449 | 735k | for (int fbc = 0; fbc < nhfb; fbc++) { |
450 | 647k | fb_info.frame_boundary[LEFT] = (MI_SIZE_64X64 * fbc == 0) ? 1 : 0; |
451 | 647k | if (fbc != nhfb - 1) |
452 | 559k | fb_info.frame_boundary[RIGHT] = |
453 | 559k | (MI_SIZE_64X64 * (fbc + 1) == cm->mi_params.mi_cols) ? 1 : 0; |
454 | 87.9k | else |
455 | 87.9k | fb_info.frame_boundary[RIGHT] = 1; |
456 | 647k | cdef_fb_col(cm, xd, &fb_info, colbuf, &cdef_left[0], fbc, fbr); |
457 | 647k | } |
458 | 88.5k | } |
459 | | |
460 | | // Perform CDEF on input frame. |
461 | | // Inputs: |
462 | | // frame: Pointer to input frame buffer. |
463 | | // cm: Pointer to common structure. |
464 | | // xd: Pointer to common current coding block structure. |
465 | | // Returns: |
466 | | // Nothing will be returned. |
467 | | void av1_cdef_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *const cm, |
468 | 6.00k | MACROBLOCKD *xd, cdef_init_fb_row_t cdef_init_fb_row_fn) { |
469 | 6.00k | const int num_planes = av1_num_planes(cm); |
470 | 6.00k | const int nvfb = (cm->mi_params.mi_rows + MI_SIZE_64X64 - 1) / MI_SIZE_64X64; |
471 | | |
472 | 6.00k | av1_setup_dst_planes(xd->plane, cm->seq_params->sb_size, frame, 0, 0, 0, |
473 | 6.00k | num_planes); |
474 | | |
475 | 25.1k | for (int fbr = 0; fbr < nvfb; fbr++) |
476 | 19.1k | av1_cdef_fb_row(cm, xd, cm->cdef_info.linebuf, cm->cdef_info.colbuf, |
477 | 19.1k | cm->cdef_info.srcbuf, fbr, cdef_init_fb_row_fn, NULL, |
478 | 19.1k | xd->error_info); |
479 | 6.00k | } |