fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-02-01 22:00:26 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Merge branch 'upstream-gallium-0.1' into darktama-gallium-0.1

Browse source 
Conflicts:

	src/mesa/drivers/dri/Makefile.template
This commit is contained in:
Ben Skeggs 2007-12-11 10:01:59 +11:00
commit fe9f4f49ef
56 changed files with 2516 additions and 282 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
configs/linux-cell
View file

@ -13,7 +13,7 @@ CXX = /usr/bin/ppu32-g++
SDK = /opt/ibm/cell-sdk/prototype/sysroot/usr
CFLAGS = -g -W -Wall -Winline -fPIC -m32 -mabi=altivec -maltivec -I. -I/usr/include -I$(SDK)/include -include altivec.h
CFLAGS = -g -W -Winline -fPIC -m32 -mabi=altivec -maltivec -I. -I/usr/include -I$(SDK)/include -include altivec.h -DGALLIUM_CELL
CXXFLAGS = $(CFLAGS)

11
src/mesa/drivers/dri/Makefile.template
View file

@ -2,13 +2,16 @@
MESA_MODULES = $(TOP)/src/mesa/libmesa.a
COMMON_SOURCES = \
COMMON_GALLIUM_SOURCES = \
../common/utils.c \
../common/texmem.c \
../common/vblank.c \
../common/dri_util.c \
../common/xmlconfig.c \
../common/drirenderbuffer.c
../common/xmlconfig.c
COMMON_SOURCES = $(COMMON_GALLIUM_SOURCES) \
../../common/driverfuncs.c \
../common/texmem.c \
../common/drirenderbuffer.c
COMMON_BM_SOURCES = \
../common/dri_bufmgr.c \

2
src/mesa/drivers/dri/intel_winsys/Makefile
View file

@ -22,7 +22,7 @@ DRIVER_SOURCES = \
intel_batchpool.c
C_SOURCES = \
$(COMMON_SOURCES) \
$(COMMON_GALLIUM_SOURCES) \
$(COMMON_BM_SOURCES) \
$(DRIVER_SOURCES)

2
src/mesa/drivers/dri/intel_winsys/intel_winsys_pipe.c
View file

@ -191,7 +191,7 @@ intel_i915_surface_pitch(struct pipe_winsys *winsys,
*/
/* XXX is the pitch different for textures vs. drawables? */
if (flags & PIPE_SURFACE_FLAG_TEXTURE) /* or PIPE_SURFACE_FLAG_RENDER? */
if (1/*flags & PIPE_SURFACE_FLAG_TEXTURE*/) /* or PIPE_SURFACE_FLAG_RENDER? */
return ((cpp * width + 63) & ~63) / cpp;
else
return ((cpp * width + 63) & ~63) / cpp;

89
src/mesa/pipe/cell/common.h
View file

@ -1,13 +1,94 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
/**
* Types and tokens which are common to the SPU and PPU code.
*/
#ifndef CELL_COMMON_H
#define CELL_COMMON_H
#include "pipe/p_util.h"
struct init_info
#define ALIGN16 __attribute__( (aligned( 16 )) )
#define ASSERT_ALIGN16(ptr) \
assert((((unsigned long) (ptr)) & 0xf) == 0);
#define TILE_SIZE 32
#define CELL_CMD_EXIT 1
#define CELL_CMD_FRAMEBUFFER 2
#define CELL_CMD_CLEAR_TILES 3
#define CELL_CMD_INVERT_TILES 4
#define CELL_CMD_FINISH 5
/**
* Tell SPUs about the framebuffer size, location
*/
struct cell_command_framebuffer
{
int foo;
int bar;
};
void *start;
int width, height;
unsigned format;
} ALIGN16;
/**
* Clear framebuffer tiles to given value/color.
*/
struct cell_command_clear_tiles
{
uint value;
} ALIGN16;
/** XXX unions don't seem to work */
struct cell_command
{
struct cell_command_framebuffer fb;
struct cell_command_clear_tiles clear;
} ALIGN16;
struct cell_init_info
{
unsigned id;
unsigned num_spus;
struct cell_command *cmd;
} ALIGN16;
#endif /* CELL_COMMON_H */

15
src/mesa/pipe/cell/ppu/Makefile
View file

@ -17,7 +17,18 @@ SPU_CODE_MODULE = ../spu/g3d_spu.a
SOURCES = \
cell_context.c \
cell_surface.c
cell_flush.c \
cell_state_blend.c \
cell_state_clip.c \
cell_state_fs.c \
cell_state_rasterizer.c \
cell_state_sampler.c \
cell_state_surface.c \
cell_state_vertex.c \
cell_spu.c \
cell_surface.c \
cell_winsys.c
OBJECTS = $(SOURCES:.c=.o) \
@ -42,7 +53,7 @@ $(CELL_LIB): $(OBJECTS) $(SPU_CODE_MODULE)
clean:
rm -f *.o $(CELL_LIB)
rm -f *.o *~ $(CELL_LIB)

247
src/mesa/pipe/cell/ppu/cell_context.c
View file

