0,0 → 1,1899 |
/************************************************************************** |
* |
* Copyright 2007 VMware, Inc. |
* All Rights Reserved. |
* |
* 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 the rights to use, copy, modify, merge, publish, |
* distribute, sub license, 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: |
* |
* The above copyright notice and this permission notice (including the |
* next paragraph) shall be included in all copies or substantial portions |
* of the Software. |
* |
* 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 NON-INFRINGEMENT. |
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS 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. |
* |
**************************************************************************/ |
|
#include <stdio.h> |
#include "main/bufferobj.h" |
#include "main/enums.h" |
#include "main/fbobject.h" |
#include "main/formats.h" |
#include "main/format_utils.h" |
#include "main/glformats.h" |
#include "main/image.h" |
#include "main/imports.h" |
#include "main/macros.h" |
#include "main/mipmap.h" |
#include "main/pack.h" |
#include "main/pbo.h" |
#include "main/pixeltransfer.h" |
#include "main/texcompress.h" |
#include "main/texcompress_etc.h" |
#include "main/texgetimage.h" |
#include "main/teximage.h" |
#include "main/texobj.h" |
#include "main/texstore.h" |
|
#include "state_tracker/st_debug.h" |
#include "state_tracker/st_context.h" |
#include "state_tracker/st_cb_fbo.h" |
#include "state_tracker/st_cb_flush.h" |
#include "state_tracker/st_cb_texture.h" |
#include "state_tracker/st_cb_bufferobjects.h" |
#include "state_tracker/st_format.h" |
#include "state_tracker/st_texture.h" |
#include "state_tracker/st_gen_mipmap.h" |
#include "state_tracker/st_atom.h" |
|
#include "pipe/p_context.h" |
#include "pipe/p_defines.h" |
#include "util/u_inlines.h" |
#include "pipe/p_shader_tokens.h" |
#include "util/u_tile.h" |
#include "util/u_format.h" |
#include "util/u_surface.h" |
#include "util/u_sampler.h" |
#include "util/u_math.h" |
#include "util/u_box.h" |
|
#define DBG if (0) printf |
|
|
enum pipe_texture_target |
gl_target_to_pipe(GLenum target) |
{ |
switch (target) { |
case GL_TEXTURE_1D: |
case GL_PROXY_TEXTURE_1D: |
return PIPE_TEXTURE_1D; |
case GL_TEXTURE_2D: |
case GL_PROXY_TEXTURE_2D: |
case GL_TEXTURE_EXTERNAL_OES: |
case GL_TEXTURE_2D_MULTISAMPLE: |
case GL_PROXY_TEXTURE_2D_MULTISAMPLE: |
return PIPE_TEXTURE_2D; |
case GL_TEXTURE_RECTANGLE_NV: |
case GL_PROXY_TEXTURE_RECTANGLE_NV: |
return PIPE_TEXTURE_RECT; |
case GL_TEXTURE_3D: |
case GL_PROXY_TEXTURE_3D: |
return PIPE_TEXTURE_3D; |
case GL_TEXTURE_CUBE_MAP_ARB: |
case GL_PROXY_TEXTURE_CUBE_MAP_ARB: |
case GL_TEXTURE_CUBE_MAP_POSITIVE_X: |
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: |
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: |
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: |
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: |
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: |
return PIPE_TEXTURE_CUBE; |
case GL_TEXTURE_1D_ARRAY_EXT: |
case GL_PROXY_TEXTURE_1D_ARRAY_EXT: |
return PIPE_TEXTURE_1D_ARRAY; |
case GL_TEXTURE_2D_ARRAY_EXT: |
case GL_PROXY_TEXTURE_2D_ARRAY_EXT: |
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY: |
case GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY: |
return PIPE_TEXTURE_2D_ARRAY; |
case GL_TEXTURE_BUFFER: |
return PIPE_BUFFER; |
case GL_TEXTURE_CUBE_MAP_ARRAY: |
case GL_PROXY_TEXTURE_CUBE_MAP_ARRAY: |
return PIPE_TEXTURE_CUBE_ARRAY; |
default: |
assert(0); |
return 0; |
} |
} |
|
|
/** called via ctx->Driver.NewTextureImage() */ |
static struct gl_texture_image * |
st_NewTextureImage(struct gl_context * ctx) |
{ |
DBG("%s\n", __func__); |
(void) ctx; |
return (struct gl_texture_image *) ST_CALLOC_STRUCT(st_texture_image); |
} |
|
|
/** called via ctx->Driver.DeleteTextureImage() */ |
static void |
st_DeleteTextureImage(struct gl_context * ctx, struct gl_texture_image *img) |
{ |
/* nothing special (yet) for st_texture_image */ |
_mesa_delete_texture_image(ctx, img); |
} |
|
|
/** called via ctx->Driver.NewTextureObject() */ |
static struct gl_texture_object * |
st_NewTextureObject(struct gl_context * ctx, GLuint name, GLenum target) |
{ |
struct st_texture_object *obj = ST_CALLOC_STRUCT(st_texture_object); |
|
DBG("%s\n", __func__); |
_mesa_initialize_texture_object(ctx, &obj->base, name, target); |
|
return &obj->base; |
} |
|
/** called via ctx->Driver.DeleteTextureObject() */ |
static void |
st_DeleteTextureObject(struct gl_context *ctx, |
struct gl_texture_object *texObj) |
{ |
struct st_context *st = st_context(ctx); |
struct st_texture_object *stObj = st_texture_object(texObj); |
|
pipe_resource_reference(&stObj->pt, NULL); |
st_texture_release_all_sampler_views(st, stObj); |
st_texture_free_sampler_views(stObj); |
_mesa_delete_texture_object(ctx, texObj); |
} |
|
|
/** called via ctx->Driver.FreeTextureImageBuffer() */ |
static void |
st_FreeTextureImageBuffer(struct gl_context *ctx, |
struct gl_texture_image *texImage) |
{ |
struct st_texture_image *stImage = st_texture_image(texImage); |
|
DBG("%s\n", __func__); |
|
if (stImage->pt) { |
pipe_resource_reference(&stImage->pt, NULL); |
} |
|
free(stImage->transfer); |
stImage->transfer = NULL; |
stImage->num_transfers = 0; |
} |
|
|
/** called via ctx->Driver.MapTextureImage() */ |
static void |
st_MapTextureImage(struct gl_context *ctx, |
struct gl_texture_image *texImage, |
GLuint slice, GLuint x, GLuint y, GLuint w, GLuint h, |
GLbitfield mode, |
GLubyte **mapOut, GLint *rowStrideOut) |
{ |
struct st_context *st = st_context(ctx); |
struct st_texture_image *stImage = st_texture_image(texImage); |
unsigned pipeMode; |
GLubyte *map; |
struct pipe_transfer *transfer; |
|
pipeMode = 0x0; |
if (mode & GL_MAP_READ_BIT) |
pipeMode |= PIPE_TRANSFER_READ; |
if (mode & GL_MAP_WRITE_BIT) |
pipeMode |= PIPE_TRANSFER_WRITE; |
if (mode & GL_MAP_INVALIDATE_RANGE_BIT) |
pipeMode |= PIPE_TRANSFER_DISCARD_RANGE; |
|
map = st_texture_image_map(st, stImage, pipeMode, x, y, slice, w, h, 1, |
&transfer); |
if (map) { |
if ((_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) || |
(texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)) { |
/* ETC isn't supported by gallium and it's represented |
* by uncompressed formats. Only write transfers with precompressed |
* data are supported by ES3, which makes this really simple. |
* |
* Just create a temporary storage where the ETC texture will |
* be stored. It will be decompressed in the Unmap function. |
*/ |
unsigned z = transfer->box.z; |
struct st_texture_image_transfer *itransfer = &stImage->transfer[z]; |
|
itransfer->temp_data = |
malloc(_mesa_format_image_size(texImage->TexFormat, w, h, 1)); |
itransfer->temp_stride = |
_mesa_format_row_stride(texImage->TexFormat, w); |
itransfer->map = map; |
|
*mapOut = itransfer->temp_data; |
*rowStrideOut = itransfer->temp_stride; |
} |
else { |
/* supported mapping */ |
*mapOut = map; |
*rowStrideOut = transfer->stride; |
} |
} |
else { |
*mapOut = NULL; |
*rowStrideOut = 0; |
} |
} |
|
|
/** called via ctx->Driver.UnmapTextureImage() */ |
static void |
st_UnmapTextureImage(struct gl_context *ctx, |
struct gl_texture_image *texImage, |
GLuint slice) |
{ |
struct st_context *st = st_context(ctx); |
struct st_texture_image *stImage = st_texture_image(texImage); |
|
if ((_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) || |
(texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)) { |
/* Decompress the ETC texture to the mapped one. */ |
unsigned z = slice + stImage->base.Face; |
struct st_texture_image_transfer *itransfer = &stImage->transfer[z]; |
struct pipe_transfer *transfer = itransfer->transfer; |
|
assert(z == transfer->box.z); |
|
if (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8) { |
_mesa_etc1_unpack_rgba8888(itransfer->map, transfer->stride, |
itransfer->temp_data, |
itransfer->temp_stride, |
transfer->box.width, transfer->box.height); |
} |
else { |
_mesa_unpack_etc2_format(itransfer->map, transfer->stride, |
itransfer->temp_data, itransfer->temp_stride, |
transfer->box.width, transfer->box.height, |
texImage->TexFormat); |
} |
|
free(itransfer->temp_data); |
itransfer->temp_data = NULL; |
itransfer->temp_stride = 0; |
itransfer->map = 0; |
} |
|
st_texture_image_unmap(st, stImage, slice); |
} |
|
|
/** |
* Return default texture resource binding bitmask for the given format. |
*/ |
static GLuint |
default_bindings(struct st_context *st, enum pipe_format format) |
{ |
struct pipe_screen *screen = st->pipe->screen; |
const unsigned target = PIPE_TEXTURE_2D; |
unsigned bindings; |
|
if (util_format_is_depth_or_stencil(format)) |
bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_DEPTH_STENCIL; |
else |
bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET; |
|
if (screen->is_format_supported(screen, format, target, 0, bindings)) |
return bindings; |
else { |
/* Try non-sRGB. */ |
format = util_format_linear(format); |
|
if (screen->is_format_supported(screen, format, target, 0, bindings)) |
return bindings; |
else |
return PIPE_BIND_SAMPLER_VIEW; |
} |
} |
|
|
/** |
* Given the size of a mipmap image, try to compute the size of the level=0 |
* mipmap image. |
* |
* Note that this isn't always accurate for odd-sized, non-POW textures. |
* For example, if level=1 and width=40 then the level=0 width may be 80 or 81. |
* |
* \return GL_TRUE for success, GL_FALSE for failure |
*/ |
static GLboolean |
guess_base_level_size(GLenum target, |
GLuint width, GLuint height, GLuint depth, GLuint level, |
GLuint *width0, GLuint *height0, GLuint *depth0) |
{ |
assert(width >= 1); |
assert(height >= 1); |
assert(depth >= 1); |
|
if (level > 0) { |
/* Guess the size of the base level. |
* Depending on the image's size, we can't always make a guess here. |
*/ |
switch (target) { |
case GL_TEXTURE_1D: |
case GL_TEXTURE_1D_ARRAY: |
width <<= level; |
break; |
|
case GL_TEXTURE_2D: |
case GL_TEXTURE_2D_ARRAY: |
/* We can't make a good guess here, because the base level dimensions |
* can be non-square. |
*/ |
if (width == 1 || height == 1) { |
return GL_FALSE; |
} |
width <<= level; |
height <<= level; |
break; |
|
case GL_TEXTURE_CUBE_MAP: |
case GL_TEXTURE_CUBE_MAP_ARRAY: |
width <<= level; |
height <<= level; |
break; |
|
case GL_TEXTURE_3D: |
/* We can't make a good guess here, because the base level dimensions |
* can be non-cube. |
*/ |
if (width == 1 || height == 1 || depth == 1) { |
return GL_FALSE; |
} |
width <<= level; |
height <<= level; |
depth <<= level; |
break; |
|
case GL_TEXTURE_RECTANGLE: |
break; |
|
default: |
assert(0); |
} |
} |
|
*width0 = width; |
*height0 = height; |
*depth0 = depth; |
|
return GL_TRUE; |
} |
|
|
/** |
* Try to allocate a pipe_resource object for the given st_texture_object. |
* |
* We use the given st_texture_image as a clue to determine the size of the |
* mipmap image at level=0. |
* |
* \return GL_TRUE for success, GL_FALSE if out of memory. |
*/ |
static GLboolean |
guess_and_alloc_texture(struct st_context *st, |
struct st_texture_object *stObj, |
const struct st_texture_image *stImage) |
{ |
GLuint lastLevel, width, height, depth; |
GLuint bindings; |
GLuint ptWidth, ptHeight, ptDepth, ptLayers; |
enum pipe_format fmt; |
|
DBG("%s\n", __func__); |
|
assert(!stObj->pt); |
|
if (!guess_base_level_size(stObj->base.Target, |
stImage->base.Width2, |
stImage->base.Height2, |
stImage->base.Depth2, |
stImage->base.Level, |
&width, &height, &depth)) { |
/* we can't determine the image size at level=0 */ |
stObj->width0 = stObj->height0 = stObj->depth0 = 0; |
/* this is not an out of memory error */ |
return GL_TRUE; |
} |
|
/* At this point, (width x height x depth) is the expected size of |
* the level=0 mipmap image. |
*/ |
|
/* Guess a reasonable value for lastLevel. With OpenGL we have no |
* idea how many mipmap levels will be in a texture until we start |
* to render with it. Make an educated guess here but be prepared |
* to re-allocating a texture buffer with space for more (or fewer) |
* mipmap levels later. |
*/ |
if ((stObj->base.Sampler.MinFilter == GL_NEAREST || |
stObj->base.Sampler.MinFilter == GL_LINEAR || |
(stObj->base.BaseLevel == 0 && |
stObj->base.MaxLevel == 0) || |
stImage->base._BaseFormat == GL_DEPTH_COMPONENT || |
stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) && |
!stObj->base.GenerateMipmap && |
stImage->base.Level == 0) { |
/* only alloc space for a single mipmap level */ |
lastLevel = 0; |
} |
else { |
/* alloc space for a full mipmap */ |
lastLevel = _mesa_get_tex_max_num_levels(stObj->base.Target, |
width, height, depth) - 1; |
} |
|
/* Save the level=0 dimensions */ |
stObj->width0 = width; |
stObj->height0 = height; |
stObj->depth0 = depth; |
|
fmt = st_mesa_format_to_pipe_format(st, stImage->base.TexFormat); |
|
bindings = default_bindings(st, fmt); |
|
st_gl_texture_dims_to_pipe_dims(stObj->base.Target, |
width, height, depth, |
&ptWidth, &ptHeight, &ptDepth, &ptLayers); |
|
stObj->pt = st_texture_create(st, |
gl_target_to_pipe(stObj->base.Target), |
fmt, |
lastLevel, |
ptWidth, |
ptHeight, |
ptDepth, |
ptLayers, 0, |
bindings); |
|
stObj->lastLevel = lastLevel; |
|
DBG("%s returning %d\n", __func__, (stObj->pt != NULL)); |
|
return stObj->pt != NULL; |
} |
|
|
/** |
* Called via ctx->Driver.AllocTextureImageBuffer(). |
* If the texture object/buffer already has space for the indicated image, |
* we're done. Otherwise, allocate memory for the new texture image. |
*/ |
static GLboolean |
st_AllocTextureImageBuffer(struct gl_context *ctx, |
struct gl_texture_image *texImage) |
{ |
struct st_context *st = st_context(ctx); |
struct st_texture_image *stImage = st_texture_image(texImage); |
struct st_texture_object *stObj = st_texture_object(texImage->TexObject); |
const GLuint level = texImage->Level; |
GLuint width = texImage->Width; |
GLuint height = texImage->Height; |
GLuint depth = texImage->Depth; |
|
DBG("%s\n", __func__); |
|
assert(!stImage->pt); /* xxx this might be wrong */ |
|
/* Look if the parent texture object has space for this image */ |
if (stObj->pt && |
level <= stObj->pt->last_level && |
st_texture_match_image(st, stObj->pt, texImage)) { |
/* this image will fit in the existing texture object's memory */ |
pipe_resource_reference(&stImage->pt, stObj->pt); |
return GL_TRUE; |
} |
|
/* The parent texture object does not have space for this image */ |
|
pipe_resource_reference(&stObj->pt, NULL); |
st_texture_release_all_sampler_views(st, stObj); |
|
if (!guess_and_alloc_texture(st, stObj, stImage)) { |
/* Probably out of memory. |
* Try flushing any pending rendering, then retry. |
*/ |
st_finish(st); |
if (!guess_and_alloc_texture(st, stObj, stImage)) { |
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); |
return GL_FALSE; |
} |
} |
|
if (stObj->pt && |
st_texture_match_image(st, stObj->pt, texImage)) { |
/* The image will live in the object's mipmap memory */ |
pipe_resource_reference(&stImage->pt, stObj->pt); |
assert(stImage->pt); |
return GL_TRUE; |
} |
else { |
/* Create a new, temporary texture/resource/buffer to hold this |
* one texture image. Note that when we later access this image |
* (either for mapping or copying) we'll want to always specify |
* mipmap level=0, even if the image represents some other mipmap |
* level. |
*/ |
enum pipe_format format = |
st_mesa_format_to_pipe_format(st, texImage->TexFormat); |
GLuint bindings = default_bindings(st, format); |
GLuint ptWidth, ptHeight, ptDepth, ptLayers; |
|
st_gl_texture_dims_to_pipe_dims(stObj->base.Target, |
width, height, depth, |
&ptWidth, &ptHeight, &ptDepth, &ptLayers); |
|
stImage->pt = st_texture_create(st, |
gl_target_to_pipe(stObj->base.Target), |
format, |
0, /* lastLevel */ |
ptWidth, |
ptHeight, |
ptDepth, |
ptLayers, 0, |
bindings); |
return stImage->pt != NULL; |
} |
} |
|
|
/** |
* Preparation prior to glTexImage. Basically check the 'surface_based' |
* field and switch to a "normal" tex image if necessary. |
*/ |
static void |
prep_teximage(struct gl_context *ctx, struct gl_texture_image *texImage, |
GLenum format, GLenum type) |
{ |
struct gl_texture_object *texObj = texImage->TexObject; |
struct st_texture_object *stObj = st_texture_object(texObj); |
|
/* switch to "normal" */ |
if (stObj->surface_based) { |
const GLenum target = texObj->Target; |
const GLuint level = texImage->Level; |
mesa_format texFormat; |
|
_mesa_clear_texture_object(ctx, texObj); |
pipe_resource_reference(&stObj->pt, NULL); |
|
/* oops, need to init this image again */ |
texFormat = _mesa_choose_texture_format(ctx, texObj, target, level, |
texImage->InternalFormat, format, |
type); |
|
_mesa_init_teximage_fields(ctx, texImage, |
texImage->Width, texImage->Height, |
texImage->Depth, texImage->Border, |
texImage->InternalFormat, texFormat); |
|
stObj->surface_based = GL_FALSE; |
} |
} |
|
|
/** |
* Return a writemask for the gallium blit. The parameters can be base |
* formats or "format" from glDrawPixels/glTexImage/glGetTexImage. |
*/ |
unsigned |
st_get_blit_mask(GLenum srcFormat, GLenum dstFormat) |
{ |
switch (dstFormat) { |
case GL_DEPTH_STENCIL: |
switch (srcFormat) { |
case GL_DEPTH_STENCIL: |
return PIPE_MASK_ZS; |
case GL_DEPTH_COMPONENT: |
return PIPE_MASK_Z; |
case GL_STENCIL_INDEX: |
return PIPE_MASK_S; |
default: |
assert(0); |
return 0; |
} |
|
case GL_DEPTH_COMPONENT: |
switch (srcFormat) { |
case GL_DEPTH_STENCIL: |
case GL_DEPTH_COMPONENT: |
return PIPE_MASK_Z; |
default: |
assert(0); |
return 0; |
} |
|
case GL_STENCIL_INDEX: |
switch (srcFormat) { |
case GL_STENCIL_INDEX: |
return PIPE_MASK_S; |
default: |
assert(0); |
return 0; |
} |
|
default: |
return PIPE_MASK_RGBA; |
} |
} |
|
|
static void |
st_TexSubImage(struct gl_context *ctx, GLuint dims, |
struct gl_texture_image *texImage, |
GLint xoffset, GLint yoffset, GLint zoffset, |
GLint width, GLint height, GLint depth, |
GLenum format, GLenum type, const void *pixels, |
const struct gl_pixelstore_attrib *unpack) |
{ |
struct st_context *st = st_context(ctx); |
struct st_texture_image *stImage = st_texture_image(texImage); |
struct st_texture_object *stObj = st_texture_object(texImage->TexObject); |
struct pipe_context *pipe = st->pipe; |
struct pipe_screen *screen = pipe->screen; |
struct pipe_resource *dst = stImage->pt; |
struct pipe_resource *src = NULL; |
struct pipe_resource src_templ; |
struct pipe_transfer *transfer; |
struct pipe_blit_info blit; |
enum pipe_format src_format, dst_format; |
mesa_format mesa_src_format; |
GLenum gl_target = texImage->TexObject->Target; |
unsigned bind; |
GLubyte *map; |
|
assert(!_mesa_is_format_etc2(texImage->TexFormat) && |
texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); |
|
if (!st->prefer_blit_based_texture_transfer) { |
goto fallback; |
} |
|
if (!dst) { |
goto fallback; |
} |
|
/* XXX Fallback for depth-stencil formats due to an incomplete stencil |
* blit implementation in some drivers. */ |
if (format == GL_DEPTH_STENCIL) { |
goto fallback; |
} |
|
/* If the base internal format and the texture format don't match, |
* we can't use blit-based TexSubImage. */ |
if (texImage->_BaseFormat != |
_mesa_get_format_base_format(texImage->TexFormat)) { |
goto fallback; |
} |
|
/* See if the texture format already matches the format and type, |
* in which case the memcpy-based fast path will likely be used and |
* we don't have to blit. */ |
if (_mesa_format_matches_format_and_type(texImage->TexFormat, format, |
type, unpack->SwapBytes)) { |
goto fallback; |
} |
|
if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL) |
bind = PIPE_BIND_DEPTH_STENCIL; |
else |
bind = PIPE_BIND_RENDER_TARGET; |
|
/* See if the destination format is supported. |
* For luminance and intensity, only the red channel is stored there. */ |
dst_format = util_format_linear(dst->format); |
dst_format = util_format_luminance_to_red(dst_format); |
dst_format = util_format_intensity_to_red(dst_format); |
|
if (!dst_format || |
!screen->is_format_supported(screen, dst_format, dst->target, |
dst->nr_samples, bind)) { |
goto fallback; |
} |
|
/* Choose the source format. */ |
src_format = st_choose_matching_format(st, PIPE_BIND_SAMPLER_VIEW, |
format, type, unpack->SwapBytes); |
if (!src_format) { |
goto fallback; |
} |
|
mesa_src_format = st_pipe_format_to_mesa_format(src_format); |
|
/* There is no reason to do this if we cannot use memcpy for the temporary |
* source texture at least. This also takes transfer ops into account, |
* etc. */ |
if (!_mesa_texstore_can_use_memcpy(ctx, |
_mesa_get_format_base_format(mesa_src_format), |
mesa_src_format, format, type, unpack)) { |
goto fallback; |
} |
|
/* TexSubImage only sets a single cubemap face. */ |
if (gl_target == GL_TEXTURE_CUBE_MAP) { |
gl_target = GL_TEXTURE_2D; |
} |
/* TexSubImage can specify subsets of cube map array faces |
* so we need to upload via 2D array instead */ |
if (gl_target == GL_TEXTURE_CUBE_MAP_ARRAY) { |
gl_target = GL_TEXTURE_2D_ARRAY; |
} |
|
/* Initialize the source texture description. */ |
memset(&src_templ, 0, sizeof(src_templ)); |
src_templ.target = gl_target_to_pipe(gl_target); |
src_templ.format = src_format; |
src_templ.bind = PIPE_BIND_SAMPLER_VIEW; |
src_templ.usage = PIPE_USAGE_STAGING; |
|
st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth, |
&src_templ.width0, &src_templ.height0, |
&src_templ.depth0, &src_templ.array_size); |
|
/* Check for NPOT texture support. */ |
if (!screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES) && |
(!util_is_power_of_two(src_templ.width0) || |
!util_is_power_of_two(src_templ.height0) || |
!util_is_power_of_two(src_templ.depth0))) { |
goto fallback; |
} |
|
/* Create the source texture. */ |
src = screen->resource_create(screen, &src_templ); |
if (!src) { |
goto fallback; |
} |
|
/* Map source pixels. */ |
pixels = _mesa_validate_pbo_teximage(ctx, dims, width, height, depth, |
format, type, pixels, unpack, |
"glTexSubImage"); |
if (!pixels) { |
/* This is a GL error. */ |
pipe_resource_reference(&src, NULL); |
return; |
} |
|
/* From now on, we need the gallium representation of dimensions. */ |
if (gl_target == GL_TEXTURE_1D_ARRAY) { |
zoffset = yoffset; |
yoffset = 0; |
depth = height; |
height = 1; |
} |
|
map = pipe_transfer_map_3d(pipe, src, 0, PIPE_TRANSFER_WRITE, 0, 0, 0, |
width, height, depth, &transfer); |
if (!map) { |
_mesa_unmap_teximage_pbo(ctx, unpack); |
pipe_resource_reference(&src, NULL); |
goto fallback; |
} |
|
/* Upload pixels (just memcpy). */ |
{ |
const uint bytesPerRow = width * util_format_get_blocksize(src_format); |
GLuint row, slice; |
|
for (slice = 0; slice < (unsigned) depth; slice++) { |
if (gl_target == GL_TEXTURE_1D_ARRAY) { |
/* 1D array textures. |
* We need to convert gallium coords to GL coords. |
*/ |
GLvoid *src = _mesa_image_address3d(unpack, pixels, |
width, depth, format, |
type, 0, slice, 0); |
memcpy(map, src, bytesPerRow); |
} |
else { |
ubyte *slice_map = map; |
|
for (row = 0; row < (unsigned) height; row++) { |
GLvoid *src = _mesa_image_address3d(unpack, pixels, |
width, height, format, |
type, slice, row, 0); |
memcpy(slice_map, src, bytesPerRow); |
slice_map += transfer->stride; |
} |
} |
map += transfer->layer_stride; |
} |
} |
|
pipe_transfer_unmap(pipe, transfer); |
_mesa_unmap_teximage_pbo(ctx, unpack); |
|
/* Blit. */ |
memset(&blit, 0, sizeof(blit)); |
blit.src.resource = src; |
blit.src.level = 0; |
blit.src.format = src_format; |
blit.dst.resource = dst; |
blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level; |
blit.dst.format = dst_format; |
blit.src.box.x = blit.src.box.y = blit.src.box.z = 0; |
blit.dst.box.x = xoffset; |
blit.dst.box.y = yoffset; |
blit.dst.box.z = zoffset + texImage->Face + texImage->TexObject->MinLayer; |
blit.src.box.width = blit.dst.box.width = width; |
blit.src.box.height = blit.dst.box.height = height; |
blit.src.box.depth = blit.dst.box.depth = depth; |
blit.mask = st_get_blit_mask(format, texImage->_BaseFormat); |
blit.filter = PIPE_TEX_FILTER_NEAREST; |
blit.scissor_enable = FALSE; |
|
st->pipe->blit(st->pipe, &blit); |
|
pipe_resource_reference(&src, NULL); |
return; |
|
fallback: |
_mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset, |
width, height, depth, format, type, pixels, |
unpack); |
} |
|
static void |
st_TexImage(struct gl_context * ctx, GLuint dims, |
struct gl_texture_image *texImage, |
GLenum format, GLenum type, const void *pixels, |
const struct gl_pixelstore_attrib *unpack) |
{ |
assert(dims == 1 || dims == 2 || dims == 3); |
|
prep_teximage(ctx, texImage, format, type); |
|
if (texImage->Width == 0 || texImage->Height == 0 || texImage->Depth == 0) |
return; |
|
/* allocate storage for texture data */ |
if (!ctx->Driver.AllocTextureImageBuffer(ctx, texImage)) { |
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage%uD", dims); |
return; |
} |
|
st_TexSubImage(ctx, dims, texImage, 0, 0, 0, |
texImage->Width, texImage->Height, texImage->Depth, |
format, type, pixels, unpack); |
} |
|
|
static void |
st_CompressedTexImage(struct gl_context *ctx, GLuint dims, |
struct gl_texture_image *texImage, |
GLsizei imageSize, const GLvoid *data) |
{ |
prep_teximage(ctx, texImage, GL_NONE, GL_NONE); |
_mesa_store_compressed_teximage(ctx, dims, texImage, imageSize, data); |
} |
|
|
|
|
/** |
* Called via ctx->Driver.GetTexImage() |
* |
* This uses a blit to copy the texture to a texture format which matches |
* the format and type combo and then a fast read-back is done using memcpy. |
* We can do arbitrary X/Y/Z/W/0/1 swizzling here as long as there is |
* a format which matches the swizzling. |
* |
* If such a format isn't available, it falls back to _mesa_GetTexImage_sw. |
* |
* NOTE: Drivers usually do a blit to convert between tiled and linear |
* texture layouts during texture uploads/downloads, so the blit |
* we do here should be free in such cases. |
*/ |
static void |
st_GetTexImage(struct gl_context * ctx, |
GLenum format, GLenum type, GLvoid * pixels, |
struct gl_texture_image *texImage) |
{ |
struct st_context *st = st_context(ctx); |
struct pipe_context *pipe = st->pipe; |
struct pipe_screen *screen = pipe->screen; |
GLuint width = texImage->Width; |
GLuint height = texImage->Height; |
GLuint depth = texImage->Depth; |
struct st_texture_image *stImage = st_texture_image(texImage); |
struct st_texture_object *stObj = st_texture_object(texImage->TexObject); |
struct pipe_resource *src = stObj->pt; |
struct pipe_resource *dst = NULL; |
struct pipe_resource dst_templ; |
enum pipe_format dst_format, src_format; |
mesa_format mesa_format; |
GLenum gl_target = texImage->TexObject->Target; |
enum pipe_texture_target pipe_target; |
struct pipe_blit_info blit; |
unsigned bind = PIPE_BIND_TRANSFER_READ; |
struct pipe_transfer *tex_xfer; |
ubyte *map = NULL; |
boolean done = FALSE; |
|
assert(!_mesa_is_format_etc2(texImage->TexFormat) && |
texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); |
|
if (!st->prefer_blit_based_texture_transfer && |
!_mesa_is_format_compressed(texImage->TexFormat)) { |
/* Try to avoid the fallback if we're doing texture decompression here */ |
goto fallback; |
} |
|
if (!stImage->pt || !src) { |
goto fallback; |
} |
|
/* XXX Fallback to _mesa_GetTexImage_sw for depth-stencil formats |
* due to an incomplete stencil blit implementation in some drivers. */ |
if (format == GL_DEPTH_STENCIL || format == GL_STENCIL_INDEX) { |
goto fallback; |
} |
|
/* If the base internal format and the texture format don't match, we have |
* to fall back to _mesa_GetTexImage_sw. */ |
if (texImage->_BaseFormat != |
_mesa_get_format_base_format(texImage->TexFormat)) { |
goto fallback; |
} |
|
/* See if the texture format already matches the format and type, |
* in which case the memcpy-based fast path will be used. */ |
if (_mesa_format_matches_format_and_type(texImage->TexFormat, format, |
type, ctx->Pack.SwapBytes)) { |
goto fallback; |
} |
|
/* Convert the source format to what is expected by GetTexImage |
* and see if it's supported. |
* |
* This only applies to glGetTexImage: |
* - Luminance must be returned as (L,0,0,1). |
* - Luminance alpha must be returned as (L,0,0,A). |
* - Intensity must be returned as (I,0,0,1) |
*/ |
if (stObj->surface_based) |
src_format = util_format_linear(stObj->surface_format); |
else |
src_format = util_format_linear(src->format); |
src_format = util_format_luminance_to_red(src_format); |
src_format = util_format_intensity_to_red(src_format); |
|
if (!src_format || |
!screen->is_format_supported(screen, src_format, src->target, |
src->nr_samples, |
PIPE_BIND_SAMPLER_VIEW)) { |
goto fallback; |
} |
|
if (format == GL_DEPTH_COMPONENT || format == GL_DEPTH_STENCIL) |
bind |= PIPE_BIND_DEPTH_STENCIL; |
else |
bind |= PIPE_BIND_RENDER_TARGET; |
|
/* GetTexImage only returns a single face for cubemaps. */ |
if (gl_target == GL_TEXTURE_CUBE_MAP) { |
gl_target = GL_TEXTURE_2D; |
} |
pipe_target = gl_target_to_pipe(gl_target); |
|
/* Choose the destination format by finding the best match |
* for the format+type combo. */ |
dst_format = st_choose_matching_format(st, bind, format, type, |
ctx->Pack.SwapBytes); |
|
if (dst_format == PIPE_FORMAT_NONE) { |
GLenum dst_glformat; |
|
/* Fall back to _mesa_GetTexImage_sw except for compressed formats, |
* where decompression with a blit is always preferred. */ |
if (!util_format_is_compressed(src->format)) { |
goto fallback; |
} |
|
/* Set the appropriate format for the decompressed texture. |
* Luminance and sRGB formats shouldn't appear here.*/ |
switch (src_format) { |
case PIPE_FORMAT_DXT1_RGB: |
case PIPE_FORMAT_DXT1_RGBA: |
case PIPE_FORMAT_DXT3_RGBA: |
case PIPE_FORMAT_DXT5_RGBA: |
case PIPE_FORMAT_RGTC1_UNORM: |
case PIPE_FORMAT_RGTC2_UNORM: |
case PIPE_FORMAT_ETC1_RGB8: |
case PIPE_FORMAT_BPTC_RGBA_UNORM: |
dst_glformat = GL_RGBA8; |
break; |
case PIPE_FORMAT_RGTC1_SNORM: |
case PIPE_FORMAT_RGTC2_SNORM: |
if (!ctx->Extensions.EXT_texture_snorm) |
goto fallback; |
dst_glformat = GL_RGBA8_SNORM; |
break; |
case PIPE_FORMAT_BPTC_RGB_FLOAT: |
case PIPE_FORMAT_BPTC_RGB_UFLOAT: |
if (!ctx->Extensions.ARB_texture_float) |
goto fallback; |
dst_glformat = GL_RGBA32F; |
break; |
default: |
assert(0); |
goto fallback; |
} |
|
dst_format = st_choose_format(st, dst_glformat, format, type, |
pipe_target, 0, bind, FALSE); |
|
if (dst_format == PIPE_FORMAT_NONE) { |
/* unable to get an rgba format!?! */ |
goto fallback; |
} |
} |
|
/* create the destination texture */ |
memset(&dst_templ, 0, sizeof(dst_templ)); |
dst_templ.target = pipe_target; |
dst_templ.format = dst_format; |
dst_templ.bind = bind; |
dst_templ.usage = PIPE_USAGE_STAGING; |
|
st_gl_texture_dims_to_pipe_dims(gl_target, width, height, depth, |
&dst_templ.width0, &dst_templ.height0, |
&dst_templ.depth0, &dst_templ.array_size); |
|
dst = screen->resource_create(screen, &dst_templ); |
if (!dst) { |
goto fallback; |
} |
|
/* From now on, we need the gallium representation of dimensions. */ |
if (gl_target == GL_TEXTURE_1D_ARRAY) { |
depth = height; |
height = 1; |
} |
|
memset(&blit, 0, sizeof(blit)); |
blit.src.resource = src; |
blit.src.level = texImage->Level + texImage->TexObject->MinLevel; |
blit.src.format = src_format; |
blit.dst.resource = dst; |
blit.dst.level = 0; |
blit.dst.format = dst->format; |
blit.src.box.x = blit.dst.box.x = 0; |
blit.src.box.y = blit.dst.box.y = 0; |
blit.src.box.z = texImage->Face + texImage->TexObject->MinLayer; |
blit.dst.box.z = 0; |
blit.src.box.width = blit.dst.box.width = width; |
blit.src.box.height = blit.dst.box.height = height; |
blit.src.box.depth = blit.dst.box.depth = depth; |
blit.mask = st_get_blit_mask(texImage->_BaseFormat, format); |
blit.filter = PIPE_TEX_FILTER_NEAREST; |
blit.scissor_enable = FALSE; |
|
/* blit/render/decompress */ |
st->pipe->blit(st->pipe, &blit); |
|
pixels = _mesa_map_pbo_dest(ctx, &ctx->Pack, pixels); |
|
map = pipe_transfer_map_3d(pipe, dst, 0, PIPE_TRANSFER_READ, |
0, 0, 0, width, height, depth, &tex_xfer); |
if (!map) { |
goto end; |
} |
|
mesa_format = st_pipe_format_to_mesa_format(dst_format); |
|
/* copy/pack data into user buffer */ |
if (_mesa_format_matches_format_and_type(mesa_format, format, type, |
ctx->Pack.SwapBytes)) { |
/* memcpy */ |
const uint bytesPerRow = width * util_format_get_blocksize(dst_format); |
GLuint row, slice; |
|
for (slice = 0; slice < depth; slice++) { |
if (gl_target == GL_TEXTURE_1D_ARRAY) { |
/* 1D array textures. |
* We need to convert gallium coords to GL coords. |
*/ |
GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels, |
width, depth, format, |
type, 0, slice, 0); |
memcpy(dest, map, bytesPerRow); |
} |
else { |
ubyte *slice_map = map; |
|
for (row = 0; row < height; row++) { |
GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels, |
width, height, format, |
type, slice, row, 0); |
memcpy(dest, slice_map, bytesPerRow); |
slice_map += tex_xfer->stride; |
} |
} |
map += tex_xfer->layer_stride; |
} |
} |
else { |
/* format translation via floats */ |
GLuint row, slice; |
GLfloat *rgba; |
uint32_t dstMesaFormat; |
int dstStride, srcStride; |
|
assert(util_format_is_compressed(src->format)); |
|
rgba = malloc(width * 4 * sizeof(GLfloat)); |
if (!rgba) { |
goto end; |
} |
|
if (ST_DEBUG & DEBUG_FALLBACK) |
debug_printf("%s: fallback format translation\n", __func__); |
|
dstMesaFormat = _mesa_format_from_format_and_type(format, type); |
dstStride = _mesa_image_row_stride(&ctx->Pack, width, format, type); |
srcStride = 4 * width * sizeof(GLfloat); |
for (slice = 0; slice < depth; slice++) { |
if (gl_target == GL_TEXTURE_1D_ARRAY) { |
/* 1D array textures. |
* We need to convert gallium coords to GL coords. |
*/ |
GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels, |
width, depth, format, |
type, 0, slice, 0); |
|
/* get float[4] rgba row from surface */ |
pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, 1, |
dst_format, rgba); |
|
_mesa_format_convert(dest, dstMesaFormat, dstStride, |
rgba, RGBA32_FLOAT, srcStride, |
width, 1, NULL); |
} |
else { |
for (row = 0; row < height; row++) { |
GLvoid *dest = _mesa_image_address3d(&ctx->Pack, pixels, |
width, height, format, |
type, slice, row, 0); |
|
/* get float[4] rgba row from surface */ |
pipe_get_tile_rgba_format(tex_xfer, map, 0, row, width, 1, |
dst_format, rgba); |
|
_mesa_format_convert(dest, dstMesaFormat, dstStride, |
rgba, RGBA32_FLOAT, srcStride, |
width, 1, NULL); |
} |
} |
map += tex_xfer->layer_stride; |
} |
|
free(rgba); |
} |
done = TRUE; |
|
end: |
if (map) |
pipe_transfer_unmap(pipe, tex_xfer); |
|
_mesa_unmap_pbo_dest(ctx, &ctx->Pack); |
pipe_resource_reference(&dst, NULL); |
|
fallback: |
if (!done) { |
_mesa_GetTexImage_sw(ctx, format, type, pixels, texImage); |
} |
} |
|
|
/** |
* Do a CopyTexSubImage operation using a read transfer from the source, |
* a write transfer to the destination and get_tile()/put_tile() to access |
* the pixels/texels. |
* |
* Note: srcY=0=TOP of renderbuffer |
*/ |
static void |
fallback_copy_texsubimage(struct gl_context *ctx, |
struct st_renderbuffer *strb, |
struct st_texture_image *stImage, |
GLenum baseFormat, |
GLint destX, GLint destY, GLint slice, |
GLint srcX, GLint srcY, |
GLsizei width, GLsizei height) |
{ |
struct st_context *st = st_context(ctx); |
struct pipe_context *pipe = st->pipe; |
struct pipe_transfer *src_trans; |
GLubyte *texDest; |
enum pipe_transfer_usage transfer_usage; |
void *map; |
unsigned dst_width = width; |
unsigned dst_height = height; |
unsigned dst_depth = 1; |
struct pipe_transfer *transfer; |
|
if (ST_DEBUG & DEBUG_FALLBACK) |
debug_printf("%s: fallback processing\n", __func__); |
|
if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { |
srcY = strb->Base.Height - srcY - height; |
} |
|
map = pipe_transfer_map(pipe, |
strb->texture, |
strb->surface->u.tex.level, |
strb->surface->u.tex.first_layer, |
PIPE_TRANSFER_READ, |
srcX, srcY, |
width, height, &src_trans); |
|
if ((baseFormat == GL_DEPTH_COMPONENT || |
baseFormat == GL_DEPTH_STENCIL) && |
util_format_is_depth_and_stencil(stImage->pt->format)) |
transfer_usage = PIPE_TRANSFER_READ_WRITE; |
else |
transfer_usage = PIPE_TRANSFER_WRITE; |
|
texDest = st_texture_image_map(st, stImage, transfer_usage, |
destX, destY, slice, |
dst_width, dst_height, dst_depth, |
&transfer); |
|
if (baseFormat == GL_DEPTH_COMPONENT || |
baseFormat == GL_DEPTH_STENCIL) { |
const GLboolean scaleOrBias = (ctx->Pixel.DepthScale != 1.0F || |
ctx->Pixel.DepthBias != 0.0F); |
GLint row, yStep; |
uint *data; |
|
/* determine bottom-to-top vs. top-to-bottom order for src buffer */ |
if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { |
srcY = height - 1; |
yStep = -1; |
} |
else { |
srcY = 0; |
yStep = 1; |
} |
|
data = malloc(width * sizeof(uint)); |
|
if (data) { |
/* To avoid a large temp memory allocation, do copy row by row */ |
for (row = 0; row < height; row++, srcY += yStep) { |
pipe_get_tile_z(src_trans, map, 0, srcY, width, 1, data); |
if (scaleOrBias) { |
_mesa_scale_and_bias_depth_uint(ctx, width, data); |
} |
|
if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) { |
pipe_put_tile_z(transfer, texDest + row*transfer->layer_stride, |
0, 0, width, 1, data); |
} |
else { |
pipe_put_tile_z(transfer, texDest, 0, row, width, 1, data); |
} |
} |
} |
else { |
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()"); |
} |
|
free(data); |
} |
else { |
/* RGBA format */ |
GLfloat *tempSrc = |
malloc(width * height * 4 * sizeof(GLfloat)); |
|
if (tempSrc && texDest) { |
const GLint dims = 2; |
GLint dstRowStride; |
struct gl_texture_image *texImage = &stImage->base; |
struct gl_pixelstore_attrib unpack = ctx->DefaultPacking; |
|
if (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP) { |
unpack.Invert = GL_TRUE; |
} |
|
if (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY) { |
dstRowStride = transfer->layer_stride; |
} |
else { |
dstRowStride = transfer->stride; |
} |
|
/* get float/RGBA image from framebuffer */ |
/* XXX this usually involves a lot of int/float conversion. |
* try to avoid that someday. |
*/ |
pipe_get_tile_rgba_format(src_trans, map, 0, 0, width, height, |
util_format_linear(strb->texture->format), |
tempSrc); |
|
/* Store into texture memory. |
* Note that this does some special things such as pixel transfer |
* ops and format conversion. In particular, if the dest tex format |
* is actually RGBA but the user created the texture as GL_RGB we |
* need to fill-in/override the alpha channel with 1.0. |
*/ |
_mesa_texstore(ctx, dims, |
texImage->_BaseFormat, |
texImage->TexFormat, |
dstRowStride, |
&texDest, |
width, height, 1, |
GL_RGBA, GL_FLOAT, tempSrc, /* src */ |
&unpack); |
} |
else { |
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexSubImage"); |
} |
|
free(tempSrc); |
} |
|
st_texture_image_unmap(st, stImage, slice); |
pipe->transfer_unmap(pipe, src_trans); |
} |
|
|
/** |
* Do a CopyTex[Sub]Image1/2/3D() using a hardware (blit) path if possible. |
* Note that the region to copy has already been clipped so we know we |
* won't read from outside the source renderbuffer's bounds. |
* |
* Note: srcY=0=Bottom of renderbuffer (GL convention) |
*/ |
static void |
st_CopyTexSubImage(struct gl_context *ctx, GLuint dims, |
struct gl_texture_image *texImage, |
GLint destX, GLint destY, GLint slice, |
struct gl_renderbuffer *rb, |
GLint srcX, GLint srcY, GLsizei width, GLsizei height) |
{ |
struct st_texture_image *stImage = st_texture_image(texImage); |
struct st_texture_object *stObj = st_texture_object(texImage->TexObject); |
struct st_renderbuffer *strb = st_renderbuffer(rb); |
struct st_context *st = st_context(ctx); |
struct pipe_context *pipe = st->pipe; |
struct pipe_screen *screen = pipe->screen; |
struct pipe_blit_info blit; |
enum pipe_format dst_format; |
GLboolean do_flip = (st_fb_orientation(ctx->ReadBuffer) == Y_0_TOP); |
unsigned bind; |
GLint srcY0, srcY1; |
|
assert(!_mesa_is_format_etc2(texImage->TexFormat) && |
texImage->TexFormat != MESA_FORMAT_ETC1_RGB8); |
|
if (!strb || !strb->surface || !stImage->pt) { |
debug_printf("%s: null strb or stImage\n", __func__); |
return; |
} |
|
if (_mesa_texstore_needs_transfer_ops(ctx, texImage->_BaseFormat, |
texImage->TexFormat)) { |
goto fallback; |
} |
|
/* The base internal format must match the mesa format, so make sure |
* e.g. an RGB internal format is really allocated as RGB and not as RGBA. |
*/ |
if (texImage->_BaseFormat != |
_mesa_get_format_base_format(texImage->TexFormat) || |
rb->_BaseFormat != _mesa_get_format_base_format(rb->Format)) { |
goto fallback; |
} |
|
/* Choose the destination format to match the TexImage behavior. */ |
dst_format = util_format_linear(stImage->pt->format); |
dst_format = util_format_luminance_to_red(dst_format); |
dst_format = util_format_intensity_to_red(dst_format); |
|
/* See if the destination format is supported. */ |
if (texImage->_BaseFormat == GL_DEPTH_STENCIL || |
texImage->_BaseFormat == GL_DEPTH_COMPONENT) { |
bind = PIPE_BIND_DEPTH_STENCIL; |
} |
else { |
bind = PIPE_BIND_RENDER_TARGET; |
} |
|
if (!dst_format || |
!screen->is_format_supported(screen, dst_format, stImage->pt->target, |
stImage->pt->nr_samples, bind)) { |
goto fallback; |
} |
|
/* Y flipping for the main framebuffer. */ |
if (do_flip) { |
srcY1 = strb->Base.Height - srcY - height; |
srcY0 = srcY1 + height; |
} |
else { |
srcY0 = srcY; |
srcY1 = srcY0 + height; |
} |
|
/* Blit the texture. |
* This supports flipping, format conversions, and downsampling. |
*/ |
memset(&blit, 0, sizeof(blit)); |
blit.src.resource = strb->texture; |
blit.src.format = util_format_linear(strb->surface->format); |
blit.src.level = strb->surface->u.tex.level; |
blit.src.box.x = srcX; |
blit.src.box.y = srcY0; |
blit.src.box.z = strb->surface->u.tex.first_layer; |
blit.src.box.width = width; |
blit.src.box.height = srcY1 - srcY0; |
blit.src.box.depth = 1; |
blit.dst.resource = stImage->pt; |
blit.dst.format = dst_format; |
blit.dst.level = stObj->pt != stImage->pt ? 0 : texImage->Level + texImage->TexObject->MinLevel; |
blit.dst.box.x = destX; |
blit.dst.box.y = destY; |
blit.dst.box.z = stImage->base.Face + slice + texImage->TexObject->MinLayer; |
blit.dst.box.width = width; |
blit.dst.box.height = height; |
blit.dst.box.depth = 1; |
blit.mask = st_get_blit_mask(rb->_BaseFormat, texImage->_BaseFormat); |
blit.filter = PIPE_TEX_FILTER_NEAREST; |
pipe->blit(pipe, &blit); |
return; |
|
fallback: |
/* software fallback */ |
fallback_copy_texsubimage(ctx, |
strb, stImage, texImage->_BaseFormat, |
destX, destY, slice, |
srcX, srcY, width, height); |
} |
|
|
/** |
* Copy image data from stImage into the texture object 'stObj' at level |
* 'dstLevel'. |
*/ |
static void |
copy_image_data_to_texture(struct st_context *st, |
struct st_texture_object *stObj, |
GLuint dstLevel, |
struct st_texture_image *stImage) |
{ |
/* debug checks */ |
{ |
const struct gl_texture_image *dstImage = |
stObj->base.Image[stImage->base.Face][dstLevel]; |
assert(dstImage); |
assert(dstImage->Width == stImage->base.Width); |
assert(dstImage->Height == stImage->base.Height); |
assert(dstImage->Depth == stImage->base.Depth); |
} |
|
if (stImage->pt) { |
/* Copy potentially with the blitter: |
*/ |
GLuint src_level; |
if (stImage->pt->last_level == 0) |
src_level = 0; |
else |
src_level = stImage->base.Level; |
|
assert(src_level <= stImage->pt->last_level); |
assert(u_minify(stImage->pt->width0, src_level) == stImage->base.Width); |
assert(stImage->pt->target == PIPE_TEXTURE_1D_ARRAY || |
u_minify(stImage->pt->height0, src_level) == stImage->base.Height); |
assert(stImage->pt->target == PIPE_TEXTURE_2D_ARRAY || |
stImage->pt->target == PIPE_TEXTURE_CUBE_ARRAY || |
u_minify(stImage->pt->depth0, src_level) == stImage->base.Depth); |
|
st_texture_image_copy(st->pipe, |
stObj->pt, dstLevel, /* dest texture, level */ |
stImage->pt, src_level, /* src texture, level */ |
stImage->base.Face); |
|
pipe_resource_reference(&stImage->pt, NULL); |
} |
pipe_resource_reference(&stImage->pt, stObj->pt); |
} |
|
|
/** |
* Called during state validation. When this function is finished, |
* the texture object should be ready for rendering. |
* \return GL_TRUE for success, GL_FALSE for failure (out of mem) |
*/ |
GLboolean |
st_finalize_texture(struct gl_context *ctx, |
struct pipe_context *pipe, |
struct gl_texture_object *tObj) |
{ |
struct st_context *st = st_context(ctx); |
struct st_texture_object *stObj = st_texture_object(tObj); |
const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1; |
GLuint face; |
const struct st_texture_image *firstImage; |
enum pipe_format firstImageFormat; |
GLuint ptWidth, ptHeight, ptDepth, ptLayers, ptNumSamples; |
|
if (tObj->Immutable) |
return GL_TRUE; |
|
if (_mesa_is_texture_complete(tObj, &tObj->Sampler)) { |
/* The texture is complete and we know exactly how many mipmap levels |
* are present/needed. This is conditional because we may be called |
* from the st_generate_mipmap() function when the texture object is |
* incomplete. In that case, we'll have set stObj->lastLevel before |
* we get here. |
*/ |
if (stObj->base.Sampler.MinFilter == GL_LINEAR || |
stObj->base.Sampler.MinFilter == GL_NEAREST) |
stObj->lastLevel = stObj->base.BaseLevel; |
else |
stObj->lastLevel = stObj->base._MaxLevel; |
} |
|
if (tObj->Target == GL_TEXTURE_BUFFER) { |
struct st_buffer_object *st_obj = st_buffer_object(tObj->BufferObject); |
|
if (!st_obj) { |
pipe_resource_reference(&stObj->pt, NULL); |
st_texture_release_all_sampler_views(st, stObj); |
return GL_TRUE; |
} |
|
if (st_obj->buffer != stObj->pt) { |
pipe_resource_reference(&stObj->pt, st_obj->buffer); |
st_texture_release_all_sampler_views(st, stObj); |
stObj->width0 = stObj->pt->width0 / _mesa_get_format_bytes(tObj->_BufferObjectFormat); |
stObj->height0 = 1; |
stObj->depth0 = 1; |
} |
return GL_TRUE; |
|
} |
|
firstImage = st_texture_image_const(_mesa_base_tex_image(&stObj->base)); |
assert(firstImage); |
|
/* If both firstImage and stObj point to a texture which can contain |
* all active images, favour firstImage. Note that because of the |
* completeness requirement, we know that the image dimensions |
* will match. |
*/ |
if (firstImage->pt && |
firstImage->pt != stObj->pt && |
(!stObj->pt || firstImage->pt->last_level >= stObj->pt->last_level)) { |
pipe_resource_reference(&stObj->pt, firstImage->pt); |
st_texture_release_all_sampler_views(st, stObj); |
} |
|
/* If this texture comes from a window system, there is nothing else to do. */ |
if (stObj->surface_based) { |
return GL_TRUE; |
} |
|
/* Find gallium format for the Mesa texture */ |
firstImageFormat = |
st_mesa_format_to_pipe_format(st, firstImage->base.TexFormat); |
|
/* Find size of level=0 Gallium mipmap image, plus number of texture layers */ |
{ |
GLuint width, height, depth; |
if (!guess_base_level_size(stObj->base.Target, |
firstImage->base.Width2, |
firstImage->base.Height2, |
firstImage->base.Depth2, |
firstImage->base.Level, |
&width, &height, &depth)) { |
width = stObj->width0; |
height = stObj->height0; |
depth = stObj->depth0; |
} |
/* convert GL dims to Gallium dims */ |
st_gl_texture_dims_to_pipe_dims(stObj->base.Target, width, height, depth, |
&ptWidth, &ptHeight, &ptDepth, &ptLayers); |
ptNumSamples = firstImage->base.NumSamples; |
} |
|
/* If we already have a gallium texture, check that it matches the texture |
* object's format, target, size, num_levels, etc. |
*/ |
if (stObj->pt) { |
if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) || |
stObj->pt->format != firstImageFormat || |
stObj->pt->last_level < stObj->lastLevel || |
stObj->pt->width0 != ptWidth || |
stObj->pt->height0 != ptHeight || |
stObj->pt->depth0 != ptDepth || |
stObj->pt->nr_samples != ptNumSamples || |
stObj->pt->array_size != ptLayers) |
{ |
/* The gallium texture does not match the Mesa texture so delete the |
* gallium texture now. We'll make a new one below. |
*/ |
pipe_resource_reference(&stObj->pt, NULL); |
st_texture_release_all_sampler_views(st, stObj); |
st->dirty.st |= ST_NEW_FRAMEBUFFER; |
} |
} |
|
/* May need to create a new gallium texture: |
*/ |
if (!stObj->pt) { |
GLuint bindings = default_bindings(st, firstImageFormat); |
|
stObj->pt = st_texture_create(st, |
gl_target_to_pipe(stObj->base.Target), |
firstImageFormat, |
stObj->lastLevel, |
ptWidth, |
ptHeight, |
ptDepth, |
ptLayers, ptNumSamples, |
bindings); |
|
if (!stObj->pt) { |
_mesa_error(ctx, GL_OUT_OF_MEMORY, "glTexImage"); |
return GL_FALSE; |
} |
} |
|
/* Pull in any images not in the object's texture: |
*/ |
for (face = 0; face < nr_faces; face++) { |
GLuint level; |
for (level = stObj->base.BaseLevel; level <= stObj->lastLevel; level++) { |
struct st_texture_image *stImage = |
st_texture_image(stObj->base.Image[face][level]); |
|
/* Need to import images in main memory or held in other textures. |
*/ |
if (stImage && stObj->pt != stImage->pt) { |
if (level == 0 || |
(stImage->base.Width == u_minify(stObj->width0, level) && |
stImage->base.Height == u_minify(stObj->height0, level) && |
stImage->base.Depth == u_minify(stObj->depth0, level))) { |
/* src image fits expected dest mipmap level size */ |
copy_image_data_to_texture(st, stObj, level, stImage); |
} |
} |
} |
} |
|
return GL_TRUE; |
} |
|
|
/** |
* Called via ctx->Driver.AllocTextureStorage() to allocate texture memory |
* for a whole mipmap stack. |
*/ |
static GLboolean |
st_AllocTextureStorage(struct gl_context *ctx, |
struct gl_texture_object *texObj, |
GLsizei levels, GLsizei width, |
GLsizei height, GLsizei depth) |
{ |
const GLuint numFaces = _mesa_num_tex_faces(texObj->Target); |
struct gl_texture_image *texImage = texObj->Image[0][0]; |
struct st_context *st = st_context(ctx); |
struct st_texture_object *stObj = st_texture_object(texObj); |
struct pipe_screen *screen = st->pipe->screen; |
GLuint ptWidth, ptHeight, ptDepth, ptLayers, bindings; |
enum pipe_format fmt; |
GLint level; |
GLuint num_samples = texImage->NumSamples; |
|
assert(levels > 0); |
|
/* Save the level=0 dimensions */ |
stObj->width0 = width; |
stObj->height0 = height; |
stObj->depth0 = depth; |
stObj->lastLevel = levels - 1; |
|
fmt = st_mesa_format_to_pipe_format(st, texImage->TexFormat); |
|
bindings = default_bindings(st, fmt); |
|
/* Raise the sample count if the requested one is unsupported. */ |
if (num_samples > 1) { |
boolean found = FALSE; |
|
for (; num_samples <= ctx->Const.MaxSamples; num_samples++) { |
if (screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D, |
num_samples, |
PIPE_BIND_SAMPLER_VIEW)) { |
/* Update the sample count in gl_texture_image as well. */ |
texImage->NumSamples = num_samples; |
found = TRUE; |
break; |
} |
} |
|
if (!found) { |
return GL_FALSE; |
} |
} |
|
st_gl_texture_dims_to_pipe_dims(texObj->Target, |
width, height, depth, |
&ptWidth, &ptHeight, &ptDepth, &ptLayers); |
|
stObj->pt = st_texture_create(st, |
gl_target_to_pipe(texObj->Target), |
fmt, |
levels - 1, |
ptWidth, |
ptHeight, |
ptDepth, |
ptLayers, num_samples, |
bindings); |
if (!stObj->pt) |
return GL_FALSE; |
|
/* Set image resource pointers */ |
for (level = 0; level < levels; level++) { |
GLuint face; |
for (face = 0; face < numFaces; face++) { |
struct st_texture_image *stImage = |
st_texture_image(texObj->Image[face][level]); |
pipe_resource_reference(&stImage->pt, stObj->pt); |
} |
} |
|
return GL_TRUE; |
} |
|
|
static GLboolean |
st_TestProxyTexImage(struct gl_context *ctx, GLenum target, |
GLint level, mesa_format format, |
GLint width, GLint height, |
GLint depth, GLint border) |
{ |
struct st_context *st = st_context(ctx); |
struct pipe_context *pipe = st->pipe; |
|
if (width == 0 || height == 0 || depth == 0) { |
/* zero-sized images are legal, and always fit! */ |
return GL_TRUE; |
} |
|
if (pipe->screen->can_create_resource) { |
/* Ask the gallium driver if the texture is too large */ |
struct gl_texture_object *texObj = |
_mesa_get_current_tex_object(ctx, target); |
struct pipe_resource pt; |
|
/* Setup the pipe_resource object |
*/ |
memset(&pt, 0, sizeof(pt)); |
|
pt.target = gl_target_to_pipe(target); |
pt.format = st_mesa_format_to_pipe_format(st, format); |
|
st_gl_texture_dims_to_pipe_dims(target, |
width, height, depth, |
&pt.width0, &pt.height0, |
&pt.depth0, &pt.array_size); |
|
if (level == 0 && (texObj->Sampler.MinFilter == GL_LINEAR || |
texObj->Sampler.MinFilter == GL_NEAREST)) { |
/* assume just one mipmap level */ |
pt.last_level = 0; |
} |
else { |
/* assume a full set of mipmaps */ |
pt.last_level = _mesa_logbase2(MAX3(width, height, depth)); |
} |
|
return pipe->screen->can_create_resource(pipe->screen, &pt); |
} |
else { |
/* Use core Mesa fallback */ |
return _mesa_test_proxy_teximage(ctx, target, level, format, |
width, height, depth, border); |
} |
} |
|
static GLboolean |
st_TextureView(struct gl_context *ctx, |
struct gl_texture_object *texObj, |
struct gl_texture_object *origTexObj) |
{ |
struct st_texture_object *orig = st_texture_object(origTexObj); |
struct st_texture_object *tex = st_texture_object(texObj); |
struct gl_texture_image *image = texObj->Image[0][0]; |
|
const int numFaces = _mesa_num_tex_faces(texObj->Target); |
const int numLevels = texObj->NumLevels; |
|
int face; |
int level; |
|
pipe_resource_reference(&tex->pt, orig->pt); |
|
/* Set image resource pointers */ |
for (level = 0; level < numLevels; level++) { |
for (face = 0; face < numFaces; face++) { |
struct st_texture_image *stImage = |
st_texture_image(texObj->Image[face][level]); |
pipe_resource_reference(&stImage->pt, tex->pt); |
} |
} |
|
tex->surface_based = GL_TRUE; |
tex->surface_format = |
st_mesa_format_to_pipe_format(st_context(ctx), image->TexFormat); |
|
tex->width0 = image->Width; |
tex->height0 = image->Height; |
tex->depth0 = image->Depth; |
tex->lastLevel = numLevels - 1; |
|
return GL_TRUE; |
} |
|
|
void |
st_init_texture_functions(struct dd_function_table *functions) |
{ |
functions->ChooseTextureFormat = st_ChooseTextureFormat; |
functions->QuerySamplesForFormat = st_QuerySamplesForFormat; |
functions->TexImage = st_TexImage; |
functions->TexSubImage = st_TexSubImage; |
functions->CompressedTexSubImage = _mesa_store_compressed_texsubimage; |
functions->CopyTexSubImage = st_CopyTexSubImage; |
functions->GenerateMipmap = st_generate_mipmap; |
|
functions->GetTexImage = st_GetTexImage; |
|
/* compressed texture functions */ |
functions->CompressedTexImage = st_CompressedTexImage; |
functions->GetCompressedTexImage = _mesa_GetCompressedTexImage_sw; |
|
functions->NewTextureObject = st_NewTextureObject; |
functions->NewTextureImage = st_NewTextureImage; |
functions->DeleteTextureImage = st_DeleteTextureImage; |
functions->DeleteTexture = st_DeleteTextureObject; |
functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer; |
functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer; |
functions->MapTextureImage = st_MapTextureImage; |
functions->UnmapTextureImage = st_UnmapTextureImage; |
|
/* XXX Temporary until we can query pipe's texture sizes */ |
functions->TestProxyTexImage = st_TestProxyTexImage; |
|
functions->AllocTextureStorage = st_AllocTextureStorage; |
functions->TextureView = st_TextureView; |
} |