aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/mesa/state_tracker/st_cb_texture.c168
-rw-r--r--src/mesa/state_tracker/st_pbo.c113
-rw-r--r--src/mesa/state_tracker/st_pbo.h43
3 files changed, 204 insertions, 120 deletions
diff --git a/src/mesa/state_tracker/st_cb_texture.c b/src/mesa/state_tracker/st_cb_texture.c
index ab791ef9a23..bf0dd4d113f 100644
--- a/src/mesa/state_tracker/st_cb_texture.c
+++ b/src/mesa/state_tracker/st_cb_texture.c
@@ -1073,34 +1073,14 @@ reinterpret_formats(enum pipe_format *src_format, enum pipe_format *dst_format)
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);
@@ -1108,7 +1088,7 @@ try_pbo_upload_common(struct gl_context *ctx,
return false;
}
- if (depth != 1 && st->pbo.use_gs && !st->pbo.gs) {
+ if (addr->depth != 1 && st->pbo.use_gs && !st->pbo.gs) {
st->pbo.gs = st_pbo_create_gs(st);
if (!st->pbo.gs)
return false;
@@ -1137,31 +1117,22 @@ try_pbo_upload_common(struct gl_context *ctx,
/* 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;
@@ -1177,10 +1148,10 @@ try_pbo_upload_common(struct gl_context *ctx,
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 x0 = (float) addr->xoffset / surface->width * 2.0f - 1.0f;
+ float y0 = (float) addr->yoffset / surface->height * 2.0f - 1.0f;
+ float x1 = (float) (addr->xoffset + addr->width) / surface->width * 2.0f - 1.0f;
+ float y1 = (float) (addr->yoffset + addr->height) / surface->height * 2.0f - 1.0f;
float *verts = NULL;
@@ -1217,38 +1188,25 @@ try_pbo_upload_common(struct gl_context *ctx,
}
/* 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),
+ u_upload_data(st->constbuf_uploader, 0, sizeof(addr->constants),
ctx->Const.UniformBufferOffsetAlignment,
- &constants, &cb.buffer_offset, &cb.buffer);
+ &addr->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.user_buffer = &addr->constants;
cb.buffer_offset = 0;
}
- cb.buffer_size = sizeof(constants);
+ cb.buffer_size = sizeof(addr->constants);
cso_set_constant_buffer(cso, PIPE_SHADER_FRAGMENT, 0, &cb);
@@ -1287,7 +1245,7 @@ try_pbo_upload_common(struct gl_context *ctx,
/* 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_geometry_shader_handle(cso, addr->depth != 1 ? st->pbo.gs : NULL);
cso_set_tessctrl_shader_handle(cso, NULL);
@@ -1298,11 +1256,11 @@ try_pbo_upload_common(struct gl_context *ctx,
/* Disable stream output */
cso_set_stream_outputs(cso, 0, NULL, 0);
- if (depth == 1) {
+ if (addr->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);
+ 0, 4, 0, addr->depth);
}
success = true;
@@ -1331,12 +1289,10 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims,
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)
@@ -1348,9 +1304,6 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims,
height = 1;
zoffset = yoffset;
yoffset = 0;
- image_height = 1;
- } else {
- image_height = unpack->ImageHeight > 0 ? unpack->ImageHeight : height;
}
if (depth != 1 && !st->pbo.layers)
@@ -1394,40 +1347,17 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims,
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 */
{
@@ -1448,12 +1378,7 @@ try_pbo_upload(struct gl_context *ctx, GLuint dims,
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);
@@ -1760,8 +1685,8 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
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;
@@ -1790,11 +1715,11 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
}
/* 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;
@@ -1818,17 +1743,29 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
/* 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. */
{
@@ -1849,16 +1786,7 @@ st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
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);
diff --git a/src/mesa/state_tracker/st_pbo.c b/src/mesa/state_tracker/st_pbo.c
index 97fef65d1cd..15d82baa503 100644
--- a/src/mesa/state_tracker/st_pbo.c
+++ b/src/mesa/state_tracker/st_pbo.c
@@ -30,6 +30,7 @@
#include "state_tracker/st_context.h"
#include "state_tracker/st_pbo.h"
+#include "state_tracker/st_cb_bufferobjects.h"
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
@@ -37,6 +38,118 @@
#include "cso_cache/cso_context.h"
#include "tgsi/tgsi_ureg.h"
+/* Final setup of buffer addressing information.
+ *
+ * buf_offset is in pixels.
+ *
+ * Returns false if something (e.g. alignment) prevents PBO upload/download.
+ */
+bool
+st_pbo_addresses_setup(struct st_context *st,
+ struct pipe_resource *buf, intptr_t buf_offset,
+ struct st_pbo_addresses *addr)
+{
+ unsigned skip_pixels;
+
+ /* Check alignment against texture buffer requirements. */
+ {
+ unsigned ofs = (buf_offset * addr->bytes_per_pixel) % st->ctx->Const.TextureBufferOffsetAlignment;
+ if (ofs != 0) {
+ if (ofs % addr->bytes_per_pixel != 0)
+ return false;
+
+ skip_pixels = ofs / addr->bytes_per_pixel;
+ buf_offset -= skip_pixels;
+ } else {
+ skip_pixels = 0;
+ }
+ }
+
+ assert(buf_offset >= 0);
+
+ addr->buffer = buf;
+ addr->first_element = buf_offset;
+ addr->last_element = buf_offset + skip_pixels + addr->width - 1
+ + (addr->height - 1 + (addr->depth - 1) * addr->image_height) * addr->pixels_per_row;
+
+ if (addr->last_element - addr->first_element > st->ctx->Const.MaxTextureBufferSize - 1)
+ return false;
+
+ /* This should be ensured by Mesa before calling our callbacks */
+ assert((addr->last_element + 1) * addr->bytes_per_pixel <= buf->width0);
+
+ addr->constants.xoffset = -addr->xoffset + skip_pixels;
+ addr->constants.yoffset = -addr->yoffset;
+ addr->constants.stride = addr->pixels_per_row;
+ addr->constants.image_size = addr->pixels_per_row * addr->image_height;
+
+ return true;
+}
+
+/* Validate and fill buffer addressing information based on GL pixelstore
+ * attributes.
+ *
+ * Returns false if some aspect of the addressing (e.g. alignment) prevents
+ * PBO upload/download.
+ */
+bool
+st_pbo_addresses_pixelstore(struct st_context *st,
+ GLenum gl_target, bool skip_images,
+ const struct gl_pixelstore_attrib *store,
+ const void *pixels,
+ struct st_pbo_addresses *addr)
+{
+ struct pipe_resource *buf = st_buffer_object(store->BufferObj)->buffer;
+ intptr_t buf_offset = (intptr_t) pixels;
+
+ if (buf_offset % addr->bytes_per_pixel)
+ return false;
+
+ /* Convert to texels */
+ buf_offset = buf_offset / addr->bytes_per_pixel;
+
+ /* Determine image height */
+ if (gl_target == GL_TEXTURE_1D_ARRAY) {
+ addr->image_height = 1;
+ } else {
+ addr->image_height = store->ImageHeight > 0 ? store->ImageHeight : addr->height;
+ }
+
+ /* Compute the stride, taking store->Alignment into account */
+ {
+ unsigned pixels_per_row = store->RowLength > 0 ?
+ store->RowLength : addr->width;
+ unsigned bytes_per_row = pixels_per_row * addr->bytes_per_pixel;
+ unsigned remainder = bytes_per_row % store->Alignment;
+ unsigned offset_rows;
+
+ if (remainder > 0)
+ bytes_per_row += store->Alignment - remainder;
+
+ if (bytes_per_row % addr->bytes_per_pixel)
+ return false;
+
+ addr->pixels_per_row = bytes_per_row / addr->bytes_per_pixel;
+
+ offset_rows = store->SkipRows;
+ if (skip_images)
+ offset_rows += addr->image_height * store->SkipImages;
+
+ buf_offset += store->SkipPixels + addr->pixels_per_row * offset_rows;
+ }
+
+ if (!st_pbo_addresses_setup(st, buf, buf_offset, addr))
+ return false;
+
+ /* Support GL_PACK_INVERT_MESA */
+ if (store->Invert) {
+ addr->constants.xoffset += (addr->height - 1) * addr->constants.stride;
+ addr->constants.stride = -addr->constants.stride;
+ }
+
+ return true;
+}
+
void *
st_pbo_create_vs(struct st_context *st)
{
diff --git a/src/mesa/state_tracker/st_pbo.h b/src/mesa/state_tracker/st_pbo.h
index 7ba426fedd2..392278e8f9d 100644
--- a/src/mesa/state_tracker/st_pbo.h
+++ b/src/mesa/state_tracker/st_pbo.h
@@ -24,8 +24,51 @@
#ifndef ST_PBO_H
#define ST_PBO_H
+struct gl_pixelstore_attrib;
+
struct st_context;
+struct st_pbo_addresses {
+ int xoffset;
+ int yoffset;
+ unsigned width;
+ unsigned height;
+ unsigned depth;
+
+ unsigned bytes_per_pixel;
+
+ /* Everything below is filled in by st_pbo_from_pixelstore */
+ unsigned pixels_per_row;
+ unsigned image_height;
+
+ /* Everything below is filled in by st_pbo_setup_buffer */
+
+ /* Buffer and view. */
+ struct pipe_resource *buffer; /* non-owning pointer */
+ unsigned first_element;
+ unsigned last_element;
+
+ /* Constant buffer for the fragment shader. */
+ struct {
+ int32_t xoffset;
+ int32_t yoffset;
+ int32_t stride;
+ int32_t image_size;
+ } constants;
+};
+
+bool
+st_pbo_addresses_setup(struct st_context *st,
+ struct pipe_resource *buf, intptr_t buf_offset,
+ struct st_pbo_addresses *addr);
+
+bool
+st_pbo_addresses_pixelstore(struct st_context *st,
+ GLenum gl_target, bool skip_images,
+ const struct gl_pixelstore_attrib *store,
+ const void *pixels,
+ struct st_pbo_addresses *addr);
+
void *
st_pbo_create_vs(struct st_context *st);
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-28 23:30:34 +0000