static struct pipe_transfer* r300_get_tex_transfer(struct pipe_screen *screen, struct pipe_texture *texture, unsigned face, unsigned level, unsigned zslice, enum pipe_transfer_usage usage, unsigned x, unsigned y, unsigned w, unsigned h) { struct r300_texture *tex = (struct r300_texture *)texture; struct r300_transfer *trans; struct r300_screen *rscreen = r300_screen(screen); unsigned offset; offset = r300_texture_get_offset(tex, level, zslice, face); /* in bytes */ trans = CALLOC_STRUCT(r300_transfer); if (trans) { pipe_texture_reference(&trans->transfer.texture, texture); trans->transfer.x = x; trans->transfer.y = y; trans->transfer.width = w; trans->transfer.height = h; trans->transfer.stride = r300_texture_get_stride(rscreen, tex, level); trans->transfer.usage = usage; trans->transfer.zslice = zslice; trans->transfer.face = face; trans->offset = offset; } return &trans->transfer; }
/* Not required to implement u_resource_vtbl, consider moving to another file: */ struct pipe_surface* r300_get_tex_surface(struct pipe_screen* screen, struct pipe_resource* texture, unsigned face, unsigned level, unsigned zslice, unsigned flags) { struct r300_texture* tex = r300_texture(texture); struct r300_surface* surface = CALLOC_STRUCT(r300_surface); if (surface) { uint32_t offset, tile_height; pipe_reference_init(&surface->base.reference, 1); pipe_resource_reference(&surface->base.texture, texture); surface->base.format = texture->format; surface->base.width = u_minify(texture->width0, level); surface->base.height = u_minify(texture->height0, level); surface->base.usage = flags; surface->base.zslice = zslice; surface->base.face = face; surface->base.level = level; surface->buffer = tex->buffer; /* Prefer VRAM if there are multiple domains to choose from. */ surface->domain = tex->domain; if (surface->domain & R300_DOMAIN_VRAM) surface->domain &= ~R300_DOMAIN_GTT; surface->offset = r300_texture_get_offset(&tex->desc, level, zslice, face); surface->pitch = tex->fb_state.pitch[level]; surface->format = tex->fb_state.format; /* Parameters for the CBZB clear. */ surface->cbzb_allowed = tex->desc.cbzb_allowed[level]; surface->cbzb_width = align(surface->base.width, 64); /* Height must be aligned to the size of a tile. */ tile_height = r300_get_pixel_alignment(tex->desc.b.b.format, tex->desc.b.b.nr_samples, tex->desc.microtile, tex->desc.macrotile[level], DIM_HEIGHT, 0); surface->cbzb_height = align((surface->base.height + 1) / 2, tile_height); /* Offset must be aligned to 2K and must point at the beginning * of a scanline. */ offset = surface->offset + tex->desc.stride_in_bytes[level] * surface->cbzb_height; surface->cbzb_midpoint_offset = offset & ~2047; surface->cbzb_pitch = surface->pitch & 0x1ffffc; if (util_format_get_blocksizebits(surface->base.format) == 32) surface->cbzb_format = R300_DEPTHFORMAT_24BIT_INT_Z_8BIT_STENCIL; else surface->cbzb_format = R300_DEPTHFORMAT_16BIT_INT_Z; SCREEN_DBG(r300_screen(screen), DBG_CBZB, "CBZB Allowed: %s, Dim: %ix%i, Misalignment: %i, Micro: %s, Macro: %s\n", surface->cbzb_allowed ? "YES" : " NO", surface->cbzb_width, surface->cbzb_height, offset & 2047, tex->desc.microtile ? "YES" : " NO", tex->desc.macrotile[level] ? "YES" : " NO"); } return &surface->base; }
struct pipe_transfer* r300_texture_get_transfer(struct pipe_context *ctx, struct pipe_resource *texture, unsigned level, unsigned usage, const struct pipe_box *box) { struct r300_context *r300 = r300_context(ctx); struct r300_resource *tex = r300_resource(texture); struct r300_transfer *trans; struct pipe_resource base; boolean referenced_cs, referenced_hw, blittable; const struct util_format_description *desc = util_format_description(texture->format); referenced_cs = r300->rws->cs_is_buffer_referenced(r300->cs, tex->cs_buf); if (referenced_cs) { referenced_hw = TRUE; } else { referenced_hw = r300->rws->buffer_is_busy(tex->buf, RADEON_USAGE_READWRITE); } blittable = desc->layout == UTIL_FORMAT_LAYOUT_PLAIN || desc->layout == UTIL_FORMAT_LAYOUT_S3TC || desc->layout == UTIL_FORMAT_LAYOUT_RGTC; trans = CALLOC_STRUCT(r300_transfer); if (trans) { /* Initialize the transfer object. */ pipe_resource_reference(&trans->transfer.resource, texture); trans->transfer.level = level; trans->transfer.usage = usage; trans->transfer.box = *box; /* If the texture is tiled, we must create a temporary detiled texture * for this transfer. * Also make write transfers pipelined. */ if (tex->tex.microtile || tex->tex.macrotile[level] || (referenced_hw && blittable && !(usage & PIPE_TRANSFER_READ))) { if (r300->blitter->running) { fprintf(stderr, "r300: ERROR: Blitter recursion in texture_get_transfer.\n"); os_break(); } base.target = PIPE_TEXTURE_2D; base.format = texture->format; base.width0 = box->width; base.height0 = box->height; base.depth0 = 1; base.array_size = 1; base.last_level = 0; base.nr_samples = 0; base.usage = PIPE_USAGE_DYNAMIC; base.bind = 0; base.flags = R300_RESOURCE_FLAG_TRANSFER; /* For texture reading, the temporary (detiled) texture is used as * a render target when blitting from a tiled texture. */ if (usage & PIPE_TRANSFER_READ) { base.bind |= PIPE_BIND_RENDER_TARGET; } /* For texture writing, the temporary texture is used as a sampler * when blitting into a tiled texture. */ if (usage & PIPE_TRANSFER_WRITE) { base.bind |= PIPE_BIND_SAMPLER_VIEW; } /* Create the temporary texture. */ trans->linear_texture = r300_resource( ctx->screen->resource_create(ctx->screen, &base)); if (!trans->linear_texture) { /* Oh crap, the thing can't create the texture. * Let's flush and try again. */ r300_flush(ctx, 0, NULL); trans->linear_texture = r300_resource( ctx->screen->resource_create(ctx->screen, &base)); if (!trans->linear_texture) { /* For linear textures, it's safe to fallback to * an unpipelined transfer. */ if (!tex->tex.microtile && !tex->tex.macrotile[level]) { goto unpipelined; } /* Otherwise, go to hell. */ fprintf(stderr, "r300: Failed to create a transfer object, praise.\n"); FREE(trans); return NULL; } } assert(!trans->linear_texture->tex.microtile && !trans->linear_texture->tex.macrotile[0]); /* Set the stride. */ trans->transfer.stride = trans->linear_texture->tex.stride_in_bytes[0]; if (usage & PIPE_TRANSFER_READ) { /* We cannot map a tiled texture directly because the data is * in a different order, therefore we do detiling using a blit. */ r300_copy_from_tiled_texture(ctx, trans); /* Always referenced in the blit. */ r300_flush(ctx, 0, NULL); } return &trans->transfer; } unpipelined: /* Unpipelined transfer. */ trans->transfer.stride = tex->tex.stride_in_bytes[level]; trans->offset = r300_texture_get_offset(tex, level, box->z); if (referenced_cs && !(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) r300_flush(ctx, 0, NULL); return &trans->transfer; } return NULL; }
void * r300_texture_transfer_map(struct pipe_context *ctx, struct pipe_resource *texture, unsigned level, unsigned usage, const struct pipe_box *box, struct pipe_transfer **transfer) { struct r300_context *r300 = r300_context(ctx); struct r300_resource *tex = r300_resource(texture); struct r300_transfer *trans; struct pipe_resource base; boolean referenced_cs, referenced_hw; enum pipe_format format = tex->b.b.format; char *map; referenced_cs = r300->rws->cs_is_buffer_referenced(r300->cs, tex->cs_buf, RADEON_USAGE_READWRITE); if (referenced_cs) { referenced_hw = TRUE; } else { referenced_hw = r300->rws->buffer_is_busy(tex->buf, RADEON_USAGE_READWRITE); } trans = CALLOC_STRUCT(r300_transfer); if (trans) { /* Initialize the transfer object. */ trans->transfer.resource = texture; trans->transfer.level = level; trans->transfer.usage = usage; trans->transfer.box = *box; /* If the texture is tiled, we must create a temporary detiled texture * for this transfer. * Also make write transfers pipelined. */ if (tex->tex.microtile || tex->tex.macrotile[level] || (referenced_hw && !(usage & PIPE_TRANSFER_READ) && r300_is_blit_supported(texture->format))) { if (r300->blitter->running) { fprintf(stderr, "r300: ERROR: Blitter recursion in texture_get_transfer.\n"); os_break(); } base.target = PIPE_TEXTURE_2D; base.format = texture->format; base.width0 = box->width; base.height0 = box->height; base.depth0 = 1; base.array_size = 1; base.last_level = 0; base.nr_samples = 0; base.usage = PIPE_USAGE_STAGING; base.bind = 0; if (usage & PIPE_TRANSFER_READ) { base.bind |= PIPE_BIND_SAMPLER_VIEW; } if (usage & PIPE_TRANSFER_WRITE) { base.bind |= PIPE_BIND_RENDER_TARGET; } base.flags = R300_RESOURCE_FLAG_TRANSFER; /* For texture reading, the temporary (detiled) texture is used as * a render target when blitting from a tiled texture. */ if (usage & PIPE_TRANSFER_READ) { base.bind |= PIPE_BIND_RENDER_TARGET; } /* For texture writing, the temporary texture is used as a sampler * when blitting into a tiled texture. */ if (usage & PIPE_TRANSFER_WRITE) { base.bind |= PIPE_BIND_SAMPLER_VIEW; } /* Create the temporary texture. */ trans->linear_texture = r300_resource( ctx->screen->resource_create(ctx->screen, &base)); if (!trans->linear_texture) { /* Oh crap, the thing can't create the texture. * Let's flush and try again. */ r300_flush(ctx, 0, NULL); trans->linear_texture = r300_resource( ctx->screen->resource_create(ctx->screen, &base)); if (!trans->linear_texture) { fprintf(stderr, "r300: Failed to create a transfer object.\n"); FREE(trans); return NULL; } } assert(!trans->linear_texture->tex.microtile && !trans->linear_texture->tex.macrotile[0]); /* Set the stride. */ trans->transfer.stride = trans->linear_texture->tex.stride_in_bytes[0]; if (usage & PIPE_TRANSFER_READ) { /* We cannot map a tiled texture directly because the data is * in a different order, therefore we do detiling using a blit. */ r300_copy_from_tiled_texture(ctx, trans); /* Always referenced in the blit. */ r300_flush(ctx, 0, NULL); } } else { /* Unpipelined transfer. */ trans->transfer.stride = tex->tex.stride_in_bytes[level]; trans->offset = r300_texture_get_offset(tex, level, box->z); if (referenced_cs && !(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) { r300_flush(ctx, 0, NULL); } } } if (trans->linear_texture) { /* The detiled texture is of the same size as the region being mapped * (no offset needed). */ map = r300->rws->buffer_map(trans->linear_texture->cs_buf, r300->cs, usage); if (!map) { pipe_resource_reference( (struct pipe_resource**)&trans->linear_texture, NULL); FREE(trans); return NULL; } *transfer = &trans->transfer; return map; } else { /* Tiling is disabled. */ map = r300->rws->buffer_map(tex->cs_buf, r300->cs, usage); if (!map) { FREE(trans); return NULL; } *transfer = &trans->transfer; return map + trans->offset + box->y / util_format_get_blockheight(format) * trans->transfer.stride + box->x / util_format_get_blockwidth(format) * util_format_get_blocksize(format); } }
struct pipe_transfer* r300_texture_get_transfer(struct pipe_context *ctx, struct pipe_resource *texture, struct pipe_subresource sr, unsigned usage, const struct pipe_box *box) { struct r300_context *r300 = r300_context(ctx); struct r300_texture *tex = r300_texture(texture); struct r300_transfer *trans; struct pipe_resource base; boolean referenced_cs, referenced_hw, blittable; referenced_cs = r300->rws->cs_is_buffer_referenced(r300->cs, tex->buffer, R300_REF_CS); if (referenced_cs) { referenced_hw = TRUE; } else { referenced_hw = r300->rws->cs_is_buffer_referenced(r300->cs, tex->buffer, R300_REF_HW); } blittable = ctx->screen->is_format_supported( ctx->screen, texture->format, texture->target, 0, PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET, 0); trans = CALLOC_STRUCT(r300_transfer); if (trans) { /* Initialize the transfer object. */ pipe_resource_reference(&trans->transfer.resource, texture); trans->transfer.sr = sr; trans->transfer.usage = usage; trans->transfer.box = *box; /* If the texture is tiled, we must create a temporary detiled texture * for this transfer. * Also make write transfers pipelined. */ if (tex->desc.microtile || tex->desc.macrotile[sr.level] || ((referenced_hw & !(usage & PIPE_TRANSFER_READ)) && blittable)) { base.target = PIPE_TEXTURE_2D; base.format = texture->format; base.width0 = box->width; base.height0 = box->height; base.depth0 = 0; base.last_level = 0; base.nr_samples = 0; base.usage = PIPE_USAGE_DYNAMIC; base.bind = 0; base.flags = R300_RESOURCE_FLAG_TRANSFER; /* For texture reading, the temporary (detiled) texture is used as * a render target when blitting from a tiled texture. */ if (usage & PIPE_TRANSFER_READ) { base.bind |= PIPE_BIND_RENDER_TARGET; } /* For texture writing, the temporary texture is used as a sampler * when blitting into a tiled texture. */ if (usage & PIPE_TRANSFER_WRITE) { base.bind |= PIPE_BIND_SAMPLER_VIEW; } /* Create the temporary texture. */ trans->linear_texture = r300_texture( ctx->screen->resource_create(ctx->screen, &base)); if (!trans->linear_texture) { /* Oh crap, the thing can't create the texture. * Let's flush and try again. */ ctx->flush(ctx, 0, NULL); trans->linear_texture = r300_texture( ctx->screen->resource_create(ctx->screen, &base)); if (!trans->linear_texture) { /* For linear textures, it's safe to fallback to * an unpipelined transfer. */ if (!tex->desc.microtile && !tex->desc.macrotile[sr.level]) { goto unpipelined; } /* Otherwise, go to hell. */ fprintf(stderr, "r300: Failed to create a transfer object, praise.\n"); FREE(trans); return NULL; } } assert(!trans->linear_texture->desc.microtile && !trans->linear_texture->desc.macrotile[0]); /* Set the stride. * * Even though we are using an internal texture for this, * the transfer sr, box and usage parameters still reflect * the arguments received to get_transfer. We just do the * right thing internally. */ trans->transfer.stride = trans->linear_texture->desc.stride_in_bytes[0]; if (usage & PIPE_TRANSFER_READ) { /* We cannot map a tiled texture directly because the data is * in a different order, therefore we do detiling using a blit. */ r300_copy_from_tiled_texture(ctx, trans); /* Always referenced in the blit. */ ctx->flush(ctx, 0, NULL); } return &trans->transfer; } unpipelined: /* Unpipelined transfer. */ trans->transfer.stride = tex->desc.stride_in_bytes[sr.level]; trans->offset = r300_texture_get_offset(&tex->desc, sr.level, box->z, sr.face); if (referenced_cs) ctx->flush(ctx, PIPE_FLUSH_RENDER_CACHE, NULL); return &trans->transfer; } return NULL; }