Subversion Repositories Kolibri OS

Compare Revisions

Regard whitespace Rev 5563 → Rev 5564

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/mesa/state_tracker/st_cb_texture.c
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;
}