@ -32,45 +32,232 @@
#include <stdio.h>
#include <libspe.h>
#include <libmisc.h>
#include "pipe/cell/ppu/cell_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_format.h"
#include "pipe/p_util.h"
#include "pipe/p_winsys.h"
#include "pipe/cell/common.h"
#define NUM_SPUS 6
#include "pipe/draw/draw_context.h"
#include "cell_context.h"
#include "cell_flush.h"
#include "cell_state.h"
#include "cell_surface.h"
#include "cell_spu.h"
extern spe_program_handle_t g3d_spu;
static speid_t speid[NUM_SPUS];
static struct init_info inits[NUM_SPUS];
static void
start_spus(void)
static boolean
cell_is_format_supported( struct pipe_context *pipe,
enum pipe_format format, uint type )
{
int i;
struct cell_context *cell = cell_context( pipe );
for (i = 0; i < NUM_SPUS; i++) {
inits[i].foo = i;
inits[i].bar = i * 10;
speid[i] = spe_create_thread(0, /* gid */
&g3d_spu, /* spe program handle */
&inits[i], /* argp */
NULL, /* envp */
-1, /* mask */
0 ); /* flags */
switch (type) {
case PIPE_TEXTURE:
/* cell supports all texture formats, XXX for now anyway */
return TRUE;
case PIPE_SURFACE:
/* cell supports all (off-screen) surface formats, XXX for now */
return TRUE;
case PIPE_SCREEN_SURFACE:
return format == cell->winsys->preferredFormat;
default:
assert(0);
return FALSE;
}
}
void cell_create_context(void)
static int cell_get_param(struct pipe_context *pipe, int param)
{
printf("cell_create_context\n");
start_spus();
/* TODO: do something with the SPUs! */
switch (param) {
case PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS:
return 8;
case PIPE_CAP_NPOT_TEXTURES:
return 1;
case PIPE_CAP_TWO_SIDED_STENCIL:
return 1;
case PIPE_CAP_GLSL:
return 1;
case PIPE_CAP_S3TC:
return 0;
case PIPE_CAP_ANISOTROPIC_FILTER:
return 0;
case PIPE_CAP_POINT_SPRITE:
return 1;
case PIPE_CAP_MAX_RENDER_TARGETS:
return 1;
case PIPE_CAP_OCCLUSION_QUERY:
return 1;
case PIPE_CAP_TEXTURE_SHADOW_MAP:
return 1;
case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
return 12; /* max 2Kx2K */
case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
return 8; /* max 128x128x128 */
case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
return 12; /* max 2Kx2K */
default:
return 0;
}
}
static float cell_get_paramf(struct pipe_context *pipe, int param)
{
switch (param) {
case PIPE_CAP_MAX_LINE_WIDTH:
/* fall-through */
case PIPE_CAP_MAX_LINE_WIDTH_AA:
return 255.0; /* arbitrary */
case PIPE_CAP_MAX_POINT_WIDTH:
/* fall-through */
case PIPE_CAP_MAX_POINT_WIDTH_AA:
return 255.0; /* arbitrary */
case PIPE_CAP_MAX_TEXTURE_ANISOTROPY:
return 0.0;
case PIPE_CAP_MAX_TEXTURE_LOD_BIAS:
return 16.0; /* arbitrary */
default:
return 0;
}
}
static const char *
cell_get_name( struct pipe_context *pipe )
{
return "Cell";
}
static const char *
cell_get_vendor( struct pipe_context *pipe )
{
return "Tungsten Graphics, Inc.";
}
static void
cell_destroy_context( struct pipe_context *pipe )
{
struct cell_context *cell = cell_context(pipe);
cell_spu_exit(cell);
wait_spus(cell->num_spus);
free(cell);
}
struct pipe_context *
cell_create_context(struct pipe_winsys *winsys, struct cell_winsys *cws)
{
struct cell_context *cell;
cell = CALLOC_STRUCT(cell_context);
if (!cell)
return NULL;
cell->winsys = cws;
cell->pipe.winsys = winsys;
cell->pipe.destroy = cell_destroy_context;
/* queries */
cell->pipe.is_format_supported = cell_is_format_supported;
cell->pipe.get_name = cell_get_name;
cell->pipe.get_vendor = cell_get_vendor;
cell->pipe.get_param = cell_get_param;
cell->pipe.get_paramf = cell_get_paramf;
/* state setters */
cell->pipe.create_alpha_test_state = cell_create_alpha_test_state;
cell->pipe.bind_alpha_test_state = cell_bind_alpha_test_state;
cell->pipe.delete_alpha_test_state = cell_delete_alpha_test_state;
cell->pipe.create_blend_state = cell_create_blend_state;
cell->pipe.bind_blend_state = cell_bind_blend_state;
cell->pipe.delete_blend_state = cell_delete_blend_state;
cell->pipe.create_sampler_state = cell_create_sampler_state;
cell->pipe.bind_sampler_state = cell_bind_sampler_state;
cell->pipe.delete_sampler_state = cell_delete_sampler_state;
cell->pipe.create_depth_stencil_state = cell_create_depth_stencil_state;
cell->pipe.bind_depth_stencil_state = cell_bind_depth_stencil_state;
cell->pipe.delete_depth_stencil_state = cell_delete_depth_stencil_state;
cell->pipe.create_rasterizer_state = cell_create_rasterizer_state;
cell->pipe.bind_rasterizer_state = cell_bind_rasterizer_state;
cell->pipe.delete_rasterizer_state = cell_delete_rasterizer_state;
cell->pipe.create_fs_state = cell_create_fs_state;
cell->pipe.bind_fs_state = cell_bind_fs_state;
cell->pipe.delete_fs_state = cell_delete_fs_state;
cell->pipe.create_vs_state = cell_create_vs_state;
cell->pipe.bind_vs_state = cell_bind_vs_state;
cell->pipe.delete_vs_state = cell_delete_vs_state;
cell->pipe.set_blend_color = cell_set_blend_color;
cell->pipe.set_clip_state = cell_set_clip_state;
cell->pipe.set_clear_color_state = cell_set_clear_color_state;
cell->pipe.set_constant_buffer = cell_set_constant_buffer;
#if 0
cell->pipe.set_feedback_state = cell_set_feedback_state;
#endif
cell->pipe.set_framebuffer_state = cell_set_framebuffer_state;
cell->pipe.set_polygon_stipple = cell_set_polygon_stipple;
cell->pipe.set_sampler_units = cell_set_sampler_units;
cell->pipe.set_scissor_state = cell_set_scissor_state;
cell->pipe.set_texture_state = cell_set_texture_state;
cell->pipe.set_viewport_state = cell_set_viewport_state;
cell->pipe.set_vertex_buffer = cell_set_vertex_buffer;
cell->pipe.set_vertex_element = cell_set_vertex_element;
#if 0
cell->pipe.set_feedback_buffer = cell_set_feedback_buffer;
cell->pipe.draw_arrays = cell_draw_arrays;
cell->pipe.draw_elements = cell_draw_elements;
#endif
cell->pipe.clear = cell_clear_surface;
cell->pipe.flush = cell_flush;
#if 0
cell->pipe.begin_query = cell_begin_query;
cell->pipe.end_query = cell_end_query;
cell->pipe.wait_query = cell_wait_query;
/* textures */
cell->pipe.mipmap_tree_layout = cell_mipmap_tree_layout;
cell->pipe.get_tex_surface = cell_get_tex_surface;
#endif
cell->draw = draw_create();
/*
* SPU stuff
*/
cell->num_spus = 6; /* XXX >6 seems to fail */
cell_start_spus(cell->num_spus);
#if 0
test_spus(cell);
wait_spus();
#endif
return &cell->pipe;
}

49
src/mesa/pipe/cell/ppu/cell_context.h
View file

@ -31,16 +31,61 @@
#include "pipe/p_context.h"
#include "cell_winsys.h"
struct cell_context
{
struct pipe_context pipe;
int spu_info;
struct cell_winsys *winsys;
const struct pipe_alpha_test_state *alpha_test;
const struct pipe_blend_state *blend;
const struct pipe_sampler_state *sampler[PIPE_MAX_SAMPLERS];
const struct pipe_depth_stencil_state *depth_stencil;
const struct pipe_rasterizer_state *rasterizer;
struct pipe_blend_color blend_color;
struct pipe_clear_color_state clear_color;
struct pipe_clip_state clip;
struct pipe_constant_buffer constants[2];
struct pipe_feedback_state feedback;
struct pipe_framebuffer_state framebuffer;
struct pipe_poly_stipple poly_stipple;
struct pipe_scissor_state scissor;
struct softpipe_texture *texture[PIPE_MAX_SAMPLERS];
struct pipe_viewport_state viewport;
struct pipe_vertex_buffer vertex_buffer[PIPE_ATTRIB_MAX];
struct pipe_vertex_element vertex_element[PIPE_ATTRIB_MAX];
uint sampler_units[PIPE_MAX_SAMPLERS];
uint dirty;
/** The primitive drawing context */
struct draw_context *draw;
struct draw_stage *setup;
struct draw_stage *vbuf;
uint num_spus;
};
static INLINE struct cell_context *
cell_context(struct pipe_context *pipe)
{
return (struct cell_context *) pipe;
}
extern struct pipe_context *
cell_create_context(struct pipe_winsys *ws, struct cell_winsys *cws);
#endif /* CELL_CONTEXT_H */

54
src/mesa/pipe/cell/ppu/cell_flush.c Normal file
View file

@ -0,0 +1,54 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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 <cbe_mfc.h>
#include "cell_context.h"
#include "cell_flush.h"
#include "cell_spu.h"
void
cell_flush(struct pipe_context *pipe, unsigned flags)
{
struct cell_context *cell = cell_context(pipe);
uint i;
printf("%s\n", __FUNCTION__);
/* Send CMD_FINISH to all SPUs */
for (i = 0; i < cell->num_spus; i++) {
send_mbox_message(control_ps_area[i], CELL_CMD_FINISH);
}
/* Wait for ack */
for (i = 0; i < cell->num_spus; i++) {
uint k = wait_mbox_message(control_ps_area[i]);
assert(k == CELL_CMD_FINISH);
}
}

35
src/mesa/pipe/cell/ppu/cell_flush.h Normal file
View file

@ -0,0 +1,35 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
#ifndef CELL_FLUSH
#define CELL_FLUSH
extern void
cell_flush(struct pipe_context *pipe, unsigned flags);
#endif

223
src/mesa/pipe/cell/ppu/cell_spu.c Normal file
View file

@ -0,0 +1,223 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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 <cbe_mfc.h>
#include "cell_spu.h"
#include "pipe/p_format.h"
#include "pipe/p_state.h"
#include "pipe/cell/common.h"
/*
helpful headers:
/opt/ibm/cell-sdk/prototype/src/include/ppu/cbe_mfc.h
*/
/**
* SPU/SPE handles, etc
*/
speid_t speid[MAX_SPUS];
spe_spu_control_area_t *control_ps_area[MAX_SPUS];
/**
* Data sent to SPUs
*/
struct cell_init_info inits[MAX_SPUS] ALIGN16;
struct cell_command command[MAX_SPUS] ALIGN16;
/**
* Write a 1-word message to the given SPE mailbox.
*/
void
send_mbox_message(spe_spu_control_area_t *ca, unsigned int msg)
{
while (_spe_in_mbox_status(ca) < 1)
;
_spe_in_mbox_write(ca, msg);
}
/**
* Wait for a 1-word message to arrive in given mailbox.
*/
uint
wait_mbox_message(spe_spu_control_area_t *ca)
{
uint k;
while (_spe_out_mbox_status(ca) < 1)
;
k = _spe_out_mbox_read(ca);
return k;
}
/**
* Create the SPU threads
*/
void
cell_start_spus(uint num_spus)
{
uint i;
assert((sizeof(struct cell_command) & 0xf) == 0);
ASSERT_ALIGN16(&command[0]);
ASSERT_ALIGN16(&command[1]);
assert((sizeof(struct cell_init_info) & 0xf) == 0);
ASSERT_ALIGN16(&inits[0]);
ASSERT_ALIGN16(&inits[1]);
/* XXX do we need to create a gid with spe_create_group()? */
for (i = 0; i < num_spus; i++) {
inits[i].id = i;
inits[i].num_spus = num_spus;
inits[i].cmd = &command[i];
speid[i] = spe_create_thread(0, /* gid */
&g3d_spu, /* spe program handle */
&inits[i], /* argp */
NULL, /* envp */
-1, /* mask */
SPE_MAP_PS/*0*/ ); /* flags */
control_ps_area[i] = spe_get_ps_area(speid[i], SPE_CONTROL_AREA);
assert(control_ps_area[i]);
}
}
/** wait for all SPUs to finish working */
/** XXX temporary */
void
finish_all(uint num_spus)
{
uint i;
for (i = 0; i < num_spus; i++) {
send_mbox_message(control_ps_area[i], CELL_CMD_FINISH);
}
for (i = 0; i < num_spus; i++) {
/* wait for mbox message */
unsigned k;
while (_spe_out_mbox_status(control_ps_area[i]) < 1)
;
k = _spe_out_mbox_read(control_ps_area[i]);
assert(k == CELL_CMD_FINISH);
}
}
/**
** Send test commands (XXX temporary)
**/
void
test_spus(struct cell_context *cell)
{
uint i;
struct pipe_surface *surf = cell->framebuffer.cbufs[0];
printf("PPU: sleep(2)\n\n\n");
sleep(2);
for (i = 0; i < cell->num_spus; i++) {
command[i].fb.start = surf->map;
command[i].fb.width = surf->width;
command[i].fb.height = surf->height;
command[i].fb.format = PIPE_FORMAT_A8R8G8B8_UNORM;
send_mbox_message(control_ps_area[i], CELL_CMD_FRAMEBUFFER);
}
for (i = 0; i < cell->num_spus; i++) {
command[i].clear.value = 0xff880044; /* XXX */
send_mbox_message(control_ps_area[i], CELL_CMD_CLEAR_TILES);
}
finish_all(cell->num_spus);
{
uint *b = (uint*) surf->map;
printf("PPU: Clear results: 0x%x 0x%x 0x%x 0x%x\n",
b[0], b[1000], b[2000], b[3000]);
}
for (i = 0; i < cell->num_spus; i++) {
send_mbox_message(control_ps_area[i], CELL_CMD_INVERT_TILES);
}
finish_all(cell->num_spus);
{
uint *b = (uint*) surf->map;
printf("PPU: Inverted results: 0x%x 0x%x 0x%x 0x%x\n",
b[0], b[1000], b[2000], b[3000]);
}
for (i = 0; i < cell->num_spus; i++) {
send_mbox_message(control_ps_area[i], CELL_CMD_EXIT);
}
}
/**
* Wait for all SPUs to exit/return.
*/
void
wait_spus(uint num_spus)
{
int i, status;
for (i = 0; i < num_spus; i++) {
spe_wait( speid[i], &status, 1 );
}
}
/**
* Tell all the SPUs to stop/exit.
*/
void
cell_spu_exit(struct cell_context *cell)
{
uint i;
int status;
for (i = 0; i < cell->num_spus; i++) {
send_mbox_message(control_ps_area[i], CELL_CMD_EXIT);
}
for (i = 0; i < cell->num_spus; i++) {
spe_wait( speid[i], &status, 1 );
}
}

81
src/mesa/pipe/cell/ppu/cell_spu.h Normal file
View file

@ -0,0 +1,81 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
#ifndef CELL_SPU
#define CELL_SPU
#include <libspe.h>
#include <libmisc.h>
#include "pipe/cell/common.h"
#include "cell_context.h"
#define MAX_SPUS 7
/**
* SPU/SPE handles, etc
*/
extern spe_program_handle_t g3d_spu;
extern speid_t speid[MAX_SPUS];
extern spe_spu_control_area_t *control_ps_area[MAX_SPUS];
/**
* Data sent to SPUs
*/
extern struct cell_init_info inits[MAX_SPUS] ALIGN16;
extern struct cell_command command[MAX_SPUS] ALIGN16;
void
send_mbox_message(spe_spu_control_area_t *ca, unsigned int msg);
uint
wait_mbox_message(spe_spu_control_area_t *ca);
void
cell_start_spus(uint num_spus);
void
finish_all(uint num_spus);
void
test_spus(struct cell_context *cell);
void
wait_spus(uint num_spus);
void
cell_spu_exit(struct cell_context *cell);
#endif /* CELL_SPU */

117
src/mesa/pipe/cell/ppu/cell_state.h Normal file
View file

@ -0,0 +1,117 @@
#ifndef CELL_STATE_H
#define CELL_STATE_H
#define CELL_NEW_VIEWPORT 0x1
#define CELL_NEW_RASTERIZER 0x2
#define CELL_NEW_FS 0x4
#define CELL_NEW_BLEND 0x8
#define CELL_NEW_CLIP 0x10
#define CELL_NEW_SCISSOR 0x20
#define CELL_NEW_STIPPLE 0x40
#define CELL_NEW_FRAMEBUFFER 0x80
#define CELL_NEW_ALPHA_TEST 0x100
#define CELL_NEW_DEPTH_STENCIL 0x200
#define CELL_NEW_SAMPLER 0x400
#define CELL_NEW_TEXTURE 0x800
#define CELL_NEW_VERTEX 0x1000
#define CELL_NEW_VS 0x2000
#define CELL_NEW_CONSTANTS 0x4000
extern void
cell_set_framebuffer_state( struct pipe_context *,
const struct pipe_framebuffer_state * );
extern void *
cell_create_alpha_test_state(struct pipe_context *,
const struct pipe_alpha_test_state *);
extern void
cell_bind_alpha_test_state(struct pipe_context *, void *);
extern void
cell_delete_alpha_test_state(struct pipe_context *, void *);
extern void *
cell_create_blend_state(struct pipe_context *, const struct pipe_blend_state *);
extern void cell_bind_blend_state(struct pipe_context *, void *);
extern void cell_delete_blend_state(struct pipe_context *, void *);
extern void cell_set_blend_color( struct pipe_context *pipe,
const struct pipe_blend_color *blend_color );
void *
cell_create_sampler_state(struct pipe_context *,
const struct pipe_sampler_state *);
extern void
cell_bind_sampler_state(struct pipe_context *, unsigned, void *);
extern void
cell_delete_sampler_state(struct pipe_context *, void *);
extern void *
cell_create_depth_stencil_state(struct pipe_context *,
const struct pipe_depth_stencil_state *);
extern void
cell_bind_depth_stencil_state(struct pipe_context *, void *);
extern void
cell_delete_depth_stencil_state(struct pipe_context *, void *);
void *cell_create_fs_state(struct pipe_context *,
const struct pipe_shader_state *);
void cell_bind_fs_state(struct pipe_context *, void *);
void cell_delete_fs_state(struct pipe_context *, void *);
void *cell_create_vs_state(struct pipe_context *,
const struct pipe_shader_state *);
void cell_bind_vs_state(struct pipe_context *, void *);
void cell_delete_vs_state(struct pipe_context *, void *);
void *
cell_create_rasterizer_state(struct pipe_context *,
const struct pipe_rasterizer_state *);
void cell_bind_rasterizer_state(struct pipe_context *, void *);
void cell_delete_rasterizer_state(struct pipe_context *, void *);
void cell_set_clip_state( struct pipe_context *,
const struct pipe_clip_state * );
void cell_set_constant_buffer(struct pipe_context *pipe,
uint shader, uint index,
const struct pipe_constant_buffer *buf);
void cell_set_polygon_stipple( struct pipe_context *,
const struct pipe_poly_stipple * );
void cell_set_sampler_units( struct pipe_context *,
uint numSamplers, const uint *units );
void cell_set_scissor_state( struct pipe_context *,
const struct pipe_scissor_state * );
void cell_set_texture_state( struct pipe_context *,
unsigned unit, struct pipe_texture * );
void cell_set_vertex_element(struct pipe_context *,
unsigned index,
const struct pipe_vertex_element *);
void cell_set_vertex_buffer(struct pipe_context *,
unsigned index,
const struct pipe_vertex_buffer *);
void cell_set_viewport_state( struct pipe_context *,
const struct pipe_viewport_state * );
#endif

128
src/mesa/pipe/cell/ppu/cell_state_blend.c Normal file
View file

@ -0,0 +1,128 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
/* Authors: Keith Whitwell <keith@tungstengraphics.com>
*/
#include "pipe/p_util.h"
#include "cell_context.h"
#include "cell_state.h"
void *
cell_create_blend_state(struct pipe_context *pipe,
const struct pipe_blend_state *blend)
{
struct pipe_blend_state *state = MALLOC( sizeof(struct pipe_blend_state) );
memcpy(state, blend, sizeof(struct pipe_blend_state));
return state;
}
void cell_bind_blend_state( struct pipe_context *pipe,
void *blend )
{
struct cell_context *cell = cell_context(pipe);
cell->blend = (const struct pipe_blend_state *)blend;
cell->dirty |= CELL_NEW_BLEND;
}
void cell_delete_blend_state(struct pipe_context *pipe,
void *blend)
{
FREE( blend );
}
void cell_set_blend_color( struct pipe_context *pipe,
const struct pipe_blend_color *blend_color )
{
struct cell_context *cell = cell_context(pipe);
cell->blend_color = *blend_color;
cell->dirty |= CELL_NEW_BLEND;
}
/** XXX move someday? Or consolidate all these simple state setters
* into one file.
*/
void *
cell_create_alpha_test_state(struct pipe_context *pipe,
const struct pipe_alpha_test_state *alpha)
{
struct pipe_alpha_test_state *state = MALLOC( sizeof(struct pipe_alpha_test_state) );
memcpy(state, alpha, sizeof(struct pipe_alpha_test_state));
return state;
}
void
cell_bind_alpha_test_state(struct pipe_context *pipe,
void *alpha)
{
struct cell_context *cell = cell_context(pipe);
cell->alpha_test = (const struct pipe_alpha_test_state *)alpha;
cell->dirty |= CELL_NEW_ALPHA_TEST;
}
void
cell_delete_alpha_test_state(struct pipe_context *pipe,
void *alpha)
{
FREE( alpha );
}
void *
cell_create_depth_stencil_state(struct pipe_context *pipe,
const struct pipe_depth_stencil_state *depth_stencil)
{
struct pipe_depth_stencil_state *state =
MALLOC( sizeof(struct pipe_depth_stencil_state) );
memcpy(state, depth_stencil, sizeof(struct pipe_depth_stencil_state));
return state;
}
void
cell_bind_depth_stencil_state(struct pipe_context *pipe,
void *depth_stencil)
{
struct cell_context *cell = cell_context(pipe);
cell->depth_stencil = (const struct pipe_depth_stencil_state *)depth_stencil;
cell->dirty |= CELL_NEW_DEPTH_STENCIL;
}
void
cell_delete_depth_stencil_state(struct pipe_context *pipe, void *depth)
{
FREE( depth );
}

84
src/mesa/pipe/cell/ppu/cell_state_clip.c Normal file
View file

@ -0,0 +1,84 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
/* Authors: Keith Whitwell <keith@tungstengraphics.com>
*/
#include "cell_context.h"
#include "cell_state.h"
#include "pipe/draw/draw_context.h"
void cell_set_clip_state( struct pipe_context *pipe,
const struct pipe_clip_state *clip )
{
struct cell_context *cell = cell_context(pipe);
/* pass the clip state to the draw module */
draw_set_clip_state(cell->draw, clip);
}
/* Called when driver state tracker notices changes to the viewport
* matrix:
*/
void cell_set_viewport_state( struct pipe_context *pipe,
const struct pipe_viewport_state *viewport )
{
struct cell_context *cell = cell_context(pipe);
cell->viewport = *viewport; /* struct copy */
cell->dirty |= CELL_NEW_VIEWPORT;
/* pass the viewport info to the draw module */
draw_set_viewport_state(cell->draw, viewport);
/* Using tnl/ and vf/ modules is temporary while getting started.
* Full pipe will have vertex shader, vertex fetch of its own.
*/
}
void cell_set_scissor_state( struct pipe_context *pipe,
const struct pipe_scissor_state *scissor )
{
struct cell_context *cell = cell_context(pipe);
memcpy( &cell->scissor, scissor, sizeof(*scissor) );
cell->dirty |= CELL_NEW_SCISSOR;
}
void cell_set_polygon_stipple( struct pipe_context *pipe,
const struct pipe_poly_stipple *stipple )
{
struct cell_context *cell = cell_context(pipe);
memcpy( &cell->poly_stipple, stipple, sizeof(*stipple) );
cell->dirty |= CELL_NEW_STIPPLE;
}

195
src/mesa/pipe/cell/ppu/cell_state_fs.c Normal file
View file

@ -0,0 +1,195 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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 "pipe/p_defines.h"
#include "pipe/p_util.h"
#include "pipe/p_winsys.h"
#if 0
#include "pipe/draw/draw_context.h"
#include "pipe/p_shader_tokens.h"
#include "pipe/llvm/gallivm.h"
#include "pipe/tgsi/util/tgsi_dump.h"
#include "pipe/tgsi/exec/tgsi_sse2.h"
#endif
#include "cell_context.h"
#include "cell_state.h"
void * cell_create_fs_state(struct pipe_context *pipe,
const struct pipe_shader_state *templ)
{
struct cell_context *cell = cell_context(pipe);
return malloc(5); /* XXX temp */
#if 0
/* Decide whether we'll be codegenerating this shader and if so do
* that now.
*/
struct sp_fragment_shader_state *state = MALLOC( sizeof(struct sp_fragment_shader_state) );
state->shader = *templ;
if( cell->dump_fs ) {
tgsi_dump(
state->shader.tokens,
0 );
}
#if defined(__i386__) || defined(__386__)
if (cell->use_sse) {
x86_init_func( &state->sse2_program );
tgsi_emit_sse2_fs( state->shader.tokens, &state->sse2_program );
}
#endif
#ifdef MESA_LLVM
state->llvm_prog = gallivm_from_tgsi(state->shader.tokens, GALLIVM_FS);
if (!gallivm_global_cpu_engine()) {
gallivm_cpu_engine_create(state->llvm_prog);
}
else
gallivm_cpu_jit_compile(gallivm_global_cpu_engine(), state->llvm_prog);
#endif
return state;
#endif
}
void cell_bind_fs_state(struct pipe_context *pipe, void *fs)
{
struct cell_context *cell = cell_context(pipe);
#if 0
cell->fs = (struct sp_fragment_shader_state *) fs;
cell->dirty |= SP_NEW_FS;
#endif
}
void cell_delete_fs_state(struct pipe_context *pipe,
void *shader)
{
#if 0
struct sp_fragment_shader_state *state = shader;
#if defined(__i386__) || defined(__386__)
x86_release_func( &state->sse2_program );
#endif
FREE( state );
#endif
}
void *
cell_create_vs_state(struct pipe_context *pipe,
const struct pipe_shader_state *templ)
{
return malloc(5); /* XXX */
#if 0
struct cell_context *cell = cell_context(pipe);
struct sp_vertex_shader_state *state;
state = MALLOC( sizeof(struct sp_vertex_shader_state) );
if (state == NULL ) {
return NULL;
}
state->state = MALLOC( sizeof(struct pipe_shader_state) );
if (state->state == NULL) {
FREE( state );
return NULL;
}
memcpy( state->state, templ, sizeof(struct pipe_shader_state) );
state->draw_data = draw_create_vertex_shader(cell->draw,
state->state);
if (state->draw_data == NULL) {
FREE( state->state );
FREE( state );
return NULL;
}
return state;
#endif
}
void
cell_bind_vs_state(struct pipe_context *pipe, void *vs)
{
#if 0
struct cell_context *cell = cell_context(pipe);
cell->vs = (const struct sp_vertex_shader_state *)vs;
draw_bind_vertex_shader(cell->draw, cell->vs->draw_data);
cell->dirty |= SP_NEW_VS;
#endif
}
void
cell_delete_vs_state(struct pipe_context *pipe, void *vs)
{
#if 0
struct cell_context *cell = cell_context(pipe);
struct sp_vertex_shader_state *state =
(struct sp_vertex_shader_state *)vs;
draw_delete_vertex_shader(cell->draw, state->draw_data);
FREE( state->state );
FREE( state );
#endif
}
void cell_set_constant_buffer(struct pipe_context *pipe,
uint shader, uint index,
const struct pipe_constant_buffer *buf)
{
#if 0
struct cell_context *cell = cell_context(pipe);
struct pipe_winsys *ws = pipe->winsys;
assert(shader < PIPE_SHADER_TYPES);
assert(index == 0);
/* note: reference counting */
ws->buffer_reference(ws,
&cell->constants[shader].buffer,
buf->buffer);
cell->constants[shader].size = buf->size;
cell->dirty |= SP_NEW_CONSTANTS;
#endif
}

65
src/mesa/pipe/cell/ppu/cell_state_rasterizer.c Normal file
View file

@ -0,0 +1,65 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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 "pipe/p_defines.h"
#include "pipe/p_util.h"
#include "pipe/draw/draw_context.h"
#include "cell_context.h"
#include "cell_state.h"
void *
cell_create_rasterizer_state(struct pipe_context *pipe,
const struct pipe_rasterizer_state *setup)
{
struct pipe_rasterizer_state *state =
MALLOC( sizeof(struct pipe_rasterizer_state) );
memcpy(state, setup, sizeof(struct pipe_rasterizer_state));
return state;
}
void
cell_bind_rasterizer_state(struct pipe_context *pipe, void *setup)
{
struct cell_context *cell = cell_context(pipe);
/* pass-through to draw module */
draw_set_rasterizer_state(cell->draw, setup);
cell->rasterizer = (struct pipe_rasterizer_state *)setup;
cell->dirty |= CELL_NEW_RASTERIZER;
}
void
cell_delete_rasterizer_state(struct pipe_context *pipe, void *rasterizer)
{
FREE( rasterizer );
}

100
src/mesa/pipe/cell/ppu/cell_state_sampler.c Normal file
View file

@ -0,0 +1,100 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
/* Authors:
* Brian Paul
*/
#include "pipe/p_util.h"
#include "cell_context.h"
#include "cell_state.h"
#if 0
#include "cell_texture.h"
#include "cell_tile_cache.h"
#endif
void *
cell_create_sampler_state(struct pipe_context *pipe,
const struct pipe_sampler_state *sampler)
{
struct pipe_sampler_state *state = MALLOC( sizeof(struct pipe_sampler_state) );
memcpy(state, sampler, sizeof(struct pipe_sampler_state));
return state;
}
void
cell_bind_sampler_state(struct pipe_context *pipe,
unsigned unit, void *sampler)
{
struct cell_context *cell = cell_context(pipe);
assert(unit < PIPE_MAX_SAMPLERS);
cell->sampler[unit] = (struct pipe_sampler_state *)sampler;
cell->dirty |= CELL_NEW_SAMPLER;
}
void
cell_delete_sampler_state(struct pipe_context *pipe,
void *sampler)
{
FREE( sampler );
}
void
cell_set_texture_state(struct pipe_context *pipe,
unsigned unit,
struct pipe_texture *texture)
{
struct cell_context *cell = cell_context(pipe);
assert(unit < PIPE_MAX_SAMPLERS);
#if 0
cell->texture[unit] = cell_texture(texture); /* ptr, not struct */
cell_tile_cache_set_texture(cell->tex_cache[unit], texture);
#endif
cell->dirty |= CELL_NEW_TEXTURE;
}
void
cell_set_sampler_units(struct pipe_context *pipe,
uint num_samplers, const uint *units )
{
struct cell_context *cell = cell_context(pipe);
uint i;
for (i = 0; i < num_samplers; i++)
cell->sampler_units[i] = units[i];
cell->dirty |= CELL_NEW_SAMPLER;
}

99
src/mesa/pipe/cell/ppu/cell_state_surface.c Normal file
View file

@ -0,0 +1,99 @@
#include "cell_context.h"
#include "cell_state.h"
void
cell_set_framebuffer_state(struct pipe_context *pipe,
const struct pipe_framebuffer_state *fb)
{
struct cell_context *cell = cell_context(pipe);
cell->framebuffer = *fb;
cell->dirty |= CELL_NEW_FRAMEBUFFER;
#if 0
struct pipe_surface *ps;
uint i;
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
/* check if changing cbuf */
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, sp->cbuf_cache[i], ps);
}
}
sp->framebuffer.num_cbufs = fb->num_cbufs;
/* zbuf changing? */
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, sp->zbuf_cache, ps);
}
/* XXX combined depth/stencil here */
/* sbuf changing? */
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;
/* update cache */
if (fb->sbuf != fb->zbuf) {
/* separate stencil buf */
sp->sbuf_cache = sp->sbuf_cache_sep;
sp_tile_cache_set_surface(sp, sp->sbuf_cache, ps);
}
else {
/* combined depth/stencil */
sp->sbuf_cache = sp->zbuf_cache;
sp_tile_cache_set_surface(sp, sp->sbuf_cache, ps);
}
}
sp->dirty |= SP_NEW_FRAMEBUFFER;
#endif
}

