void radeonGenerateMipmap(GLcontext* ctx, GLenum target, struct gl_texture_object *texObj)
{
radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
struct radeon_bo *bo;
GLuint face = _mesa_tex_target_to_face(target);
radeon_texture_image *baseimage = get_radeon_texture_image(texObj->Image[face][texObj->BaseLevel]);
bo = !baseimage->mt ? baseimage->bo : baseimage->mt->bo;
radeon_print(RADEON_TEXTURE, RADEON_TRACE,
"%s(%p, target %s, tex %p)\n",
__func__, ctx, _mesa_lookup_enum_by_nr(target),
texObj);
if (bo && radeon_bo_is_referenced_by_cs(bo, rmesa->cmdbuf.cs)) {
radeon_print(RADEON_TEXTURE, RADEON_NORMAL,
"%s(%p, tex %p) Trying to generate mipmap for texture "
"in processing by GPU.\n",
__func__, ctx, texObj);
radeon_firevertices(rmesa);
}
if (_mesa_meta_check_generate_mipmap_fallback(ctx, target, texObj)) {
radeon_teximage_map(baseimage, GL_FALSE);
radeon_generate_mipmap(ctx, target, texObj);
radeon_teximage_unmap(baseimage);
} else {
_mesa_meta_GenerateMipmap(ctx, target, texObj);
}
}
/**
* Called via ctx->Driver.GenerateMipmap()
* This is basically a wrapper for _mesa_meta_GenerateMipmap() which checks
* if we'll be using software mipmap generation. In that case, we need to
* map/unmap the base level texture image.
*/
static void
intelGenerateMipmap(struct gl_context *ctx, GLenum target,
struct gl_texture_object *texObj)
{
if (_mesa_meta_check_generate_mipmap_fallback(ctx, target, texObj)) {
/* sw path: need to map texture images */
struct intel_context *intel = intel_context(ctx);
struct intel_texture_object *intelObj = intel_texture_object(texObj);
struct gl_texture_image *first_image = texObj->Image[0][texObj->BaseLevel];
fallback_debug("%s - fallback to swrast\n", __FUNCTION__);
intel_tex_map_level_images(intel, intelObj, texObj->BaseLevel);
_mesa_generate_mipmap(ctx, target, texObj);
intel_tex_unmap_level_images(intel, intelObj, texObj->BaseLevel);
if (!_mesa_is_format_compressed(first_image->TexFormat)) {
GLuint nr_faces = (texObj->Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
GLuint face, i;
/* Update the level information in our private data in the new images,
* since it didn't get set as part of a normal TexImage path.
*/
for (face = 0; face < nr_faces; face++) {
for (i = texObj->BaseLevel + 1; i < texObj->MaxLevel; i++) {
struct intel_texture_image *intelImage =
intel_texture_image(texObj->Image[face][i]);
if (!intelImage)
break;
intelImage->level = i;
intelImage->face = face;
/* Unreference the miptree to signal that the new Data is a
* bare pointer from mesa.
*/
intel_miptree_release(intel, &intelImage->mt);
}
}
}
}
else {
_mesa_meta_GenerateMipmap(ctx, target, texObj);
}
}
/**
* The GenerateMipmap() driver hook.
*/
void
brw_generate_mipmap(struct gl_context *ctx, GLenum target,
struct gl_texture_object *tex_obj)
{
struct brw_context *brw = brw_context(ctx);
struct gen_device_info *devinfo = &brw->screen->devinfo;
struct intel_texture_object *intel_obj = intel_texture_object(tex_obj);
const unsigned base_level = tex_obj->BaseLevel;
unsigned last_level, first_layer, last_layer;
/* Blorp doesn't handle combined depth/stencil surfaces on Gen4-5 yet. */
if (devinfo->gen <= 5 &&
(tex_obj->Image[0][base_level]->_BaseFormat == GL_DEPTH_COMPONENT ||
tex_obj->Image[0][base_level]->_BaseFormat == GL_DEPTH_STENCIL)) {
_mesa_meta_GenerateMipmap(ctx, target, tex_obj);
return;
}
/* find expected last mipmap level to generate */
last_level = _mesa_compute_num_levels(ctx, tex_obj, target) - 1;
if (last_level == 0)
return;
/* The texture isn't in a "complete" state yet so set the expected
* last_level here; we're not going through normal texture validation.
*/
intel_obj->_MaxLevel = last_level;
if (!tex_obj->Immutable) {
_mesa_prepare_mipmap_levels(ctx, tex_obj, base_level, last_level);
/* At this point, memory for all the texture levels has been
* allocated. However, the base level image may be in one resource
* while the subsequent/smaller levels may be in another resource.
* Finalizing the texture will copy the base images from the former
* resource to the latter.
*
* After this, we'll have all mipmap levels in one resource.
*/
intel_finalize_mipmap_tree(brw, tex_obj);
}
struct intel_mipmap_tree *mt = intel_obj->mt;
if (!mt) {
_mesa_error(ctx, GL_OUT_OF_MEMORY, "mipmap generation");
return;
}
const mesa_format format = intel_obj->_Format;
/* Fall back to the CPU for non-renderable cases.
*
* TODO: 3D textures require blending data from multiple slices,
* which means we need custom shaders. For now, fall back.
*/
if (!brw->mesa_format_supports_render[format] || target == GL_TEXTURE_3D) {
_mesa_generate_mipmap(ctx, target, tex_obj);
return;
}
const struct isl_extent4d *base_size = &mt->surf.logical_level0_px;
if (mt->target == GL_TEXTURE_CUBE_MAP) {
first_layer = _mesa_tex_target_to_face(target);
last_layer = first_layer;
} else {
first_layer = 0;
last_layer = base_size->array_len - 1;
}
/* The GL_EXT_texture_sRGB_decode extension's issues section says:
*
* "10) How is mipmap generation of sRGB textures affected by the
* TEXTURE_SRGB_DECODE_EXT parameter?
*
* RESOLVED: When the TEXTURE_SRGB_DECODE parameter is DECODE_EXT
* for an sRGB texture, mipmap generation should decode sRGB texels
* to a linear RGB color space, perform downsampling, then encode
* back to an sRGB color space. (Issue 24 in the EXT_texture_sRGB
* specification provides a rationale for why.) When the parameter
* is SKIP_DECODE_EXT instead, mipmap generation skips the encode
* and decode steps during mipmap generation. By skipping the
* encode and decode steps, sRGB mipmap generation should match
* the mipmap generation for a non-sRGB texture."
*/
bool do_srgb = tex_obj->Sampler.sRGBDecode == GL_DECODE_EXT;
for (unsigned dst_level = base_level + 1;
dst_level <= last_level;
dst_level++) {
const unsigned src_level = dst_level - 1;
for (unsigned layer = first_layer; layer <= last_layer; layer++) {
brw_blorp_blit_miptrees(brw, mt, src_level, layer, format,
SWIZZLE_XYZW, mt, dst_level, layer, format,
0, 0,
minify(base_size->width, src_level),
minify(base_size->height, src_level),
0, 0,
minify(base_size->width, dst_level),
minify(base_size->height, dst_level),
GL_LINEAR, false, false,
do_srgb, do_srgb);
}
}
}
