/**************************************************************************
- *
+ *
* 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
* 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.
* 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/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 "state_tracker/st_gen_mipmap.h"
#include "state_tracker/st_atom.h"
#include "state_tracker/st_sampler_view.h"
+#include "state_tracker/st_util.h"
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "util/u_upload_mgr.h"
#include "pipe/p_shader_tokens.h"
#include "util/u_tile.h"
-#include "util/u_format.h"
+#include "util/format/u_format.h"
#include "util/u_surface.h"
#include "util/u_sampler.h"
#include "util/u_math.h"
if (!obj)
return NULL;
- /* Pre-allocate a sampler views container to save a branch in the fast path. */
- obj->sampler_views = calloc(1, sizeof(struct st_sampler_views) + sizeof(struct st_sampler_view));
+ obj->level_override = -1;
+ obj->layer_override = -1;
+
+ /* Pre-allocate a sampler views container to save a branch in the
+ * fast path.
+ */
+ obj->sampler_views = calloc(1, sizeof(struct st_sampler_views)
+ + sizeof(struct st_sampler_view));
if (!obj->sampler_views) {
free(obj);
return NULL;
return &obj->base;
}
+
/** called via ctx->Driver.DeleteTextureObject() */
-static void
+static void
st_DeleteTextureObject(struct gl_context *ctx,
struct gl_texture_object *texObj)
{
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);
+ st_delete_texture_sampler_views(st, stObj);
simple_mtx_destroy(&stObj->validate_mutex);
_mesa_delete_texture_object(ctx, texObj);
}
+/**
+ * Called via ctx->Driver.TextureRemovedFromShared()
+ * When texture is removed from ctx->Shared->TexObjects we lose
+ * the ability to clean up views on context destruction, which may
+ * lead to dangling pointers to destroyed contexts.
+ * Release the views to prevent this.
+ */
+static void
+st_TextureReleaseAllSamplerViews(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);
+
+ st_texture_release_all_sampler_views(st, stObj);
+}
/** called via ctx->Driver.FreeTextureImageBuffer() */
static void
stImage->transfer = NULL;
stImage->num_transfers = 0;
- if (stImage->compressed_data) {
+ if (stImage->compressed_data &&
+ pipe_reference(&stImage->compressed_data->reference, NULL)) {
+ free(stImage->compressed_data->ptr);
free(stImage->compressed_data);
stImage->compressed_data = NULL;
}
st_texture_release_all_sampler_views(st, stObj);
}
+bool
+st_astc_format_fallback(const struct st_context *st, mesa_format format)
+{
+ if (!_mesa_is_format_astc_2d(format))
+ return false;
+
+ if (format == MESA_FORMAT_RGBA_ASTC_5x5 ||
+ format == MESA_FORMAT_SRGB8_ALPHA8_ASTC_5x5)
+ return !st->has_astc_5x5_ldr;
+
+ return !st->has_astc_2d_ldr;
+}
+
bool
st_compressed_format_fallback(struct st_context *st, mesa_format format)
{
if (_mesa_is_format_etc2(format))
return !st->has_etc2;
- if (_mesa_is_format_astc_2d(format))
- return !st->has_astc_2d_ldr;
+ if (st_astc_format_fallback(st, format))
+ return true;
return false;
}
+
static void
compressed_tex_fallback_allocate(struct st_context *st,
struct st_texture_image *stImage)
if (!st_compressed_format_fallback(st, texImage->TexFormat))
return;
- if (stImage->compressed_data)
+ if (stImage->compressed_data &&
+ pipe_reference(&stImage->compressed_data->reference, NULL)) {
+ free(stImage->compressed_data->ptr);
free(stImage->compressed_data);
+ }
unsigned data_size = _mesa_format_image_size(texImage->TexFormat,
texImage->Width2,
texImage->Height2,
texImage->Depth2);
- stImage->compressed_data =
+ stImage->compressed_data = ST_CALLOC_STRUCT(st_compressed_data);
+ stImage->compressed_data->ptr =
malloc(data_size * _mesa_num_tex_faces(texImage->TexObject->Target));
+ pipe_reference_init(&stImage->compressed_data->reference, 1);
}
+
/** called via ctx->Driver.MapTextureImage() */
static void
st_MapTextureImage(struct gl_context *ctx,
_mesa_format_row_stride(texImage->TexFormat, texImage->Width2);
unsigned block_size = _mesa_get_format_bytes(texImage->TexFormat);
+ assert(stImage->compressed_data);
*mapOut = itransfer->temp_data =
- stImage->compressed_data +
+ stImage->compressed_data->ptr +
(z * y_blocks + (y / blk_h)) * stride +
(x / blk_w) * block_size;
itransfer->map = map;
_mesa_etc1_unpack_rgba8888(itransfer->map, transfer->stride,
itransfer->temp_data,
itransfer->temp_stride,
- transfer->box.width, transfer->box.height);
+ transfer->box.width,
+ transfer->box.height);
} else if (_mesa_is_format_etc2(texImage->TexFormat)) {
- bool bgra = stImage->pt->format == PIPE_FORMAT_B8G8R8A8_SRGB;
+ bool bgra = stImage->pt->format == PIPE_FORMAT_B8G8R8A8_SRGB;
_mesa_unpack_etc2_format(itransfer->map, transfer->stride,
- itransfer->temp_data, itransfer->temp_stride,
+ itransfer->temp_data,
+ itransfer->temp_stride,
transfer->box.width, transfer->box.height,
- texImage->TexFormat,
- bgra);
+ texImage->TexFormat,
+ bgra);
} else if (_mesa_is_format_astc_2d(texImage->TexFormat)) {
_mesa_unpack_astc_2d_ldr(itransfer->map, transfer->stride,
- itransfer->temp_data, itransfer->temp_stride,
+ itransfer->temp_data,
+ itransfer->temp_stride,
transfer->box.width, transfer->box.height,
texImage->TexFormat);
} else {
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 (stImage->base.Level > 0 || stObj->base.GenerateMipmap)
return TRUE;
+ /* If the application has explicitly called glTextureParameter to set
+ * GL_TEXTURE_MAX_LEVEL, such that (max - base) > 0, then they're trying
+ * to communicate that they will have multiple miplevels.
+ *
+ * Core Mesa will initialize MaxLevel to value much larger than
+ * MAX_TEXTURE_LEVELS, so we check that to see if it's been set at all.
+ */
+ if (stObj->base.MaxLevel < MAX_TEXTURE_LEVELS &&
+ stObj->base.MaxLevel - stObj->base.BaseLevel > 0)
+ return TRUE;
+
if (stImage->base._BaseFormat == GL_DEPTH_COMPONENT ||
stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT)
/* depth/stencil textures are seldom mipmapped */
/* not a mipmap minification filter */
return FALSE;
+ /* If the following sequence of GL calls is used:
+ * glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, ...
+ * glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ *
+ * we would needlessly allocate a mipmapped texture, because the initial
+ * MinFilter is GL_NEAREST_MIPMAP_LINEAR. Catch this case and don't
+ * allocate a mipmapped texture by default. This may cause texture
+ * reallocation later, but GL_NEAREST_MIPMAP_LINEAR is pretty rare.
+ */
+ if (stObj->base.Sampler.MinFilter == GL_NEAREST_MIPMAP_LINEAR)
+ return FALSE;
+
if (stObj->base.Target == GL_TEXTURE_3D)
/* 3D textures are seldom mipmapped */
return FALSE;
*/
static GLboolean
guess_and_alloc_texture(struct st_context *st,
- struct st_texture_object *stObj,
- const struct st_texture_image *stImage)
+ struct st_texture_object *stObj,
+ const struct st_texture_image *stImage)
{
const struct gl_texture_image *firstImage;
GLuint lastLevel, width, height, depth;
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;
stObj->needs_validation = true;
compressed_tex_fallback_allocate(st, stImage);
+ const bool allowAllocateToStObj = !stObj->pt ||
+ stObj->pt->last_level == 0 ||
+ texImage->Level == 0;
- /* 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;
- }
+ if (allowAllocateToStObj) {
+ /* Look if the parent texture object has space for this image */
+ if (stObj->pt &&
+ 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);
+ assert(stImage->pt);
+ return GL_TRUE;
+ }
- /* The parent texture object does not have space for this image */
+ /* 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);
+ 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;
+ /* 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;
+ }
}
}
assert(!st_texture_image(texImage)->pt);
_mesa_clear_texture_object(ctx, texObj, texImage);
- stObj->layer_override = 0;
- stObj->level_override = 0;
+ stObj->layer_override = -1;
+ stObj->level_override = -1;
pipe_resource_reference(&stObj->pt, NULL);
/* oops, need to init this image again */
case GL_STENCIL_INDEX:
switch (srcFormat) {
+ case GL_DEPTH_STENCIL:
case GL_STENCIL_INDEX:
return PIPE_MASK_S;
default:
}
}
+
/**
* Converts PIPE_FORMAT_A* to PIPE_FORMAT_R*.
*/
}
}
+
/**
* Converts PIPE_FORMAT_R*A* to PIPE_FORMAT_R*G*.
*/
}
}
+
/**
* Converts PIPE_FORMAT_L*A* to PIPE_FORMAT_R*G*.
*/
}
}
+
/**
* Returns true if format is a PIPE_FORMAT_A* format, and false otherwise.
*/
return false;
}
+
/**
* Returns true if format is a PIPE_FORMAT_R* format, and false otherwise.
*/
return false;
}
+
static bool
format_is_swizzled_rgba(enum pipe_format format)
{
return true;
}
+
struct format_table
{
unsigned char swizzle[4];
CSO_BIT_DEPTH_STENCIL_ALPHA |
CSO_BIT_RASTERIZER |
CSO_BIT_STREAM_OUTPUTS |
- CSO_BIT_PAUSE_QUERIES |
+ (st->active_queries ? CSO_BIT_PAUSE_QUERIES : 0) |
CSO_BIT_SAMPLE_MASK |
CSO_BIT_MIN_SAMPLES |
CSO_BIT_RENDER_CONDITION |
return success;
}
+
static bool
try_pbo_upload(struct gl_context *ctx, GLuint dims,
struct gl_texture_image *texImage,
* support at all because of the remapping we later perform and because
* at least the Radeon driver actually supports some formats for texture
* buffers which it doesn't support for regular textures. */
- src_format = st_choose_matching_format(st, 0, format, type, unpack->SwapBytes);
+ src_format = st_choose_matching_format(st, 0, format, type,
+ unpack->SwapBytes);
if (!src_format) {
return false;
}
/* Set up the surface */
{
- unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
+ unsigned level = stObj->pt != stImage->pt
+ ? 0 : texImage->TexObject->MinLevel + texImage->Level;
unsigned max_layer = util_max_layer(texture, level);
zoffset += texImage->Face + texImage->TexObject->MinLayer;
/* Try texture_subdata, which should be the fastest memcpy path. */
if (pixels &&
- !_mesa_is_bufferobj(unpack->BufferObj) &&
+ !unpack->BufferObj &&
_mesa_texstore_can_use_memcpy(ctx, texImage->_BaseFormat,
texImage->TexFormat, format, type,
unpack)) {
}
util_throttle_memory_usage(pipe, &st->throttle,
- width * height * depth *
+ (uint64_t) width * height * depth *
util_format_get_blocksize(dst->format));
u_box_3d(xoffset, yoffset, zoffset + dstz, width, height, depth, &box);
goto fallback;
}
- if (_mesa_is_bufferobj(unpack->BufferObj)) {
+ if (unpack->BufferObj) {
if (try_pbo_upload(ctx, dims, texImage, format, type, dst_format,
xoffset, yoffset, zoffset,
width, height, depth, pixels, unpack))
}
util_throttle_memory_usage(pipe, &st->throttle,
- width * height * depth *
+ (uint64_t) width * height * depth *
util_format_get_blocksize(src_templ.format));
throttled = true;
fallback:
if (!throttled) {
util_throttle_memory_usage(pipe, &st->throttle,
- width * height * depth *
+ (uint64_t) width * height * depth *
_mesa_get_format_bytes(texImage->TexFormat));
}
_mesa_store_texsubimage(ctx, dims, texImage, xoffset, yoffset, zoffset,
unpack);
}
+
static void
st_TexImage(struct gl_context * ctx, GLuint dims,
struct gl_texture_image *texImage,
goto fallback;
}
- if (!_mesa_is_bufferobj(ctx->Unpack.BufferObj))
+ if (!ctx->Unpack.BufferObj)
goto fallback;
if (st_compressed_format_fallback(st, texImage->TexFormat))
addr.pixels_per_row = store.TotalBytesPerRow / addr.bytes_per_pixel;
addr.image_height = store.TotalRowsPerSlice;
- if (!st_pbo_addresses_setup(st, st_buffer_object(ctx->Unpack.BufferObj)->buffer,
+ if (!st_pbo_addresses_setup(st,
+ st_buffer_object(ctx->Unpack.BufferObj)->buffer,
buf_offset, &addr))
goto fallback;
/* Set up the surface. */
{
- unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
+ unsigned level = stObj->pt != stImage->pt
+ ? 0 : texImage->TexObject->MinLevel + texImage->Level;
unsigned max_layer = util_max_layer(texture, level);
z += texImage->Face + texImage->TexObject->MinLayer;
format, imageSize, data);
}
+
static void
st_CompressedTexImage(struct gl_context *ctx, GLuint dims,
struct gl_texture_image *texImage,
}
-
-
/**
* Called via ctx->Driver.GetTexSubImage()
*
/* 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);
+ ctx->Pack.SwapBytes);
if (dst_format == PIPE_FORMAT_NONE) {
GLenum dst_glformat;
case PIPE_FORMAT_ASTC_12x10:
case PIPE_FORMAT_ASTC_12x12:
case PIPE_FORMAT_BPTC_RGBA_UNORM:
+ case PIPE_FORMAT_FXT1_RGB:
+ case PIPE_FORMAT_FXT1_RGBA:
dst_glformat = GL_RGBA8;
break;
case PIPE_FORMAT_RGTC1_SNORM:
}
dst_format = st_choose_format(st, dst_glformat, format, type,
- pipe_target, 0, 0, bind, FALSE);
+ pipe_target, 0, 0, bind,
+ false, false);
if (dst_format == PIPE_FORMAT_NONE) {
/* unable to get an rgba format!?! */
slice, 0, 0);
/* get float[4] rgba row from surface */
- pipe_get_tile_rgba_format(tex_xfer, map, 0, 0, width, height,
- dst_format, rgba);
+ pipe_get_tile_rgba(tex_xfer, map, 0, 0, width, height, dst_format,
+ rgba);
_mesa_format_convert(dest, dstMesaFormat, dstStride,
rgba, RGBA32_FLOAT, srcStride,
PIPE_TRANSFER_READ,
srcX, srcY,
width, height, &src_trans);
+ if (!map) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()");
+ return;
+ }
if ((baseFormat == GL_DEPTH_COMPONENT ||
baseFormat == GL_DEPTH_STENCIL) &&
destX, destY, slice,
dst_width, dst_height, dst_depth,
&transfer);
+ if (!texDest) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCopyTexSubImage()");
+ goto err;
+ }
if (baseFormat == GL_DEPTH_COMPONENT ||
baseFormat == GL_DEPTH_STENCIL) {
data = malloc(width * sizeof(uint));
if (data) {
+ unsigned dst_stride = (stImage->pt->target == PIPE_TEXTURE_1D_ARRAY ?
+ transfer->layer_stride : transfer->stride);
/* 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);
+ util_format_unpack_z_32unorm(strb->texture->format,
+ data, (uint8_t *)map + src_trans->stride * srcY,
+ width);
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);
- }
+ util_format_pack_z_32unorm(stImage->pt->format,
+ texDest + row * dst_stride, data, width);
}
}
else {
GLfloat *tempSrc =
malloc(width * height * 4 * sizeof(GLfloat));
- if (tempSrc && texDest) {
+ if (tempSrc) {
const GLint dims = 2;
GLint dstRowStride;
struct gl_texture_image *texImage = &stImage->base;
/* 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);
+ pipe_get_tile_rgba(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
* need to fill-in/override the alpha channel with 1.0.
*/
_mesa_texstore(ctx, dims,
- texImage->_BaseFormat,
- texImage->TexFormat,
+ texImage->_BaseFormat,
+ texImage->TexFormat,
dstRowStride,
&texDest,
width, height, 1,
}
st_texture_image_unmap(st, stImage, slice);
+err:
pipe->transfer_unmap(pipe, src_trans);
}
+
static bool
st_can_copyteximage_using_blit(const struct gl_texture_image *texImage,
const struct gl_renderbuffer *rb)
return true;
}
+
/**
* 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
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.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;
*/
static void
copy_image_data_to_texture(struct st_context *st,
- struct st_texture_object *stObj,
+ struct st_texture_object *stObj,
GLuint dstLevel,
- struct st_texture_image *stImage)
+ struct st_texture_image *stImage)
{
/* debug checks */
{
- const struct gl_texture_image MAYBE_UNUSED *dstImage =
+ ASSERTED const struct gl_texture_image *dstImage =
stObj->base.Image[stImage->base.Face][dstLevel];
assert(dstImage);
assert(dstImage->Width == stImage->base.Width);
*/
GLboolean
st_finalize_texture(struct gl_context *ctx,
- struct pipe_context *pipe,
- struct gl_texture_object *tObj,
- GLuint cubeMapFace)
+ struct pipe_context *pipe,
+ struct gl_texture_object *tObj,
+ GLuint cubeMapFace)
{
struct st_context *st = st_context(ctx);
struct st_texture_object *stObj = st_texture_object(tObj);
return GL_TRUE;
}
- firstImage = st_texture_image_const(stObj->base.Image[cubeMapFace][stObj->base.BaseLevel]);
+ firstImage = st_texture_image_const(stObj->base.Image[cubeMapFace]
+ [stObj->base.BaseLevel]);
assert(firstImage);
/* If both firstImage and stObj point to a texture which can contain
return GL_TRUE;
}
+
/**
* Allocate a new pipe_resource object
* width0, height0, depth0 are the dimensions of the level 0 image
GLuint depth0,
GLuint layers,
GLuint nr_samples,
- GLuint bind )
+ GLuint bind)
{
struct pipe_resource pt, *newtex;
struct pipe_screen *screen = st->pipe->screen;
return newtex;
}
+
/**
* Allocate texture memory for a whole mipmap stack.
* Note: for multisample textures if the requested sample count is not
}
else {
/* assume a full set of mipmaps */
- pt.last_level = _mesa_logbase2(MAX3(width, height, depth));
+ pt.last_level = util_logbase2(MAX3(width, height, depth));
}
return pipe->screen->can_create_resource(pipe->screen, &pt);
for (face = 0; face < numFaces; face++) {
struct st_texture_image *stImage =
st_texture_image(texObj->Image[face][level]);
+ struct st_texture_image *origImage =
+ st_texture_image(origTexObj->Image[face][level]);
pipe_resource_reference(&stImage->pt, tex->pt);
+ if (origImage &&
+ origImage->compressed_data) {
+ pipe_reference(NULL,
+ &origImage->compressed_data->reference);
+ stImage->compressed_data = origImage->compressed_data;
+ }
}
}
functions->NewTextureImage = st_NewTextureImage;
functions->DeleteTextureImage = st_DeleteTextureImage;
functions->DeleteTexture = st_DeleteTextureObject;
+ functions->TextureRemovedFromShared = st_TextureReleaseAllSamplerViews;
functions->AllocTextureImageBuffer = st_AllocTextureImageBuffer;
functions->FreeTextureImageBuffer = st_FreeTextureImageBuffer;
functions->MapTextureImage = st_MapTextureImage;
projects / mesa.git / blobdiff