63
src/mesa/pipe/cell/ppu/cell_state_vertex.c Normal file
View file

@ -0,0 +1,63 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
/* Authors: Keith Whitwell <keith@tungstengraphics.com>
*/
#include "cell_context.h"
#include "cell_state.h"
#include "pipe/draw/draw_context.h"
void
cell_set_vertex_element(struct pipe_context *pipe,
unsigned index,
const struct pipe_vertex_element *attrib)
{
struct cell_context *cell = cell_context(pipe);
assert(index < PIPE_ATTRIB_MAX);
cell->vertex_element[index] = *attrib; /* struct copy */
cell->dirty |= CELL_NEW_VERTEX;
draw_set_vertex_element(cell->draw, index, attrib);
}
void
cell_set_vertex_buffer(struct pipe_context *pipe,
unsigned index,
const struct pipe_vertex_buffer *buffer)
{
struct cell_context *cell = cell_context(pipe);
assert(index < PIPE_ATTRIB_MAX);
cell->vertex_buffer[index] = *buffer; /* struct copy */
cell->dirty |= CELL_NEW_VERTEX;
draw_set_vertex_buffer(cell->draw, index, buffer);
}

99
src/mesa/pipe/cell/ppu/cell_surface.c
View file

@ -1,9 +1,106 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
/**
* Authors
* Brian Paul
*/
#include <stdio.h>
#include <assert.h>
#include <stdint.h>
#include "pipe/p_inlines.h"
#include "pipe/p_util.h"
#include "pipe/cell/common.h"
#include "cell_context.h"
#include "cell_surface.h"
#include "cell_spu.h"
void cell_create_surface(void)
struct pipe_surface *
cell_create_surface(int width, int height)
{
#if 0
/* XXX total hack */
struct pipe_surface *ps = CALLOC_STRUCT(pipe_surface);
printf("cell_create_surface\n");
ps->width = width;
ps->height = height;
ps->region = CALLOC_STRUCT(pipe_region);
ps->region->map = align_malloc(width * height * 4, 16);
return ps;
#endif
return NULL;
}
void
cell_clear_surface(struct pipe_context *pipe, struct pipe_surface *ps,
unsigned clearValue)
{
struct cell_context *cell = cell_context(pipe);
uint i;
printf("%s 0x%08x\n", __FUNCTION__, clearValue);
{
char s[100];
pf_sprint_name(s, ps->format);
printf("format = %s\n", s);
}
if (!ps->map)
pipe_surface_map(ps);
for (i = 0; i < cell->num_spus; i++) {
command[i].fb.start = ps->map;
command[i].fb.width = ps->width;
command[i].fb.height = ps->height;
command[i].fb.format = ps->format;
send_mbox_message(control_ps_area[i], CELL_CMD_FRAMEBUFFER);
}
for (i = 0; i < cell->num_spus; i++) {
command[i].clear.value = clearValue | (i << 21);
send_mbox_message(control_ps_area[i], CELL_CMD_CLEAR_TILES);
}
}
void
cell_set_clear_color_state(struct pipe_context *pipe,
const struct pipe_clear_color_state *clear)
{
struct cell_context *cell = cell_context(pipe);
cell->clear_color = *clear; /* struct copy */
}

