iris_blit.c 31.3 KB
Newer Older
1
2
3
4
5
6
/*
 * Copyright © 2017 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
7
8
9
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
10
 *
11
12
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
13
 *
14
15
16
17
18
19
20
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
21
 */
22

23
24
25
26
27
#include <stdio.h>
#include "pipe/p_defines.h"
#include "pipe/p_state.h"
#include "pipe/p_context.h"
#include "pipe/p_screen.h"
28
#include "util/format/u_format.h"
29
30
#include "util/u_inlines.h"
#include "util/ralloc.h"
31
#include "intel/blorp/blorp.h"
32
33
34
35
#include "iris_context.h"
#include "iris_resource.h"
#include "iris_screen.h"

36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
/**
 * Helper function for handling mirror image blits.
 *
 * If coord0 > coord1, swap them and return "true" (mirrored).
 */
static bool
apply_mirror(float *coord0, float *coord1)
{
   if (*coord0 > *coord1) {
      float tmp = *coord0;
      *coord0 = *coord1;
      *coord1 = tmp;
      return true;
   }
   return false;
}

/**
 * Compute the number of pixels to clip for each side of a rect
 *
 * \param x0 The rect's left coordinate
 * \param y0 The rect's bottom coordinate
 * \param x1 The rect's right coordinate
 * \param y1 The rect's top coordinate
 * \param min_x The clipping region's left coordinate
 * \param min_y The clipping region's bottom coordinate
 * \param max_x The clipping region's right coordinate
 * \param max_y The clipping region's top coordinate
 * \param clipped_x0 The number of pixels to clip from the left side
 * \param clipped_y0 The number of pixels to clip from the bottom side
 * \param clipped_x1 The number of pixels to clip from the right side
 * \param clipped_y1 The number of pixels to clip from the top side
 *
 * \return false if we clip everything away, true otherwise
 */
static inline bool
compute_pixels_clipped(float x0, float y0, float x1, float y1,
                       float min_x, float min_y, float max_x, float max_y,
                       float *clipped_x0, float *clipped_y0,
                       float *clipped_x1, float *clipped_y1)
{
   /* If we are going to clip everything away, stop. */
   if (!(min_x <= max_x &&
         min_y <= max_y &&
         x0 <= max_x &&
         y0 <= max_y &&
         min_x <= x1 &&
         min_y <= y1 &&
         x0 <= x1 &&
         y0 <= y1)) {
      return false;
   }

   if (x0 < min_x)
      *clipped_x0 = min_x - x0;
   else
      *clipped_x0 = 0;
   if (max_x < x1)
      *clipped_x1 = x1 - max_x;
   else
      *clipped_x1 = 0;

   if (y0 < min_y)
      *clipped_y0 = min_y - y0;
   else
      *clipped_y0 = 0;
   if (max_y < y1)
      *clipped_y1 = y1 - max_y;
   else
      *clipped_y1 = 0;

   return true;
}

/**
 * Clips a coordinate (left, right, top or bottom) for the src or dst rect
 * (whichever requires the largest clip) and adjusts the coordinate
 * for the other rect accordingly.
 *
 * \param mirror true if mirroring is required
 * \param src the source rect coordinate (for example src_x0)
 * \param dst0 the dst rect coordinate (for example dst_x0)
 * \param dst1 the opposite dst rect coordinate (for example dst_x1)
 * \param clipped_dst0 number of pixels to clip from the dst coordinate
 * \param clipped_dst1 number of pixels to clip from the opposite dst coordinate
 * \param scale the src vs dst scale involved for that coordinate
 * \param is_left_or_bottom true if we are clipping the left or bottom sides
 *        of the rect.
 */
static void
clip_coordinates(bool mirror,
                 float *src, float *dst0, float *dst1,
                 float clipped_dst0,
                 float clipped_dst1,
                 float scale,
                 bool is_left_or_bottom)
{
   /* When clipping we need to add or subtract pixels from the original
    * coordinates depending on whether we are acting on the left/bottom
    * or right/top sides of the rect respectively. We assume we have to
    * add them in the code below, and multiply by -1 when we should
    * subtract.
    */
   int mult = is_left_or_bottom ? 1 : -1;

   if (!mirror) {
      *dst0 += clipped_dst0 * mult;
      *src += clipped_dst0 * scale * mult;
   } else {
      *dst1 -= clipped_dst1 * mult;
      *src += clipped_dst1 * scale * mult;
   }
}

/**
 * Apply a scissor rectangle to blit coordinates.
 *
 * Returns true if the blit was entirely scissored away.
 */
