#include "state_tracker/st_debug.h"
#include "state_tracker/st_context.h"
+#include "state_tracker/st_cb_bitmap.h"
#include "state_tracker/st_cb_fbo.h"
#include "state_tracker/st_cb_flush.h"
#include "state_tracker/st_cb_texture.h"
free(stImage->transfer);
stImage->transfer = NULL;
stImage->num_transfers = 0;
+
+ if (stImage->etc_data) {
+ free(stImage->etc_data);
+ stImage->etc_data = NULL;
+ }
}
+bool
+st_etc_fallback(struct st_context *st, struct gl_texture_image *texImage)
+{
+ return (_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) ||
+ (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1);
+}
+
+static void
+etc_fallback_allocate(struct st_context *st, struct st_texture_image *stImage)
+{
+ struct gl_texture_image *texImage = &stImage->base;
+
+ if (!st_etc_fallback(st, texImage))
+ return;
+
+ if (stImage->etc_data)
+ free(stImage->etc_data);
+
+ unsigned data_size = _mesa_format_image_size(texImage->TexFormat,
+ texImage->Width2,
+ texImage->Height2,
+ texImage->Depth2);
+
+ stImage->etc_data =
+ malloc(data_size * _mesa_num_tex_faces(texImage->TexObject->Target));
+}
/** called via ctx->Driver.MapTextureImage() */
static void
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.
+ if (st_etc_fallback(st, texImage)) {
+ /* ETC isn't supported by all gallium drivers, where it's represented
+ * by uncompressed formats. We store the compressed data (as it's
+ * needed for image copies in OES_copy_image), and decompress as
+ * necessary in Unmap.
*
- * Just create a temporary storage where the ETC texture will
- * be stored. It will be decompressed in the Unmap function.
+ * Note: all ETC1/ETC2 formats have 4x4 block sizes.
*/
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);
+ unsigned bytes = _mesa_get_format_bytes(texImage->TexFormat);
+ unsigned stride = *rowStrideOut = itransfer->temp_stride =
+ _mesa_format_row_stride(texImage->TexFormat, texImage->Width2);
+ *mapOut = itransfer->temp_data =
+ stImage->etc_data + ((x / 4) * bytes + (y / 4) * stride) +
+ z * stride * texImage->Height2 / 4;
itransfer->map = map;
-
- *mapOut = itransfer->temp_data;
- *rowStrideOut = itransfer->temp_stride;
}
else {
/* supported mapping */
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)) {
+ if (st_etc_fallback(st, texImage)) {
/* Decompress the ETC texture to the mapped one. */
unsigned z = slice + stImage->base.Face;
struct st_texture_image_transfer *itransfer = &stImage->transfer[z];
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);
+ if (transfer->usage & PIPE_TRANSFER_WRITE) {
+ 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;
struct st_texture_object *stObj,
const struct st_texture_image *stImage)
{
+ const struct gl_texture_image *firstImage;
GLuint lastLevel, width, height, depth;
GLuint bindings;
GLuint ptWidth, ptHeight, ptDepth, ptLayers;
enum pipe_format fmt;
+ bool guessed_box = false;
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)) {
+ /* If a base level image with compatible size exists, use that as our guess.
+ */
+ firstImage = _mesa_base_tex_image(&stObj->base);
+ if (firstImage &&
+ firstImage->Width2 > 0 &&
+ firstImage->Height2 > 0 &&
+ firstImage->Depth2 > 0 &&
+ guess_base_level_size(stObj->base.Target,
+ firstImage->Width2,
+ firstImage->Height2,
+ firstImage->Depth2,
+ firstImage->Level,
+ &width, &height, &depth)) {
+ if (stImage->base.Width2 == u_minify(width, stImage->base.Level) &&
+ stImage->base.Height2 == u_minify(height, stImage->base.Level) &&
+ stImage->base.Depth2 == u_minify(depth, stImage->base.Level))
+ guessed_box = true;
+ }
+
+ if (!guessed_box)
+ guessed_box = guess_base_level_size(stObj->base.Target,
+ stImage->base.Width2,
+ stImage->base.Height2,
+ stImage->base.Depth2,
+ stImage->base.Level,
+ &width, &height, &depth);
+
+ if (!guessed_box) {
/* 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;
}
lastLevel = 0;
}
- /* 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);
assert(!stImage->pt); /* xxx this might be wrong */
+ etc_fallback_allocate(st, stImage);
+
/* Look if the parent texture object has space for this image */
if (stObj->pt &&
level <= stObj->pt->last_level &&
return true;
}
-static void *
-create_pbo_upload_fs(struct st_context *st)
-{
- struct pipe_context *pipe = st->pipe;
- struct pipe_screen *screen = pipe->screen;
- struct ureg_program *ureg;
- struct ureg_dst out;
- struct ureg_src sampler;
- struct ureg_src pos;
- struct ureg_src layer;
- struct ureg_src const0;
- struct ureg_dst temp0;
-
- ureg = ureg_create(PIPE_SHADER_FRAGMENT);
- if (!ureg)
- return NULL;
-
- out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
- sampler = ureg_DECL_sampler(ureg, 0);
- if (screen->get_param(screen, PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL)) {
- pos = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_POSITION, 0);
- } else {
- pos = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_POSITION, 0,
- TGSI_INTERPOLATE_LINEAR);
- }
- if (st->pbo.layers) {
- layer = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_LAYER, 0,
- TGSI_INTERPOLATE_CONSTANT);
- }
- const0 = ureg_DECL_constant(ureg, 0);
- temp0 = ureg_DECL_temporary(ureg);
-
- /* Note: const0 = [ -xoffset + skip_pixels, -yoffset, stride, image_height ] */
-
- /* temp0.xy = f2i(temp0.xy) */
- ureg_F2I(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY),
- ureg_swizzle(pos,
- TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
- TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y));
-
- /* temp0.xy = temp0.xy + const0.xy */
- ureg_UADD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY),
- ureg_swizzle(ureg_src(temp0),
- TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
- TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y),
- ureg_swizzle(const0,
- TGSI_SWIZZLE_X, TGSI_SWIZZLE_Y,
- TGSI_SWIZZLE_Y, TGSI_SWIZZLE_Y));
-
- /* temp0.x = const0.z * temp0.y + temp0.x */
- ureg_UMAD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_X),
- ureg_scalar(const0, TGSI_SWIZZLE_Z),
- ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_Y),
- ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X));
-
- if (st->pbo.layers) {
- /* temp0.x = const0.w * layer + temp0.x */
- ureg_UMAD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_X),
- ureg_scalar(const0, TGSI_SWIZZLE_W),
- ureg_scalar(layer, TGSI_SWIZZLE_X),
- ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X));
- }
-
- /* temp0.w = 0 */
- ureg_MOV(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_W), ureg_imm1u(ureg, 0));
-
- /* out = txf(sampler, temp0.x) */
- ureg_TXF(ureg, out, TGSI_TEXTURE_BUFFER, ureg_src(temp0), sampler);
-
- ureg_release_temporary(ureg, temp0);
-
- ureg_END(ureg);
-
- return ureg_create_shader_and_destroy(ureg, pipe);
-}
-
static bool
try_pbo_upload_common(struct gl_context *ctx,
struct pipe_surface *surface,
- int xoffset, int yoffset,
- unsigned upload_width, unsigned upload_height,
- struct pipe_resource *buffer,
- enum pipe_format src_format,
- intptr_t buf_offset,
- unsigned bytes_per_pixel,
- unsigned stride,
- unsigned image_height)
+ const struct st_pbo_addresses *addr,
+ enum pipe_format src_format)
{
struct st_context *st = st_context(ctx);
struct cso_context *cso = st->cso_context;
struct pipe_context *pipe = st->pipe;
- unsigned depth = surface->u.tex.last_layer - surface->u.tex.first_layer + 1;
- unsigned skip_pixels = 0;
bool success = false;
- /* Check alignment. */
- {
- unsigned ofs = (buf_offset * bytes_per_pixel) % ctx->Const.TextureBufferOffsetAlignment;
- if (ofs != 0) {
- if (ofs % bytes_per_pixel != 0)
- return false;
-
- skip_pixels = ofs / bytes_per_pixel;
- buf_offset -= skip_pixels;
- }
- }
-
- /* Create the shaders */
- if (!st->pbo.vs) {
- st->pbo.vs = st_pbo_create_vs(st);
- if (!st->pbo.vs)
- return false;
- }
-
- if (depth != 1 && st->pbo.use_gs && !st->pbo.gs) {
- st->pbo.gs = st_pbo_create_gs(st);
- if (!st->pbo.gs)
- return false;
- }
-
+ /* Create fragment shader */
if (!st->pbo.upload_fs) {
- st->pbo.upload_fs = create_pbo_upload_fs(st);
+ st->pbo.upload_fs = st_pbo_create_upload_fs(st);
if (!st->pbo.upload_fs)
return false;
}
/* Set up the sampler_view */
{
- unsigned first_element = buf_offset;
- unsigned last_element = buf_offset + skip_pixels + upload_width - 1
- + (upload_height - 1 + (depth - 1) * image_height) * stride;
struct pipe_sampler_view templ;
struct pipe_sampler_view *sampler_view;
struct pipe_sampler_state sampler = {0};
const struct pipe_sampler_state *samplers[1] = {&sampler};
- /* This should be ensured by Mesa before calling our callbacks */
- assert((last_element + 1) * bytes_per_pixel <= buffer->width0);
-
- if (last_element - first_element > ctx->Const.MaxTextureBufferSize - 1)
- goto fail;
-
memset(&templ, 0, sizeof(templ));
templ.target = PIPE_BUFFER;
templ.format = src_format;
- templ.u.buf.first_element = first_element;
- templ.u.buf.last_element = last_element;
+ templ.u.buf.first_element = addr->first_element;
+ templ.u.buf.last_element = addr->last_element;
templ.swizzle_r = PIPE_SWIZZLE_X;
templ.swizzle_g = PIPE_SWIZZLE_Y;
templ.swizzle_b = PIPE_SWIZZLE_Z;
templ.swizzle_a = PIPE_SWIZZLE_W;
- sampler_view = pipe->create_sampler_view(pipe, buffer, &templ);
+ sampler_view = pipe->create_sampler_view(pipe, addr->buffer, &templ);
if (sampler_view == NULL)
goto fail;
cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers);
}
- /* Upload vertices */
- {
- struct pipe_vertex_buffer vbo;
- struct pipe_vertex_element velem;
-
- float x0 = (float) xoffset / surface->width * 2.0f - 1.0f;
- float y0 = (float) yoffset / surface->height * 2.0f - 1.0f;
- float x1 = (float) (xoffset + upload_width) / surface->width * 2.0f - 1.0f;
- float y1 = (float) (yoffset + upload_height) / surface->height * 2.0f - 1.0f;
-
- float *verts = NULL;
-
- vbo.user_buffer = NULL;
- vbo.buffer = NULL;
- vbo.stride = 2 * sizeof(float);
-
- u_upload_alloc(st->uploader, 0, 8 * sizeof(float), 4,
- &vbo.buffer_offset, &vbo.buffer, (void **) &verts);
- if (!verts)
- goto fail;
-
- verts[0] = x0;
- verts[1] = y0;
- verts[2] = x0;
- verts[3] = y1;
- verts[4] = x1;
- verts[5] = y0;
- verts[6] = x1;
- verts[7] = y1;
-
- u_upload_unmap(st->uploader);
-
- velem.src_offset = 0;
- velem.instance_divisor = 0;
- velem.vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
- velem.src_format = PIPE_FORMAT_R32G32_FLOAT;
-
- cso_set_vertex_elements(cso, 1, &velem);
-
- cso_set_vertex_buffers(cso, velem.vertex_buffer_index, 1, &vbo);
-
- pipe_resource_reference(&vbo.buffer, NULL);
- }
-
- /* Upload constants */
- /* Note: the user buffer must be valid until draw time */
- struct {
- int32_t xoffset;
- int32_t yoffset;
- int32_t stride;
- int32_t image_size;
- } constants;
-
- {
- struct pipe_constant_buffer cb;
-
- constants.xoffset = -xoffset + skip_pixels;
- constants.yoffset = -yoffset;
- constants.stride = stride;
- constants.image_size = stride * image_height;
-
- if (st->constbuf_uploader) {
- cb.buffer = NULL;
- cb.user_buffer = NULL;
- u_upload_data(st->constbuf_uploader, 0, sizeof(constants),
- ctx->Const.UniformBufferOffsetAlignment,
- &constants, &cb.buffer_offset, &cb.buffer);
- if (!cb.buffer)
- goto fail;
-
- u_upload_unmap(st->constbuf_uploader);
- } else {
- cb.buffer = NULL;
- cb.user_buffer = &constants;
- cb.buffer_offset = 0;
- }
- cb.buffer_size = sizeof(constants);
-
- cso_set_constant_buffer(cso, PIPE_SHADER_FRAGMENT, 0, &cb);
-
- pipe_resource_reference(&cb.buffer, NULL);
- }
-
/* Framebuffer_state */
{
struct pipe_framebuffer_state fb;
cso_set_depth_stencil_alpha(cso, &dsa);
}
- /* Rasterizer state */
- cso_set_rasterizer(cso, &st->pbo.raster);
-
- /* Set up the shaders */
- cso_set_vertex_shader_handle(cso, st->pbo.vs);
-
- cso_set_geometry_shader_handle(cso, depth != 1 ? st->pbo.gs : NULL);
-
- cso_set_tessctrl_shader_handle(cso, NULL);
-
- cso_set_tesseval_shader_handle(cso, NULL);
-
+ /* Set up the fragment shader */
cso_set_fragment_shader_handle(cso, st->pbo.upload_fs);
- /* Disable stream output */
- cso_set_stream_outputs(cso, 0, NULL, 0);
-
- if (depth == 1) {
- cso_draw_arrays(cso, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
- } else {
- cso_draw_arrays_instanced(cso, PIPE_PRIM_TRIANGLE_STRIP,
- 0, 4, 0, depth);
- }
-
- success = true;
+ success = st_pbo_draw(st, addr, surface->width, surface->height);
fail:
cso_restore_state(cso);
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_surface *surface = NULL;
+ struct st_pbo_addresses addr;
enum pipe_format src_format;
const struct util_format_description *desc;
GLenum gl_target = texImage->TexObject->Target;
- intptr_t buf_offset;
- unsigned bytes_per_pixel;
- unsigned stride, image_height;
bool success;
if (!st->pbo.upload_enabled)
height = 1;
zoffset = yoffset;
yoffset = 0;
- image_height = 1;
- } else {
- image_height = unpack->ImageHeight > 0 ? unpack->ImageHeight : height;
}
if (depth != 1 && !st->pbo.layers)
return false;
}
- /* Check if the offset satisfies the alignment requirements */
- buf_offset = (intptr_t) pixels;
- bytes_per_pixel = desc->block.bits / 8;
+ /* Compute buffer addresses */
+ addr.xoffset = xoffset;
+ addr.yoffset = yoffset;
+ addr.width = width;
+ addr.height = height;
+ addr.depth = depth;
+ addr.bytes_per_pixel = desc->block.bits / 8;
- if (buf_offset % bytes_per_pixel) {
+ if (!st_pbo_addresses_pixelstore(st, gl_target, dims == 3, unpack, pixels,
+ &addr))
return false;
- }
-
- /* Convert to texels */
- buf_offset = buf_offset / bytes_per_pixel;
-
- /* Compute the stride, taking unpack->Alignment into account */
- {
- unsigned pixels_per_row = unpack->RowLength > 0 ?
- unpack->RowLength : width;
- unsigned bytes_per_row = pixels_per_row * bytes_per_pixel;
- unsigned remainder = bytes_per_row % unpack->Alignment;
- unsigned offset_rows;
-
- if (remainder > 0)
- bytes_per_row += (unpack->Alignment - remainder);
-
- if (bytes_per_row % bytes_per_pixel) {
- return false;
- }
-
- stride = bytes_per_row / bytes_per_pixel;
-
- offset_rows = unpack->SkipRows;
- if (dims == 3)
- offset_rows += image_height * unpack->SkipImages;
-
- buf_offset += unpack->SkipPixels + stride * offset_rows;
- }
/* Set up the surface */
{
return false;
}
- success = try_pbo_upload_common(ctx, surface,
- xoffset, yoffset, width, height,
- st_buffer_object(unpack->BufferObj)->buffer,
- src_format,
- buf_offset,
- bytes_per_pixel, stride, image_height);
+ success = try_pbo_upload_common(ctx, surface, &addr, src_format);
pipe_surface_reference(&surface, NULL);
unsigned dstz = texImage->Face + texImage->TexObject->MinLayer;
unsigned dst_level = 0;
+ st_flush_bitmap_cache(st);
+ st_invalidate_readpix_cache(st);
+
if (stObj->pt == stImage->pt)
dst_level = texImage->TexObject->MinLevel + texImage->Level;
if (!dst)
goto fallback;
- /* Try transfer_inline_write, which should be the fastest memcpy path. */
+ /* Try texture_subdata, which should be the fastest memcpy path. */
if (pixels &&
!_mesa_is_bufferobj(unpack->BufferObj) &&
_mesa_texstore_can_use_memcpy(ctx, texImage->_BaseFormat,
}
u_box_3d(xoffset, yoffset, zoffset + dstz, width, height, depth, &box);
- pipe->transfer_inline_write(pipe, dst, dst_level, 0,
- &box, data, stride, layer_stride);
+ pipe->texture_subdata(pipe, dst, dst_level, 0,
+ &box, data, stride, layer_stride);
return;
}
struct pipe_resource *dst = stImage->pt;
struct pipe_surface *surface = NULL;
struct compressed_pixelstore store;
+ struct st_pbo_addresses addr;
enum pipe_format copy_format;
- unsigned bytes_per_block;
unsigned bw, bh;
intptr_t buf_offset;
bool success = false;
if (!_mesa_is_bufferobj(ctx->Unpack.BufferObj))
goto fallback;
- if ((_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) ||
- (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)) {
+ if (st_etc_fallback(st, texImage)) {
/* ETC isn't supported and is represented by uncompressed formats. */
goto fallback;
}
}
/* Choose the pipe format for the upload. */
- bytes_per_block = util_format_get_blocksize(dst->format);
+ addr.bytes_per_pixel = util_format_get_blocksize(dst->format);
bw = util_format_get_blockwidth(dst->format);
bh = util_format_get_blockheight(dst->format);
- switch (bytes_per_block) {
+ switch (addr.bytes_per_pixel) {
case 8:
copy_format = PIPE_FORMAT_R16G16B16A16_UINT;
break;
/* Interpret the pixelstore settings. */
_mesa_compute_compressed_pixelstore(dims, texImage->TexFormat, w, h, d,
&ctx->Unpack, &store);
- assert(store.CopyBytesPerRow % bytes_per_block == 0);
- assert(store.SkipBytes % bytes_per_block == 0);
+ assert(store.CopyBytesPerRow % addr.bytes_per_pixel == 0);
+ assert(store.SkipBytes % addr.bytes_per_pixel == 0);
/* Compute the offset into the buffer */
buf_offset = (intptr_t)data + store.SkipBytes;
- if (buf_offset % bytes_per_block) {
+ if (buf_offset % addr.bytes_per_pixel) {
goto fallback;
}
- buf_offset = buf_offset / bytes_per_block;
+ buf_offset = buf_offset / addr.bytes_per_pixel;
+
+ addr.xoffset = x / bw;
+ addr.yoffset = y / bh;
+ addr.width = store.CopyBytesPerRow / addr.bytes_per_pixel;
+ addr.height = store.CopyRowsPerSlice;
+ addr.depth = d;
+ 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,
+ buf_offset, &addr))
+ goto fallback;
/* Set up the surface. */
{
goto fallback;
}
- success = try_pbo_upload_common(ctx, surface,
- x / bw, y / bh,
- store.CopyBytesPerRow / bytes_per_block,
- store.CopyRowsPerSlice,
- st_buffer_object(ctx->Unpack.BufferObj)->buffer,
- copy_format,
- buf_offset,
- bytes_per_block,
- store.TotalBytesPerRow / bytes_per_block,
- store.TotalRowsPerSlice);
+ success = try_pbo_upload_common(ctx, surface, &addr, copy_format);
pipe_surface_reference(&surface, NULL);
assert(!_mesa_is_format_etc2(texImage->TexFormat) &&
texImage->TexFormat != MESA_FORMAT_ETC1_RGB8);
+ st_flush_bitmap_cache(st);
+
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 */
unsigned bind;
GLint srcY0, srcY1;
+ st_flush_bitmap_cache(st);
+ st_invalidate_readpix_cache(st);
+
assert(!_mesa_is_format_etc2(texImage->TexFormat) &&
texImage->TexFormat != MESA_FORMAT_ETC1_RGB8);
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;
/* 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;
+
+ st_gl_texture_dims_to_pipe_dims(stObj->base.Target,
+ firstImage->base.Width2,
+ firstImage->base.Height2,
+ firstImage->base.Depth2,
+ &width, &height, &depth, &ptLayers);
+
+ /* If we previously allocated a pipe texture and its sizes are
+ * compatible, use them.
+ */
+ if (stObj->pt &&
+ u_minify(stObj->pt->width0, firstImage->base.Level) == width &&
+ u_minify(stObj->pt->height0, firstImage->base.Level) == height &&
+ u_minify(stObj->pt->depth0, firstImage->base.Level) == depth) {
+ ptWidth = stObj->pt->width0;
+ ptHeight = stObj->pt->height0;
+ ptDepth = stObj->pt->depth0;
} else {
- /* The width/height/depth may have been previously reset in
- * guess_and_alloc_texture. */
- stObj->width0 = width;
- stObj->height0 = height;
- stObj->depth0 = depth;
+ /* Otherwise, compute a new level=0 size that is compatible with the
+ * base level image.
+ */
+ ptWidth = width > 1 ? width << firstImage->base.Level : 1;
+ ptHeight = height > 1 ? height << firstImage->base.Level : 1;
+ ptDepth = depth > 1 ? depth << firstImage->base.Level : 1;
+
+ /* If the base level image is 1x1x1, we still need to ensure that the
+ * resulting pipe texture ends up with the required number of levels
+ * in total.
+ */
+ if (ptWidth == 1 && ptHeight == 1 && ptDepth == 1) {
+ ptWidth <<= firstImage->base.Level;
+
+ if (stObj->base.Target == GL_TEXTURE_CUBE_MAP ||
+ stObj->base.Target == GL_TEXTURE_CUBE_MAP_ARRAY)
+ ptHeight = ptWidth;
+ }
}
- /* 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;
}
*/
pipe_resource_reference(&stObj->pt, NULL);
st_texture_release_all_sampler_views(st, stObj);
- st->dirty.st |= ST_NEW_FRAMEBUFFER;
+ st->dirty |= ST_NEW_FRAMEBUFFER;
}
}
/* Need to import images in main memory or held in other textures.
*/
if (stImage && stObj->pt != stImage->pt) {
- GLuint height = stObj->height0;
- GLuint depth = stObj->depth0;
+ GLuint height;
+ GLuint depth;
if (stObj->base.Target != GL_TEXTURE_1D_ARRAY)
- height = u_minify(height, level);
+ height = u_minify(ptHeight, level);
+ else
+ height = ptLayers;
+
if (stObj->base.Target == GL_TEXTURE_3D)
- depth = u_minify(depth, level);
+ depth = u_minify(ptDepth, level);
+ else if (stObj->base.Target == GL_TEXTURE_CUBE_MAP)
+ depth = 1;
+ else
+ depth = ptLayers;
if (level == 0 ||
- (stImage->base.Width == u_minify(stObj->width0, level) &&
+ (stImage->base.Width == u_minify(ptWidth, level) &&
stImage->base.Height == height &&
stImage->base.Depth == depth)) {
/* src image fits expected dest mipmap level size */
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);
struct st_texture_image *stImage =
st_texture_image(texObj->Image[face][level]);
pipe_resource_reference(&stImage->pt, stObj->pt);
+
+ etc_fallback_allocate(st, stImage);
}
}
static GLboolean
st_TestProxyTexImage(struct gl_context *ctx, GLenum target,
- GLint level, mesa_format format,
- GLint width, GLint height,
- GLint depth, GLint border)
+ GLuint numLevels, GLint level,
+ mesa_format format, GLuint numSamples,
+ GLint width, GLint height, GLint depth)
{
struct st_context *st = st_context(ctx);
struct pipe_context *pipe = st->pipe;
pt.target = gl_target_to_pipe(target);
pt.format = st_mesa_format_to_pipe_format(st, format);
+ pt.nr_samples = numSamples;
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)) {
+ if (numLevels > 0) {
+ /* For immutable textures we know the final number of mip levels */
+ pt.last_level = numLevels - 1;
+ }
+ else if (level == 0 && (texObj->Sampler.MinFilter == GL_LINEAR ||
+ texObj->Sampler.MinFilter == GL_NEAREST)) {
/* assume just one mipmap level */
pt.last_level = 0;
}
}
else {
/* Use core Mesa fallback */
- return _mesa_test_proxy_teximage(ctx, target, level, format,
- width, height, depth, border);
+ return _mesa_test_proxy_teximage(ctx, target, numLevels, level, format,
+ numSamples, width, height, depth);
}
}
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;
if (!pt)
return;
+ st_flush_bitmap_cache(st);
+ st_invalidate_readpix_cache(st);
+
u_box_3d(xoffset, yoffset, zoffset + texImage->Face,
width, height, depth, &box);
if (texImage->TexObject->Immutable) {