49
src/mesa/pipe/cell/ppu/cell_surface.h Normal file
View file

@ -0,0 +1,49 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
#ifndef CELL_SURFACE
#define CELL_SURFACE
#include "pipe/p_state.h"
extern struct pipe_surface *
cell_create_surface(int width, int height);
extern void
cell_clear_surface(struct pipe_context *pipe, struct pipe_surface *ps,
unsigned clearValue);
extern void
cell_set_clear_color_state(struct pipe_context *pipe,
const struct pipe_clear_color_state *clear);
#endif /* CELL_SURFACE */

40
src/mesa/pipe/cell/ppu/cell_winsys.c Normal file
View file

@ -0,0 +1,40 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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 "pipe/p_util.h"
#include "cell_winsys.h"
struct cell_winsys *
cell_get_winsys(uint format)
{
struct cell_winsys *cws = CALLOC_STRUCT(cell_winsys);
if (cws)
cws->preferredFormat = format;
return cws;
}

50
src/mesa/pipe/cell/ppu/cell_winsys.h Normal file
View file

@ -0,0 +1,50 @@
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
#ifndef CELL_WINSYS_H
#define CELL_WINSYS_H
#include "pipe/p_compiler.h"
/**
* Very simple winsys at this time.
* Will probably eventually add SPU control info.
*/
struct cell_winsys
{
uint preferredFormat;
};
extern struct cell_winsys *
cell_get_winsys(uint format);
#endif

2
src/mesa/pipe/cell/spu/Makefile
View file

@ -45,7 +45,7 @@ tri.o: tri.c
clean:
rm -f *.o *.a *.d $(PROG_SPU)
rm -f *~ *.o *.a *.d $(PROG_SPU)

243
src/mesa/pipe/cell/spu/main.c
View file