static bool
apply_blit_scissor(const struct pipe_scissor_state *scissor,
                   float *src_x0, float *src_y0,
                   float *src_x1, float *src_y1,
                   float *dst_x0, float *dst_y0,
                   float *dst_x1, float *dst_y1,
                   bool mirror_x, bool mirror_y)
{
   float clip_dst_x0, clip_dst_x1, clip_dst_y0, clip_dst_y1;

   /* Compute number of pixels to scissor away. */
   if (!compute_pixels_clipped(*dst_x0, *dst_y0, *dst_x1, *dst_y1,
                               scissor->minx, scissor->miny,
                               scissor->maxx, scissor->maxy,
                               &clip_dst_x0, &clip_dst_y0,
                               &clip_dst_x1, &clip_dst_y1))
      return true;

   // XXX: comments assume source clipping, which we don't do

   /* When clipping any of the two rects we need to adjust the coordinates
    * in the other rect considering the scaling factor involved.  To obtain
    * the best precision we want to make sure that we only clip once per
    * side to avoid accumulating errors due to the scaling adjustment.
    *
    * For example, if src_x0 and dst_x0 need both to be clipped we want to
    * avoid the situation where we clip src_x0 first, then adjust dst_x0
    * accordingly but then we realize that the resulting dst_x0 still needs
    * to be clipped, so we clip dst_x0 and adjust src_x0 again.  Because we are
    * applying scaling factors to adjust the coordinates in each clipping
    * pass we lose some precision and that can affect the results of the
    * blorp blit operation slightly.  What we want to do here is detect the
    * rect that we should clip first for each side so that when we adjust
    * the other rect we ensure the resulting coordinate does not need to be
    * clipped again.
    *
    * The code below implements this by comparing the number of pixels that
    * we need to clip for each side of both rects considering the scales
    * involved.  For example, clip_src_x0 represents the number of pixels
    * to be clipped for the src rect's left side, so if clip_src_x0 = 5,
    * clip_dst_x0 = 4 and scale_x = 2 it means that we are clipping more
    * from the dst rect so we should clip dst_x0 only and adjust src_x0.
    * This is because clipping 4 pixels in the dst is equivalent to
    * clipping 4 * 2 = 8 > 5 in the src.
    */

201
202
203
204
   if (*src_x0 == *src_x1 || *src_y0 == *src_y1
       || *dst_x0 == *dst_x1 || *dst_y0 == *dst_y1)
      return true;

205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
   float scale_x = (float) (*src_x1 - *src_x0) / (*dst_x1 - *dst_x0);
   float scale_y = (float) (*src_y1 - *src_y0) / (*dst_y1 - *dst_y0);

   /* Clip left side */
   clip_coordinates(mirror_x, src_x0, dst_x0, dst_x1,
                    clip_dst_x0, clip_dst_x1, scale_x, true);

   /* Clip right side */
   clip_coordinates(mirror_x, src_x1, dst_x1, dst_x0,
                    clip_dst_x1, clip_dst_x0, scale_x, false);

   /* Clip bottom side */
   clip_coordinates(mirror_y, src_y0, dst_y0, dst_y1,
                    clip_dst_y0, clip_dst_y1, scale_y, true);

   /* Clip top side */
   clip_coordinates(mirror_y, src_y1, dst_y1, dst_y0,
                    clip_dst_y1, clip_dst_y0, scale_y, false);

224
225
226
227
228
   /* Check for invalid bounds
    * Can't blit for 0-dimensions
    */
   return *src_x0 == *src_x1 || *src_y0 == *src_y1
      || *dst_x0 == *dst_x1 || *dst_y0 == *dst_y1;
229
230
}

Kenneth Graunke's avatar
Kenneth Graunke committed
231
void
232
iris_blorp_surf_for_resource(struct isl_device *isl_dev,
233
                             struct blorp_surf *surf,
Kenneth Graunke's avatar
Kenneth Graunke committed
234
235
                             struct pipe_resource *p_res,
                             enum isl_aux_usage aux_usage,
Kenneth Graunke's avatar
Kenneth Graunke committed
236
                             unsigned level,
Kenneth Graunke's avatar
Kenneth Graunke committed
237
                             bool is_render_target)
