1/* 2 * Copyright © 2017 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 18 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 19 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 20 * DEALINGS IN THE SOFTWARE. 21 */ 22 23#include <stdio.h> 24#include "pipe/p_defines.h" 25#include "pipe/p_state.h" 26#include "pipe/p_context.h" 27#include "pipe/p_screen.h" 28#include "util/u_format.h" 29#include "util/u_inlines.h" 30#include "util/ralloc.h" 31#include "intel/blorp/blorp.h" 32#include "iris_context.h" 33#include "iris_resource.h" 34#include "iris_screen.h" 35 36/** 37 * Helper function for handling mirror image blits. 38 * 39 * If coord0 > coord1, swap them and return "true" (mirrored). 40 */ 41static bool 42apply_mirror(float *coord0, float *coord1) 43{ 44 if (*coord0 > *coord1) { 45 float tmp = *coord0; 46 *coord0 = *coord1; 47 *coord1 = tmp; 48 return true; 49 } 50 return false; 51} 52 53/** 54 * Compute the number of pixels to clip for each side of a rect 55 * 56 * \param x0 The rect's left coordinate 57 * \param y0 The rect's bottom coordinate 58 * \param x1 The rect's right coordinate 59 * \param y1 The rect's top coordinate 60 * \param min_x The clipping region's left coordinate 61 * \param min_y The clipping region's bottom coordinate 62 * \param max_x The clipping region's right coordinate 63 * \param max_y The clipping region's top coordinate 64 * \param clipped_x0 The number of pixels to clip from the left side 65 * \param clipped_y0 The number of pixels to clip from the bottom side 66 * \param clipped_x1 The number of pixels to clip from the right side 67 * \param clipped_y1 The number of pixels to clip from the top side 68 * 69 * \return false if we clip everything away, true otherwise 70 */ 71static inline bool 72compute_pixels_clipped(float x0, float y0, float x1, float y1, 73 float min_x, float min_y, float max_x, float max_y, 74 float *clipped_x0, float *clipped_y0, 75 float *clipped_x1, float *clipped_y1) 76{ 77 /* If we are going to clip everything away, stop. */ 78 if (!(min_x <= max_x && 79 min_y <= max_y && 80 x0 <= max_x && 81 y0 <= max_y && 82 min_x <= x1 && 83 min_y <= y1 && 84 x0 <= x1 && 85 y0 <= y1)) { 86 return false; 87 } 88 89 if (x0 < min_x) 90 *clipped_x0 = min_x - x0; 91 else 92 *clipped_x0 = 0; 93 if (max_x < x1) 94 *clipped_x1 = x1 - max_x; 95 else 96 *clipped_x1 = 0; 97 98 if (y0 < min_y) 99 *clipped_y0 = min_y - y0; 100 else 101 *clipped_y0 = 0; 102 if (max_y < y1) 103 *clipped_y1 = y1 - max_y; 104 else 105 *clipped_y1 = 0; 106 107 return true; 108} 109 110/** 111 * Clips a coordinate (left, right, top or bottom) for the src or dst rect 112 * (whichever requires the largest clip) and adjusts the coordinate 113 * for the other rect accordingly. 114 * 115 * \param mirror true if mirroring is required 116 * \param src the source rect coordinate (for example src_x0) 117 * \param dst0 the dst rect coordinate (for example dst_x0) 118 * \param dst1 the opposite dst rect coordinate (for example dst_x1) 119 * \param clipped_dst0 number of pixels to clip from the dst coordinate 120 * \param clipped_dst1 number of pixels to clip from the opposite dst coordinate 121 * \param scale the src vs dst scale involved for that coordinate 122 * \param is_left_or_bottom true if we are clipping the left or bottom sides 123 * of the rect. 124 */ 125static void 126clip_coordinates(bool mirror, 127 float *src, float *dst0, float *dst1, 128 float clipped_dst0, 129 float clipped_dst1, 130 float scale, 131 bool is_left_or_bottom) 132{ 133 /* When clipping we need to add or subtract pixels from the original 134 * coordinates depending on whether we are acting on the left/bottom 135 * or right/top sides of the rect respectively. We assume we have to 136 * add them in the code below, and multiply by -1 when we should 137 * subtract. 138 */ 139 int mult = is_left_or_bottom ? 1 : -1; 140 141 if (!mirror) { 142 *dst0 += clipped_dst0 * mult; 143 *src += clipped_dst0 * scale * mult; 144 } else { 145 *dst1 -= clipped_dst1 * mult; 146 *src += clipped_dst1 * scale * mult; 147 } 148} 149 150/** 151 * Apply a scissor rectangle to blit coordinates. 152 * 153 * Returns true if the blit was entirely scissored away. 154 */ 155static bool 156apply_blit_scissor(const struct pipe_scissor_state *scissor, 157 float *src_x0, float *src_y0, 158 float *src_x1, float *src_y1, 159 float *dst_x0, float *dst_y0, 160 float *dst_x1, float *dst_y1, 161 bool mirror_x, bool mirror_y) 162{ 163 float clip_dst_x0, clip_dst_x1, clip_dst_y0, clip_dst_y1; 164 165 /* Compute number of pixels to scissor away. */ 166 if (!compute_pixels_clipped(*dst_x0, *dst_y0, *dst_x1, *dst_y1, 167 scissor->minx, scissor->miny, 168 scissor->maxx, scissor->maxy, 169 &clip_dst_x0, &clip_dst_y0, 170 &clip_dst_x1, &clip_dst_y1)) 171 return true; 172 173 // XXX: comments assume source clipping, which we don't do 174 175 /* When clipping any of the two rects we need to adjust the coordinates 176 * in the other rect considering the scaling factor involved. To obtain 177 * the best precision we want to make sure that we only clip once per 178 * side to avoid accumulating errors due to the scaling adjustment. 179 * 180 * For example, if src_x0 and dst_x0 need both to be clipped we want to 181 * avoid the situation where we clip src_x0 first, then adjust dst_x0 182 * accordingly but then we realize that the resulting dst_x0 still needs 183 * to be clipped, so we clip dst_x0 and adjust src_x0 again. Because we are 184 * applying scaling factors to adjust the coordinates in each clipping 185 * pass we lose some precision and that can affect the results of the 186 * blorp blit operation slightly. What we want to do here is detect the 187 * rect that we should clip first for each side so that when we adjust 188 * the other rect we ensure the resulting coordinate does not need to be 189 * clipped again. 190 * 191 * The code below implements this by comparing the number of pixels that 192 * we need to clip for each side of both rects considering the scales 193 * involved. For example, clip_src_x0 represents the number of pixels 194 * to be clipped for the src rect's left side, so if clip_src_x0 = 5, 195 * clip_dst_x0 = 4 and scale_x = 2 it means that we are clipping more 196 * from the dst rect so we should clip dst_x0 only and adjust src_x0. 197 * This is because clipping 4 pixels in the dst is equivalent to 198 * clipping 4 * 2 = 8 > 5 in the src. 199 */ 200 201 if (*src_x0 == *src_x1 || *src_y0 == *src_y1 202 || *dst_x0 == *dst_x1 || *dst_y0 == *dst_y1) 203 return true; 204 205 float scale_x = (float) (*src_x1 - *src_x0) / (*dst_x1 - *dst_x0); 206 float scale_y = (float) (*src_y1 - *src_y0) / (*dst_y1 - *dst_y0); 207 208 /* Clip left side */ 209 clip_coordinates(mirror_x, src_x0, dst_x0, dst_x1, 210 clip_dst_x0, clip_dst_x1, scale_x, true); 211 212 /* Clip right side */ 213 clip_coordinates(mirror_x, src_x1, dst_x1, dst_x0, 214 clip_dst_x1, clip_dst_x0, scale_x, false); 215 216 /* Clip bottom side */ 217 clip_coordinates(mirror_y, src_y0, dst_y0, dst_y1, 218 clip_dst_y0, clip_dst_y1, scale_y, true); 219 220 /* Clip top side */ 221 clip_coordinates(mirror_y, src_y1, dst_y1, dst_y0, 222 clip_dst_y1, clip_dst_y0, scale_y, false); 223 224 /* Check for invalid bounds 225 * Can't blit for 0-dimensions 226 */ 227 return *src_x0 == *src_x1 || *src_y0 == *src_y1 228 || *dst_x0 == *dst_x1 || *dst_y0 == *dst_y1; 229} 230 231void 232iris_blorp_surf_for_resource(struct iris_vtable *vtbl, 233 struct blorp_surf *surf, 234 struct pipe_resource *p_res, 235 enum isl_aux_usage aux_usage, 236 unsigned level, 237 bool is_render_target) 238{ 239 struct iris_resource *res = (void *) p_res; 240 241 if (aux_usage == ISL_AUX_USAGE_HIZ && 242 !iris_resource_level_has_hiz(res, level)) 243 aux_usage = ISL_AUX_USAGE_NONE; 244 245 *surf = (struct blorp_surf) { 246 .surf = &res->surf, 247 .addr = (struct blorp_address) { 248 .buffer = res->bo, 249 .offset = 0, // XXX: ??? 250 .reloc_flags = is_render_target ? EXEC_OBJECT_WRITE : 0, 251 .mocs = vtbl->mocs(res->bo), 252 }, 253 .aux_usage = aux_usage, 254 }; 255 256 if (aux_usage != ISL_AUX_USAGE_NONE) { 257 surf->aux_surf = &res->aux.surf; 258 surf->aux_addr = (struct blorp_address) { 259 .buffer = res->aux.bo, 260 .offset = res->aux.offset, 261 .reloc_flags = is_render_target ? EXEC_OBJECT_WRITE : 0, 262 .mocs = vtbl->mocs(res->bo), 263 }; 264 surf->clear_color = 265 iris_resource_get_clear_color(res, NULL, NULL); 266 surf->clear_color_addr = (struct blorp_address) { 267 .buffer = res->aux.clear_color_bo, 268 .offset = res->aux.clear_color_offset, 269 .reloc_flags = 0, 270 .mocs = vtbl->mocs(res->aux.clear_color_bo), 271 }; 272 } 273 274 // XXX: ASTC 275} 276 277static void 278tex_cache_flush_hack(struct iris_batch *batch) 279{ 280 /* The hardware seems to have issues with having a two different 281 * format views of the same texture in the sampler cache at the 282 * same time. It's unclear exactly what the issue is but it hurts 283 * blits and copies particularly badly because they often reinterpret 284 * formats. We badly need better understanding of the sampler issue 285 * and a better fix but this works for now and fixes CTS tests. 286 * 287 * If the BO hasn't been referenced yet this batch, we assume that the 288 * texture cache doesn't contain any relevant data nor need flushing. 289 * 290 * TODO: Remove this hack! 291 */ 292 iris_emit_pipe_control_flush(batch, 293 PIPE_CONTROL_CS_STALL | 294 PIPE_CONTROL_TEXTURE_CACHE_INVALIDATE); 295} 296 297/** 298 * The pipe->blit() driver hook. 299 * 300 * This performs a blit between two surfaces, which copies data but may 301 * also perform format conversion, scaling, flipping, and so on. 302 */ 303static void 304iris_blit(struct pipe_context *ctx, const struct pipe_blit_info *info) 305{ 306 struct iris_context *ice = (void *) ctx; 307 struct iris_screen *screen = (struct iris_screen *)ctx->screen; 308 const struct gen_device_info *devinfo = &screen->devinfo; 309 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER]; 310 enum blorp_batch_flags blorp_flags = 0; 311 struct iris_resource *src_res = (void *) info->src.resource; 312 struct iris_resource *dst_res = (void *) info->dst.resource; 313 314 /* We don't support color masking. */ 315 assert((info->mask & PIPE_MASK_RGBA) == PIPE_MASK_RGBA || 316 (info->mask & PIPE_MASK_RGBA) == 0); 317 318 if (info->render_condition_enable) { 319 if (ice->state.predicate == IRIS_PREDICATE_STATE_DONT_RENDER) 320 return; 321 322 if (ice->state.predicate == IRIS_PREDICATE_STATE_USE_BIT) 323 blorp_flags |= BLORP_BATCH_PREDICATE_ENABLE; 324 } 325 326 struct iris_format_info src_fmt = 327 iris_format_for_usage(devinfo, info->src.format, 328 ISL_SURF_USAGE_TEXTURE_BIT); 329 enum isl_aux_usage src_aux_usage = 330 iris_resource_texture_aux_usage(ice, src_res, src_fmt.fmt, 0); 331 332 if (src_aux_usage == ISL_AUX_USAGE_HIZ) 333 src_aux_usage = ISL_AUX_USAGE_NONE; 334 335 bool src_clear_supported = src_aux_usage != ISL_AUX_USAGE_NONE && 336 src_res->surf.format == src_fmt.fmt; 337 338 iris_resource_prepare_access(ice, batch, src_res, info->src.level, 1, 339 info->src.box.z, info->src.box.depth, 340 src_aux_usage, src_clear_supported); 341 342 struct iris_format_info dst_fmt = 343 iris_format_for_usage(devinfo, info->dst.format, 344 ISL_SURF_USAGE_RENDER_TARGET_BIT); 345 enum isl_aux_usage dst_aux_usage = 346 iris_resource_render_aux_usage(ice, dst_res, dst_fmt.fmt, false, false); 347 bool dst_clear_supported = dst_aux_usage != ISL_AUX_USAGE_NONE; 348 349 struct blorp_surf src_surf, dst_surf; 350 iris_blorp_surf_for_resource(&ice->vtbl, &src_surf, info->src.resource, 351 src_aux_usage, info->src.level, false); 352 iris_blorp_surf_for_resource(&ice->vtbl, &dst_surf, info->dst.resource, 353 dst_aux_usage, info->dst.level, true); 354 355 iris_resource_prepare_access(ice, batch, dst_res, info->dst.level, 1, 356 info->dst.box.z, info->dst.box.depth, 357 dst_aux_usage, dst_clear_supported); 358 359 float src_x0 = info->src.box.x; 360 float src_x1 = info->src.box.x + info->src.box.width; 361 float src_y0 = info->src.box.y; 362 float src_y1 = info->src.box.y + info->src.box.height; 363 float dst_x0 = info->dst.box.x; 364 float dst_x1 = info->dst.box.x + info->dst.box.width; 365 float dst_y0 = info->dst.box.y; 366 float dst_y1 = info->dst.box.y + info->dst.box.height; 367 bool mirror_x = apply_mirror(&src_x0, &src_x1); 368 bool mirror_y = apply_mirror(&src_y0, &src_y1); 369 enum blorp_filter filter; 370 371 if (info->scissor_enable) { 372 bool noop = apply_blit_scissor(&info->scissor, 373 &src_x0, &src_y0, &src_x1, &src_y1, 374 &dst_x0, &dst_y0, &dst_x1, &dst_y1, 375 mirror_x, mirror_y); 376 if (noop) 377 return; 378 } 379 380 if (abs(info->dst.box.width) == abs(info->src.box.width) && 381 abs(info->dst.box.height) == abs(info->src.box.height)) { 382 if (src_surf.surf->samples > 1 && dst_surf.surf->samples <= 1) { 383 /* The OpenGL ES 3.2 specification, section 16.2.1, says: 384 * 385 * "If the read framebuffer is multisampled (its effective 386 * value of SAMPLE_BUFFERS is one) and the draw framebuffer 387 * is not (its value of SAMPLE_BUFFERS is zero), the samples 388 * corresponding to each pixel location in the source are 389 * converted to a single sample before being written to the 390 * destination. The filter parameter is ignored. If the 391 * source formats are integer types or stencil values, a 392 * single sample’s value is selected for each pixel. If the 393 * source formats are floating-point or normalized types, 394 * the sample values for each pixel are resolved in an 395 * implementation-dependent manner. If the source formats 396 * are depth values, sample values are resolved in an 397 * implementation-dependent manner where the result will be 398 * between the minimum and maximum depth values in the pixel." 399 * 400 * When selecting a single sample, we always choose sample 0. 401 */ 402 if (util_format_is_depth_or_stencil(info->src.format) || 403 util_format_is_pure_integer(info->src.format)) { 404 filter = BLORP_FILTER_SAMPLE_0; 405 } else { 406 filter = BLORP_FILTER_AVERAGE; 407 } 408 } else { 409 /* The OpenGL 4.6 specification, section 18.3.1, says: 410 * 411 * "If the source and destination dimensions are identical, 412 * no filtering is applied." 413 * 414 * Using BLORP_FILTER_NONE will also handle the upsample case by 415 * replicating the one value in the source to all values in the 416 * destination. 417 */ 418 filter = BLORP_FILTER_NONE; 419 } 420 } else if (info->filter == PIPE_TEX_FILTER_LINEAR) { 421 filter = BLORP_FILTER_BILINEAR; 422 } else { 423 filter = BLORP_FILTER_NEAREST; 424 } 425 426 bool flush_hack = src_fmt.fmt != src_res->surf.format && 427 iris_batch_references(batch, src_res->bo); 428 429 if (flush_hack) 430 tex_cache_flush_hack(batch); 431 432 if (dst_res->base.target == PIPE_BUFFER) 433 util_range_add(&dst_res->valid_buffer_range, dst_x0, dst_x1); 434 435 struct blorp_batch blorp_batch; 436 blorp_batch_init(&ice->blorp, &blorp_batch, batch, blorp_flags); 437 438 unsigned main_mask; 439 if (util_format_is_depth_or_stencil(info->dst.format)) 440 main_mask = PIPE_MASK_Z; 441 else 442 main_mask = PIPE_MASK_RGBA; 443 444 if (info->mask & main_mask) { 445 for (int slice = 0; slice < info->dst.box.depth; slice++) { 446 iris_batch_maybe_flush(batch, 1500); 447 448 blorp_blit(&blorp_batch, 449 &src_surf, info->src.level, info->src.box.z + slice, 450 src_fmt.fmt, src_fmt.swizzle, 451 &dst_surf, info->dst.level, info->dst.box.z + slice, 452 dst_fmt.fmt, dst_fmt.swizzle, 453 src_x0, src_y0, src_x1, src_y1, 454 dst_x0, dst_y0, dst_x1, dst_y1, 455 filter, mirror_x, mirror_y); 456 } 457 } 458 459 if ((info->mask & PIPE_MASK_S) && 460 util_format_has_stencil(util_format_description(info->dst.format)) && 461 util_format_has_stencil(util_format_description(info->src.format))) { 462 struct iris_resource *src_res, *dst_res, *junk; 463 iris_get_depth_stencil_resources(info->src.resource, &junk, &src_res); 464 iris_get_depth_stencil_resources(info->dst.resource, &junk, &dst_res); 465 iris_blorp_surf_for_resource(&ice->vtbl, &src_surf, &src_res->base, 466 ISL_AUX_USAGE_NONE, info->src.level, false); 467 iris_blorp_surf_for_resource(&ice->vtbl, &dst_surf, &dst_res->base, 468 ISL_AUX_USAGE_NONE, info->dst.level, true); 469 470 for (int slice = 0; slice < info->dst.box.depth; slice++) { 471 iris_batch_maybe_flush(batch, 1500); 472 473 blorp_blit(&blorp_batch, 474 &src_surf, info->src.level, info->src.box.z + slice, 475 ISL_FORMAT_R8_UINT, ISL_SWIZZLE_IDENTITY, 476 &dst_surf, info->dst.level, info->dst.box.z + slice, 477 ISL_FORMAT_R8_UINT, ISL_SWIZZLE_IDENTITY, 478 src_x0, src_y0, src_x1, src_y1, 479 dst_x0, dst_y0, dst_x1, dst_y1, 480 filter, mirror_x, mirror_y); 481 } 482 } 483 484 blorp_batch_finish(&blorp_batch); 485 486 if (flush_hack) 487 tex_cache_flush_hack(batch); 488 489 iris_resource_finish_write(ice, dst_res, info->dst.level, info->dst.box.z, 490 info->dst.box.depth, dst_aux_usage); 491 492 iris_flush_and_dirty_for_history(ice, batch, (struct iris_resource *) 493 info->dst.resource); 494} 495 496static void 497get_copy_region_aux_settings(const struct gen_device_info *devinfo, 498 struct iris_resource *res, 499 enum isl_aux_usage *out_aux_usage, 500 bool *out_clear_supported) 501{ 502 switch (res->aux.usage) { 503 case ISL_AUX_USAGE_MCS: 504 case ISL_AUX_USAGE_CCS_E: 505 *out_aux_usage = res->aux.usage; 506 /* Prior to Gen9, fast-clear only supported 0/1 clear colors. Since 507 * we're going to re-interpret the format as an integer format possibly 508 * with a different number of components, we can't handle clear colors 509 * until Gen9. 510 */ 511 *out_clear_supported = devinfo->gen >= 9; 512 break; 513 default: 514 *out_aux_usage = ISL_AUX_USAGE_NONE; 515 *out_clear_supported = false; 516 break; 517 } 518} 519 520/** 521 * Perform a GPU-based raw memory copy between compatible view classes. 522 * 523 * Does not perform any flushing - the new data may still be left in the 524 * render cache, and old data may remain in other caches. 525 * 526 * Wraps blorp_copy() and blorp_buffer_copy(). 527 */ 528void 529iris_copy_region(struct blorp_context *blorp, 530 struct iris_batch *batch, 531 struct pipe_resource *dst, 532 unsigned dst_level, 533 unsigned dstx, unsigned dsty, unsigned dstz, 534 struct pipe_resource *src, 535 unsigned src_level, 536 const struct pipe_box *src_box) 537{ 538 struct blorp_batch blorp_batch; 539 struct iris_context *ice = blorp->driver_ctx; 540 struct iris_screen *screen = (void *) ice->ctx.screen; 541 const struct gen_device_info *devinfo = &screen->devinfo; 542 struct iris_resource *src_res = (void *) src; 543 struct iris_resource *dst_res = (void *) dst; 544 545 enum isl_aux_usage src_aux_usage, dst_aux_usage; 546 bool src_clear_supported, dst_clear_supported; 547 get_copy_region_aux_settings(devinfo, src_res, &src_aux_usage, 548 &src_clear_supported); 549 get_copy_region_aux_settings(devinfo, dst_res, &dst_aux_usage, 550 &dst_clear_supported); 551 552 bool flush_hack = iris_batch_references(batch, src_res->bo); 553 if (flush_hack) 554 tex_cache_flush_hack(batch); 555 556 if (dst->target == PIPE_BUFFER) 557 util_range_add(&dst_res->valid_buffer_range, dstx, dstx + src_box->width); 558 559 if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) { 560 struct blorp_address src_addr = { 561 .buffer = iris_resource_bo(src), .offset = src_box->x, 562 }; 563 struct blorp_address dst_addr = { 564 .buffer = iris_resource_bo(dst), .offset = dstx, 565 .reloc_flags = EXEC_OBJECT_WRITE, 566 }; 567 568 iris_batch_maybe_flush(batch, 1500); 569 570 blorp_batch_init(&ice->blorp, &blorp_batch, batch, 0); 571 blorp_buffer_copy(&blorp_batch, src_addr, dst_addr, src_box->width); 572 blorp_batch_finish(&blorp_batch); 573 574 iris_flush_and_dirty_for_history(ice, batch, 575 (struct iris_resource *) dst); 576 } else { 577 // XXX: what about one surface being a buffer and not the other? 578 579 struct blorp_surf src_surf, dst_surf; 580 iris_blorp_surf_for_resource(&ice->vtbl, &src_surf, src, src_aux_usage, 581 src_level, false); 582 iris_blorp_surf_for_resource(&ice->vtbl, &dst_surf, dst, dst_aux_usage, 583 dst_level, true); 584 585 iris_resource_prepare_access(ice, batch, src_res, src_level, 1, 586 src_box->z, src_box->depth, 587 src_aux_usage, src_clear_supported); 588 iris_resource_prepare_access(ice, batch, dst_res, dst_level, 1, 589 dstz, src_box->depth, 590 dst_aux_usage, dst_clear_supported); 591 592 blorp_batch_init(&ice->blorp, &blorp_batch, batch, 0); 593 594 for (int slice = 0; slice < src_box->depth; slice++) { 595 iris_batch_maybe_flush(batch, 1500); 596 597 blorp_copy(&blorp_batch, &src_surf, src_level, src_box->z + slice, 598 &dst_surf, dst_level, dstz + slice, 599 src_box->x, src_box->y, dstx, dsty, 600 src_box->width, src_box->height); 601 } 602 blorp_batch_finish(&blorp_batch); 603 604 iris_resource_finish_write(ice, dst_res, dst_level, dstz, 605 src_box->depth, dst_aux_usage); 606 } 607 608 if (flush_hack) 609 tex_cache_flush_hack(batch); 610} 611 612 613/** 614 * The pipe->resource_copy_region() driver hook. 615 * 616 * This implements ARB_copy_image semantics - a raw memory copy between 617 * compatible view classes. 618 */ 619static void 620iris_resource_copy_region(struct pipe_context *ctx, 621 struct pipe_resource *dst, 622 unsigned dst_level, 623 unsigned dstx, unsigned dsty, unsigned dstz, 624 struct pipe_resource *src, 625 unsigned src_level, 626 const struct pipe_box *src_box) 627{ 628 struct iris_context *ice = (void *) ctx; 629 struct iris_batch *batch = &ice->batches[IRIS_BATCH_RENDER]; 630 631 iris_copy_region(&ice->blorp, batch, dst, dst_level, dstx, dsty, dstz, 632 src, src_level, src_box); 633} 634 635void 636iris_init_blit_functions(struct pipe_context *ctx) 637{ 638 ctx->blit = iris_blit; 639 ctx->resource_copy_region = iris_resource_copy_region; 640} 641