@ -1,15 +1,241 @@
/* main.c for cell SPU code */
/**************************************************************************
*
* Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
* 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 TUNGSTEN GRAPHICS 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.
*
**************************************************************************/
/* main() for Cell SPU code */
#include <stdio.h>
#include <assert.h>
#include <libmisc.h>
#include <spu_mfcio.h>
#include "tri.h"
#include "pipe/cell/common.h"
/*
helpful headers:
/usr/lib/gcc/spu/4.1.1/include/spu_mfcio.h
/opt/ibm/cell-sdk/prototype/sysroot/usr/include/libmisc.h
*/
static struct cell_init_info init;
struct framebuffer {
void *start;
uint width, height;
uint width_tiles, height_tiles; /**< width and height in tiles */
};
static struct framebuffer fb;
static int DefaultTag = 1;
static inline void
wait_on_mask(unsigned tag)
{
mfc_write_tag_mask( tag );
mfc_read_tag_status_any();
}
static void
get_tile(const struct framebuffer *fb, uint tx, uint ty, uint *tile)
{
uint offset = ty * fb->width_tiles + tx;
uint bytesPerTile = TILE_SIZE * TILE_SIZE * 4;
ubyte *src = (ubyte *) fb->start + offset * bytesPerTile;
int tag = DefaultTag;
assert(tx < fb->width_tiles);
assert(ty < fb->height_tiles);
ASSERT_ALIGN16(tile);
/*
printf("get_tile: dest: %p src: 0x%x size: %d\n",
tile, (unsigned int) src, bytesPerTile);
*/
mfc_get(tile, /* dest in local memory */
(unsigned int) src, /* src in main memory */
bytesPerTile,
tag,
0, /* tid */
0 /* rid */);
}
static void
put_tile(const struct framebuffer *fb, uint tx, uint ty, const uint *tile)
{
uint offset = ty * fb->width_tiles + tx;
uint bytesPerTile = TILE_SIZE * TILE_SIZE * 4;
ubyte *dst = (ubyte *) fb->start + offset * bytesPerTile;
int tag = DefaultTag;
assert(tx < fb->width_tiles);
assert(ty < fb->height_tiles);
ASSERT_ALIGN16(tile);
/*
printf("put_tile: src: %p dst: 0x%x size: %d\n",
tile, (unsigned int) dst, bytesPerTile);
*/
mfc_put((void *) tile, /* src in local memory */
(unsigned int) dst, /* dst in main mory */
bytesPerTile,
tag,
0, /* tid */
0 /* rid */);
}
static void
clear_tiles(const struct cell_command_clear_tiles *clear)
{
uint num_tiles = fb.width_tiles * fb.height_tiles;
uint i;
uint tile[TILE_SIZE * TILE_SIZE] ALIGN16;
for (i = 0; i < TILE_SIZE * TILE_SIZE; i++)
tile[i] = clear->value;
printf("SPU: %s num=%d w=%d h=%d\n",
__FUNCTION__, num_tiles, fb.width_tiles, fb.height_tiles);
for (i = init.id; i < num_tiles; i += init.num_spus) {
uint tx = i % fb.width_tiles;
uint ty = i / fb.width_tiles;
put_tile(&fb, tx, ty, tile);
/* XXX we don't want this here, but it fixes bad tile results */
wait_on_mask(1 << DefaultTag);
}
}
/** Invert all pixels in all tiles */
static void
invert_tiles(void)
{
uint num_tiles = fb.width_tiles * fb.height_tiles;
uint i, j;
uint tile[TILE_SIZE * TILE_SIZE] ALIGN16;
for (i = init.id; i < num_tiles; i += init.num_spus) {
uint tx = i % fb.width_tiles;
uint ty = i / fb.width_tiles;
get_tile(&fb, tx, ty, tile);
wait_on_mask(1 << DefaultTag);
for (j = 0; j < TILE_SIZE * TILE_SIZE; j++) {
tile[j] = ~tile[j];
}
put_tile(&fb, tx, ty, tile);
}
}
struct cell_command cmd ALIGN16;
/**
* Temporary/simple main loop for SPEs: Get a command, execute it, repeat.
*/
static void
main_loop(void)
{
int exitFlag = 0;
printf("SPU %u: Enter main loop\n", init.id);
assert((sizeof(struct cell_command) & 0xf) == 0);
ASSERT_ALIGN16(&cmd);
while (!exitFlag) {
unsigned opcode;
int tag = 0;
printf("SPU %u: Wait for cmd...\n", init.id);
/* read/wait from mailbox */
opcode = (unsigned int) spu_read_in_mbox();
printf("SPU %u: got cmd %u\n", init.id, opcode);
/* command payload */
mfc_get(&cmd, /* dest */
(unsigned int) init.cmd, /* src */
sizeof(struct cell_command), /* bytes */
tag,
0, /* tid */
0 /* rid */);
wait_on_mask( 1 << tag );
switch (opcode) {
case CELL_CMD_EXIT:
printf("SPU %u: EXIT\n", init.id);
exitFlag = 1;
break;
case CELL_CMD_FRAMEBUFFER:
printf("SPU %u: FRAMEBUFFER: %d x %d at %p\n", init.id,
cmd.fb.width,
cmd.fb.height,
cmd.fb.start);
fb.width = cmd.fb.width;
fb.height = cmd.fb.height;
fb.width_tiles = fb.width / TILE_SIZE;
fb.height_tiles = fb.height / TILE_SIZE;
fb.start = cmd.fb.start;
break;
case CELL_CMD_CLEAR_TILES:
printf("SPU %u: CLEAR to 0x%08x\n", init.id, cmd.clear.value);
clear_tiles(&cmd.clear);
break;
case CELL_CMD_INVERT_TILES:
printf("SPU %u: INVERT_TILES\n", init.id);
invert_tiles();
break;
case CELL_CMD_FINISH:
printf("SPU %u: FINISH\n", init.id);
/* wait for all outstanding DMAs to finish */
mfc_write_tag_mask(~0);
mfc_read_tag_status_all();
/* send mbox message to PPU */
spu_write_out_mbox(CELL_CMD_FINISH);
break;
default:
printf("Bad opcode!\n");
}
}
printf("SPU %u: Exit main loop\n", init.id);
}
static struct init_info init;
int
@ -19,11 +245,18 @@ main(unsigned long long speid,
{
int tag = 0;
mfc_get(&init, (unsigned int) argp, sizeof(struct init_info), tag, 0, 0);
(void) speid;
(void) envp;
printf("Enter spu main(): init.foo=%d\n", init.foo);
mfc_get(&init, /* dest */
(unsigned int) argp, /* src */
sizeof(struct cell_init_info), /* bytes */
tag,
0, /* tid */
0 /* rid */);
wait_on_mask( 1 << tag );
draw_triangle(0, 1, 2);
main_loop();
return 0;
}

13
src/mesa/pipe/draw/draw_vertex_shader.c
View file

@ -51,7 +51,18 @@ compute_clipmask(const float *clip, /*const*/ float plane[][4], unsigned nr)
unsigned mask = 0;
unsigned i;
for (i = 0; i < nr; i++) {
/* Do the hardwired planes first:
*/
if (-clip[0] + clip[3] < 0) mask |= CLIP_RIGHT_BIT;
if ( clip[0] + clip[3] < 0) mask |= CLIP_LEFT_BIT;
if (-clip[1] + clip[3] < 0) mask |= CLIP_TOP_BIT;
if ( clip[1] + clip[3] < 0) mask |= CLIP_BOTTOM_BIT;
if (-clip[2] + clip[3] < 0) mask |= CLIP_FAR_BIT;
if ( clip[2] + clip[3] < 0) mask |= CLIP_NEAR_BIT;
/* Followed by any remaining ones:
*/
for (i = 6; i < nr; i++) {
if (dot4(clip, plane[i]) < 0)
mask |= (1<<i);
}

77
src/mesa/pipe/i915simple/i915_context.c
View file

@ -39,72 +39,61 @@
/**
* Query format support.
* If we find texture and drawable support differs, add a selector
* parameter or another function.
* Query format support for creating a texture, drawing surface, etc.
* \param format the format to test
* \param type one of PIPE_TEXTURE, PIPE_SURFACE, PIPE_SCREEN_SURFACE
*/
static boolean
i915_is_format_supported( struct pipe_context *pipe,
enum pipe_format format )
enum pipe_format format, uint type )
{
#if 0
/* XXX: This is broken -- rewrite if still needed. */
static const unsigned tex_supported[] = {
static const enum pipe_format tex_supported[] = {
PIPE_FORMAT_R8G8B8A8_UNORM,
PIPE_FORMAT_A8R8G8B8_UNORM,
PIPE_FORMAT_R5G6B5_UNORM,
PIPE_FORMAT_U_L8,
PIPE_FORMAT_U_A8,
PIPE_FORMAT_U_I8,
PIPE_FORMAT_U_L8_A8,
PIPE_FORMAT_U_A8_L8,
PIPE_FORMAT_YCBCR,
PIPE_FORMAT_YCBCR_REV,
PIPE_FORMAT_S8Z24_UNORM,
PIPE_FORMAT_NONE /* list terminator */
};
/* Actually a lot more than this - add later:
*/
static const unsigned render_supported[] = {
static const enum pipe_format surface_supported[] = {
PIPE_FORMAT_A8R8G8B8_UNORM,
PIPE_FORMAT_R5G6B5_UNORM,
};
/*
*/
static const unsigned z_stencil_supported[] = {
PIPE_FORMAT_Z16_UNORM,
PIPE_FORMAT_Z32_UNORM,
PIPE_FORMAT_S8Z24_UNORM,
PIPE_FORMAT_R16G16B16A16_SNORM,
PIPE_FORMAT_NONE /* list terminator */
};
static const enum pipe_format screen_surface_supported[] = {
PIPE_FORMAT_A8R8G8B8_UNORM,
PIPE_FORMAT_NONE /* list terminator */
};
const enum pipe_format *list;
uint i;
switch (type) {
case PIPE_RENDER_FORMAT:
*numFormats = Elements(render_supported);
return render_supported;
case PIPE_TEX_FORMAT:
*numFormats = Elements(tex_supported);
return render_supported;
case PIPE_Z_STENCIL_FORMAT:
*numFormats = Elements(render_supported);
return render_supported;
case PIPE_TEXTURE:
list = tex_supported;
break;
case PIPE_SURFACE:
list = surface_supported;
break;
case PIPE_SCREEN_SURFACE:
list = screen_surface_supported;
break;
default:
*numFormats = 0;
return NULL;
assert(0);
}
#else
switch( format ) {
case PIPE_FORMAT_A8R8G8B8_UNORM:
case PIPE_FORMAT_R5G6B5_UNORM:
case PIPE_FORMAT_S8Z24_UNORM:
return TRUE;
default:
return FALSE;
};
#endif
for (i = 0; list[i] != PIPE_FORMAT_NONE; i++) {
if (list[i] == format)
return TRUE;
}
return FALSE;
}

34
src/mesa/pipe/i915simple/i915_surface.c
View file

@ -52,6 +52,7 @@
* Note: this is exactly like a8r8g8b8_get_tile() in sp_surface.c
* Share it someday.
*/
/** XXX this will go away eventually */
static void
i915_get_tile_rgba(struct pipe_context *pipe,
struct pipe_surface *ps,
@ -105,13 +106,42 @@ i915_get_tile_rgba(struct pipe_context *pipe,
}
/** XXX this will go away eventually */
static void
i915_put_tile_rgba(struct pipe_context *pipe,
struct pipe_surface *ps,
uint x, uint y, uint w, uint h, const float *p)
{
/* TODO */
assert(0);
unsigned *dst
= ((unsigned *) (ps->map))
+ y * ps->pitch + x;
unsigned i, j;
unsigned w0 = w;
assert(ps->format == PIPE_FORMAT_A8R8G8B8_UNORM);
CLIP_TILE;
switch (ps->format) {
case PIPE_FORMAT_A8R8G8B8_UNORM:
for (i = 0; i < h; i++) {
const float *pRow = p;
for (j = 0; j < w; j++) {
unsigned r, g, b, a;
UNCLAMPED_FLOAT_TO_UBYTE(r, pRow[0]);
UNCLAMPED_FLOAT_TO_UBYTE(g, pRow[1]);
UNCLAMPED_FLOAT_TO_UBYTE(b, pRow[2]);
UNCLAMPED_FLOAT_TO_UBYTE(a, pRow[3]);
dst[j] = (a << 24) | (r << 16) | (g << 8) | b;
pRow += 4;
}
dst += ps->pitch;
p += w0 * 4;
}
break;
default:
assert(0);
}
}

4
src/mesa/pipe/i915simple/i915_texture.c
View file

@ -495,9 +495,7 @@ i915_texture_create(struct pipe_context *pipe, struct pipe_texture **pt)
if (i915->flags.is_i945 ? i945_miptree_layout(pipe, tex) :
i915_miptree_layout(pipe, tex)) {
tex->buffer = pipe->winsys->buffer_create(pipe->winsys,
PIPE_SURFACE_FLAG_TEXTURE,
0, 0);
tex->buffer = pipe->winsys->buffer_create(pipe->winsys, 64, 0, 0);
if (tex->buffer)
pipe->winsys->buffer_data(pipe->winsys, tex->buffer,

3
src/mesa/pipe/p_context.h
View file

@ -50,8 +50,9 @@ struct pipe_context {
/*
* Queries
*/
/** type is one of PIPE_SURFACE, PIPE_TEXTURE, etc. */
boolean (*is_format_supported)( struct pipe_context *pipe,
enum pipe_format format );
enum pipe_format format, uint type );
const char *(*get_name)( struct pipe_context *pipe );

7
src/mesa/pipe/p_defines.h
View file

@ -161,10 +161,11 @@
#define PIPE_TEX_FACE_MAX 6
/**
* Surface flags
* Surfaces, textures, etc. (others may be added)
*/
#define PIPE_SURFACE_FLAG_TEXTURE 0x1
#define PIPE_SURFACE_FLAG_RENDER 0x2
#define PIPE_TEXTURE 1
#define PIPE_SURFACE 2 /**< user-created surfaces */
#define PIPE_SCREEN_SURFACE 3 /**< On-screen front/back colorbuffer */
/**

24
src/mesa/pipe/softpipe/sp_context.c
View file

@ -46,17 +46,29 @@
/**
* Query format support.
* If we find texture and drawable support differs, add a selector
* parameter or another function.
* Query format support for creating a texture, drawing surface, etc.
* \param format the format to test
* \param type one of PIPE_TEXTURE, PIPE_SURFACE, PIPE_SCREEN_SURFACE
*/
static boolean
softpipe_is_format_supported( struct pipe_context *pipe,
enum pipe_format format )
enum pipe_format format, uint type )
{
struct softpipe_context *softpipe = softpipe_context( pipe );
/* ask winsys if the format is supported */
return softpipe->winsys->is_format_supported( softpipe->winsys, format );
switch (type) {
case PIPE_TEXTURE:
/* softpipe supports all texture formats */
return TRUE;
case PIPE_SURFACE:
/* softpipe supports all (off-screen) surface formats */
return TRUE;
case PIPE_SCREEN_SURFACE:
return softpipe->winsys->is_format_supported( softpipe->winsys, format );
default:
assert(0);
return FALSE;
}
}

3
src/mesa/pipe/softpipe/sp_quad_alpha_test.c
View file

@ -84,8 +84,7 @@ alpha_test_quad(struct quad_stage *qs, struct quad_header *quad)
static void alpha_test_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

3
src/mesa/pipe/softpipe/sp_quad_blend.c
View file

@ -726,8 +726,7 @@ blend_quad(struct quad_stage *qs, struct quad_header *quad)
static void blend_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

3
src/mesa/pipe/softpipe/sp_quad_bufloop.c
View file

@ -43,8 +43,7 @@ cbuf_loop_quad(struct quad_stage *qs, struct quad_header *quad)
static void cbuf_loop_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

3
src/mesa/pipe/softpipe/sp_quad_colormask.c
View file

@ -87,8 +87,7 @@ colormask_quad(struct quad_stage *qs, struct quad_header *quad)
static void colormask_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

3
src/mesa/pipe/softpipe/sp_quad_coverage.c
View file

@ -65,8 +65,7 @@ coverage_quad(struct quad_stage *qs, struct quad_header *quad)
static void coverage_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

3
src/mesa/pipe/softpipe/sp_quad_depth_test.c
View file

@ -253,8 +253,7 @@ depth_test_quad(struct quad_stage *qs, struct quad_header *quad)
static void depth_test_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

8
src/mesa/pipe/softpipe/sp_quad_earlyz.c
View file

@ -56,18 +56,14 @@ earlyz_quad(
quad->outputs.depth[2] = z0 + dzdy;
quad->outputs.depth[3] = z0 + dzdx + dzdy;
if (qs->next) {
qs->next->run( qs->next, quad );
}
qs->next->run( qs->next, quad );
}
static void
earlyz_begin(
struct quad_stage *qs )
{
if (qs->next) {
qs->next->begin( qs->next );
}
qs->next->begin( qs->next );
}
static void

3
src/mesa/pipe/softpipe/sp_quad_fs.c
View file

@ -304,8 +304,7 @@ static void shade_begin(struct quad_stage *qs)
}
}
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

6
src/mesa/pipe/softpipe/sp_quad_occlusion.c
View file

@ -52,15 +52,13 @@ occlusion_count_quad(struct quad_stage *qs, struct quad_header *quad)
occ->count += (quad->mask >> 2) & 1;
occ->count += (quad->mask >> 3) & 1;
if (quad->mask)
qs->next->run(qs->next, quad);
qs->next->run(qs->next, quad);
}
static void occlusion_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

3
src/mesa/pipe/softpipe/sp_quad_output.c
View file

@ -67,8 +67,7 @@ output_quad(struct quad_stage *qs, struct quad_header *quad)
static void output_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
assert(qs->next == NULL);
}

3
src/mesa/pipe/softpipe/sp_quad_stencil.c
View file

@ -334,8 +334,7 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
static void stencil_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

3
src/mesa/pipe/softpipe/sp_quad_stipple.c
View file

@ -60,8 +60,7 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
static void stipple_begin(struct quad_stage *qs)
{
if (qs->next)
qs->next->begin(qs->next);
qs->next->begin(qs->next);
}

5
src/mesa/pipe/softpipe/sp_texture.c
View file

@ -381,10 +381,7 @@ softpipe_texture_create(struct pipe_context *pipe, struct pipe_texture **pt)
sizeof(struct softpipe_texture) - sizeof(struct pipe_texture));
if (softpipe_mipmap_tree_layout(pipe, spt)) {
spt->buffer = pipe->winsys->buffer_create(pipe->winsys,
32,
PIPE_SURFACE_FLAG_TEXTURE,
0);
spt->buffer = pipe->winsys->buffer_create(pipe->winsys, 32, 0, 0);
if (spt->buffer) {
pipe->winsys->buffer_data(pipe->winsys, spt->buffer,

2
src/mesa/pipe/softpipe/sp_tile_cache.c
View file

@ -141,7 +141,7 @@ sp_tile_cache_set_surface(struct softpipe_tile_cache *tc,
assert(!tc->texture);
if (tc->surface && tc->surface->map) {
assert(tc->surface != ps);
/*assert(tc->surface != ps);*/
pipe_surface_unmap(tc->surface);
}

18
src/mesa/pipe/softpipe/sp_winsys.h
View file

@ -25,21 +25,23 @@
*
**************************************************************************/
#ifndef SP_WINSYS_H
#define SP_WINSYS_H
#include "pipe/p_compiler.h" // for boolean
/* This is the interface that softpipe requires any window system
* hosting it to implement. This is the only include file in softpipe
* which is public.
*/
#ifndef SP_WINSYS_H
#define SP_WINSYS_H
#include "pipe/p_compiler.h" /* for boolean */
struct softpipe_winsys {
/** test if the given format is supported for front/back color bufs */
boolean (*is_format_supported)( struct softpipe_winsys *sws,
uint format );
enum pipe_format format );
};

158
src/mesa/pipe/xlib/xm_winsys.c
View file

@ -42,6 +42,52 @@
#include "pipe/p_context.h"
#include "pipe/softpipe/sp_winsys.h"
#ifdef GALLIUM_CELL
#include "pipe/cell/ppu/cell_context.h"
#include "pipe/cell/ppu/cell_winsys.h"
#endif
/** XXX from Mesa core */
static void *
align_malloc(size_t bytes, unsigned long alignment)
{
#if defined(HAVE_POSIX_MEMALIGN)
void *mem;
(void) posix_memalign(& mem, alignment, bytes);
return mem;
#else
uintptr_t ptr, buf;
assert( alignment > 0 );
ptr = (uintptr_t) malloc(bytes + alignment + sizeof(void *));
if (!ptr)
return NULL;
buf = (ptr + alignment + sizeof(void *)) & ~(uintptr_t)(alignment - 1);
*(uintptr_t *)(buf - sizeof(void *)) = ptr;
return (void *) buf;
#endif /* defined(HAVE_POSIX_MEMALIGN) */
}
/** XXX from Mesa core */
static void
align_free(void *ptr)
{
#if defined(HAVE_POSIX_MEMALIGN)
free(ptr);
#else
void **cubbyHole = (void **) ((char *) ptr - sizeof(void *));
void *realAddr = *cubbyHole;
free(realAddr);
#endif /* defined(HAVE_POSIX_MEMALIGN) */
}
/**
* Low-level OS/window system memory buffer
@ -59,7 +105,8 @@ struct xm_buffer
struct xmesa_surface
{
struct pipe_surface surface;
/* no extra fields for now */
int tileSize;
};
@ -71,7 +118,7 @@ struct xmesa_surface
struct xmesa_softpipe_winsys
{
struct softpipe_winsys spws;
uint pixelformat;
enum pipe_format pixelformat;
};
@ -80,7 +127,7 @@ struct xmesa_softpipe_winsys
static INLINE struct xmesa_surface *
xmesa_surface(struct pipe_surface *ps)
{
assert(0);
// assert(0);
return (struct xmesa_surface *) ps;
}
@ -138,7 +185,7 @@ xm_buffer_reference(struct pipe_winsys *pws,
if (oldBuf->refcount == 0) {
if (oldBuf->data) {
if (!oldBuf->userBuffer)
free(oldBuf->data);
align_free(oldBuf->data);
oldBuf->data = NULL;
}
free(oldBuf);
@ -163,8 +210,8 @@ xm_buffer_data(struct pipe_winsys *pws, struct pipe_buffer_handle *buf,
assert(!xm_buf->userBuffer);
if (xm_buf->size != size) {
if (xm_buf->data)
free(xm_buf->data);
xm_buf->data = malloc(size);
align_free(xm_buf->data);
xm_buf->data = align_malloc(size, 16);
xm_buf->size = size;
}
if (data)
@ -197,6 +244,45 @@ xm_buffer_get_subdata(struct pipe_winsys *pws, struct pipe_buffer_handle *buf,
}
/**
* Display a surface that's in a tiled configuration. That is, all the
* pixels for a TILE_SIZExTILE_SIZE block are contiguous in memory.
*/
static void
xmesa_display_surface_tiled(XMesaBuffer b, const struct pipe_surface *surf)
{
XImage *ximage = b->tempImage;
struct xm_buffer *xm_buf = xm_bo(surf->buffer);
const int TILE_SIZE = 32;
uint x, y;
/* check that the XImage has been previously initialized */
assert(ximage->format);
assert(ximage->bitmap_unit);
/* update XImage's fields */
ximage->width = TILE_SIZE;
ximage->height = TILE_SIZE;
ximage->bytes_per_line = TILE_SIZE * 4;
for (y = 0; y < surf->height; y += TILE_SIZE) {
for (x = 0; x < surf->width; x += TILE_SIZE) {
int dx = x;
int dy = y;
int tx = x / TILE_SIZE;
int ty = y / TILE_SIZE;
int offset = ty * (surf->width / TILE_SIZE) + tx;
offset *= 4 * TILE_SIZE * TILE_SIZE;
ximage->data = (char *) xm_buf->data + offset;
XPutImage(b->xm_visual->display, b->drawable, b->gc,
ximage, 0, 0, dx, dy, TILE_SIZE, TILE_SIZE);
}
}
}
/**
* Display/copy the image in the surface into the X window specified
* by the XMesaBuffer.
@ -206,6 +292,13 @@ xmesa_display_surface(XMesaBuffer b, const struct pipe_surface *surf)
{
XImage *ximage = b->tempImage;
struct xm_buffer *xm_buf = xm_bo(surf->buffer);
const struct xmesa_surface *xm_surf
= xmesa_surface((struct pipe_surface *) surf);
if (xm_surf->tileSize) {
xmesa_display_surface_tiled(b, surf);
return;
}
/* check that the XImage has been previously initialized */
assert(ximage->format);
@ -234,7 +327,6 @@ xm_flush_frontbuffer(struct pipe_winsys *pws,
* this would be the place to copy the Ximage to the on-screen Window.
*/
XMesaContext xmctx = (XMesaContext) context_private;
xmesa_display_surface(xmctx->xm_buffer, surf);
}
@ -318,6 +410,12 @@ xm_surface_alloc(struct pipe_winsys *ws, enum pipe_format pipeFormat)
xms->surface.refcount = 1;
xms->surface.winsys = ws;
#ifdef GALLIUM_CELL
if (getenv("GALLIUM_CELL")) {
xms->tileSize = 32; /** probably temporary */
}
#endif
return &xms->surface;
}
@ -377,35 +475,17 @@ xmesa_get_pipe_winsys(void)
/**
* Called via softpipe_winsys->is_format_supported().
* This function is only called to test formats for front/back color surfaces.
* The winsys being queried will have been created at glXCreateContext
* time, with a pixel format corresponding to the context's visual.
*
* XXX we should pass a flag indicating if the format is going to be
* use for a drawing surface vs. a texture. In the later case, we
* can support any format.
*/
static boolean
xmesa_is_format_supported(struct softpipe_winsys *sws,
enum pipe_format format)
{
struct xmesa_softpipe_winsys *xmws = xmesa_softpipe_winsys(sws);
if (format == xmws->pixelformat) {
return TRUE;
}
else {
/* non-color / window surface format */
switch (format) {
case PIPE_FORMAT_R16G16B16A16_SNORM:
case PIPE_FORMAT_S8Z24_UNORM:
case PIPE_FORMAT_U_S8:
case PIPE_FORMAT_Z16_UNORM:
case PIPE_FORMAT_Z32_UNORM:
return TRUE;
default:
return FALSE;
}
}
return (format == xmws->pixelformat);
}
@ -431,12 +511,24 @@ struct pipe_context *
xmesa_create_pipe_context(XMesaContext xmesa, uint pixelformat)
{
struct pipe_winsys *pws = xmesa_get_pipe_winsys();
struct softpipe_winsys *spws = xmesa_get_softpipe_winsys(pixelformat);
struct pipe_context *pipe;
pipe = softpipe_create( pws, spws );
if (pipe)
pipe->priv = xmesa;
#ifdef GALLIUM_CELL
if (getenv("GALLIUM_CELL")) {
struct cell_winsys *cws = cell_get_winsys(pixelformat);
pipe = cell_create_context(pws, cws);
if (pipe)
pipe->priv = xmesa;
return pipe;
}
else
#endif
{
struct softpipe_winsys *spws = xmesa_get_softpipe_winsys(pixelformat);
pipe = softpipe_create( pws, spws );
if (pipe)
pipe->priv = xmesa;
return pipe;
return pipe;
}
}

119
src/mesa/state_tracker/st_cb_accum.c
View file

@ -45,6 +45,10 @@
#include "pipe/p_inlines.h"
#define UNCLAMPED_FLOAT_TO_SHORT(us, f) \
us = ( (short) ( CLAMP((f), -1.0, 1.0) * 32767.0F) )
/**
* For hardware that supports deep color buffers, we could accelerate
* most/all the accum operations with blending/texturing.
@ -55,7 +59,6 @@
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;
@ -66,28 +69,104 @@ st_clear_accum_buffer(GLcontext *ctx, struct gl_renderbuffer *rb)
const GLfloat g = ctx->Accum.ClearColor[1];
const GLfloat b = ctx->Accum.ClearColor[2];
const GLfloat a = ctx->Accum.ClearColor[3];
GLfloat *accBuf;
GLint i;
(void) pipe_surface_map(acc_ps);
accBuf = (GLfloat *) malloc(width * height * 4 * sizeof(GLfloat));
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;
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);
}
pipe->put_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
free(accBuf);
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);
}
}
/** For ADD/MULT */
static void
@ -102,13 +181,13 @@ accum_mad(struct pipe_context *pipe, GLfloat scale, GLfloat bias,
(void) pipe_surface_map(acc_ps);
pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
get_accum_tile(pipe, acc_ps, xpos, ypos, width, height, accBuf);
for (i = 0; i < 4 * width * height; i++) {
accBuf[i] = accBuf[i] * scale + bias;
}
pipe->put_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
put_accum_tile(pipe, acc_ps, xpos, ypos, width, height, accBuf);
free(accBuf);
@ -133,13 +212,13 @@ accum_accum(struct pipe_context *pipe, GLfloat value,
accMap = pipe_surface_map(acc_ps);
pipe->get_tile_rgba(pipe, color_ps, xpos, ypos, width, height, colorBuf);
pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
get_accum_tile(pipe, acc_ps, xpos, ypos, width, height, accBuf);
for (i = 0; i < 4 * width * height; i++) {
accBuf[i] = accBuf[i] + colorBuf[i] * value;
}
pipe->put_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, accBuf);
put_accum_tile(pipe, acc_ps, xpos, ypos, width, height, accBuf);
free(colorBuf);
free(accBuf);
@ -169,7 +248,7 @@ accum_load(struct pipe_context *pipe, GLfloat value,
buf[i] = buf[i] * value;
}
pipe->put_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, buf);
put_accum_tile(pipe, acc_ps, xpos, ypos, width, height, buf);
free(buf);
@ -194,7 +273,7 @@ accum_return(GLcontext *ctx, GLfloat value,
(void) pipe_surface_map(color_ps);
(void) pipe_surface_map(acc_ps);
pipe->get_tile_rgba(pipe, acc_ps, xpos, ypos, width, height, abuf);
get_accum_tile(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));

4
src/mesa/state_tracker/st_cb_drawpixels.c
View file

@ -993,13 +993,13 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
int row, col;
/* find a texture format we know */
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_I8 )) {
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_I8, PIPE_TEXTURE )) {
format = PIPE_FORMAT_U_I8;
internal_format = GL_INTENSITY8;
cpp = 1;
comp = 0;
}
else if (pipe->is_format_supported( pipe, PIPE_FORMAT_A8R8G8B8_UNORM )) {
else if (pipe->is_format_supported( pipe, PIPE_FORMAT_A8R8G8B8_UNORM, PIPE_TEXTURE )) {
format = PIPE_FORMAT_A8R8G8B8_UNORM;
internal_format = GL_RGBA8;
cpp = 4;

13
src/mesa/state_tracker/st_cb_fbo.c
View file

@ -87,12 +87,14 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
{
struct pipe_context *pipe = ctx->st->pipe;
struct st_renderbuffer *strb = st_renderbuffer(rb);
uint type = strb->screenSurface ? PIPE_SCREEN_SURFACE : PIPE_SURFACE;
const enum pipe_format pipeFormat
= st_choose_pipe_format(pipe, internalFormat, GL_NONE, GL_NONE);
= st_choose_pipe_format(pipe, internalFormat, GL_NONE, GL_NONE, type);
GLuint cpp;
GLbitfield flags = PIPE_SURFACE_FLAG_RENDER; /* want to render to surface */
GLbitfield flags = 0x0; /* XXX needed? */
cpp = init_renderbuffer_bits(strb, pipeFormat);
assert(cpp);
if (strb->surface && strb->surface->format != pipeFormat) {
/* need to change surface types, free this surface */
@ -118,7 +120,7 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
pipe->winsys->buffer_reference(pipe->winsys, &strb->surface->buffer,
NULL);
strb->surface->buffer = pipe->winsys->buffer_create(pipe->winsys, 32, flags, 0);
strb->surface->buffer = pipe->winsys->buffer_create(pipe->winsys, 32, 0, 0);
if (!strb->surface->buffer)
return GL_FALSE; /* out of memory, try s/w buffer? */
@ -201,9 +203,11 @@ st_new_renderbuffer(GLcontext *ctx, GLuint name)
/**
* Allocate a renderbuffer for a an on-screen window (not a user-created
* renderbuffer). The window system code determines the internal format.
* \param screenSurface indicates if the renderbuffer is a front/back color
* buffer that'll be displayed/copied to the screen
*/
struct gl_renderbuffer *
st_new_renderbuffer_fb(GLenum intFormat)
st_new_renderbuffer_fb(GLenum intFormat, GLboolean screenSurface)
{
struct st_renderbuffer *strb;
@ -216,6 +220,7 @@ st_new_renderbuffer_fb(GLenum intFormat)
_mesa_init_renderbuffer(&strb->Base, 0);
strb->Base.ClassID = 0x4242; /* just a unique value */
strb->Base.InternalFormat = intFormat;
strb->screenSurface = screenSurface;
switch (intFormat) {
case GL_RGB5:

3
src/mesa/state_tracker/st_cb_fbo.h
View file

@ -39,6 +39,7 @@ struct st_renderbuffer
{
struct gl_renderbuffer Base;
struct pipe_surface *surface;
GLboolean screenSurface; /**< A front/back colorbuffer? */
};
@ -50,7 +51,7 @@ st_renderbuffer(struct gl_renderbuffer *rb)
extern struct gl_renderbuffer *
st_new_renderbuffer_fb(GLenum intFormat);
st_new_renderbuffer_fb(GLenum intFormat, GLboolean screen_surface);
extern void

95
src/mesa/state_tracker/st_format.c
View file

@ -276,10 +276,9 @@ st_mesa_format_to_pipe_format(GLuint mesaFormat)
* Find an RGBA format supported by the context/winsys.
*/
static GLuint
default_rgba_format(
struct pipe_context *pipe )
default_rgba_format(struct pipe_context *pipe, uint type)
{
static const uint colorFormats[] = {
static const enum pipe_format colorFormats[] = {
PIPE_FORMAT_R8G8B8A8_UNORM,
PIPE_FORMAT_A8R8G8B8_UNORM,
PIPE_FORMAT_B8G8R8A8_UNORM,
@ -287,7 +286,7 @@ default_rgba_format(
};
uint i;
for (i = 0; i < Elements(colorFormats); i++) {
if (pipe->is_format_supported( pipe, colorFormats[i] )) {
if (pipe->is_format_supported( pipe, colorFormats[i], type )) {
return colorFormats[i];
}
}
@ -299,10 +298,9 @@ default_rgba_format(
* Search list of formats for first RGBA format with >8 bits/channel.
*/
static GLuint
default_deep_rgba_format(
struct pipe_context *pipe )
default_deep_rgba_format(struct pipe_context *pipe, uint type)
{
if (pipe->is_format_supported( pipe, PIPE_FORMAT_R16G16B16A16_SNORM )) {
if (pipe->is_format_supported(pipe, PIPE_FORMAT_R16G16B16A16_SNORM, type)) {
return PIPE_FORMAT_R16G16B16A16_SNORM;
}
return PIPE_FORMAT_NONE;
@ -313,10 +311,9 @@ default_deep_rgba_format(
* Find an Z format supported by the context/winsys.
*/
static GLuint
default_depth_format(
struct pipe_context *pipe )
default_depth_format(struct pipe_context *pipe, uint type)
{
static const uint zFormats[] = {
static const enum pipe_format zFormats[] = {
PIPE_FORMAT_Z16_UNORM,
PIPE_FORMAT_Z32_UNORM,
PIPE_FORMAT_S8Z24_UNORM,
@ -324,7 +321,7 @@ default_depth_format(
};
uint i;
for (i = 0; i < Elements(zFormats); i++) {
if (pipe->is_format_supported( pipe, zFormats[i] )) {
if (pipe->is_format_supported( pipe, zFormats[i], type )) {
return zFormats[i];
}
}
@ -348,67 +345,71 @@ default_depth_format(
*/
GLuint
st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
GLenum format, GLenum type)
GLenum format, GLenum type, uint surfType)
{
assert(surfType == PIPE_TEXTURE ||
surfType == PIPE_SURFACE ||
surfType == PIPE_SCREEN_SURFACE);
switch (internalFormat) {
case 4:
case GL_RGBA:
case GL_COMPRESSED_RGBA:
if (format == GL_BGRA) {
if (type == GL_UNSIGNED_BYTE || type == GL_UNSIGNED_INT_8_8_8_8_REV) {
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A8R8G8B8_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A8R8G8B8_UNORM, surfType ))
return PIPE_FORMAT_A8R8G8B8_UNORM;
}
else if (type == GL_UNSIGNED_SHORT_4_4_4_4_REV) {
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A4R4G4B4_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A4R4G4B4_UNORM, surfType ))
return PIPE_FORMAT_A4R4G4B4_UNORM;
}
else if (type == GL_UNSIGNED_SHORT_1_5_5_5_REV) {
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM, surfType ))
return PIPE_FORMAT_A1R5G5B5_UNORM;
}
}
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case 3:
case GL_RGB:
case GL_COMPRESSED_RGB:
if (format == GL_RGB && type == GL_UNSIGNED_SHORT_5_6_5) {
if (pipe->is_format_supported( pipe, PIPE_FORMAT_R5G6B5_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_R5G6B5_UNORM, surfType ))
return PIPE_FORMAT_R5G6B5_UNORM;
}
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case GL_RGBA8:
case GL_RGB10_A2:
case GL_RGBA12:
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case GL_RGBA16:
return default_deep_rgba_format( pipe );
return default_deep_rgba_format( pipe, surfType );
case GL_RGBA4:
case GL_RGBA2:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A4R4G4B4_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A4R4G4B4_UNORM, surfType ))
return PIPE_FORMAT_A4R4G4B4_UNORM;
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case GL_RGB5_A1:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM, surfType ))
return PIPE_FORMAT_A1R5G5B5_UNORM;
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case GL_RGB8:
case GL_RGB10:
case GL_RGB12:
case GL_RGB16:
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case GL_RGB5:
case GL_RGB4:
case GL_R3_G3_B2:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_A1R5G5B5_UNORM, surfType ))
return PIPE_FORMAT_A1R5G5B5_UNORM;
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case GL_ALPHA:
case GL_ALPHA4:
@ -416,9 +417,9 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
case GL_ALPHA12:
case GL_ALPHA16:
case GL_COMPRESSED_ALPHA:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8 ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8, surfType ))
return PIPE_FORMAT_U_A8;
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case 1:
case GL_LUMINANCE:
@ -427,9 +428,9 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
case GL_LUMINANCE12:
case GL_LUMINANCE16:
case GL_COMPRESSED_LUMINANCE:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8 ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8, surfType ))
return PIPE_FORMAT_U_A8;
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case 2:
case GL_LUMINANCE_ALPHA:
@ -440,9 +441,9 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
case GL_LUMINANCE12_ALPHA12:
case GL_LUMINANCE16_ALPHA16:
case GL_COMPRESSED_LUMINANCE_ALPHA:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8_L8 ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_A8_L8, surfType ))
return PIPE_FORMAT_U_A8_L8;
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case GL_INTENSITY:
case GL_INTENSITY4:
@ -450,17 +451,17 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
case GL_INTENSITY12:
case GL_INTENSITY16:
case GL_COMPRESSED_INTENSITY:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_I8 ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_I8, surfType ))
return PIPE_FORMAT_U_I8;
return default_rgba_format( pipe );
return default_rgba_format( pipe, surfType );
case GL_YCBCR_MESA:
if (type == GL_UNSIGNED_SHORT_8_8_MESA || type == GL_UNSIGNED_BYTE) {
if (pipe->is_format_supported( pipe, PIPE_FORMAT_YCBCR ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_YCBCR, surfType ))
return PIPE_FORMAT_YCBCR;
}
else {
if (pipe->is_format_supported( pipe, PIPE_FORMAT_YCBCR_REV ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_YCBCR_REV, surfType ))
return PIPE_FORMAT_YCBCR_REV;
}
return PIPE_FORMAT_NONE;
@ -489,40 +490,40 @@ st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
#endif
case GL_DEPTH_COMPONENT16:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z16_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z16_UNORM, surfType ))
return PIPE_FORMAT_Z16_UNORM;
/* fall-through */
case GL_DEPTH_COMPONENT24:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM, surfType ))
return PIPE_FORMAT_S8Z24_UNORM;
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM, surfType ))
return PIPE_FORMAT_Z24S8_UNORM;
/* fall-through */
case GL_DEPTH_COMPONENT32:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z32_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z32_UNORM, surfType ))
return PIPE_FORMAT_Z32_UNORM;
/* fall-through */
case GL_DEPTH_COMPONENT:
return default_depth_format( pipe );
return default_depth_format( pipe, surfType );
case GL_STENCIL_INDEX:
case GL_STENCIL_INDEX1_EXT:
case GL_STENCIL_INDEX4_EXT:
case GL_STENCIL_INDEX8_EXT:
case GL_STENCIL_INDEX16_EXT:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_S8 ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_U_S8, surfType ))
return PIPE_FORMAT_U_S8;
if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM, surfType ))
return PIPE_FORMAT_S8Z24_UNORM;
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM, surfType ))
return PIPE_FORMAT_Z24S8_UNORM;
return PIPE_FORMAT_NONE;
case GL_DEPTH_STENCIL_EXT:
case GL_DEPTH24_STENCIL8_EXT:
if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_S8Z24_UNORM, surfType ))
return PIPE_FORMAT_S8Z24_UNORM;
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM ))
if (pipe->is_format_supported( pipe, PIPE_FORMAT_Z24S8_UNORM, surfType ))
return PIPE_FORMAT_Z24S8_UNORM;
return PIPE_FORMAT_NONE;