238
239
240
{
   struct iris_resource *res = (void *) p_res;

241
242
   assert(!iris_resource_unfinished_aux_import(res));

243
   if (isl_aux_usage_has_hiz(aux_usage) &&
Kenneth Graunke's avatar
Kenneth Graunke committed
244
245
246
       !iris_resource_level_has_hiz(res, level))
      aux_usage = ISL_AUX_USAGE_NONE;

247
248
249
250
   *surf = (struct blorp_surf) {
      .surf = &res->surf,
      .addr = (struct blorp_address) {
         .buffer = res->bo,
251
         .offset = res->offset,
252
         .reloc_flags = is_render_target ? EXEC_OBJECT_WRITE : 0,
253
254
255
         .mocs = iris_mocs(res->bo, isl_dev,
                           is_render_target ? ISL_SURF_USAGE_RENDER_TARGET_BIT
                                            : ISL_SURF_USAGE_TEXTURE_BIT),
256
257
258
259
      },
      .aux_usage = aux_usage,
   };

260
261
262
263
264
265
   if (aux_usage != ISL_AUX_USAGE_NONE) {
      surf->aux_surf = &res->aux.surf;
      surf->aux_addr = (struct blorp_address) {
         .buffer = res->aux.bo,
         .offset = res->aux.offset,
         .reloc_flags = is_render_target ? EXEC_OBJECT_WRITE : 0,
266
         .mocs = iris_mocs(res->bo, isl_dev, 0),
267
      };
268
269
      surf->clear_color =
         iris_resource_get_clear_color(res, NULL, NULL);
270
271
272
273
      surf->clear_color_addr = (struct blorp_address) {
         .buffer = res->aux.clear_color_bo,
         .offset = res->aux.clear_color_offset,
         .reloc_flags = 0,
274
         .mocs = iris_mocs(res->aux.clear_color_bo, isl_dev, 0),
275
      };
276
   }
277
278
}

279
280
281
282
283
284
285
static bool
is_astc(enum isl_format format)
{
   return format != ISL_FORMAT_UNSUPPORTED &&
          isl_format_get_layout(format)->txc == ISL_TXC_ASTC;
}

286
static void
287
288
289
tex_cache_flush_hack(struct iris_batch *batch,
                     enum isl_format view_format,
                     enum isl_format surf_format)
290
{
291
292
293
294
295
296
297
298
299
300
301
   const struct gen_device_info *devinfo = &batch->screen->devinfo;

   /* The WaSamplerCacheFlushBetweenRedescribedSurfaceReads workaround says:
    *
    *    "Currently Sampler assumes that a surface would not have two
    *     different format associate with it.  It will not properly cache
    *     the different views in the MT cache, causing a data corruption."
    *
    * We may need to handle this for texture views in general someday, but
    * for now we handle it here, as it hurts copies and blits particularly
    * badly because they ofter reinterpret formats.
302
303
304
305
    *
    * If the BO hasn't been referenced yet this batch, we assume that the
    * texture cache doesn't contain any relevant data nor need flushing.
    *
306
307
    * Icelake (Gen11+) claims to fix this issue, but seems to still have
    * issues with ASTC formats.
308
    */
309
310
311
312
313
314
   bool need_flush = devinfo->gen >= 11 ?
                     is_astc(surf_format) != is_astc(view_format) :
                     view_format != surf_format;
   if (!need_flush)
      return;

315
316
317
318
319
320
   const char *reason =
      "workaround: WaSamplerCacheFlushBetweenRedescribedSurfaceReads";

   iris_emit_pipe_control_flush(batch, reason, PIPE_CONTROL_CS_STALL);
   iris_emit_pipe_control_flush(batch, reason,
                                PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE);
321
322
}

323
324
325
326
327
328
329
330
331
332
static enum isl_aux_usage
iris_resource_blorp_write_aux_usage(struct iris_context *ice,
                                    struct iris_resource *res,
                                    enum isl_format render_format)
{
   if (res->surf.usage & (ISL_SURF_USAGE_DEPTH_BIT |
                          ISL_SURF_USAGE_STENCIL_BIT)) {
      assert(render_format == res->surf.format);
      return res->aux.usage;
   } else {
333
      return iris_resource_render_aux_usage(ice, res, render_format, false);
334
335
336
   }
}

Kenneth Graunke's avatar
Kenneth Graunke committed
337
338
339
340
341
342
/**
 * The pipe->blit() driver hook.
 *
 * This performs a blit between two surfaces, which copies data but may
 * also perform format conversion, scaling, flipping, and so on.
 */
