It's now the responsibility of surface users to keep track of their mappings.
/* Fill a rectangular sub-region. Need better logic about when to
* push buffers into AGP - will currently do so whenever possible.
*/
-static ubyte *
-get_pointer(struct pipe_surface *dst, unsigned x, unsigned y)
+static void *
+get_pointer(struct pipe_surface *dst, void *dst_map, unsigned x, unsigned y)
{
- return dst->map + (y * dst->pitch + x) * dst->cpp;
+ return (char *)dst_map + (y * dst->pitch + x) * dst->cpp;
}
{
if (0) {
unsigned i, j;
-
- (void)pipe_surface_map(dst);
+ void *dst_map = pipe_surface_map(dst);
switch (dst->cpp) {
case 1: {
- ubyte *row = get_pointer(dst, dstx, dsty);
+ ubyte *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
memset(row, value, width);
row += dst->pitch;
}
break;
case 2: {
- ushort *row = (ushort *) get_pointer(dst, dstx, dsty);
+ ushort *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++)
row[j] = (ushort) value;
}
break;
case 4: {
- unsigned *row = (unsigned *) get_pointer(dst, dstx, dsty);
+ unsigned *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++)
row[j] = value;
assert(0);
break;
}
+
+ pipe_surface_unmap( dst );
}
else {
i915_fill_blit( i915_context(pipe),
/* Fill a rectangular sub-region. Need better logic about when to
* push buffers into AGP - will currently do so whenever possible.
*/
-static ubyte *
-get_pointer(struct pipe_surface *dst, unsigned x, unsigned y)
+static void *
+get_pointer(struct pipe_surface *dst, void *dst_map, unsigned x, unsigned y)
{
- return dst->map + (y * dst->pitch + x) * dst->cpp;
+ return (char *)dst_map + (y * dst->pitch + x) * dst->cpp;
}
{
if (0) {
unsigned i, j;
-
- (void)pipe_surface_map(dst);
+ void *dst_map = pipe_surface_map(dst);
switch (dst->cpp) {
case 1: {
- ubyte *row = get_pointer(dst, dstx, dsty);
+ ubyte *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
memset(row, value, width);
row += dst->pitch;
}
break;
case 2: {
- ushort *row = (ushort *) get_pointer(dst, dstx, dsty);
+ ushort *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++)
row[j] = (ushort) value;
}
break;
case 4: {
- unsigned *row = (unsigned *) get_pointer(dst, dstx, dsty);
+ unsigned *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++)
row[j] = value;
assert(0);
break;
}
+
+ pipe_surface_unmap( dst );
}
else {
brw_fill_blit(brw_context(pipe),
const void *p, int src_stride);
/* XXX temporary here, move these to softpipe */
void (*get_tile_rgba)(struct pipe_context *pipe, struct pipe_surface *ps,
- uint x, uint y, uint w, uint h, float *p);
+ uint x, uint y, uint w, uint h, float *p);
void (*put_tile_rgba)(struct pipe_context *pipe, struct pipe_surface *ps,
- uint x, uint y, uint w, uint h, const float *p);
+ uint x, uint y, uint w, uint h, const float *p);
/*
#include "p_winsys.h"
-static INLINE ubyte *
+static INLINE void *
pipe_surface_map(struct pipe_surface *surface)
{
- if (!surface->map_refcount++) {
- surface->map
- = (ubyte *) surface->winsys->buffer_map( surface->winsys,
- surface->buffer,
- PIPE_BUFFER_FLAG_WRITE |
- PIPE_BUFFER_FLAG_READ )
- + surface->offset;
- }
-
- return surface->map;
+ return (char *)surface->winsys->buffer_map( surface->winsys, surface->buffer,
+ PIPE_BUFFER_FLAG_WRITE |
+ PIPE_BUFFER_FLAG_READ )
+ + surface->offset;
}
static INLINE void
pipe_surface_unmap(struct pipe_surface *surface)
{
- if (surface->map_refcount > 0) {
- assert(surface->map);
- if (!--surface->map_refcount) {
- surface->winsys->buffer_unmap( surface->winsys,
- surface->buffer );
- surface->map = NULL;
- }
- }
+ surface->winsys->buffer_unmap( surface->winsys, surface->buffer );
}
-
/**
* Set 'ptr' to point to 'surf' and update reference counting.
* The old thing pointed to, if any, will be unreferenced first.
struct pipe_surface
{
struct pipe_buffer_handle *buffer; /**< driver private buffer handle */
- ubyte *map; /**< only non-NULL when surface is actually mapped */
- unsigned map_refcount; /**< Reference count for mapping */
enum pipe_format format; /**< PIPE_FORMAT_x */
unsigned cpp; /**< bytes per pixel */
unsigned width, height;
void
softpipe_map_surfaces(struct softpipe_context *sp)
{
- struct pipe_surface *ps;
unsigned i;
for (i = 0; i < sp->framebuffer.num_cbufs; i++) {
- ps = sp->framebuffer.cbufs[i];
- if (ps->buffer && !ps->map)
- pipe_surface_map(ps);
+ sp_tile_cache_map_surfaces(sp->cbuf_cache[i]);
}
- ps = sp->framebuffer.zbuf;
- if (ps && ps->buffer && !ps->map)
- pipe_surface_map(ps);
+ sp_tile_cache_map_surfaces(sp->zbuf_cache);
- ps = sp->framebuffer.sbuf;
- if (ps && ps->buffer && !ps->map)
- pipe_surface_map(ps);
+ sp_tile_cache_map_surfaces(sp->sbuf_cache);
}
void
softpipe_unmap_surfaces(struct softpipe_context *sp)
{
- struct pipe_surface *ps;
uint i;
for (i = 0; i < sp->framebuffer.num_cbufs; i++)
sp_flush_tile_cache(sp, sp->sbuf_cache);
for (i = 0; i < sp->framebuffer.num_cbufs; i++) {
- ps = sp->framebuffer.cbufs[i];
- if (ps->map)
- pipe_surface_unmap(ps);
+ sp_tile_cache_unmap_surfaces(sp->cbuf_cache[i]);
}
- ps = sp->framebuffer.zbuf;
- if (ps && ps->map)
- pipe_surface_unmap(ps);
+ sp_tile_cache_unmap_surfaces(sp->zbuf_cache);
- ps = sp->framebuffer.sbuf;
- if (ps && ps->map)
- pipe_surface_unmap(ps);
+ sp_tile_cache_unmap_surfaces(sp->sbuf_cache);
}
/**
* XXX this might get moved someday
* Set the framebuffer surface info: color buffers, zbuffer, stencil buffer.
- * Here, we map the surfaces and update the tile cache to point to the new
+ * Here, we flush the old surfaces and update the tile cache to point to the new
* surfaces.
*/
void
const struct pipe_framebuffer_state *fb)
{
struct softpipe_context *sp = softpipe_context(pipe);
- struct pipe_surface *ps;
uint i;
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
if (sp->framebuffer.cbufs[i] != fb->cbufs[i]) {
/* flush old */
sp_flush_tile_cache(sp, sp->cbuf_cache[i]);
- /* unmap old */
- ps = sp->framebuffer.cbufs[i];
- if (ps && ps->map)
- pipe_surface_unmap(ps);
- /* map new */
- ps = fb->cbufs[i];
- if (ps)
- pipe_surface_map(ps);
+
/* assign new */
sp->framebuffer.cbufs[i] = fb->cbufs[i];
/* update cache */
- sp_tile_cache_set_surface(sp->cbuf_cache[i], ps);
+ sp_tile_cache_set_surface(sp->cbuf_cache[i], fb->cbufs[i]);
}
}
if (sp->framebuffer.zbuf != fb->zbuf) {
/* flush old */
sp_flush_tile_cache(sp, sp->zbuf_cache);
- /* unmap old */
- ps = sp->framebuffer.zbuf;
- if (ps && ps->map)
- pipe_surface_unmap(ps);
- if (sp->framebuffer.sbuf == sp->framebuffer.zbuf) {
- /* combined z/stencil */
- sp->framebuffer.sbuf = NULL;
- }
- /* map new */
- ps = fb->zbuf;
- if (ps)
- pipe_surface_map(ps);
+
/* assign new */
sp->framebuffer.zbuf = fb->zbuf;
/* update cache */
- sp_tile_cache_set_surface(sp->zbuf_cache, ps);
+ sp_tile_cache_set_surface(sp->zbuf_cache, fb->zbuf);
}
/* XXX combined depth/stencil here */
if (sp->framebuffer.sbuf != fb->sbuf) {
/* flush old */
sp_flush_tile_cache(sp, sp->sbuf_cache_sep);
- /* unmap old */
- ps = sp->framebuffer.sbuf;
- if (ps && ps->map)
- pipe_surface_unmap(ps);
- /* map new */
- ps = fb->sbuf;
- if (ps && fb->sbuf != fb->zbuf)
- pipe_surface_map(ps);
+
/* assign new */
sp->framebuffer.sbuf = fb->sbuf;
if (fb->sbuf != fb->zbuf) {
/* separate stencil buf */
sp->sbuf_cache = sp->sbuf_cache_sep;
- sp_tile_cache_set_surface(sp->sbuf_cache, ps);
+ sp_tile_cache_set_surface(sp->sbuf_cache, fb->sbuf);
}
else {
/* combined depth/stencil */
sp->sbuf_cache = sp->zbuf_cache;
- sp_tile_cache_set_surface(sp->sbuf_cache, ps);
+ sp_tile_cache_set_surface(sp->sbuf_cache, fb->sbuf);
}
}
}
-static ubyte *
-get_pointer(struct pipe_surface *dst, unsigned x, unsigned y)
+static void *
+get_pointer(struct pipe_surface *dst, void *dst_map, unsigned x, unsigned y)
{
- return dst->map + (y * dst->pitch + x) * dst->cpp;
+ return (char *)dst_map + (y * dst->pitch + x) * dst->cpp;
}
unsigned width, unsigned height, unsigned value)
{
unsigned i, j;
+ void *dst_map = pipe_surface_map(dst);
assert(dst->pitch > 0);
assert(width <= dst->pitch);
- (void)pipe_surface_map(dst);
switch (dst->cpp) {
case 1:
{
- ubyte *row = get_pointer(dst, dstx, dsty);
+ ubyte *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
memset(row, value, width);
row += dst->pitch;
break;
case 2:
{
- ushort *row = (ushort *) get_pointer(dst, dstx, dsty);
+ ushort *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++)
row[j] = (ushort) value;
break;
case 4:
{
- unsigned *row = (unsigned *) get_pointer(dst, dstx, dsty);
+ unsigned *row = get_pointer(dst, dst_map, dstx, dsty);
for (i = 0; i < height; i++) {
for (j = 0; j < width; j++)
row[j] = value;
case 8:
{
/* expand the 4-byte clear value to an 8-byte value */
- ushort *row = (ushort *) get_pointer(dst, dstx, dsty);
+ ushort *row = (ushort *) get_pointer(dst, dst_map, dstx, dsty);
ushort val0 = UBYTE_TO_USHORT((value >> 0) & 0xff);
ushort val1 = UBYTE_TO_USHORT((value >> 8) & 0xff);
ushort val2 = UBYTE_TO_USHORT((value >> 16) & 0xff);
struct softpipe_tile_cache
{
struct pipe_surface *surface; /**< the surface we're caching */
+ void *surface_map;
struct pipe_texture *texture; /**< if caching a texture */
struct softpipe_cached_tile entries[NUM_ENTRIES];
uint clear_flags[(MAX_WIDTH / TILE_SIZE) * (MAX_HEIGHT / TILE_SIZE) / 32];
boolean depth_stencil; /** Is the surface a depth/stencil format? */
struct pipe_surface *tex_surf;
+ void *tex_surf_map;
int tex_face, tex_level, tex_z;
struct softpipe_cached_tile tile; /**< scratch tile for clears */
{
assert(!tc->texture);
- if (tc->surface && tc->surface->map) {
+ if (tc->surface_map) {
/*assert(tc->surface != ps);*/
pipe_surface_unmap(tc->surface);
}
pipe_surface_reference(&tc->surface, ps);
if (ps) {
- if (!ps->map)
- pipe_surface_map(ps);
+ if (tc->surface_map)
+ tc->surface_map = pipe_surface_map(ps);
tc->depth_stencil = (ps->format == PIPE_FORMAT_S8Z24_UNORM ||
ps->format == PIPE_FORMAT_Z16_UNORM ||
}
+void
+sp_tile_cache_map_surfaces(struct softpipe_tile_cache *tc)
+{
+ if (tc->surface && !tc->surface_map)
+ tc->surface_map = pipe_surface_map(tc->surface);
+
+ if (tc->tex_surf && !tc->tex_surf_map)
+ tc->tex_surf_map = pipe_surface_map(tc->tex_surf);
+}
+
+
+void
+sp_tile_cache_unmap_surfaces(struct softpipe_tile_cache *tc)
+{
+ if (tc->surface_map) {
+ pipe_surface_unmap(tc->surface);
+ tc->surface_map = NULL;
+ }
+
+ if (tc->tex_surf_map) {
+ pipe_surface_unmap(tc->tex_surf);
+ tc->tex_surf_map = NULL;
+ }
+}
+
+
/**
* Specify the texture to cache.
*/
tc->texture = texture;
- if (tc->tex_surf && tc->tex_surf->map)
+ if (tc->tex_surf_map) {
pipe_surface_unmap(tc->tex_surf);
+ tc->tex_surf_map = NULL;
+ }
pipe_surface_reference(&tc->tex_surf, NULL);
/* mark as entries as invalid/empty */
if (!ps || !ps->buffer)
return;
- if (!ps->map)
- pipe_surface_map(ps);
-
for (pos = 0; pos < NUM_ENTRIES; pos++) {
struct softpipe_cached_tile *tile = tc->entries + pos;
if (tile->x >= 0) {
tc->tex_z != z) {
/* get new surface (view into texture) */
- if (tc->tex_surf && tc->tex_surf->map)
+ if (tc->tex_surf_map)
pipe_surface_unmap(tc->tex_surf);
tc->tex_surf = pipe->get_tex_surface(pipe, tc->texture, face, level, z);
- pipe_surface_map(tc->tex_surf);
+ tc->tex_surf_map = pipe_surface_map(tc->tex_surf);
tc->tex_face = face;
tc->tex_level = level;
extern struct pipe_surface *
sp_tile_cache_get_surface(struct softpipe_tile_cache *tc);
+extern void
+sp_tile_cache_map_surfaces(struct softpipe_tile_cache *tc);
+
+extern void
+sp_tile_cache_unmap_surfaces(struct softpipe_tile_cache *tc);
+
extern void
sp_tile_cache_set_texture(struct softpipe_tile_cache *tc,
struct pipe_texture *texture);
ubyte *pDest;
uint i;
- assert(ps->map);
-
if (dst_stride == 0) {
dst_stride = w * cpp;
}
if (pipe_clip_tile(x, y, &w, &h, ps))
return;
- pSrc = ps->map + (y * ps->pitch + x) * cpp;
+ pSrc = (const ubyte *) pipe_surface_map(ps) + (y * ps->pitch + x) * cpp;
pDest = (ubyte *) p;
for (i = 0; i < h; i++) {
pDest += dst_stride;
pSrc += src_stride;
}
+
+ pipe_surface_unmap(ps);
}
ubyte *pDest;
uint i;
- assert(ps->map);
-
if (src_stride == 0) {
src_stride = w * cpp;
}
return;
pSrc = (const ubyte *) p;
- pDest = ps->map + (y * ps->pitch + x) * cpp;
+ pDest = (ubyte *) pipe_surface_map(ps) + (y * ps->pitch + x) * cpp;
for (i = 0; i < h; i++) {
memcpy(pDest, pSrc, w * cpp);
pDest += dst_stride;
pSrc += src_stride;
}
+
+ pipe_surface_unmap(ps);
}
static void
a8r8g8b8_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const unsigned *src
- = ((const unsigned *) (ps->map))
+ = ((const unsigned *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
static void
a8r8g8b8_put_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
const float *p)
{
unsigned *dst
- = ((unsigned *) (ps->map))
+ = ((unsigned *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
static void
b8g8r8a8_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const unsigned *src
- = ((const unsigned *) (ps->map))
+ = ((const unsigned *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
static void
b8g8r8a8_put_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
const float *p)
{
unsigned *dst
- = ((unsigned *) (ps->map))
+ = ((unsigned *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
static void
a1r5g5b5_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const ushort *src
- = ((const ushort *) (ps->map))
+ = ((const ushort *) map)
+ y * ps->pitch + x;
unsigned i, j;
static void
a4r4g4b4_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const ushort *src
- = ((const ushort *) (ps->map))
+ = ((const ushort *) map)
+ y * ps->pitch + x;
unsigned i, j;
static void
r5g6b5_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const ushort *src
- = ((const ushort *) (ps->map))
+ = ((const ushort *) map)
+ y * ps->pitch + x;
unsigned i, j;
static void
r5g5b5_put_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
const float *p)
{
ushort *dst
- = ((ushort *) (ps->map))
+ = ((ushort *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
*/
static void
z16_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const ushort *src
- = ((const ushort *) (ps->map))
+ = ((const ushort *) map)
+ y * ps->pitch + x;
const float scale = 1.0f / 65535.0f;
unsigned i, j;
static void
l8_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const ubyte *src
- = ((const ubyte *) (ps->map))
+ = ((const ubyte *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
static void
a8_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const ubyte *src
- = ((const ubyte *) (ps->map))
+ = ((const ubyte *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
static void
r16g16b16a16_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const short *src
- = ((const short *) (ps->map))
+ = ((const short *) map)
+ (y * ps->pitch + x) * 4;
unsigned i, j;
unsigned w0 = w;
static void
r16g16b16a16_put_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
const float *p)
{
short *dst
- = ((short *) (ps->map))
+ = ((short *) map)
+ (y * ps->pitch + x) * 4;
unsigned i, j;
unsigned w0 = w;
static void
i8_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const ubyte *src
- = ((const ubyte *) (ps->map))
+ = ((const ubyte *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
static void
a8_l8_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const ushort *src
- = ((const ushort *) (ps->map))
+ = ((const ushort *) map)
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
*/
static void
z32_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const uint *src
- = ((const uint *) (ps->map))
+ = ((const uint *) map)
+ y * ps->pitch + x;
const double scale = 1.0 / (double) 0xffffffff;
unsigned i, j;
*/
static void
s8z24_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const uint *src
- = ((const uint *) (ps->map))
+ = ((const uint *) map)
+ y * ps->pitch + x;
const double scale = 1.0 / ((1 << 24) - 1);
unsigned i, j;
*/
static void
z24s8_get_tile_rgba(struct pipe_surface *ps,
+ void *map,
unsigned x, unsigned y, unsigned w, unsigned h,
float *p)
{
const uint *src
- = ((const uint *) (ps->map))
+ = ((const uint *) map)
+ y * ps->pitch + x;
const double scale = 1.0 / ((1 << 24) - 1);
unsigned i, j;
uint x, uint y, uint w, uint h,
float *p)
{
+ void *map = pipe_surface_map(ps);
+
switch (ps->format) {
case PIPE_FORMAT_A8R8G8B8_UNORM:
- a8r8g8b8_get_tile_rgba(ps, x, y, w, h, p);
+ a8r8g8b8_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_B8G8R8A8_UNORM:
- b8g8r8a8_get_tile_rgba(ps, x, y, w, h, p);
+ b8g8r8a8_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_A1R5G5B5_UNORM:
- a1r5g5b5_get_tile_rgba(ps, x, y, w, h, p);
+ a1r5g5b5_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_A4R4G4B4_UNORM:
- a4r4g4b4_get_tile_rgba(ps, x, y, w, h, p);
+ a4r4g4b4_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_R5G6B5_UNORM:
- r5g6b5_get_tile_rgba(ps, x, y, w, h, p);
+ r5g6b5_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_U_L8:
- l8_get_tile_rgba(ps, x, y, w, h, p);
+ l8_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_U_A8:
- a8_get_tile_rgba(ps, x, y, w, h, p);
+ a8_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_U_I8:
- i8_get_tile_rgba(ps, x, y, w, h, p);
+ i8_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_U_A8_L8:
- a8_l8_get_tile_rgba(ps, x, y, w, h, p);
+ a8_l8_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_R16G16B16A16_SNORM:
- r16g16b16a16_get_tile_rgba(ps, x, y, w, h, p);
+ r16g16b16a16_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_Z16_UNORM:
- z16_get_tile_rgba(ps, x, y, w, h, p);
+ z16_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_Z32_UNORM:
- z32_get_tile_rgba(ps, x, y, w, h, p);
+ z32_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_S8Z24_UNORM:
- s8z24_get_tile_rgba(ps, x, y, w, h, p);
+ s8z24_get_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_Z24S8_UNORM:
- z24s8_get_tile_rgba(ps, x, y, w, h, p);
+ z24s8_get_tile_rgba(ps, map, x, y, w, h, p);
break;
default:
assert(0);
}
+
+ pipe_surface_unmap(ps);
}
uint x, uint y, uint w, uint h,
const float *p)
{
+ void *map = pipe_surface_map(ps);
+
switch (ps->format) {
case PIPE_FORMAT_A8R8G8B8_UNORM:
- a8r8g8b8_put_tile_rgba(ps, x, y, w, h, p);
+ a8r8g8b8_put_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_B8G8R8A8_UNORM:
- b8g8r8a8_put_tile_rgba(ps, x, y, w, h, p);
+ b8g8r8a8_put_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_A1R5G5B5_UNORM:
- /*a1r5g5b5_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*a1r5g5b5_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
case PIPE_FORMAT_R5G6B5_UNORM:
- r5g5b5_put_tile_rgba(ps, x, y, w, h, p);
+ r5g5b5_put_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_R8G8B8A8_UNORM:
break;
case PIPE_FORMAT_U_L8:
- /*l8_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*l8_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
case PIPE_FORMAT_U_A8:
- /*a8_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*a8_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
case PIPE_FORMAT_U_I8:
- /*i8_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*i8_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
case PIPE_FORMAT_U_A8_L8:
- /*a8_l8_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*a8_l8_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
case PIPE_FORMAT_R16G16B16A16_SNORM:
- r16g16b16a16_put_tile_rgba(ps, x, y, w, h, p);
+ r16g16b16a16_put_tile_rgba(ps, map, x, y, w, h, p);
break;
case PIPE_FORMAT_Z16_UNORM:
- /*z16_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*z16_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
case PIPE_FORMAT_Z32_UNORM:
- /*z32_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*z32_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
case PIPE_FORMAT_S8Z24_UNORM:
- /*s8z24_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*s8z24_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
case PIPE_FORMAT_Z24S8_UNORM:
- /*z24s8_put_tile_rgba(ps, x, y, w, h, p);*/
+ /*z24s8_put_tile_rgba(ps, map, x, y, w, h, p);*/
break;
default:
assert(0);
}
+
+ pipe_surface_unmap(ps);
}
GLboolean XMesaGetDepthBuffer( XMesaBuffer b, GLint *width, GLint *height,
GLint *bytesPerValue, void **buffer )
{
- struct pipe_surface *surf
- = st_get_framebuffer_surface(b->stfb, ST_SURFACE_DEPTH);
- if (surf) {
- *width = surf->width;
- *height = surf->pitch;
- *bytesPerValue = surf->cpp;
- *buffer = surf->map;
- return GL_TRUE;
- }
- else {
- *width = 0;
- *height = 0;
- *bytesPerValue = 0;
- *buffer = 0;
- return GL_FALSE;
- }
+ *width = 0;
+ *height = 0;
+ *bytesPerValue = 0;
+ *buffer = 0;
+ return GL_FALSE;
}
void
st_clear_accum_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
{
+ struct pipe_context *pipe = ctx->st->pipe;
struct st_renderbuffer *acc_strb = st_renderbuffer(rb);
struct pipe_surface *acc_ps = acc_strb->surface;
const GLint xpos = ctx->DrawBuffer->_Xmin;
const GLfloat g = ctx->Accum.ClearColor[1];
const GLfloat b = ctx->Accum.ClearColor[2];
const GLfloat a = ctx->Accum.ClearColor[3];
+ GLfloat *accBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
+ int i;
- (void) pipe_surface_map(acc_ps);
-
- switch (acc_ps->format) {
- case PIPE_FORMAT_R16G16B16A16_SNORM:
- {
- const short sr = (short) (32767 * r);
- const short sg = (short) (32767 * g);
- const short sb = (short) (32767 * b);
- const short sa = (short) (32767 * a);
- short *acc = ((short *) acc_ps->map)
- + (ypos * acc_ps->pitch + xpos) * 4;
- int i, j;
- for (i = 0; i < height; i++) {
- for (j = 0; j < width; j++) {
- acc[j*4+0] = sr;
- acc[j*4+1] = sg;
- acc[j*4+2] = sb;
- acc[j*4+3] = sa;
- }
- acc += acc_ps->pitch * 4;
- }
- }
- break;
- default:
- assert(0);
+ for (i = 0; i < width * height; i++) {
+ accBuf[i*4+0] = r;
+ accBuf[i*4+1] = g;
+ accBuf[i*4+2] = b;
+ accBuf[i*4+3] = a;
}
- pipe_surface_unmap(acc_ps);
-}
-
-
-/** Get block of values from accum buffer, converting to float */
-static void
-get_accum_tile(struct pipe_context *pipe,
- struct pipe_surface *acc_surf,
- int xpos, int ypos, int width, int height,
- float *buf)
-{
- switch (acc_surf->format) {
- case PIPE_FORMAT_R16G16B16A16_SNORM:
- {
- const short *acc = ((const short *) acc_surf->map)
- + (ypos * acc_surf->pitch + xpos) * 4;
- int i, j;
- for (i = 0; i < height; i++) {
- for (j = 0; j < width; j++) {
- buf[j*4+0] = SHORT_TO_FLOAT(acc[j*4+0]);
- buf[j*4+1] = SHORT_TO_FLOAT(acc[j*4+1]);
- buf[j*4+2] = SHORT_TO_FLOAT(acc[j*4+2]);
- buf[j*4+3] = SHORT_TO_FLOAT(acc[j*4+3]);
- }
- acc += acc_surf->pitch * 4;
- buf += width * 4;
- }
- }
- break;
- default:
- assert(0);
- }
-}
-
-
-/** Put block of values into accum buffer, converting from float */
-static void
-put_accum_tile(struct pipe_context *pipe,
- struct pipe_surface *acc_surf,
- int xpos, int ypos, int width, int height,
- const float *buf)
-{
- switch (acc_surf->format) {
- case PIPE_FORMAT_R16G16B16A16_SNORM:
- {
- short *acc = ((short *) acc_surf->map)
- + (ypos * acc_surf->pitch + xpos) * 4;
- int i, j;
- for (i = 0; i < height; i++) {
- for (j = 0; j < width; j++) {
- short r, g, b, a;
- UNCLAMPED_FLOAT_TO_SHORT(r, buf[j*4+0]);
- UNCLAMPED_FLOAT_TO_SHORT(g, buf[j*4+1]);
- UNCLAMPED_FLOAT_TO_SHORT(b, buf[j*4+2]);
- UNCLAMPED_FLOAT_TO_SHORT(a, buf[j*4+3]);
- acc[j*4+0] = r;
- acc[j*4+1] = g;
- acc[j*4+2] = b;
- acc[j*4+3] = a;
- }
- acc += acc_surf->pitch * 4;
- buf += width * 4;
- }
- }
- break;
- default:
- assert(0);
- }
+ pipe->put_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
}
accBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
- (void) pipe_surface_map(acc_ps);
-
- get_accum_tile(pipe, acc_ps, xpos, ypos, width, height, accBuf);
+ pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
for (i = 0; i < 4 * width * height; i++) {
accBuf[i] = accBuf[i] * scale + bias;
}
- put_accum_tile(pipe, acc_ps, xpos, ypos, width, height, accBuf);
+ pipe->put_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
free(accBuf);
-
- pipe_surface_unmap(acc_ps);
}
struct pipe_surface *acc_ps,
struct pipe_surface *color_ps)
{
- ubyte *colorMap, *accMap;
GLfloat *colorBuf, *accBuf;
GLint i;
colorBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
accBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
- colorMap = pipe_surface_map(color_ps);
- accMap = pipe_surface_map(acc_ps);
-
pipe->get_tile_rgba(pipe, color_ps, xpos, ypos, width, height, colorBuf);
- get_accum_tile(pipe, acc_ps, xpos, ypos, width, height, accBuf);
+ pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
for (i = 0; i < 4 * width * height; i++) {
accBuf[i] = accBuf[i] + colorBuf[i] * value;
}
- put_accum_tile(pipe, acc_ps, xpos, ypos, width, height, accBuf);
+ pipe->put_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
free(colorBuf);
free(accBuf);
-
- pipe_surface_unmap(color_ps);
- pipe_surface_unmap(acc_ps);
}
buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
- (void) pipe_surface_map(color_ps);
- (void) pipe_surface_map(acc_ps);
-
pipe->get_tile_rgba(pipe, color_ps, xpos, ypos, width, height, buf);
for (i = 0; i < 4 * width * height; i++) {
buf[i] = buf[i] * value;
}
- put_accum_tile(pipe, acc_ps, xpos, ypos, width, height, buf);
+ pipe->put_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, buf);
free(buf);
-
- pipe_surface_unmap(color_ps);
- pipe_surface_unmap(acc_ps);
}
abuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
- (void) pipe_surface_map(color_ps);
- (void) pipe_surface_map(acc_ps);
-
- get_accum_tile(pipe, acc_ps, xpos, ypos, width, height, abuf);
+ pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, abuf);
if (!colormask[0] || !colormask[1] || !colormask[2] || !colormask[3]) {
cbuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
free(abuf);
if (cbuf)
free(cbuf);
-
- pipe_surface_unmap(color_ps);
- pipe_surface_unmap(acc_ps);
}
/* alternate path using get/put_tile() */
GLfloat *buf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
- (void) pipe_surface_map(psRead);
- (void) pipe_surface_map(psTex);
-
pipe->get_tile_rgba(pipe, psRead, srcx, srcy, width, height, buf);
pipe->put_tile_rgba(pipe, psTex, 0, 0, width, height, buf);
- pipe_surface_unmap(psRead);
- pipe_surface_unmap(psTex);
-
free(buf);
}
return GL_FALSE;
}
- /* loop here since mapping is refcounted */
- while (strb->surface->map)
- pipe_surface_unmap(strb->surface);
if (strb->surface->buffer)
pipe->winsys->buffer_reference(pipe->winsys, &strb->surface->buffer,
NULL);
if (!strb)
return;
- pipe_surface_map(strb->surface);
-
if (format == GL_RGBA && type == GL_FLOAT) {
/* write tile(row) directly into user's buffer */
df = (GLfloat *) _mesa_image_address2d(&clippedPacking, dest, width,
}
}
}
-
- pipe_surface_unmap(strb->surface);
}
dest_surf = pipe->get_tex_surface(pipe, pt,
face, level, destZ);
- (void) pipe_surface_map(dest_surf);
- (void) pipe_surface_map(src_surf);
-
/* buffer for one row */
data = (GLfloat *) malloc(width * 4 * sizeof(GLfloat));
/* do copy row by row */
for (row = 0; row < height; row++) {
- pipe->get_tile_rgba(pipe, src_surf, srcX, srcY + row, width, 1, data);
+ pipe->get_tile_rgba(pipe, src_surf, srcX, srcY + row, width, 1,
+ data);
/* XXX we're ignoring convolution for now */
if (ctx->_ImageTransferState) {
width, (GLfloat (*)[4])data);
}
- pipe->put_tile_rgba(pipe, dest_surf, destX, destY, width, 1, data);
+ pipe->put_tile_rgba(pipe, dest_surf, destX, destY, width, 1,
+ data);
destY += yStep;
}
-
- (void) pipe_surface_unmap(dest_surf);
- (void) pipe_surface_unmap(src_surf);
-
free(data);
}
projects / mesa.git / commitdiff