xref: /aosp_15_r20/external/mesa3d/src/gallium/drivers/zink/zink_blit.c (revision 6104692788411f58d303aa86923a9ff6ecaded22) 
1 #include "zink_clear.h"
2 #include "zink_context.h"
3 #include "zink_format.h"
4 #include "zink_inlines.h"
5 #include "zink_kopper.h"
6 #include "zink_helpers.h"
7 #include "zink_query.h"
8 #include "zink_resource.h"
9 #include "zink_screen.h"
10 
11 #include "util/u_blitter.h"
12 #include "util/u_rect.h"
13 #include "util/u_surface.h"
14 #include "util/format/u_format.h"
15 
16 static void
apply_dst_clears(struct zink_context * ctx,const struct pipe_blit_info * info,bool discard_only)17 apply_dst_clears(struct zink_context *ctx, const struct pipe_blit_info *info, bool discard_only)
18 {
19    if (info->scissor_enable) {
20       struct u_rect rect = { info->scissor.minx, info->scissor.maxx,
21                              info->scissor.miny, info->scissor.maxy };
22       zink_fb_clears_apply_or_discard(ctx, info->dst.resource, rect, discard_only);
23    } else
24       zink_fb_clears_apply_or_discard(ctx, info->dst.resource, zink_rect_from_box(&info->dst.box), discard_only);
25 }
26 
27 static bool
blit_resolve(struct zink_context * ctx,const struct pipe_blit_info * info,bool * needs_present_readback)28 blit_resolve(struct zink_context *ctx, const struct pipe_blit_info *info, bool *needs_present_readback)
29 {
30    if (util_format_get_mask(info->dst.format) != info->mask ||
31        util_format_get_mask(info->src.format) != info->mask ||
32        util_format_is_depth_or_stencil(info->dst.format) ||
33        info->scissor_enable ||
34        info->alpha_blend)
35       return false;
36 
37    if (info->src.box.width < 0 ||
38        info->dst.box.width < 0 ||
39        info->src.box.height < 0 ||
40        info->dst.box.height < 0 ||
41        info->src.box.depth < 0 ||
42        info->dst.box.depth < 0)
43       return false;
44    /* vulkan resolves can't downscale */
45    if (info->src.box.width > info->dst.box.width ||
46        info->src.box.height > info->dst.box.height ||
47        info->src.box.depth > info->dst.box.depth)
48       return false;
49 
50    if (info->render_condition_enable &&
51        ctx->render_condition_active)
52       return false;
53 
54    struct zink_resource *src = zink_resource(info->src.resource);
55    struct zink_resource *use_src = src;
56    struct zink_resource *dst = zink_resource(info->dst.resource);
57 
58    struct zink_screen *screen = zink_screen(ctx->base.screen);
59    /* aliased/swizzled formats need u_blitter */
60    if (src->format != zink_get_format(screen, info->src.format) ||
61        dst->format != zink_get_format(screen, info->dst.format))
62       return false;
63    if (src->format != dst->format)
64       return false;
65 
66 
67    apply_dst_clears(ctx, info, false);
68    zink_fb_clears_apply_region(ctx, info->src.resource, zink_rect_from_box(&info->src.box));
69 
70    if (src->obj->dt)
71       *needs_present_readback = zink_kopper_acquire_readback(ctx, src, &use_src);
72 
73    zink_resource_setup_transfer_layouts(ctx, use_src, dst);
74    VkCommandBuffer cmdbuf = *needs_present_readback ?
75                             ctx->bs->cmdbuf :
76                             zink_get_cmdbuf(ctx, src, dst);
77    zink_batch_reference_resource_rw(ctx, use_src, false);
78    zink_batch_reference_resource_rw(ctx, dst, true);
79 
80    bool marker = zink_cmd_debug_marker_begin(ctx, cmdbuf, "blit_resolve(%s->%s, %dx%d->%dx%d)",
81                                              util_format_short_name(info->src.format),
82                                              util_format_short_name(info->src.format),
83                                              info->src.box.width, info->src.box.height,
84                                              info->dst.box.width, info->dst.box.height);
85    VkImageResolve region = {0};
86 
87    region.srcSubresource.aspectMask = src->aspect;
88    region.srcSubresource.mipLevel = info->src.level;
89    region.srcOffset.x = info->src.box.x;
90    region.srcOffset.y = info->src.box.y;
91 
92    if (src->base.b.array_size > 1) {
93       region.srcOffset.z = 0;
94       region.srcSubresource.baseArrayLayer = info->src.box.z;
95       region.srcSubresource.layerCount = info->src.box.depth;
96    } else {
97       assert(info->src.box.depth == 1);
98       region.srcOffset.z = info->src.box.z;
99       region.srcSubresource.baseArrayLayer = 0;
100       region.srcSubresource.layerCount = 1;
101    }
102 
103    region.dstSubresource.aspectMask = dst->aspect;
104    region.dstSubresource.mipLevel = info->dst.level;
105    region.dstOffset.x = info->dst.box.x;
106    region.dstOffset.y = info->dst.box.y;
107 
108    if (dst->base.b.array_size > 1) {
109       region.dstOffset.z = 0;
110       region.dstSubresource.baseArrayLayer = info->dst.box.z;
111       region.dstSubresource.layerCount = info->dst.box.depth;
112    } else {
113       assert(info->dst.box.depth == 1);
114       region.dstOffset.z = info->dst.box.z;
115       region.dstSubresource.baseArrayLayer = 0;
116       region.dstSubresource.layerCount = 1;
117    }
118 
119    region.extent.width = info->dst.box.width;
120    region.extent.height = info->dst.box.height;
121    region.extent.depth = info->dst.box.depth;
122    if (region.srcOffset.x + region.extent.width >= u_minify(src->base.b.width0, region.srcSubresource.mipLevel))
123       region.extent.width = u_minify(src->base.b.width0, region.srcSubresource.mipLevel) - region.srcOffset.x;
124    if (region.dstOffset.x + region.extent.width >= u_minify(dst->base.b.width0, region.dstSubresource.mipLevel))
125       region.extent.width = u_minify(dst->base.b.width0, region.dstSubresource.mipLevel) - region.dstOffset.x;
126    if (region.srcOffset.y + region.extent.height >= u_minify(src->base.b.height0, region.srcSubresource.mipLevel))
127       region.extent.height = u_minify(src->base.b.height0, region.srcSubresource.mipLevel) - region.srcOffset.y;
128    if (region.dstOffset.y + region.extent.height >= u_minify(dst->base.b.height0, region.dstSubresource.mipLevel))
129       region.extent.height = u_minify(dst->base.b.height0, region.dstSubresource.mipLevel) - region.dstOffset.y;
130    if (region.srcOffset.z + region.extent.depth >= u_minify(src->base.b.depth0, region.srcSubresource.mipLevel))
131       region.extent.depth = u_minify(src->base.b.depth0, region.srcSubresource.mipLevel) - region.srcOffset.z;
132    if (region.dstOffset.z + region.extent.depth >= u_minify(dst->base.b.depth0, region.dstSubresource.mipLevel))
133       region.extent.depth = u_minify(dst->base.b.depth0, region.dstSubresource.mipLevel) - region.dstOffset.z;
134    VKCTX(CmdResolveImage)(cmdbuf, use_src->obj->image, src->layout,
135                      dst->obj->image, dst->layout,
136                      1, &region);
137    zink_cmd_debug_marker_end(ctx, cmdbuf, marker);
138 
139    return true;
140 }
141 
142 static bool
blit_native(struct zink_context * ctx,const struct pipe_blit_info * info,bool * needs_present_readback)143 blit_native(struct zink_context *ctx, const struct pipe_blit_info *info, bool *needs_present_readback)
144 {
145    if (util_format_get_mask(info->dst.format) != info->mask ||
146        util_format_get_mask(info->src.format) != info->mask ||
147        info->scissor_enable ||
148        info->alpha_blend)
149       return false;
150 
151    if (info->render_condition_enable &&
152        ctx->render_condition_active)
153       return false;
154 
155    if (util_format_is_depth_or_stencil(info->dst.format) &&
156        (info->dst.format != info->src.format || info->filter == PIPE_TEX_FILTER_LINEAR))
157       return false;
158 
159    /* vkCmdBlitImage must not be used for multisampled source or destination images. */
160    if (info->src.resource->nr_samples > 1 || info->dst.resource->nr_samples > 1)
161       return false;
162 
163    struct zink_resource *src = zink_resource(info->src.resource);
164    struct zink_resource *use_src = src;
165    struct zink_resource *dst = zink_resource(info->dst.resource);
166 
167    struct zink_screen *screen = zink_screen(ctx->base.screen);
168    if (src->format != zink_get_format(screen, info->src.format) ||
169        dst->format != zink_get_format(screen, info->dst.format))
170       return false;
171    if (src->format != VK_FORMAT_A8_UNORM_KHR && zink_format_is_emulated_alpha(info->src.format))
172       return false;
173 
174    if (!(src->obj->vkfeats & VK_FORMAT_FEATURE_BLIT_SRC_BIT) ||
175        !(dst->obj->vkfeats & VK_FORMAT_FEATURE_BLIT_DST_BIT))
176       return false;
177 
178    if ((util_format_is_pure_sint(info->src.format) !=
179         util_format_is_pure_sint(info->dst.format)) ||
180        (util_format_is_pure_uint(info->src.format) !=
181         util_format_is_pure_uint(info->dst.format)))
182       return false;
183 
184    if (info->filter == PIPE_TEX_FILTER_LINEAR &&
185        !(src->obj->vkfeats & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT))
186       return false;
187 
188 
189    VkImageBlit region = {0};
190    region.srcSubresource.aspectMask = src->aspect;
191    region.srcSubresource.mipLevel = info->src.level;
192    region.srcOffsets[0].x = info->src.box.x;
193    region.srcOffsets[0].y = info->src.box.y;
194    region.srcOffsets[1].x = info->src.box.x + info->src.box.width;
195    region.srcOffsets[1].y = info->src.box.y + info->src.box.height;
196 
197    enum pipe_texture_target src_target = src->base.b.target;
198    if (src->need_2D)
199       src_target = src_target == PIPE_TEXTURE_1D ? PIPE_TEXTURE_2D : PIPE_TEXTURE_2D_ARRAY;
200    switch (src_target) {
201    case PIPE_TEXTURE_CUBE:
202    case PIPE_TEXTURE_CUBE_ARRAY:
203    case PIPE_TEXTURE_2D_ARRAY:
204    case PIPE_TEXTURE_1D_ARRAY:
205       /* these use layer */
206       region.srcSubresource.baseArrayLayer = info->src.box.z;
207       /* VUID-vkCmdBlitImage-srcImage-00240 */
208       if (region.srcSubresource.baseArrayLayer && dst->base.b.target == PIPE_TEXTURE_3D)
209          return false;
210       region.srcSubresource.layerCount = info->src.box.depth;
211       region.srcOffsets[0].z = 0;
212       region.srcOffsets[1].z = 1;
213       break;
214    case PIPE_TEXTURE_3D:
215       /* this uses depth */
216       region.srcSubresource.baseArrayLayer = 0;
217       region.srcSubresource.layerCount = 1;
218       region.srcOffsets[0].z = info->src.box.z;
219       region.srcOffsets[1].z = info->src.box.z + info->src.box.depth;
220       break;
221    default:
222       /* these must only copy one layer */
223       region.srcSubresource.baseArrayLayer = 0;
224       region.srcSubresource.layerCount = 1;
225       region.srcOffsets[0].z = 0;
226       region.srcOffsets[1].z = 1;
227    }
228 
229    region.dstSubresource.aspectMask = dst->aspect;
230    region.dstSubresource.mipLevel = info->dst.level;
231    region.dstOffsets[0].x = info->dst.box.x;
232    region.dstOffsets[0].y = info->dst.box.y;
233    region.dstOffsets[1].x = info->dst.box.x + info->dst.box.width;
234    region.dstOffsets[1].y = info->dst.box.y + info->dst.box.height;
235    assert(region.dstOffsets[0].x != region.dstOffsets[1].x);
236    assert(region.dstOffsets[0].y != region.dstOffsets[1].y);
237 
238    enum pipe_texture_target dst_target = dst->base.b.target;
239    if (dst->need_2D)
240       dst_target = dst_target == PIPE_TEXTURE_1D ? PIPE_TEXTURE_2D : PIPE_TEXTURE_2D_ARRAY;
241    switch (dst_target) {
242    case PIPE_TEXTURE_CUBE:
243    case PIPE_TEXTURE_CUBE_ARRAY:
244    case PIPE_TEXTURE_2D_ARRAY:
245    case PIPE_TEXTURE_1D_ARRAY:
246       /* these use layer */
247       region.dstSubresource.baseArrayLayer = info->dst.box.z;
248       /* VUID-vkCmdBlitImage-srcImage-00240 */
249       if (region.dstSubresource.baseArrayLayer && src->base.b.target == PIPE_TEXTURE_3D)
250          return false;
251       region.dstSubresource.layerCount = info->dst.box.depth;
252       region.dstOffsets[0].z = 0;
253       region.dstOffsets[1].z = 1;
254       break;
255    case PIPE_TEXTURE_3D:
256       /* this uses depth */
257       region.dstSubresource.baseArrayLayer = 0;
258       region.dstSubresource.layerCount = 1;
259       region.dstOffsets[0].z = info->dst.box.z;
260       region.dstOffsets[1].z = info->dst.box.z + info->dst.box.depth;
261       break;
262    default:
263       /* these must only copy one layer */
264       region.dstSubresource.baseArrayLayer = 0;
265       region.dstSubresource.layerCount = 1;
266       region.dstOffsets[0].z = 0;
267       region.dstOffsets[1].z = 1;
268    }
269    assert(region.dstOffsets[0].z != region.dstOffsets[1].z);
270 
271    apply_dst_clears(ctx, info, false);
272    zink_fb_clears_apply_region(ctx, info->src.resource, zink_rect_from_box(&info->src.box));
273 
274    if (src->obj->dt)
275       *needs_present_readback = zink_kopper_acquire_readback(ctx, src, &use_src);
276 
277    zink_resource_setup_transfer_layouts(ctx, use_src, dst);
278    VkCommandBuffer cmdbuf = *needs_present_readback ?
279                             ctx->bs->cmdbuf :
280                             zink_get_cmdbuf(ctx, src, dst);
281    zink_batch_reference_resource_rw(ctx, use_src, false);
282    zink_batch_reference_resource_rw(ctx, dst, true);
283 
284    bool marker = zink_cmd_debug_marker_begin(ctx, cmdbuf, "blit_native(%s->%s, %dx%d->%dx%d)",
285                                              util_format_short_name(info->src.format),
286                                              util_format_short_name(info->src.format),
287                                              info->src.box.width, info->src.box.height,
288                                              info->dst.box.width, info->dst.box.height);
289 
290    VKCTX(CmdBlitImage)(cmdbuf, use_src->obj->image, src->layout,
291                   dst->obj->image, dst->layout,
292                   1, &region,
293                   zink_filter(info->filter));
294 
295    zink_cmd_debug_marker_end(ctx, cmdbuf, marker);
296 
297    return true;
298 }
299 
300 static bool
try_copy_region(struct pipe_context * pctx,const struct pipe_blit_info * info)301 try_copy_region(struct pipe_context *pctx, const struct pipe_blit_info *info)
302 {
303    struct zink_context *ctx = zink_context(pctx);
304    struct zink_resource *src = zink_resource(info->src.resource);
305    struct zink_resource *dst = zink_resource(info->dst.resource);
306    /* if we're copying between resources with matching aspects then we can probably just copy_region */
307    if (src->aspect != dst->aspect)
308       return false;
309    struct pipe_blit_info new_info = *info;
310 
311    if (src->aspect & VK_IMAGE_ASPECT_STENCIL_BIT &&
312        new_info.render_condition_enable &&
313        !ctx->render_condition_active)
314       new_info.render_condition_enable = false;
315 
316    return util_try_blit_via_copy_region(pctx, &new_info, ctx->render_condition_active);
317 }
318 
319 void
zink_blit(struct pipe_context * pctx,const struct pipe_blit_info * info)320 zink_blit(struct pipe_context *pctx,
321           const struct pipe_blit_info *info)
322 {
323    struct zink_context *ctx = zink_context(pctx);
324    const struct util_format_description *src_desc = util_format_description(info->src.format);
325    const struct util_format_description *dst_desc = util_format_description(info->dst.format);
326 
327    struct zink_resource *src = zink_resource(info->src.resource);
328    struct zink_resource *use_src = src;
329    struct zink_resource *dst = zink_resource(info->dst.resource);
330    bool needs_present_readback = false;
331    if (zink_is_swapchain(dst)) {
332       if (!zink_kopper_acquire(ctx, dst, UINT64_MAX))
333          return;
334    }
335 
336    if (src_desc == dst_desc ||
337        src_desc->nr_channels != 4 || src_desc->layout != UTIL_FORMAT_LAYOUT_PLAIN ||
338        (src_desc->nr_channels == 4 && src_desc->channel[3].type != UTIL_FORMAT_TYPE_VOID)) {
339       /* we can't blit RGBX -> RGBA formats directly since they're emulated
340        * so we have to use sampler views
341        */
342       if (info->src.resource->nr_samples > 1 &&
343           info->dst.resource->nr_samples <= 1) {
344          if (blit_resolve(ctx, info, &needs_present_readback))
345             goto end;
346       } else {
347          if (try_copy_region(pctx, info))
348             goto end;
349          if (blit_native(ctx, info, &needs_present_readback))
350             goto end;
351       }
352    }
353 
354 
355 
356    bool stencil_blit = false;
357    if (!util_blitter_is_blit_supported(ctx->blitter, info)) {
358       if (util_format_is_depth_or_stencil(info->src.resource->format)) {
359          if (info->mask & PIPE_MASK_Z) {
360             struct pipe_blit_info depth_blit = *info;
361             depth_blit.mask = PIPE_MASK_Z;
362             if (util_blitter_is_blit_supported(ctx->blitter, &depth_blit)) {
363                zink_blit_begin(ctx, ZINK_BLIT_SAVE_FB | ZINK_BLIT_SAVE_FS | ZINK_BLIT_SAVE_TEXTURES);
364                util_blitter_blit(ctx->blitter, &depth_blit, NULL);
365             } else {
366                mesa_loge("ZINK: depth blit unsupported %s -> %s",
367                          util_format_short_name(info->src.resource->format),
368                          util_format_short_name(info->dst.resource->format));
369             }
370          }
371          if (info->mask & PIPE_MASK_S)
372             stencil_blit = true;
373       }
374       if (!stencil_blit) {
375          mesa_loge("ZINK: blit unsupported %s -> %s",
376                  util_format_short_name(info->src.resource->format),
377                  util_format_short_name(info->dst.resource->format));
378          goto end;
379       }
380    }
381 
382    if (src->obj->dt) {
383       zink_fb_clears_apply_region(ctx, info->src.resource, zink_rect_from_box(&info->src.box));
384       needs_present_readback = zink_kopper_acquire_readback(ctx, src, &use_src);
385    }
386 
387    /* this is discard_only because we're about to start a renderpass that will
388     * flush all pending clears anyway
389     */
390    apply_dst_clears(ctx, info, true);
391    zink_fb_clears_apply_region(ctx, info->src.resource, zink_rect_from_box(&info->src.box));
392    unsigned rp_clears_enabled = ctx->rp_clears_enabled;
393    unsigned clears_enabled = ctx->clears_enabled;
394    if (!dst->fb_bind_count) {
395       /* avoid applying clears from fb unbind by storing and re-setting them after the blit */
396       ctx->rp_clears_enabled = 0;
397       ctx->clears_enabled = 0;
398    } else {
399       unsigned bit;
400       /* convert to PIPE_CLEAR_XYZ */
401       if (dst->fb_binds & BITFIELD_BIT(PIPE_MAX_COLOR_BUFS))
402          bit = PIPE_CLEAR_DEPTHSTENCIL;
403       else
404          bit = dst->fb_binds << 2;
405       rp_clears_enabled &= ~bit;
406       clears_enabled &= ~bit;
407       ctx->rp_clears_enabled &= bit;
408       ctx->clears_enabled &= bit;
409    }
410 
411    /* this will draw a full-resource quad, so ignore existing data */
412    bool whole = util_blit_covers_whole_resource(info);
413    if (whole)
414       pctx->invalidate_resource(pctx, info->dst.resource);
415 
416    ctx->unordered_blitting = !(info->render_condition_enable && ctx->render_condition_active) &&
417                              zink_screen(ctx->base.screen)->info.have_KHR_dynamic_rendering &&
418                              !needs_present_readback &&
419                              zink_get_cmdbuf(ctx, src, dst) == ctx->bs->reordered_cmdbuf;
420    VkCommandBuffer cmdbuf = ctx->bs->cmdbuf;
421    VkPipeline pipeline = ctx->gfx_pipeline_state.pipeline;
422    bool in_rp = ctx->in_rp;
423    uint64_t tc_data = ctx->dynamic_fb.tc_info.data;
424    bool queries_disabled = ctx->queries_disabled;
425    bool rp_changed = ctx->rp_changed || (!ctx->fb_state.zsbuf && util_format_is_depth_or_stencil(info->dst.format));
426    unsigned ds3_states = ctx->ds3_states;
427    bool rp_tc_info_updated = ctx->rp_tc_info_updated;
428    if (ctx->unordered_blitting) {
429       /* for unordered blit, swap the unordered cmdbuf for the main one for the whole op to avoid conditional hell */
430       ctx->bs->cmdbuf = ctx->bs->reordered_cmdbuf;
431       ctx->in_rp = false;
432       ctx->rp_changed = true;
433       ctx->queries_disabled = true;
434       ctx->pipeline_changed[0] = true;
435       zink_reset_ds3_states(ctx);
436       zink_select_draw_vbo(ctx);
437    }
438    zink_blit_begin(ctx, ZINK_BLIT_SAVE_FB | ZINK_BLIT_SAVE_FS | ZINK_BLIT_SAVE_TEXTURES);
439    if (zink_format_needs_mutable(info->src.format, info->src.resource->format))
440       zink_resource_object_init_mutable(ctx, src);
441    if (zink_format_needs_mutable(info->dst.format, info->dst.resource->format))
442       zink_resource_object_init_mutable(ctx, dst);
443    zink_blit_barriers(ctx, use_src, dst, whole);
444    ctx->blitting = true;
445    ctx->blit_scissor = info->scissor_enable;
446    ctx->blit_nearest = info->filter == PIPE_TEX_FILTER_NEAREST;
447 
448    if (stencil_blit) {
449       struct pipe_surface *dst_view, dst_templ;
450       util_blitter_default_dst_texture(&dst_templ, info->dst.resource, info->dst.level, info->dst.box.z);
451       dst_view = pctx->create_surface(pctx, info->dst.resource, &dst_templ);
452 
453       util_blitter_clear_depth_stencil(ctx->blitter, dst_view, PIPE_CLEAR_STENCIL,
454                                        0, 0, info->dst.box.x, info->dst.box.y,
455                                        info->dst.box.width, info->dst.box.height);
456       zink_blit_begin(ctx, ZINK_BLIT_SAVE_FB | ZINK_BLIT_SAVE_FS | ZINK_BLIT_SAVE_TEXTURES | ZINK_BLIT_SAVE_FS_CONST_BUF);
457       util_blitter_stencil_fallback(ctx->blitter,
458                                     info->dst.resource,
459                                     info->dst.level,
460                                     &info->dst.box,
461                                     info->src.resource,
462                                     info->src.level,
463                                     &info->src.box,
464                                     info->scissor_enable ? &info->scissor : NULL);
465 
466       pipe_surface_release(pctx, &dst_view);
467    } else {
468       struct pipe_blit_info new_info = *info;
469       new_info.src.resource = &use_src->base.b;
470       util_blitter_blit(ctx->blitter, &new_info, NULL);
471    }
472    ctx->blitting = false;
473    ctx->rp_clears_enabled = rp_clears_enabled;
474    ctx->clears_enabled = clears_enabled;
475    if (ctx->unordered_blitting) {
476       zink_batch_no_rp(ctx);
477       ctx->in_rp = in_rp;
478       ctx->gfx_pipeline_state.rp_state = zink_update_rendering_info(ctx);
479       ctx->rp_changed = rp_changed;
480       ctx->rp_tc_info_updated |= rp_tc_info_updated;
481       ctx->queries_disabled = queries_disabled;
482       ctx->dynamic_fb.tc_info.data = tc_data;
483       ctx->bs->cmdbuf = cmdbuf;
484       ctx->gfx_pipeline_state.pipeline = pipeline;
485       ctx->pipeline_changed[0] = true;
486       ctx->ds3_states = ds3_states;
487       zink_select_draw_vbo(ctx);
488    }
489    ctx->unordered_blitting = false;
490 end:
491    if (needs_present_readback) {
492       src->obj->unordered_read = false;
493       dst->obj->unordered_write = false;
494       zink_kopper_present_readback(ctx, src);
495    }
496 }
497 
498 /* similar to radeonsi */
499 void
zink_blit_begin(struct zink_context * ctx,enum zink_blit_flags flags)500 zink_blit_begin(struct zink_context *ctx, enum zink_blit_flags flags)
501 {
502    util_blitter_save_vertex_elements(ctx->blitter, ctx->element_state);
503    util_blitter_save_viewport(ctx->blitter, ctx->vp_state.viewport_states);
504 
505    util_blitter_save_vertex_buffers(ctx->blitter, ctx->vertex_buffers,
506                                     util_last_bit(ctx->gfx_pipeline_state.vertex_buffers_enabled_mask));
507    util_blitter_save_vertex_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_VERTEX]);
508    util_blitter_save_tessctrl_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_TESS_CTRL]);
509    util_blitter_save_tesseval_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_TESS_EVAL]);
510    util_blitter_save_geometry_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_GEOMETRY]);
511    util_blitter_save_rasterizer(ctx->blitter, ctx->rast_state);
512    util_blitter_save_so_targets(ctx->blitter, ctx->num_so_targets, ctx->so_targets);
513 
514    if (flags & ZINK_BLIT_SAVE_FS_CONST_BUF)
515       util_blitter_save_fragment_constant_buffer_slot(ctx->blitter, ctx->ubos[MESA_SHADER_FRAGMENT]);
516 
517    if (flags & ZINK_BLIT_SAVE_FS) {
518       util_blitter_save_blend(ctx->blitter, ctx->gfx_pipeline_state.blend_state);
519       util_blitter_save_depth_stencil_alpha(ctx->blitter, ctx->dsa_state);
520       util_blitter_save_stencil_ref(ctx->blitter, &ctx->stencil_ref);
521       util_blitter_save_sample_mask(ctx->blitter, ctx->gfx_pipeline_state.sample_mask, ctx->gfx_pipeline_state.min_samples + 1);
522       util_blitter_save_scissor(ctx->blitter, ctx->vp_state.scissor_states);
523       /* also util_blitter_save_window_rectangles when we have that? */
524 
525       util_blitter_save_fragment_shader(ctx->blitter, ctx->gfx_stages[MESA_SHADER_FRAGMENT]);
526    }
527 
528    if (flags & ZINK_BLIT_SAVE_FB)
529       util_blitter_save_framebuffer(ctx->blitter, &ctx->fb_state);
530 
531 
532    if (flags & ZINK_BLIT_SAVE_TEXTURES) {
533       util_blitter_save_fragment_sampler_states(ctx->blitter,
534                                                 ctx->di.num_samplers[MESA_SHADER_FRAGMENT],
535                                                 (void**)ctx->sampler_states[MESA_SHADER_FRAGMENT]);
536       util_blitter_save_fragment_sampler_views(ctx->blitter,
537                                                ctx->di.num_sampler_views[MESA_SHADER_FRAGMENT],
538                                                ctx->sampler_views[MESA_SHADER_FRAGMENT]);
539    }
540 
541    if (flags & ZINK_BLIT_NO_COND_RENDER && ctx->render_condition_active)
542       zink_stop_conditional_render(ctx);
543 }
544 
545 void
zink_blit_barriers(struct zink_context * ctx,struct zink_resource * src,struct zink_resource * dst,bool whole_dst)546 zink_blit_barriers(struct zink_context *ctx, struct zink_resource *src, struct zink_resource *dst, bool whole_dst)
547 {
548    struct zink_screen *screen = zink_screen(ctx->base.screen);
549    if (src && zink_is_swapchain(src)) {
550       if (!zink_kopper_acquire(ctx, src, UINT64_MAX))
551          return;
552    } else if (dst && zink_is_swapchain(dst)) {
553       if (!zink_kopper_acquire(ctx, dst, UINT64_MAX))
554          return;
555    }
556 
557    VkAccessFlagBits flags;
558    VkPipelineStageFlagBits pipeline;
559    if (util_format_is_depth_or_stencil(dst->base.b.format)) {
560       flags = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
561       if (!whole_dst)
562          flags |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
563       pipeline = VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
564    } else {
565       flags = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
566       if (!whole_dst)
567          flags |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
568       pipeline = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
569    }
570    if (src == dst) {
571       VkImageLayout layout = zink_screen(ctx->base.screen)->info.have_EXT_attachment_feedback_loop_layout ?
572                              VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT :
573                              VK_IMAGE_LAYOUT_GENERAL;
574       screen->image_barrier(ctx, src, layout, VK_ACCESS_SHADER_READ_BIT | flags, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | pipeline);
575    } else {
576       if (src) {
577          VkImageLayout layout = util_format_is_depth_or_stencil(src->base.b.format) &&
578                                 src->obj->vkusage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT ?
579                                 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL :
580                                 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
581          screen->image_barrier(ctx, src, layout,
582                               VK_ACCESS_SHADER_READ_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
583          if (!ctx->unordered_blitting)
584             src->obj->unordered_read = false;
585       }
586       VkImageLayout layout = util_format_is_depth_or_stencil(dst->base.b.format) ?
587                            VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL :
588                            VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
589       screen->image_barrier(ctx, dst, layout, flags, pipeline);
590    }
591    if (!ctx->unordered_blitting)
592       dst->obj->unordered_read = dst->obj->unordered_write = false;
593 }
594 
595 bool
zink_blit_region_fills(struct u_rect region,unsigned width,unsigned height)596 zink_blit_region_fills(struct u_rect region, unsigned width, unsigned height)
597 {
598    struct u_rect intersect = {0, width, 0, height};
599    struct u_rect r = {
600       MIN2(region.x0, region.x1),
601       MAX2(region.x0, region.x1),
602       MIN2(region.y0, region.y1),
603       MAX2(region.y0, region.y1),
604    };
605 
606    if (!u_rect_test_intersection(&r, &intersect))
607       /* is this even a thing? */
608       return false;
609 
610    u_rect_find_intersection(&r, &intersect);
611    if (intersect.x0 != 0 || intersect.y0 != 0 ||
612        intersect.x1 != width || intersect.y1 != height)
613       return false;
614 
615    return true;
616 }
617 
618 bool
zink_blit_region_covers(struct u_rect region,struct u_rect covers)619 zink_blit_region_covers(struct u_rect region, struct u_rect covers)
620 {
621    struct u_rect r = {
622       MIN2(region.x0, region.x1),
623       MAX2(region.x0, region.x1),
624       MIN2(region.y0, region.y1),
625       MAX2(region.y0, region.y1),
626    };
627    struct u_rect c = {
628       MIN2(covers.x0, covers.x1),
629       MAX2(covers.x0, covers.x1),
630       MIN2(covers.y0, covers.y1),
631       MAX2(covers.y0, covers.y1),
632    };
633    struct u_rect intersect;
634    if (!u_rect_test_intersection(&r, &c))
635       return false;
636 
637     u_rect_union(&intersect, &r, &c);
638     return intersect.x0 == c.x0 && intersect.y0 == c.y0 &&
639            intersect.x1 == c.x1 && intersect.y1 == c.y1;
640 }
641 
642 void
zink_draw_rectangle(struct blitter_context * blitter,void * vertex_elements_cso,blitter_get_vs_func get_vs,int x1,int y1,int x2,int y2,float depth,unsigned num_instances,enum blitter_attrib_type type,const union blitter_attrib * attrib)643 zink_draw_rectangle(struct blitter_context *blitter, void *vertex_elements_cso,
644                     blitter_get_vs_func get_vs, int x1, int y1, int x2, int y2,
645                     float depth, unsigned num_instances, enum blitter_attrib_type type,
646                     const union blitter_attrib *attrib)
647 {
648    struct zink_context *ctx = zink_context(blitter->pipe);
649 
650    union blitter_attrib new_attrib = *attrib;
651 
652    /* Avoid inconsistencies in rounding between both triangles which can show with
653     * nearest filtering by expanding the rect so only one triangle is effectively drawn.
654     */
655    if (ctx->blit_scissor && ctx->blit_nearest) {
656       int64_t new_x1 = (int64_t)x1 * 2 - x2;
657       int64_t new_y2 = (int64_t)y2 * 2 - y1;
658       if (new_x1 < INT32_MAX && new_x1 > INT32_MIN &&
659           new_y2 < INT32_MAX && new_y2 > INT32_MIN) {
660          x1 = new_x1;
661          y2 = new_y2;
662 
663          if (type == UTIL_BLITTER_ATTRIB_TEXCOORD_XY ||
664              type == UTIL_BLITTER_ATTRIB_TEXCOORD_XYZW) {
665             new_attrib.texcoord.x1 += new_attrib.texcoord.x1 - new_attrib.texcoord.x2;
666             new_attrib.texcoord.y2 += new_attrib.texcoord.y2 - new_attrib.texcoord.y1;
667          }
668       }
669    }
670 
671    util_blitter_draw_rectangle(blitter, vertex_elements_cso, get_vs, x1, y1, x2, y2,
672                                depth, num_instances, type, &new_attrib);
673 }
674