343
344
345
346
static void
iris_blit(struct pipe_context *ctx, const struct pipe_blit_info *info)
{
   struct iris_context *ice = (void *) ctx;
347
348
   struct iris_screen *screen = (struct iris_screen *)ctx->screen;
   const struct gen_device_info *devinfo = &screen->devinfo;
349
   struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
350
   enum blorp_batch_flags blorp_flags = 0;
351
352
   struct iris_resource *src_res = (void *) info->src.resource;
   struct iris_resource *dst_res = (void *) info->dst.resource;
353

354
355
356
357
   /* We don't support color masking. */
   assert((info->mask & PIPE_MASK_RGBA) == PIPE_MASK_RGBA ||
          (info->mask & PIPE_MASK_RGBA) == 0);

358
   if (info->render_condition_enable) {
359
      if (ice->state.predicate == IRIS_PREDICATE_STATE_DONT_RENDER)
360
361
         return;

362
      if (ice->state.predicate == IRIS_PREDICATE_STATE_USE_BIT)
363
364
         blorp_flags |= BLORP_BATCH_PREDICATE_ENABLE;
   }
365

366
367
368
369
370
   if (iris_resource_unfinished_aux_import(src_res))
      iris_resource_finish_aux_import(ctx->screen, src_res);
   if (iris_resource_unfinished_aux_import(dst_res))
      iris_resource_finish_aux_import(ctx->screen, dst_res);

371
372
373
   struct iris_format_info src_fmt =
      iris_format_for_usage(devinfo, info->src.format,
                            ISL_SURF_USAGE_TEXTURE_BIT);
374
   enum isl_aux_usage src_aux_usage =
375
      iris_resource_texture_aux_usage(ice, src_res, src_fmt.fmt);
376

Nanley Chery's avatar
Nanley Chery committed
377
   if (iris_resource_level_has_hiz(src_res, info->src.level))
378
      assert(src_res->surf.format == src_fmt.fmt);
379

380
   bool src_clear_supported = isl_aux_usage_has_fast_clears(src_aux_usage) &&
381
382
                              src_res->surf.format == src_fmt.fmt;

383
   iris_resource_prepare_access(ice, src_res, info->src.level, 1,
384
385
                                info->src.box.z, info->src.box.depth,
                                src_aux_usage, src_clear_supported);
386
   iris_emit_buffer_barrier_for(batch, src_res->bo, IRIS_DOMAIN_OTHER_READ);
387

388
389
390
   struct iris_format_info dst_fmt =
      iris_format_for_usage(devinfo, info->dst.format,
                            ISL_SURF_USAGE_RENDER_TARGET_BIT);
391
   enum isl_aux_usage dst_aux_usage =
392
      iris_resource_blorp_write_aux_usage(ice, dst_res, dst_fmt.fmt);
393
   bool dst_clear_supported = isl_aux_usage_has_fast_clears(dst_aux_usage);
394
395

   struct blorp_surf src_surf, dst_surf;
396
   iris_blorp_surf_for_resource(&screen->isl_dev,  &src_surf,
397
398
                                info->src.resource, src_aux_usage,
                                info->src.level, false);
399
   iris_blorp_surf_for_resource(&screen->isl_dev, &dst_surf,
400
401
                                info->dst.resource, dst_aux_usage,
                                info->dst.level, true);
402

403
   iris_resource_prepare_access(ice, dst_res, info->dst.level, 1,
404
405
                                info->dst.box.z, info->dst.box.depth,
                                dst_aux_usage, dst_clear_supported);
406
   iris_emit_buffer_barrier_for(batch, dst_res->bo, IRIS_DOMAIN_RENDER_WRITE);
407

408
409
410
411
412
413
414
415
416
417
   float src_x0 = info->src.box.x;
   float src_x1 = info->src.box.x + info->src.box.width;
   float src_y0 = info->src.box.y;
   float src_y1 = info->src.box.y + info->src.box.height;
   float dst_x0 = info->dst.box.x;
   float dst_x1 = info->dst.box.x + info->dst.box.width;
   float dst_y0 = info->dst.box.y;
   float dst_y1 = info->dst.box.y + info->dst.box.height;
   bool mirror_x = apply_mirror(&src_x0, &src_x1);
   bool mirror_y = apply_mirror(&src_y0, &src_y1);
Kenneth Graunke's avatar
Kenneth Graunke committed
418
419
   enum blorp_filter filter;

420
421
422
423
424
425
426
427
428
   if (info->scissor_enable) {
      bool noop = apply_blit_scissor(&info->scissor,
                                     &src_x0, &src_y0, &src_x1, &src_y1,
                                     &dst_x0, &dst_y0, &dst_x1, &dst_y1,
                                     mirror_x, mirror_y);
      if (noop)
         return;
   }

429
430
   if (abs(info->dst.box.width) == abs(info->src.box.width) &&
       abs(info->dst.box.height) == abs(info->src.box.height)) {
Kenneth Graunke's avatar
Kenneth Graunke committed
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
      if (src_surf.surf->samples > 1 && dst_surf.surf->samples <= 1) {
         /* The OpenGL ES 3.2 specification, section 16.2.1, says:
          *
          *    "If the read framebuffer is multisampled (its effective
          *     value of SAMPLE_BUFFERS is one) and the draw framebuffer
          *     is not (its value of SAMPLE_BUFFERS is zero), the samples
          *     corresponding to each pixel location in the source are
          *     converted to a single sample before being written to the
          *     destination.  The filter parameter is ignored.  If the
          *     source formats are integer types or stencil values, a
          *     single sample’s value is selected for each pixel.  If the
          *     source formats are floating-point or normalized types,
          *     the sample values for each pixel are resolved in an
          *     implementation-dependent manner.  If the source formats
          *     are depth values, sample values are resolved in an
          *     implementation-dependent manner where the result will be
          *     between the minimum and maximum depth values in the pixel."
          *
          * When selecting a single sample, we always choose sample 0.
          */
         if (util_format_is_depth_or_stencil(info->src.format) ||
             util_format_is_pure_integer(info->src.format)) {
            filter = BLORP_FILTER_SAMPLE_0;
         } else {
            filter = BLORP_FILTER_AVERAGE;
         }
      } else {
         /* The OpenGL 4.6 specification, section 18.3.1, says:
          *
          *    "If the source and destination dimensions are identical,
          *     no filtering is applied."
          *
          * Using BLORP_FILTER_NONE will also handle the upsample case by
          * replicating the one value in the source to all values in the
          * destination.
          */
         filter = BLORP_FILTER_NONE;
      }
   } else if (info->filter == PIPE_TEX_FILTER_LINEAR) {
      filter = BLORP_FILTER_BILINEAR;
   } else {
      filter = BLORP_FILTER_NEAREST;
   }
474

475
476
   if (iris_batch_references(batch, src_res->bo))
      tex_cache_flush_hack(batch, src_fmt.fmt, src_res->surf.format);
477

478
   if (dst_res->base.target == PIPE_BUFFER)
479
      util_range_add(&dst_res->base, &dst_res->valid_buffer_range, dst_x0, dst_x1);
480

481
   struct blorp_batch blorp_batch;
482
   blorp_batch_init(&ice->blorp, &blorp_batch, batch, blorp_flags);
483

484
   unsigned main_mask;
485
   if (util_format_is_depth_or_stencil(info->dst.format))
486
487
488
489
490
491
492
      main_mask = PIPE_MASK_Z;
   else
      main_mask = PIPE_MASK_RGBA;

   if (info->mask & main_mask) {
      for (int slice = 0; slice < info->dst.box.depth; slice++) {
         iris_batch_maybe_flush(batch, 1500);
493
         iris_batch_sync_region_start(batch);
494
495
496
497
498

         blorp_blit(&blorp_batch,
                    &src_surf, info->src.level, info->src.box.z + slice,
                    src_fmt.fmt, src_fmt.swizzle,
                    &dst_surf, info->dst.level, info->dst.box.z + slice,
499
                    dst_fmt.fmt, dst_fmt.swizzle,
500
501
502
                    src_x0, src_y0, src_x1, src_y1,
                    dst_x0, dst_y0, dst_x1, dst_y1,
                    filter, mirror_x, mirror_y);
503
504

         iris_batch_sync_region_end(batch);
505
      }
506
   }
507

508
   struct iris_resource *stc_dst = NULL;
509
   enum isl_aux_usage stc_dst_aux_usage = ISL_AUX_USAGE_NONE;
510
   if ((info->mask & PIPE_MASK_S) &&
511
       util_format_has_stencil(util_format_description(info->dst.format)) &&
512
       util_format_has_stencil(util_format_description(info->src.format))) {
513
514
      struct iris_resource *src_res, *junk;
      struct blorp_surf src_surf, dst_surf;
515
      iris_get_depth_stencil_resources(info->src.resource, &junk, &src_res);
516
517
518
519
520
      iris_get_depth_stencil_resources(info->dst.resource, &junk, &stc_dst);

      struct iris_format_info src_fmt =
         iris_format_for_usage(devinfo, src_res->base.format,
                               ISL_SURF_USAGE_TEXTURE_BIT);
521
      enum isl_aux_usage stc_src_aux_usage =
522
         iris_resource_texture_aux_usage(ice, src_res, src_fmt.fmt);
523
524
525
526
527

      struct iris_format_info dst_fmt =
         iris_format_for_usage(devinfo, stc_dst->base.format,
                               ISL_SURF_USAGE_RENDER_TARGET_BIT);
      stc_dst_aux_usage =
528
         iris_resource_blorp_write_aux_usage(ice, stc_dst, dst_fmt.fmt);
529

530
      iris_resource_prepare_access(ice, src_res, info->src.level, 1,
531
532
                                   info->src.box.z, info->src.box.depth,
                                   stc_src_aux_usage, false);
533
      iris_emit_buffer_barrier_for(batch, src_res->bo, IRIS_DOMAIN_OTHER_READ);
534
      iris_resource_prepare_access(ice, stc_dst, info->dst.level, 1,
535
536
                                   info->dst.box.z, info->dst.box.depth,
                                   stc_dst_aux_usage, false);
537
      iris_emit_buffer_barrier_for(batch, stc_dst->bo, IRIS_DOMAIN_RENDER_WRITE);
538
      iris_blorp_surf_for_resource(&screen->isl_dev, &src_surf,
539
540
                                   &src_res->base, stc_src_aux_usage,
                                   info->src.level, false);
541
      iris_blorp_surf_for_resource(&screen->isl_dev, &dst_surf,
542
543
                                   &stc_dst->base, stc_dst_aux_usage,
                                   info->dst.level, true);
544

545
      for (int slice = 0; slice < info->dst.box.depth; slice++) {
546
         iris_batch_maybe_flush(batch, 1500);
547
         iris_batch_sync_region_start(batch);
548

549
550
         blorp_blit(&blorp_batch,
                    &src_surf, info->src.level, info->src.box.z + slice,
551
                    ISL_FORMAT_R8_UINT, ISL_SWIZZLE_IDENTITY,
552
553
554
555
556
                    &dst_surf, info->dst.level, info->dst.box.z + slice,
                    ISL_FORMAT_R8_UINT, ISL_SWIZZLE_IDENTITY,
                    src_x0, src_y0, src_x1, src_y1,
                    dst_x0, dst_y0, dst_x1, dst_y1,
                    filter, mirror_x, mirror_y);
557
558

         iris_batch_sync_region_end(batch);
559
      }
560
561
   }

562
   blorp_batch_finish(&blorp_batch);
563

564
   tex_cache_flush_hack(batch, src_fmt.fmt, src_res->surf.format);
565

566
567
568
569
570
571
572
573
574
   if (info->mask & main_mask) {
      iris_resource_finish_write(ice, dst_res, info->dst.level, info->dst.box.z,
                                 info->dst.box.depth, dst_aux_usage);
   }

   if (stc_dst) {
      iris_resource_finish_write(ice, stc_dst, info->dst.level, info->dst.box.z,
                                 info->dst.box.depth, stc_dst_aux_usage);
   }
575

576
   iris_flush_and_dirty_for_history(ice, batch, (struct iris_resource *)
577
                                    info->dst.resource,
578
                                    PIPE_CONTROL_RENDER_TARGET_FLUSH,
579
                                    "cache history: post-blit");
580
}
581