2
src/mesa/state_tracker/st_format.h
View file

@ -65,7 +65,7 @@ st_mesa_format_to_pipe_format(GLuint mesaFormat);
extern GLuint
st_choose_pipe_format(struct pipe_context *pipe, GLint internalFormat,
GLenum format, GLenum type);
GLenum format, GLenum type, uint surfType);
extern const struct gl_texture_format *

29
src/mesa/state_tracker/st_framebuffer.c
View file

@ -51,19 +51,21 @@ struct st_framebuffer *st_create_framebuffer( const __GLcontextModes *visual,
/* fake frontbuffer */
/* XXX allocation should only happen in the unusual case
it's actually needed */
struct gl_renderbuffer *rb = st_new_renderbuffer_fb(rgbFormat);
struct gl_renderbuffer *rb
= st_new_renderbuffer_fb(rgbFormat, GL_TRUE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_FRONT_LEFT, rb);
}
if (visual->doubleBufferMode) {
struct gl_renderbuffer *rb = st_new_renderbuffer_fb(rgbFormat);
struct gl_renderbuffer *rb
= st_new_renderbuffer_fb(rgbFormat, GL_TRUE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_BACK_LEFT, rb);
}
if (visual->depthBits == 24 && visual->stencilBits == 8) {
/* combined depth/stencil buffer */
struct gl_renderbuffer *depthStencilRb
= st_new_renderbuffer_fb(GL_DEPTH24_STENCIL8_EXT);
= st_new_renderbuffer_fb(GL_DEPTH24_STENCIL8_EXT, GL_FALSE);
/* note: bind RB to two attachment points */
_mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthStencilRb);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, depthStencilRb);
@ -74,47 +76,36 @@ struct st_framebuffer *st_create_framebuffer( const __GLcontextModes *visual,
if (visual->depthBits == 32) {
/* 32-bit depth buffer */
struct gl_renderbuffer *depthRb
= st_new_renderbuffer_fb(GL_DEPTH_COMPONENT32);
= st_new_renderbuffer_fb(GL_DEPTH_COMPONENT32, GL_FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
}
else if (visual->depthBits == 24) {
/* 24-bit depth buffer, ignore stencil bits */
struct gl_renderbuffer *depthRb
= st_new_renderbuffer_fb(GL_DEPTH24_STENCIL8_EXT);
= st_new_renderbuffer_fb(GL_DEPTH24_STENCIL8_EXT, GL_FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
}
else if (visual->depthBits > 0) {
/* 16-bit depth buffer */
struct gl_renderbuffer *depthRb
= st_new_renderbuffer_fb(GL_DEPTH_COMPONENT16);
= st_new_renderbuffer_fb(GL_DEPTH_COMPONENT16, GL_FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_DEPTH, depthRb);
}
if (visual->stencilBits > 0) {
/* 8-bit stencil */
struct gl_renderbuffer *stencilRb
= st_new_renderbuffer_fb(GL_STENCIL_INDEX8_EXT);
= st_new_renderbuffer_fb(GL_STENCIL_INDEX8_EXT, GL_FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_STENCIL, stencilRb);
}
}
#if 0
if (visual->accumRedBits > 0) {
/* 16-bit/channel accum */
struct gl_renderbuffer *accumRb
= st_new_renderbuffer_fb(GL_RGBA16);
= st_new_renderbuffer_fb(GL_RGBA16, GL_FALSE);
_mesa_add_renderbuffer(&stfb->Base, BUFFER_ACCUM, accumRb);
}
#endif
/* now add any/all software-based renderbuffers we may need */
_mesa_add_soft_renderbuffers(&stfb->Base,
GL_FALSE, /* never sw color */
GL_FALSE, /* never sw depth */
GL_FALSE, /* stencil */
visual->accumRedBits > 0,
GL_FALSE, /* never sw alpha */
GL_FALSE /* never sw aux */ );
}
stfb->Base.Initialized = GL_TRUE;