582
static void
583
get_copy_region_aux_settings(struct iris_context *ice,
584
585
                             struct iris_resource *res,
                             enum isl_aux_usage *out_aux_usage,
586
587
                             bool *out_clear_supported,
                             bool is_render_target)
588
{
589
590
591
   struct iris_screen *screen = (void *) ice->ctx.screen;
   const struct gen_device_info *devinfo = &screen->devinfo;

592
   switch (res->aux.usage) {
593
   case ISL_AUX_USAGE_HIZ:
594
   case ISL_AUX_USAGE_HIZ_CCS:
595
   case ISL_AUX_USAGE_HIZ_CCS_WT:
596
      if (is_render_target) {
597
         *out_aux_usage = res->aux.usage;
598
599
600
      } else {
         *out_aux_usage = iris_resource_texture_aux_usage(ice, res,
                                                          res->surf.format);
601
      }
602
      *out_clear_supported = (*out_aux_usage != ISL_AUX_USAGE_NONE);
603
      break;
604
   case ISL_AUX_USAGE_MCS:
605
   case ISL_AUX_USAGE_MCS_CCS:
606
   case ISL_AUX_USAGE_CCS_E:
607
   case ISL_AUX_USAGE_GEN12_CCS_E:
608
609
610
611
612
      *out_aux_usage = res->aux.usage;
      /* Prior to Gen9, fast-clear only supported 0/1 clear colors.  Since
       * we're going to re-interpret the format as an integer format possibly
       * with a different number of components, we can't handle clear colors
       * until Gen9.
613
       */
614
      *out_clear_supported = devinfo->gen >= 9;
615
      break;
616
617
618
619
   case ISL_AUX_USAGE_STC_CCS:
      *out_aux_usage = res->aux.usage;
      *out_clear_supported = false;
      break;
620
621
622
623
624
625
626
   default:
      *out_aux_usage = ISL_AUX_USAGE_NONE;
      *out_clear_supported = false;
      break;
   }
}

Kenneth Graunke's avatar
Kenneth Graunke committed
627
/**
628
 * Perform a GPU-based raw memory copy between compatible view classes.
Kenneth Graunke's avatar
Kenneth Graunke committed
629
 *
630
631
632
633
 * Does not perform any flushing - the new data may still be left in the
 * render cache, and old data may remain in other caches.
 *
 * Wraps blorp_copy() and blorp_buffer_copy().
Kenneth Graunke's avatar
Kenneth Graunke committed
634
 */
635
636
637
638
639
640
641
642
643
void
iris_copy_region(struct blorp_context *blorp,
                 struct iris_batch *batch,
                 struct pipe_resource *dst,
                 unsigned dst_level,
                 unsigned dstx, unsigned dsty, unsigned dstz,
                 struct pipe_resource *src,
                 unsigned src_level,
                 const struct pipe_box *src_box)
Kenneth Graunke's avatar
Kenneth Graunke committed
644
{
645
   struct blorp_batch blorp_batch;
646
647
   struct iris_context *ice = blorp->driver_ctx;
   struct iris_screen *screen = (void *) ice->ctx.screen;
648
649
650
651
652
   struct iris_resource *src_res = (void *) src;
   struct iris_resource *dst_res = (void *) dst;

   enum isl_aux_usage src_aux_usage, dst_aux_usage;
   bool src_clear_supported, dst_clear_supported;
653
   get_copy_region_aux_settings(ice, src_res, &src_aux_usage,
654
                                &src_clear_supported, false);
655
   get_copy_region_aux_settings(ice, dst_res, &dst_aux_usage,
656
                                &dst_clear_supported, true);
657

658
   if (iris_batch_references(batch, src_res->bo))
659
      tex_cache_flush_hack(batch, ISL_FORMAT_UNSUPPORTED, src_res->surf.format);
660

661
   if (dst->target == PIPE_BUFFER)
662
      util_range_add(&dst_res->base, &dst_res->valid_buffer_range, dstx, dstx + src_box->width);
663

664
665
666
667
668
669
   if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
      struct blorp_address src_addr = {
         .buffer = iris_resource_bo(src), .offset = src_box->x,
      };
      struct blorp_address dst_addr = {
         .buffer = iris_resource_bo(dst), .offset = dstx,
670
         .reloc_flags = EXEC_OBJECT_WRITE,
671
672
      };

673
674
675
676
677
      iris_emit_buffer_barrier_for(batch, iris_resource_bo(src),
                                   IRIS_DOMAIN_OTHER_READ);
      iris_emit_buffer_barrier_for(batch, iris_resource_bo(dst),
                                   IRIS_DOMAIN_RENDER_WRITE);

678
679
      iris_batch_maybe_flush(batch, 1500);

680
      iris_batch_sync_region_start(batch);
681
      blorp_batch_init(&ice->blorp, &blorp_batch, batch, 0);
682
      blorp_buffer_copy(&blorp_batch, src_addr, dst_addr, src_box->width);
683
      blorp_batch_finish(&blorp_batch);
684
      iris_batch_sync_region_end(batch);
685
686
687
688
   } else {
      // XXX: what about one surface being a buffer and not the other?

      struct blorp_surf src_surf, dst_surf;
689
      iris_blorp_surf_for_resource(&screen->isl_dev, &src_surf,
690
                                   src, src_aux_usage, src_level, false);
691
      iris_blorp_surf_for_resource(&screen->isl_dev, &dst_surf,
692
                                   dst, dst_aux_usage, dst_level, true);
693

694
      iris_resource_prepare_access(ice, src_res, src_level, 1,
695
696
                                   src_box->z, src_box->depth,
                                   src_aux_usage, src_clear_supported);
697
      iris_resource_prepare_access(ice, dst_res, dst_level, 1,
698
699
700
                                   dstz, src_box->depth,
                                   dst_aux_usage, dst_clear_supported);

701
702
703
704
705
      iris_emit_buffer_barrier_for(batch, iris_resource_bo(src),
                                   IRIS_DOMAIN_OTHER_READ);
      iris_emit_buffer_barrier_for(batch, iris_resource_bo(dst),
                                   IRIS_DOMAIN_RENDER_WRITE);

706
707
      blorp_batch_init(&ice->blorp, &blorp_batch, batch, 0);

708
709
      for (int slice = 0; slice < src_box->depth; slice++) {
         iris_batch_maybe_flush(batch, 1500);
710

711
         iris_batch_sync_region_start(batch);
712
713
714
715
         blorp_copy(&blorp_batch, &src_surf, src_level, src_box->z + slice,
                    &dst_surf, dst_level, dstz + slice,
                    src_box->x, src_box->y, dstx, dsty,
                    src_box->width, src_box->height);
716
         iris_batch_sync_region_end(batch);
717
      }
718
      blorp_batch_finish(&blorp_batch);
719

720
721
722
      iris_resource_finish_write(ice, dst_res, dst_level, dstz,
                                 src_box->depth, dst_aux_usage);
   }
723

724
   tex_cache_flush_hack(batch, ISL_FORMAT_UNSUPPORTED, src_res->surf.format);
Kenneth Graunke's avatar
Kenneth Graunke committed
725
726
}

727
728
729
730
731
732
733
734
735
736
737
738
739
static struct iris_batch *
get_preferred_batch(struct iris_context *ice, struct iris_bo *bo)
{
   /* If the compute batch is already using this buffer, we'd prefer to
    * continue queueing in the compute batch.
    */
   if (iris_batch_references(&ice->batches[IRIS_BATCH_COMPUTE], bo))
      return &ice->batches[IRIS_BATCH_COMPUTE];

   /* Otherwise default to the render batch. */
   return &ice->batches[IRIS_BATCH_RENDER];
}

740
741
742
743
744
745
746
747
748

/**
 * The pipe->resource_copy_region() driver hook.
 *
 * This implements ARB_copy_image semantics - a raw memory copy between
 * compatible view classes.
 */
static void
iris_resource_copy_region(struct pipe_context *ctx,
749
                          struct pipe_resource *p_dst,
750
751
                          unsigned dst_level,
                          unsigned dstx, unsigned dsty, unsigned dstz,
752
                          struct pipe_resource *p_src,
753
754
755
756
                          unsigned src_level,
                          const struct pipe_box *src_box)
{
   struct iris_context *ice = (void *) ctx;
757
   struct iris_screen *screen = (void *) ctx->screen;
758
   struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER];
759
760
761
762
763
764
765
   struct iris_resource *src = (void *) p_src;
   struct iris_resource *dst = (void *) p_dst;

   if (iris_resource_unfinished_aux_import(src))
      iris_resource_finish_aux_import(ctx->screen, src);
   if (iris_resource_unfinished_aux_import(dst))
      iris_resource_finish_aux_import(ctx->screen, dst);
766

767
   /* Use MI_COPY_MEM_MEM for tiny (<= 16 byte, % 4) buffer copies. */
768
   if (p_src->target == PIPE_BUFFER && p_dst->target == PIPE_BUFFER &&
769
       (src_box->width % 4 == 0) && src_box->width <= 16) {
770
      struct iris_bo *dst_bo = iris_resource_bo(p_dst);
771
772
773
774
775
      batch = get_preferred_batch(ice, dst_bo);
      iris_batch_maybe_flush(batch, 24 + 5 * (src_box->width / 4));
      iris_emit_pipe_control_flush(batch,
                                   "stall for MI_COPY_MEM_MEM copy_region",
                                   PIPE_CONTROL_CS_STALL);
776
777
      screen->vtbl.copy_mem_mem(batch, dst_bo, dstx, iris_resource_bo(p_src),
                                src_box->x, src_box->width);
778
779
780
      return;
   }

781
782
   iris_copy_region(&ice->blorp, batch, p_dst, dst_level, dstx, dsty, dstz,
                    p_src, src_level, src_box);
783

784
785
   if (util_format_is_depth_and_stencil(p_dst->format) &&
       util_format_has_stencil(util_format_description(p_src->format))) {
786
      struct iris_resource *junk, *s_src_res, *s_dst_res;
787
788
      iris_get_depth_stencil_resources(p_src, &junk, &s_src_res);
      iris_get_depth_stencil_resources(p_dst, &junk, &s_dst_res);
789
790
791
792

      iris_copy_region(&ice->blorp, batch, &s_dst_res->base, dst_level, dstx,
                       dsty, dstz, &s_src_res->base, src_level, src_box);
   }
793

794
   iris_flush_and_dirty_for_history(ice, batch, dst,
795
                                    PIPE_CONTROL_RENDER_TARGET_FLUSH,
796
                                    "cache history: post copy_region");
797
798
}

799
800
801
802
void
iris_init_blit_functions(struct pipe_context *ctx)
{
   ctx->blit = iris_blit;
Kenneth Graunke's avatar
Kenneth Graunke committed
803
   ctx->resource_copy_region = iris_resource_copy_region;
804
}