AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote branch 'upstream/gallium-0.1' into nouveau-gallium-0.1

Browse Source
This commit is contained in:
Ben Skeggs
2008-05-05 19:44:16 +10:00
parent 1e6191e0af 736f535b4f
commit 33d9e213ee
85 changed files with 1557 additions and 1161 deletions
Download Patch File Download Diff File Expand all files Collapse all files
common.py
+8 -2
View File
@@ -44,8 +44,14 @@ else:
# Common options
def AddOptions(opts):
from SCons.Options.BoolOption import BoolOption
from SCons.Options.EnumOption import EnumOption
try:
from SCons.Options.BoolOption import BoolOption
except ImportError:
from SCons.Variables.BoolVariable import BoolVariable as BoolOption
try:
from SCons.Options.EnumOption import EnumOption
except ImportError:
from SCons.Variables.EnumVariable import EnumVariable as EnumOption
opts.Add(BoolOption('debug', 'build debug version', 'no'))
#opts.Add(BoolOption('quiet', 'quiet command lines', 'no'))
opts.Add(EnumOption('machine', 'use machine-specific assembly code', default_machine,
progs/tests/manytex.c
+1
View File
@@ -133,6 +133,7 @@ static void DeleteTextures(void)
{
glDeleteTextures(NumTextures, TextureID);
free(TextureID);
TextureID = NULL;
}
progs/tests/mipmap_limits.c
+25 -7
View File
@@ -59,6 +59,18 @@ static GLfloat LodBias = 0.0;
static GLboolean NearestFilter = GL_TRUE;
static void
InitValues(void)
{
BaseLevel = 0;
MaxLevel = 8;
MinLod = -1;
MaxLod = 9;
LodBias = 0.0;
NearestFilter = GL_TRUE;
}
static void MakeImage(int level, int width, int height, const GLubyte color[4])
{
const int makeStripes = 0;
@@ -108,6 +120,8 @@ static void makeImages(void)
static void myinit(void)
{
InitValues();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glShadeModel(GL_FLAT);
@@ -125,7 +139,7 @@ static void myinit(void)
static void display(void)
{
GLfloat tcm = 4.0;
printf("BASE_LEVEL = %d MAX_LEVEL = %d MIN_LOD = %f MAX_LOD = %f Bias = %.2g filter = %s\n",
printf("BASE_LEVEL=%d MAX_LEVEL=%d MIN_LOD=%.2g MAX_LOD=%.2g Bias=%.2g Filter=%s\n",
BaseLevel, MaxLevel, MinLod, MaxLod, LodBias,
NearestFilter ? "NEAREST" : "LINEAR");
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, BaseLevel);
@@ -214,6 +228,9 @@ key(unsigned char k, int x, int y)
case 'f':
NearestFilter = !NearestFilter;
break;
case ' ':
InitValues();
break;
case 27: /* Escape */
exit(0);
break;
@@ -227,12 +244,13 @@ key(unsigned char k, int x, int y)
static void usage(void)
{
printf("usage:\n");
printf(" b/B decrease/increase GL_TEXTURE_BASE_LEVEL\n");
printf(" m/M decrease/increase GL_TEXTURE_MAX_LEVEL\n");
printf(" n/N decrease/increase GL_TEXTURE_MIN_LOD\n");
printf(" x/X decrease/increase GL_TEXTURE_MAX_LOD\n");
printf(" l/L decrease/increase GL_TEXTURE_LOD_BIAS\n");
printf(" f toggle nearest/linear filtering\n");
printf(" b/B decrease/increase GL_TEXTURE_BASE_LEVEL\n");
printf(" m/M decrease/increase GL_TEXTURE_MAX_LEVEL\n");
printf(" n/N decrease/increase GL_TEXTURE_MIN_LOD\n");
printf(" x/X decrease/increase GL_TEXTURE_MAX_LOD\n");
printf(" l/L decrease/increase GL_TEXTURE_LOD_BIAS\n");
printf(" f toggle nearest/linear filtering\n");
printf(" SPACE reset values\n");
}
progs/xdemos/Makefile
+1
View File
@@ -23,6 +23,7 @@ PROGS = glthreads \
overlay \
pbinfo \
pbdemo \
sharedtex \
texture_from_pixmap \
wincopy \
xfont \
progs/xdemos/sharedtex.c
+324
View File
@@ -0,0 +1,324 @@
/*
* Test sharing of texture objects by two rendering contexts.
* In particular, test that changing a texture object in one context
* effects the texture in the second context.
*
* Brian Paul
* 30 Apr 2008
*
* Copyright (C) 2008 Brian Paul 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, sublicense,
* 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 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 NONINFRINGEMENT. IN NO EVENT SHALL
* BRIAN PAUL 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 <GL/gl.h>
#include <GL/glx.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <X11/keysym.h>
#define MAX_CONTEXTS 2
#define TEX_SIZE 32
static const char *DisplayName = NULL;
static Display *Dpy;
static XVisualInfo *VisInfo;
static Window Win;
static GLXContext Contexts[MAX_CONTEXTS];
static int WinWidth = 300, WinHeight = 300;
static int DrawContext = 0, TexContext = 1;
static GLuint TexObj = 0;
static GLboolean NewTexture = GL_FALSE;
static void
Error(const char *msg)
{
fprintf(stderr, "sharedtex error: %s\n", msg);
exit(1);
}
static void
CreateWindow(const char *name)
{
int attrib[] = { GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER,
None };
int scrnum;
XSetWindowAttributes attr;
unsigned long mask;
Window root;
int xpos = 0, ypos = 0;
static int n = 0;
scrnum = DefaultScreen(Dpy);
root = RootWindow(Dpy, scrnum);
VisInfo = glXChooseVisual(Dpy, scrnum, attrib);
if (!VisInfo) {
Error("Unable to find RGB, double-buffered visual");
}
/* window attributes */
xpos = (n % 10) * 100;
ypos = (n / 10) * 100;
n++;
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = XCreateColormap(Dpy, root, VisInfo->visual, AllocNone);
attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
Win = XCreateWindow(Dpy, root, xpos, ypos, WinWidth, WinHeight,
0, VisInfo->depth, InputOutput,
VisInfo->visual, mask, &attr);
if (!Win) {
Error("Couldn't create window");
}
{
XSizeHints sizehints;
sizehints.x = xpos;
sizehints.y = ypos;
sizehints.width = WinWidth;
sizehints.height = WinHeight;
sizehints.flags = USSize | USPosition;
XSetNormalHints(Dpy, Win, &sizehints);
XSetStandardProperties(Dpy, Win, name, name,
None, (char **)NULL, 0, &sizehints);
}
XMapWindow(Dpy, Win);
}
/**
* Change texture image, using TexContext
*/
static void
ModifyTexture(void)
{
GLuint tex[TEX_SIZE][TEX_SIZE];
GLuint c0, c1;
int i, j;
if (Win && !glXMakeCurrent(Dpy, Win, Contexts[TexContext])) {
Error("glXMakeCurrent failed");
}
/* choose two random colors */
c0 = rand() & 0xffffffff;
c1 = rand() & 0xffffffff;
for (i = 0; i < TEX_SIZE; i++) {
for (j = 0; j < TEX_SIZE; j++) {
if (((i / 4) ^ (j / 4)) & 1) {
tex[i][j] = c0;
}
else {
tex[i][j] = c1;
}
}
}
glBindTexture(GL_TEXTURE_2D, TexObj);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 0,
GL_RGBA, GL_UNSIGNED_BYTE, tex);
NewTexture = GL_TRUE;
}
static void
InitContext(void)
{
glGenTextures(1, &TexObj);
assert(TexObj);
glBindTexture(GL_TEXTURE_2D, TexObj);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glEnable(GL_TEXTURE_2D);
printf("GL_RENDERER = %s\n", (char*) glGetString(GL_RENDERER));
}
static void
Setup(void)
{
int i;
Dpy = XOpenDisplay(DisplayName);
if (!Dpy) {
Error("Unable to open display");
}
CreateWindow("sharedtex");
for (i = 0; i < MAX_CONTEXTS; i++) {
GLXContext share = i > 0 ? Contexts[0] : 0;
Contexts[i] = glXCreateContext(Dpy, VisInfo, share, True);
if (!Contexts[i]) {
Error("Unable to create GLX context");
}
if (!glXMakeCurrent(Dpy, Win, Contexts[i])) {
Error("glXMakeCurrent failed");
}
InitContext();
}
ModifyTexture();
}
/**
* Redraw window, using DrawContext
*/
static void
Redraw(void)
{
static float rot = 0.0;
float ar;
rot += 1.0;
if (Win && !glXMakeCurrent(Dpy, Win, Contexts[DrawContext])) {
Error("glXMakeCurrent failed");
}
glViewport(0, 0, WinWidth, WinHeight);
ar = (float) WinWidth / (float) WinHeight;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-ar, ar, -1.0, 1.0, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glShadeModel(GL_FLAT);
glClearColor(0.5, 0.5, 0.5, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glPushMatrix();
glRotatef(rot, 0, 0, 1);
glScalef(0.7, 0.7, 0.7);
if (NewTexture) {
/* rebind to get new contents */
glBindTexture(GL_TEXTURE_2D, TexObj);
NewTexture = GL_FALSE;
}
/* draw textured quad */
glBegin(GL_POLYGON);
glTexCoord2f( 0.0, 0.0 ); glVertex2f( -1.0, -1.0 );
glTexCoord2f( 1.0, 0.0 ); glVertex2f( 1.0, -1.0 );
glTexCoord2f( 1.0, 1.0 ); glVertex2f( 1.0, 1.0 );
glTexCoord2f( 0.0, 1.0 ); glVertex2f( -1.0, 1.0 );
glEnd();
glPopMatrix();
if (Win)
glXSwapBuffers(Dpy, Win);
}
static void
EventLoop(void)
{
while (1) {
while (XPending(Dpy) > 0) {
XEvent event;
XNextEvent(Dpy, &event);
switch (event.type) {
case Expose:
Redraw();
break;
case ConfigureNotify:
WinWidth = event.xconfigure.width;
WinHeight = event.xconfigure.height;
break;
case KeyPress:
{
char buf[100];
KeySym keySym;
XComposeStatus stat;
XLookupString(&event.xkey, buf, sizeof(buf), &keySym, &stat);
switch (keySym) {
case XK_Escape:
exit(0);
break;
case XK_t:
case XK_T:
ModifyTexture();
break;
default:
;
}
}
Redraw();
break;
default:
/*no-op*/ ;
}
}
Redraw();
usleep(10000);
}
}
int
main(int argc, char *argv[])
{
int i;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-display") == 0 && i < argc) {
DisplayName = argv[i+1];
i++;
}
}
Setup();
printf("Press 't' to change texture image/colors\n");
EventLoop();
return 0;
}
src/gallium/README.portability
+65
View File
@@ -24,6 +24,7 @@ headers in general, should stricly follow these guidelines to ensure
* Don't use variable number of macro arguments. Use static inline functions
instead.
* Don't use C99 features.
= Standard Library =
@@ -42,3 +43,67 @@ portable way.
* Use the functions/macros in p_debug.h.
* Don't include assert.h, call abort, printf, etc.
= Code Style =
== Inherantice in C ==
The main thing we do is mimic inheritance by structure containment.
Here's a silly made-up example:
/* base class */
struct buffer
{
int size;
void (*validate)(struct buffer *buf);
};
/* sub-class of bufffer */
struct texture_buffer
{
struct buffer base; /* the base class, MUST COME FIRST! */
int format;
int width, height;
};
Then, we'll typically have cast-wrapper functions to convert base-class
pointers to sub-class pointers where needed:
static inline struct vertex_buffer *vertex_buffer(struct buffer *buf)
{
return (struct vertex_buffer *) buf;
}
To create/init a sub-classed object:
struct buffer *create_texture_buffer(int w, int h, int format)
{
struct texture_buffer *t = malloc(sizeof(*t));
t->format = format;
t->width = w;
t->height = h;
t->base.size = w * h;
t->base.validate = tex_validate;
return &t->base;
}
Example sub-class method:
void tex_validate(struct buffer *buf)
{
struct texture_buffer *tb = texture_buffer(buf);
assert(tb->format);
assert(tb->width);
assert(tb->height);
}
Note that we typically do not use typedefs to make "class names"; we use
'struct whatever' everywhere.
Gallium's pipe_context and the subclassed psb_context, etc are prime examples
of this. There's also many examples in Mesa and the Mesa state tracker.
src/gallium/auxiliary/cso_cache/cso_cache.c
+32 -8
View File
@@ -43,6 +43,9 @@ struct cso_cache {
struct cso_hash *rasterizer_hash;
struct cso_hash *sampler_hash;
int max_size;
cso_sanitize_callback sanitize_cb;
void *sanitize_data;
};
#if 1
@@ -205,8 +208,19 @@ static INLINE void delete_cso(void *state, enum cso_cache_type type)
}
}
static INLINE void sanitize_hash(struct cso_hash *hash, enum cso_cache_type type,
static INLINE void sanitize_hash(struct cso_cache *sc,
struct cso_hash *hash,
enum cso_cache_type type,
int max_size)
{
if (sc->sanitize_cb)
sc->sanitize_cb(hash, type, max_size, sc->sanitize_data);
}
static INLINE void sanitize_cb(struct cso_hash *hash, enum cso_cache_type type,
int max_size, void *user_data)
{
/* if we're approach the maximum size, remove fourth of the entries
* otherwise every subsequent call will go through the same */
@@ -231,7 +245,7 @@ cso_insert_state(struct cso_cache *sc,
void *state)
{
struct cso_hash *hash = _cso_hash_for_type(sc, type);
sanitize_hash(hash, type, sc->max_size);
sanitize_hash(sc, hash, type, sc->max_size);
return cso_hash_insert(hash, hash_key, state);
}
@@ -300,6 +314,8 @@ struct cso_cache *cso_cache_create(void)
sc->rasterizer_hash = cso_hash_create();
sc->fs_hash = cso_hash_create();
sc->vs_hash = cso_hash_create();
sc->sanitize_cb = sanitize_cb;
sc->sanitize_data = 0;
return sc;
}
@@ -365,13 +381,13 @@ void cso_set_maximum_cache_size(struct cso_cache *sc, int number)
{
sc->max_size = number;
sanitize_hash(sc->blend_hash, CSO_BLEND, sc->max_size);
sanitize_hash(sc->depth_stencil_hash, CSO_DEPTH_STENCIL_ALPHA,
sanitize_hash(sc, sc->blend_hash, CSO_BLEND, sc->max_size);
sanitize_hash(sc, sc->depth_stencil_hash, CSO_DEPTH_STENCIL_ALPHA,
sc->max_size);
sanitize_hash(sc->fs_hash, CSO_FRAGMENT_SHADER, sc->max_size);
sanitize_hash(sc->vs_hash, CSO_VERTEX_SHADER, sc->max_size);
sanitize_hash(sc->rasterizer_hash, CSO_RASTERIZER, sc->max_size);
sanitize_hash(sc->sampler_hash, CSO_SAMPLER, sc->max_size);
sanitize_hash(sc, sc->fs_hash, CSO_FRAGMENT_SHADER, sc->max_size);
sanitize_hash(sc, sc->vs_hash, CSO_VERTEX_SHADER, sc->max_size);
sanitize_hash(sc, sc->rasterizer_hash, CSO_RASTERIZER, sc->max_size);
sanitize_hash(sc, sc->sampler_hash, CSO_SAMPLER, sc->max_size);
}
int cso_maximum_cache_size(const struct cso_cache *sc)
@@ -379,3 +395,11 @@ int cso_maximum_cache_size(const struct cso_cache *sc)
return sc->max_size;
}
void cso_cache_set_sanitize_callback(struct cso_cache *sc,
cso_sanitize_callback cb,
void *user_data)
{
sc->sanitize_cb = cb;
sc->sanitize_data = user_data;
}
src/gallium/auxiliary/cso_cache/cso_cache.h
+18 -10
View File
@@ -84,8 +84,22 @@
extern "C" {
#endif
enum cso_cache_type {
CSO_BLEND,
CSO_SAMPLER,
CSO_DEPTH_STENCIL_ALPHA,
CSO_RASTERIZER,
CSO_FRAGMENT_SHADER,
CSO_VERTEX_SHADER
};
typedef void (*cso_state_callback)(void *ctx, void *obj);
typedef void (*cso_sanitize_callback)(struct cso_hash *hash,
enum cso_cache_type type,
int max_size,
void *user_data);
struct cso_cache;
struct cso_blend {
@@ -130,21 +144,15 @@ struct cso_sampler {
struct pipe_context *context;
};
enum cso_cache_type {
CSO_BLEND,
CSO_SAMPLER,
CSO_DEPTH_STENCIL_ALPHA,
CSO_RASTERIZER,
CSO_FRAGMENT_SHADER,
CSO_VERTEX_SHADER
};
unsigned cso_construct_key(void *item, int item_size);
struct cso_cache *cso_cache_create(void);
void cso_cache_delete(struct cso_cache *sc);
void cso_cache_set_sanitize_callback(struct cso_cache *sc,
cso_sanitize_callback cb,
void *user_data);
struct cso_hash_iter cso_insert_state(struct cso_cache *sc,
unsigned hash_key, enum cso_cache_type type,
void *state);
src/gallium/auxiliary/cso_cache/cso_context.c
+128
View File
@@ -80,6 +80,131 @@ struct cso_context {
};
static boolean delete_blend_state(struct cso_context *ctx, void *state)
{
struct cso_blend *cso = (struct cso_blend *)state;
if (ctx->blend == state)
return FALSE;
if (cso->delete_state)
cso->delete_state(cso->context, cso->data);
FREE(state);
return TRUE;
}
static boolean delete_depth_stencil_state(struct cso_context *ctx, void *state)
{
struct cso_depth_stencil_alpha *cso = (struct cso_depth_stencil_alpha *)state;
if (ctx->depth_stencil == cso->data)
return FALSE;
if (cso->delete_state)
cso->delete_state(cso->context, cso->data);
FREE(state);
return TRUE;
}
static boolean delete_sampler_state(struct cso_context *ctx, void *state)
{
struct cso_sampler *cso = (struct cso_sampler *)state;
if (cso->delete_state)
cso->delete_state(cso->context, cso->data);
FREE(state);
return TRUE;
}
static boolean delete_rasterizer_state(struct cso_context *ctx, void *state)
{
struct cso_rasterizer *cso = (struct cso_rasterizer *)state;
if (ctx->rasterizer == cso->data)
return FALSE;
if (cso->delete_state)
cso->delete_state(cso->context, cso->data);
FREE(state);
return TRUE;
}
static boolean delete_fs_state(struct cso_context *ctx, void *state)
{
struct cso_fragment_shader *cso = (struct cso_fragment_shader *)state;
if (ctx->fragment_shader == cso->data)
return FALSE;
if (cso->delete_state)
cso->delete_state(cso->context, cso->data);
FREE(state);
return TRUE;
}
static boolean delete_vs_state(struct cso_context *ctx, void *state)
{
struct cso_vertex_shader *cso = (struct cso_vertex_shader *)state;
if (ctx->vertex_shader == cso->data)
return TRUE;
if (cso->delete_state)
cso->delete_state(cso->context, cso->data);
FREE(state);
return FALSE;
}
static INLINE boolean delete_cso(struct cso_context *ctx,
void *state, enum cso_cache_type type)
{
switch (type) {
case CSO_BLEND:
return delete_blend_state(ctx, state);
break;
case CSO_SAMPLER:
return delete_sampler_state(ctx, state);
break;
case CSO_DEPTH_STENCIL_ALPHA:
return delete_depth_stencil_state(ctx, state);
break;
case CSO_RASTERIZER:
return delete_rasterizer_state(ctx, state);
break;
case CSO_FRAGMENT_SHADER:
return delete_fs_state(ctx, state);
break;
case CSO_VERTEX_SHADER:
return delete_vs_state(ctx, state);
break;
default:
assert(0);
FREE(state);
}
return FALSE;
}
static INLINE void sanitize_hash(struct cso_hash *hash, enum cso_cache_type type,
int max_size, void *user_data)
{
struct cso_context *ctx = (struct cso_context *)user_data;
/* if we're approach the maximum size, remove fourth of the entries
* otherwise every subsequent call will go through the same */
int hash_size = cso_hash_size(hash);
int max_entries = (max_size > hash_size) ? max_size : hash_size;
int to_remove = (max_size < max_entries) * max_entries/4;
struct cso_hash_iter iter = cso_hash_first_node(hash);
if (hash_size > max_size)
to_remove += hash_size - max_size;
while (to_remove) {
/*remove elements until we're good */
/*fixme: currently we pick the nodes to remove at random*/
void *cso = cso_hash_iter_data(iter);
if (delete_cso(ctx, cso, type)) {
iter = cso_hash_erase(hash, iter);
--to_remove;
} else
iter = cso_hash_iter_next(iter);
}
}
struct cso_context *cso_create_context( struct pipe_context *pipe )
{
struct cso_context *ctx = CALLOC_STRUCT(cso_context);
@@ -89,6 +214,9 @@ struct cso_context *cso_create_context( struct pipe_context *pipe )
ctx->cache = cso_cache_create();
if (ctx->cache == NULL)
goto out;
cso_cache_set_sanitize_callback(ctx->cache,
sanitize_hash,
ctx);
ctx->pipe = pipe;
src/gallium/auxiliary/draw/draw_pipe_aaline.c
+1 -1
View File
@@ -392,7 +392,7 @@ aaline_create_texture(struct aaline_stage *aaline)
memset(&texTemp, 0, sizeof(texTemp));
texTemp.target = PIPE_TEXTURE_2D;
texTemp.format = PIPE_FORMAT_U_A8; /* XXX verify supported by driver! */
texTemp.format = PIPE_FORMAT_A8_UNORM; /* XXX verify supported by driver! */
texTemp.last_level = MAX_TEXTURE_LEVEL;
texTemp.width[0] = 1 << MAX_TEXTURE_LEVEL;
texTemp.height[0] = 1 << MAX_TEXTURE_LEVEL;
src/gallium/auxiliary/draw/draw_pipe_pstipple.c
+2 -2
View File
@@ -256,7 +256,7 @@ pstip_transform_inst(struct tgsi_transform_context *ctx,
uint size = 4;
immed = tgsi_default_full_immediate();
immed.Immediate.Size = 1 + size; /* one for the token itself */
immed.u.ImmediateFloat32 = (struct tgsi_immediate_float32 *) value;
immed.u.Pointer = (void *) value;
ctx->emit_immediate(ctx, &immed);
}
@@ -417,7 +417,7 @@ pstip_create_texture(struct pstip_stage *pstip)
memset(&texTemp, 0, sizeof(texTemp));
texTemp.target = PIPE_TEXTURE_2D;
texTemp.format = PIPE_FORMAT_U_A8; /* XXX verify supported by driver! */
texTemp.format = PIPE_FORMAT_A8_UNORM; /* XXX verify supported by driver! */
texTemp.last_level = 0;
texTemp.width[0] = 32;
texTemp.height[0] = 32;
src/gallium/auxiliary/draw/draw_pt_varray.c
-1
View File
@@ -200,7 +200,6 @@ static void varray_prepare(struct draw_pt_front_end *frontend,
unsigned opt)
{
struct varray_frontend *varray = (struct varray_frontend *)frontend;
const struct pipe_rasterizer_state *rasterizer = varray->draw->rasterizer;
if (opt & PT_PIPELINE)
{
src/gallium/auxiliary/draw/draw_pt_vcache.c
-1
View File
@@ -225,7 +225,6 @@ static void vcache_prepare( struct draw_pt_front_end *frontend,
unsigned opt )
{
struct vcache_frontend *vcache = (struct vcache_frontend *)frontend;
const struct pipe_rasterizer_state *rasterizer = vcache->draw->rasterizer;
if (opt & PT_PIPELINE)
{
src/gallium/auxiliary/draw/draw_vs_sse.c
+12 -12
View File
@@ -47,21 +47,21 @@
#include "tgsi/util/tgsi_parse.h"
#define SSE_MAX_VERTICES 4
#define SSE_SWIZZLES 0
#define SSE_SWIZZLES 1
#if SSE_SWIZZLES
typedef void (XSTDCALL *codegen_function) (
const struct tgsi_exec_vector *input,
struct tgsi_exec_vector *output,
float (*constant)[4],
struct tgsi_exec_vector *temporary,
float (*immediates)[4],
const float (*aos_input)[4],
uint num_inputs,
uint input_stride,
float (*aos_output)[4],
uint num_outputs,
uint output_stride );
const struct tgsi_exec_vector *input, /* 1 */
struct tgsi_exec_vector *output, /* 2 */
float (*constant)[4], /* 3 */
struct tgsi_exec_vector *temporary, /* 4 */
float (*immediates)[4], /* 5 */
const float (*aos_input)[4], /* 6 */
uint num_inputs, /* 7 */
uint input_stride, /* 8 */
float (*aos_output)[4], /* 9 */
uint num_outputs, /* 10 */
uint output_stride ); /* 11 */
#else
typedef void (XSTDCALL *codegen_function) (
const struct tgsi_exec_vector *input,
src/gallium/auxiliary/rtasm/rtasm_x86sse.c
+28 -33
View File
@@ -347,9 +347,9 @@ struct x86_reg x86_get_base_reg( struct x86_reg reg )
return x86_make_reg( reg.file, reg.idx );
}
unsigned char *x86_get_label( struct x86_function *p )
int x86_get_label( struct x86_function *p )
{
return p->csr;
return p->csr - p->store;
}
@@ -361,17 +361,22 @@ unsigned char *x86_get_label( struct x86_function *p )
void x86_jcc( struct x86_function *p,
enum x86_cc cc,
unsigned char *label )
int label )
{
intptr_t offset = pointer_to_intptr( label ) - (pointer_to_intptr( x86_get_label(p) ) + 2);
int offset = label - (x86_get_label(p) + 2);
DUMP_I(cc);
if (offset < 0) {
int amt = p->csr - p->store;
assert(amt > -offset);
}
if (offset <= 127 && offset >= -128) {
emit_1ub(p, 0x70 + cc);
emit_1b(p, (char) offset);
}
else {
offset = pointer_to_intptr( label ) - (pointer_to_intptr( x86_get_label(p) ) + 6);
offset = label - (x86_get_label(p) + 6);
emit_2ub(p, 0x0f, 0x80 + cc);
emit_1i(p, offset);
}
@@ -379,8 +384,8 @@ void x86_jcc( struct x86_function *p,
/* Always use a 32bit offset for forward jumps:
*/
unsigned char *x86_jcc_forward( struct x86_function *p,
enum x86_cc cc )
int x86_jcc_forward( struct x86_function *p,
enum x86_cc cc )
{
DUMP_I(cc);
emit_2ub(p, 0x0f, 0x80 + cc);
@@ -388,7 +393,7 @@ unsigned char *x86_jcc_forward( struct x86_function *p,
return x86_get_label(p);
}
unsigned char *x86_jmp_forward( struct x86_function *p)
int x86_jmp_forward( struct x86_function *p)
{
DUMP();
emit_1ub(p, 0xe9);
@@ -396,7 +401,7 @@ unsigned char *x86_jmp_forward( struct x86_function *p)
return x86_get_label(p);
}
unsigned char *x86_call_forward( struct x86_function *p)
int x86_call_forward( struct x86_function *p)
{
DUMP();
@@ -408,42 +413,24 @@ unsigned char *x86_call_forward( struct x86_function *p)
/* Fixup offset from forward jump:
*/
void x86_fixup_fwd_jump( struct x86_function *p,
unsigned char *fixup )
int fixup )
{
*(int *)(fixup - 4) = pointer_to_intptr( x86_get_label(p) ) - pointer_to_intptr( fixup );
*(int *)(p->store + fixup - 4) = x86_get_label(p) - fixup;
}
void x86_jmp( struct x86_function *p, unsigned char *label)
void x86_jmp( struct x86_function *p, int label)
{
DUMP_I( label );
emit_1ub(p, 0xe9);
emit_1i(p, pointer_to_intptr( label ) - pointer_to_intptr( x86_get_label(p) ) - 4);
emit_1i(p, label - x86_get_label(p) - 4);
}
#if 0
static unsigned char *cptr( void (*label)() )
{
return (unsigned char *) label;
}
/* This doesn't work once we start reallocating & copying the
* generated code on buffer fills, because the call is relative to the
* current pc.
*/
void x86_call( struct x86_function *p, void (*label)())
{
DUMP_I( label );
emit_1ub(p, 0xe8);
emit_1i(p, cptr(label) - x86_get_label(p) - 4);
}
#else
void x86_call( struct x86_function *p, struct x86_reg reg)
{
DUMP_R( reg );
emit_1ub(p, 0xff);
emit_modrm_noreg(p, 2, reg);
}
#endif
/* michal:
@@ -462,8 +449,15 @@ void x86_push( struct x86_function *p,
struct x86_reg reg )
{
DUMP_R( reg );
assert(reg.mod == mod_REG);
emit_1ub(p, 0x50 + reg.idx);
if (reg.mod == mod_REG)
emit_1ub(p, 0x50 + reg.idx);
else
{
emit_1ub(p, 0xff);
emit_modrm_noreg(p, 6, reg);
}
p->stack_offset += 4;
}
@@ -495,6 +489,7 @@ void x86_dec( struct x86_function *p,
void x86_ret( struct x86_function *p )
{
DUMP();
assert(p->stack_offset == 0);
emit_1ub(p, 0xc3);
}
src/gallium/auxiliary/rtasm/rtasm_x86sse.h
+7 -7
View File
@@ -124,23 +124,23 @@ struct x86_reg x86_get_base_reg( struct x86_reg reg );
/* Labels, jumps and fixup:
*/
unsigned char *x86_get_label( struct x86_function *p );
int x86_get_label( struct x86_function *p );
void x86_jcc( struct x86_function *p,
enum x86_cc cc,
unsigned char *label );
int label );
unsigned char *x86_jcc_forward( struct x86_function *p,
int x86_jcc_forward( struct x86_function *p,
enum x86_cc cc );
unsigned char *x86_jmp_forward( struct x86_function *p);
int x86_jmp_forward( struct x86_function *p);
unsigned char *x86_call_forward( struct x86_function *p);
int x86_call_forward( struct x86_function *p);
void x86_fixup_fwd_jump( struct x86_function *p,
unsigned char *fixup );
int fixup );
void x86_jmp( struct x86_function *p, unsigned char *label );
void x86_jmp( struct x86_function *p, int label );
/* void x86_call( struct x86_function *p, void (*label)() ); */
void x86_call( struct x86_function *p, struct x86_reg reg);
src/gallium/auxiliary/sct/sct.c
+1
View File
@@ -209,6 +209,7 @@ remove_context_from_surface(struct sct_surface *si,
}
else {
prev = curr;
next = curr->next;
}
}
}
src/gallium/auxiliary/tgsi/exec/tgsi_exec.c
+37 -28
View File
@@ -88,6 +88,10 @@
#define TEMP_OUTPUT_C TGSI_EXEC_TEMP_OUTPUT_C
#define TEMP_PRIMITIVE_I TGSI_EXEC_TEMP_PRIMITIVE_I
#define TEMP_PRIMITIVE_C TGSI_EXEC_TEMP_PRIMITIVE_C
#define TEMP_3_I TGSI_EXEC_TEMP_THREE_I
#define TEMP_3_C TGSI_EXEC_TEMP_THREE_C
#define TEMP_HALF_I TGSI_EXEC_TEMP_HALF_I
#define TEMP_HALF_C TGSI_EXEC_TEMP_HALF_C
#define TEMP_R0 TGSI_EXEC_TEMP_R0
#define FOR_EACH_CHANNEL(CHAN)\
@@ -262,6 +266,8 @@ tgsi_exec_machine_init(
mach->Temps[TEMP_2_I].xyzw[TEMP_2_C].f[i] = 2.0f;
mach->Temps[TEMP_128_I].xyzw[TEMP_128_C].f[i] = 128.0f;
mach->Temps[TEMP_M128_I].xyzw[TEMP_M128_C].f[i] = -128.0f;
mach->Temps[TEMP_3_I].xyzw[TEMP_3_C].f[i] = 3.0f;
mach->Temps[TEMP_HALF_I].xyzw[TEMP_HALF_C].f[i] = 0.5f;
}
}
@@ -1530,41 +1536,44 @@ exec_instruction(
break;
case TGSI_OPCODE_EXP:
debug_printf("TGSI: EXP opcode not implemented\n");
/* from ARB_v_p:
tmp = ScalarLoad(op0);
result.x = 2^floor(tmp);
result.y = tmp - floor(tmp);
result.z = RoughApprox2ToX(tmp);
result.w = 1.0;
*/
#if 0
/* something like this: */
FETCH( &r[0], 0, CHAN_X );
micro_exp2( &r[0], &r[0] );
FOR_EACH_ENABLED_CHANNEL( *inst, chan_index ) {
STORE( &r[0], 0, chan_index );
micro_flr( &r[1], &r[0] ); /* r1 = floor(r0) */
if (IS_CHANNEL_ENABLED( *inst, CHAN_X )) {
micro_exp2( &r[2], &r[1] ); /* r2 = 2 ^ r1 */
STORE( &r[2], 0, CHAN_X ); /* store r2 */
}
if (IS_CHANNEL_ENABLED( *inst, CHAN_Y )) {
micro_sub( &r[2], &r[0], &r[1] ); /* r2 = r0 - r1 */
STORE( &r[2], 0, CHAN_Y ); /* store r2 */
}
if (IS_CHANNEL_ENABLED( *inst, CHAN_Z )) {
micro_exp2( &r[2], &r[0] ); /* r2 = 2 ^ r0 */
STORE( &r[2], 0, CHAN_Z ); /* store r2 */
}
if (IS_CHANNEL_ENABLED( *inst, CHAN_W )) {
STORE( &mach->Temps[TEMP_1_I].xyzw[TEMP_1_C], 0, CHAN_W );
}
#endif
break;
case TGSI_OPCODE_LOG:
debug_printf("TGSI: LOG opcode not implemented\n");
/* from ARB_v_p:
tmp = fabs(ScalarLoad(op0));
result.x = floor(log2(tmp));
result.y = tmp / 2^(floor(log2(tmp)));
result.z = RoughApproxLog2(tmp);
result.w = 1.0;
*/
#if 0
/* something like this: */
FETCH( &r[0], 0, CHAN_X );
micro_lg2( &r[0], &r[0] );
FOR_EACH_ENABLED_CHANNEL( *inst, chan_index ) {
STORE( &r[0], 0, chan_index );
micro_abs( &r[2], &r[0] ); /* r2 = abs(r0) */
micro_lg2( &r[1], &r[2] ); /* r1 = lg2(r2) */
micro_flr( &r[0], &r[1] ); /* r0 = floor(r1) */
if (IS_CHANNEL_ENABLED( *inst, CHAN_X )) {
STORE( &r[0], 0, CHAN_X );
}
if (IS_CHANNEL_ENABLED( *inst, CHAN_Y )) {
micro_exp2( &r[0], &r[0] ); /* r0 = 2 ^ r0 */
micro_div( &r[0], &r[2], &r[0] ); /* r0 = r2 / r0 */
STORE( &r[0], 0, CHAN_Y );
}
if (IS_CHANNEL_ENABLED( *inst, CHAN_Z )) {
STORE( &r[1], 0, CHAN_Z );
}
if (IS_CHANNEL_ENABLED( *inst, CHAN_W )) {
STORE( &mach->Temps[TEMP_1_I].xyzw[TEMP_1_C], 0, CHAN_W );
}
#endif
break;
case TGSI_OPCODE_MUL:
src/gallium/auxiliary/tgsi/exec/tgsi_exec.h
+8 -2
View File
@@ -133,9 +133,15 @@ struct tgsi_exec_labels
#define TGSI_EXEC_TEMP_PRIMITIVE_I 34
#define TGSI_EXEC_TEMP_PRIMITIVE_C 2
#define TGSI_EXEC_TEMP_R0 35
#define TGSI_EXEC_TEMP_THREE_I 34
#define TGSI_EXEC_TEMP_THREE_C 3
#define TGSI_EXEC_NUM_TEMPS (32 + 4)
#define TGSI_EXEC_TEMP_HALF_I 35
#define TGSI_EXEC_TEMP_HALF_C 0
#define TGSI_EXEC_TEMP_R0 36
#define TGSI_EXEC_NUM_TEMPS (32 + 5)
#define TGSI_EXEC_NUM_ADDRS 1
#define TGSI_EXEC_NUM_IMMEDIATES 256
src/gallium/auxiliary/tgsi/exec/tgsi_sse2.c
+116 -143
View File
@@ -36,7 +36,11 @@
#ifdef PIPE_ARCH_X86
#define HIGH_PRECISION 1 /* for 1/sqrt() */
/* for 1/sqrt()
*
* This costs about 100fps (close to 10%) in gears:
*/
#define HIGH_PRECISION 1
#define FOR_EACH_CHANNEL( CHAN )\
@@ -103,15 +107,9 @@ get_output_base( void )
static struct x86_reg
get_temp_base( void )
{
#ifdef WIN32
return x86_make_reg(
file_REG32,
reg_BX );
#else
return x86_make_reg(
file_REG32,
reg_SI );
#endif
}
static struct x86_reg
@@ -133,14 +131,6 @@ get_immediate_base( void )
* Data access helpers.
*/
static struct x86_reg
get_argument(
unsigned index )
{
return x86_make_disp(
x86_make_reg( file_REG32, reg_SP ),
(index + 1) * 4 );
}
static struct x86_reg
get_immediate(
@@ -455,19 +445,13 @@ emit_push_gp(
{
x86_push(
func,
get_const_base() );
x86_make_reg( file_REG32, reg_AX) );
x86_push(
func,
get_input_base() );
x86_make_reg( file_REG32, reg_CX) );
x86_push(
func,
get_output_base() );
/* It is important on non-win32 platforms that temp base is pushed last.
*/
x86_push(
func,
get_temp_base() );
x86_make_reg( file_REG32, reg_DX) );
}
static void
@@ -478,16 +462,13 @@ x86_pop_gp(
*/
x86_pop(
func,
get_temp_base() );
x86_make_reg( file_REG32, reg_DX) );
x86_pop(
func,
get_output_base() );
x86_make_reg( file_REG32, reg_CX) );
x86_pop(
func,
get_input_base() );
x86_pop(
func,
get_const_base() );
x86_make_reg( file_REG32, reg_AX) );
}
static void
@@ -504,19 +485,23 @@ emit_func_call_dst(
emit_push_gp(
func );
#ifdef WIN32
x86_push(
func,
get_temp( TEMP_R0, 0 ) );
#endif
{
struct x86_reg ecx = x86_make_reg( file_REG32, reg_CX );
x86_lea(
func,
ecx,
get_temp( TEMP_R0, 0 ) );
x86_push( func, ecx );
x86_mov_reg_imm( func, ecx, (unsigned long) code );
x86_call( func, ecx );
#ifndef WIN32
x86_pop(func, ecx );
#endif
}
x86_pop_gp(
func );
@@ -577,11 +562,7 @@ static void XSTDCALL
cos4f(
float *store )
{
#ifdef WIN32
const unsigned X = 0;
#else
const unsigned X = TEMP_R0 * 16;
#endif
store[X + 0] = cosf( store[X + 0] );
store[X + 1] = cosf( store[X + 1] );
@@ -604,11 +585,8 @@ static void XSTDCALL
ex24f(
float *store )
{
#ifdef WIN32
const unsigned X = 0;
#else
const unsigned X = TEMP_R0 * 16;
#endif
store[X + 0] = powf( 2.0f, store[X + 0] );
store[X + 1] = powf( 2.0f, store[X + 1] );
store[X + 2] = powf( 2.0f, store[X + 2] );
@@ -641,11 +619,8 @@ static void XSTDCALL
flr4f(
float *store )
{
#ifdef WIN32
const unsigned X = 0;
#else
const unsigned X = TEMP_R0 * 16;
#endif
store[X + 0] = floorf( store[X + 0] );
store[X + 1] = floorf( store[X + 1] );
store[X + 2] = floorf( store[X + 2] );
@@ -667,11 +642,8 @@ static void XSTDCALL
frc4f(
float *store )
{
#ifdef WIN32
const unsigned X = 0;
#else
const unsigned X = TEMP_R0 * 16;
#endif
store[X + 0] -= floorf( store[X + 0] );
store[X + 1] -= floorf( store[X + 1] );
store[X + 2] -= floorf( store[X + 2] );
@@ -693,11 +665,8 @@ static void XSTDCALL
lg24f(
float *store )
{
#ifdef WIN32
const unsigned X = 0;
#else
const unsigned X = TEMP_R0 * 16;
#endif
store[X + 0] = LOG2( store[X + 0] );
store[X + 1] = LOG2( store[X + 1] );
store[X + 2] = LOG2( store[X + 2] );
@@ -755,11 +724,8 @@ static void XSTDCALL
pow4f(
float *store )
{
#ifdef WIN32
const unsigned X = 0;
#else
const unsigned X = TEMP_R0 * 16;
#endif
store[X + 0] = powf( store[X + 0], store[X + 4] );
store[X + 1] = powf( store[X + 1], store[X + 5] );
store[X + 2] = powf( store[X + 2], store[X + 6] );
@@ -795,23 +761,6 @@ emit_rcp (
make_xmm( xmm_src ) );
}
#if HIGH_PRECISION
static void XSTDCALL
rsqrt4f(
float *store )
{
#ifdef WIN32
const unsigned X = 0;
#else
const unsigned X = TEMP_R0 * 16;
#endif
store[X + 0] = 1.0F / sqrtf( store[X + 0] );
store[X + 1] = 1.0F / sqrtf( store[X + 1] );
store[X + 2] = 1.0F / sqrtf( store[X + 2] );
store[X + 3] = 1.0F / sqrtf( store[X + 3] );
}
#endif
static void
emit_rsqrt(
struct x86_function *func,
@@ -819,13 +768,6 @@ emit_rsqrt(
unsigned xmm_src )
{
#if HIGH_PRECISION
#if 1
emit_func_call_dst_src(
func,
xmm_dst,
xmm_src,
rsqrt4f );
#else
/* Although rsqrtps() and rcpps() are low precision on some/all SSE
* implementations, it is possible to improve its precision at
* fairly low cost, using a newton/raphson step, as below:
@@ -835,21 +777,25 @@ emit_rsqrt(
*
* See: http://softwarecommunity.intel.com/articles/eng/1818.htm
*/
/* This is some code that woudl do the above for a scalar 'a'. We
* obviously are interested in a vector version:
*
* movss xmm3, a;
* movss xmm1, half;
* movss xmm2, three;
* rsqrtss xmm0, xmm3;
* mulss xmm3, xmm0;
* mulss xmm1, xmm0;
* mulss xmm3, xmm0;
* subss xmm2, xmm3;
* mulss xmm1, xmm2;
* movss x, xmm1;
*/
#endif
{
struct x86_reg dst = make_xmm( xmm_dst );
struct x86_reg src = make_xmm( xmm_src );
struct x86_reg tmp0 = make_xmm( 2 );
struct x86_reg tmp1 = make_xmm( 3 );
assert( xmm_dst != xmm_src );
assert( xmm_dst != 2 && xmm_dst != 3 );
assert( xmm_src != 2 && xmm_src != 3 );
sse_movaps( func, dst, get_temp( TGSI_EXEC_TEMP_HALF_I, TGSI_EXEC_TEMP_HALF_C ) );
sse_movaps( func, tmp0, get_temp( TGSI_EXEC_TEMP_THREE_I, TGSI_EXEC_TEMP_THREE_C ) );
sse_rsqrtps( func, tmp1, src );
sse_mulps( func, src, tmp1 );
sse_mulps( func, dst, tmp1 );
sse_mulps( func, src, tmp1 );
sse_subps( func, tmp0, src );
sse_mulps( func, dst, tmp0 );
}
#else
/* On Intel CPUs at least, this is only accurate to 12 bits -- not
* good enough.
@@ -878,11 +824,8 @@ static void XSTDCALL
sin4f(
float *store )
{
#ifdef WIN32
const unsigned X = 0;
#else
const unsigned X = TEMP_R0 * 16;
#endif
store[X + 0] = sinf( store[X + 0] );
store[X + 1] = sinf( store[X + 1] );
store[X + 2] = sinf( store[X + 2] );
@@ -1234,11 +1177,16 @@ emit_instruction(
switch( inst->Instruction.Opcode ) {
case TGSI_OPCODE_ARL:
#if 0
/* XXX this isn't working properly (see glean vertProg1 test) */
FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
FETCH( func, *inst, 0, 0, chan_index );
emit_f2it( func, 0 );
STORE( func, *inst, 0, 0, chan_index );
}
#else
return 0;
#endif
break;
case TGSI_OPCODE_MOV:
@@ -1334,9 +1282,9 @@ emit_instruction(
case TGSI_OPCODE_RSQ:
/* TGSI_OPCODE_RECIPSQRT */
FETCH( func, *inst, 0, 0, CHAN_X );
emit_rsqrt( func, 0, 0 );
emit_rsqrt( func, 1, 0 );
FOR_EACH_DST0_ENABLED_CHANNEL( *inst, chan_index ) {
STORE( func, *inst, 0, 0, chan_index );
STORE( func, *inst, 1, 0, chan_index );
}
break;
@@ -2029,40 +1977,40 @@ emit_declaration(
}
}
static void aos_to_soa( struct x86_function *func, uint aos, uint soa, uint num, uint stride )
static void aos_to_soa( struct x86_function *func,
uint arg_aos,
uint arg_soa,
uint arg_num,
uint arg_stride )
{
struct x86_reg soa_input;
struct x86_reg aos_input;
struct x86_reg num_inputs;
struct x86_reg temp;
unsigned char *inner_loop;
struct x86_reg soa_input = x86_make_reg( file_REG32, reg_AX );
struct x86_reg aos_input = x86_make_reg( file_REG32, reg_BX );
struct x86_reg num_inputs = x86_make_reg( file_REG32, reg_CX );
struct x86_reg stride = x86_make_reg( file_REG32, reg_DX );
int inner_loop;
soa_input = x86_make_reg( file_REG32, reg_AX );
aos_input = x86_make_reg( file_REG32, reg_BX );
num_inputs = x86_make_reg( file_REG32, reg_CX );
temp = x86_make_reg( file_REG32, reg_DX );
/* Save EBX */
x86_push( func, x86_make_reg( file_REG32, reg_BX ) );
x86_mov( func, soa_input, get_argument( soa + 1 ) );
x86_mov( func, aos_input, get_argument( aos + 1 ) );
x86_mov( func, num_inputs, get_argument( num + 1 ) );
x86_mov( func, aos_input, x86_fn_arg( func, arg_aos ) );
x86_mov( func, soa_input, x86_fn_arg( func, arg_soa ) );
x86_mov( func, num_inputs, x86_fn_arg( func, arg_num ) );
x86_mov( func, stride, x86_fn_arg( func, arg_stride ) );
/* do */
inner_loop = x86_get_label( func );
{
x86_mov( func, temp, get_argument( stride + 1 ) );
x86_push( func, aos_input );
sse_movlps( func, make_xmm( 0 ), x86_make_disp( aos_input, 0 ) );
sse_movlps( func, make_xmm( 3 ), x86_make_disp( aos_input, 8 ) );
x86_add( func, aos_input, temp );
x86_add( func, aos_input, stride );
sse_movhps( func, make_xmm( 0 ), x86_make_disp( aos_input, 0 ) );
sse_movhps( func, make_xmm( 3 ), x86_make_disp( aos_input, 8 ) );
x86_add( func, aos_input, temp );
x86_add( func, aos_input, stride );
sse_movlps( func, make_xmm( 1 ), x86_make_disp( aos_input, 0 ) );
sse_movlps( func, make_xmm( 4 ), x86_make_disp( aos_input, 8 ) );
x86_add( func, aos_input, temp );
x86_add( func, aos_input, stride );
sse_movhps( func, make_xmm( 1 ), x86_make_disp( aos_input, 0 ) );
sse_movhps( func, make_xmm( 4 ), x86_make_disp( aos_input, 8 ) );
x86_pop( func, aos_input );
@@ -2088,7 +2036,7 @@ static void aos_to_soa( struct x86_function *func, uint aos, uint soa, uint num,
x86_jcc( func, cc_NE, inner_loop );
/* Restore EBX */
x86_pop( func, x86_make_reg( file_REG32, reg_BX ) );
x86_pop( func, aos_input );
}
static void soa_to_aos( struct x86_function *func, uint aos, uint soa, uint num, uint stride )
@@ -2097,7 +2045,7 @@ static void soa_to_aos( struct x86_function *func, uint aos, uint soa, uint num,
struct x86_reg aos_output;
struct x86_reg num_outputs;
struct x86_reg temp;
unsigned char *inner_loop;
int inner_loop;
soa_output = x86_make_reg( file_REG32, reg_AX );
aos_output = x86_make_reg( file_REG32, reg_BX );
@@ -2105,11 +2053,11 @@ static void soa_to_aos( struct x86_function *func, uint aos, uint soa, uint num,
temp = x86_make_reg( file_REG32, reg_DX );
/* Save EBX */
x86_push( func, x86_make_reg( file_REG32, reg_BX ) );
x86_push( func, aos_output );
x86_mov( func, soa_output, get_argument( soa + 1 ) );
x86_mov( func, aos_output, get_argument( aos + 1 ) );
x86_mov( func, num_outputs, get_argument( num + 1 ) );
x86_mov( func, soa_output, x86_fn_arg( func, soa ) );
x86_mov( func, aos_output, x86_fn_arg( func, aos ) );
x86_mov( func, num_outputs, x86_fn_arg( func, num ) );
/* do */
inner_loop = x86_get_label( func );
@@ -2126,7 +2074,7 @@ static void soa_to_aos( struct x86_function *func, uint aos, uint soa, uint num,
sse_unpcklps( func, make_xmm( 3 ), make_xmm( 4 ) );
sse_unpckhps( func, make_xmm( 5 ), make_xmm( 4 ) );
x86_mov( func, temp, get_argument( stride + 1 ) );
x86_mov( func, temp, x86_fn_arg( func, stride ) );
x86_push( func, aos_output );
sse_movlps( func, x86_make_disp( aos_output, 0 ), make_xmm( 0 ) );
sse_movlps( func, x86_make_disp( aos_output, 8 ), make_xmm( 3 ) );
@@ -2150,7 +2098,7 @@ static void soa_to_aos( struct x86_function *func, uint aos, uint soa, uint num,
x86_jcc( func, cc_NE, inner_loop );
/* Restore EBX */
x86_pop( func, x86_make_reg( file_REG32, reg_BX ) );
x86_pop( func, aos_output );
}
/**
@@ -2185,6 +2133,17 @@ tgsi_emit_sse2(
tgsi_parse_init( &parse, tokens );
/* Can't just use EDI, EBX without save/restoring them:
*/
x86_push(
func,
get_immediate_base() );
x86_push(
func,
get_temp_base() );
/*
* Different function args for vertex/fragment shaders:
*/
@@ -2193,51 +2152,55 @@ tgsi_emit_sse2(
x86_mov(
func,
get_input_base(),
get_argument( 0 ) );
x86_fn_arg( func, 1 ) );
/* skipping outputs argument here */
x86_mov(
func,
get_const_base(),
get_argument( 2 ) );
x86_fn_arg( func, 3 ) );
x86_mov(
func,
get_temp_base(),
get_argument( 3 ) );
x86_fn_arg( func, 4 ) );
x86_mov(
func,
get_coef_base(),
get_argument( 4 ) );
x86_fn_arg( func, 5 ) );
x86_mov(
func,
get_immediate_base(),
get_argument( 5 ) );
x86_fn_arg( func, 6 ) );
}
else {
assert(parse.FullHeader.Processor.Processor == TGSI_PROCESSOR_VERTEX);
if (do_swizzles)
aos_to_soa( func, 5, 0, 6, 7 );
aos_to_soa( func,
6, /* aos_input */
1, /* machine->input */
7, /* num_inputs */
8 ); /* input_stride */
x86_mov(
func,
get_input_base(),
get_argument( 0 ) );
x86_fn_arg( func, 1 ) );
x86_mov(
func,
get_output_base(),
get_argument( 1 ) );
x86_fn_arg( func, 2 ) );
x86_mov(
func,
get_const_base(),
get_argument( 2 ) );
x86_fn_arg( func, 3 ) );
x86_mov(
func,
get_temp_base(),
get_argument( 3 ) );
x86_fn_arg( func, 4 ) );
x86_mov(
func,
get_immediate_base(),
get_argument( 4 ) );
x86_fn_arg( func, 5 ) );
}
while( !tgsi_parse_end_of_tokens( &parse ) && ok ) {
@@ -2260,7 +2223,7 @@ tgsi_emit_sse2(
x86_mov(
func,
get_output_base(),
get_argument( 1 ) );
x86_fn_arg( func, 2 ) );
}
}
@@ -2307,9 +2270,19 @@ tgsi_emit_sse2(
if (parse.FullHeader.Processor.Processor == TGSI_PROCESSOR_VERTEX) {
if (do_swizzles)
soa_to_aos( func, 8, 1, 9, 10 );
soa_to_aos( func, 9, 2, 10, 11 );
}
/* Can't just use EBX, EDI without save/restoring them:
*/
x86_pop(
func,
get_temp_base() );
x86_pop(
func,
get_immediate_base() );
#ifdef WIN32
emit_retw( func, 16 );
#else
src/gallium/auxiliary/tgsi/util/tgsi_dump.c
+25
View File
@@ -767,6 +767,31 @@ dump_instruction_short(
SID( dst->DstRegister.Index );
CHR( ']' );
switch (dst->DstRegisterExtModulate.Modulate) {
case TGSI_MODULATE_1X:
break;
case TGSI_MODULATE_2X:
TXT( "_2X" );
break;
case TGSI_MODULATE_4X:
TXT( "_4X" );
break;
case TGSI_MODULATE_8X:
TXT( "_8X" );
break;
case TGSI_MODULATE_HALF:
TXT( "_D2" );
break;
case TGSI_MODULATE_QUARTER:
TXT( "_D4" );
break;
case TGSI_MODULATE_EIGHTH:
TXT( "_D8" );
break;
default:
assert( 0 );
}
if( dst->DstRegister.WriteMask != TGSI_WRITEMASK_XYZW ) {
CHR( '.' );
if( dst->DstRegister.WriteMask & TGSI_WRITEMASK_X ) {
src/gallium/auxiliary/tgsi/util/tgsi_parse.c
+2 -2
View File
@@ -43,7 +43,7 @@ tgsi_full_token_free(
union tgsi_full_token *full_token )
{
if( full_token->Token.Type == TGSI_TOKEN_TYPE_IMMEDIATE ) {
FREE( full_token->FullImmediate.u.Pointer );
FREE( (void *) full_token->FullImmediate.u.Pointer );
}
}
@@ -156,7 +156,7 @@ tgsi_parse_token(
imm->u.Pointer = MALLOC(
sizeof( struct tgsi_immediate_float32 ) * (imm->Immediate.Size - 1) );
for( i = 0; i < imm->Immediate.Size - 1; i++ ) {
next_token( ctx, &imm->u.ImmediateFloat32[i] );
next_token( ctx, (struct tgsi_immediate_float32 *) &imm->u.ImmediateFloat32[i] );
}
break;
src/gallium/auxiliary/tgsi/util/tgsi_parse.h
+2 -2
View File
@@ -52,8 +52,8 @@ struct tgsi_full_immediate
struct tgsi_immediate Immediate;
union
{
void *Pointer;
struct tgsi_immediate_float32 *ImmediateFloat32;
const void *Pointer;
const struct tgsi_immediate_float32 *ImmediateFloat32;
} u;
};
src/gallium/auxiliary/tgsi/util/tgsi_scan.c
+7 -8
View File
@@ -103,18 +103,14 @@ tgsi_scan_shader(const struct tgsi_token *tokens,
info->file_max[file] = MAX2(info->file_max[file], (int)i);
if (file == TGSI_FILE_INPUT) {
info->input_semantic_name[info->num_inputs]
= (ubyte)fulldecl->Semantic.SemanticName;
info->input_semantic_index[info->num_inputs]
= (ubyte)fulldecl->Semantic.SemanticIndex;
info->input_semantic_name[i] = (ubyte)fulldecl->Semantic.SemanticName;
info->input_semantic_index[i] = (ubyte)fulldecl->Semantic.SemanticIndex;
info->num_inputs++;
}
if (file == TGSI_FILE_OUTPUT) {
info->output_semantic_name[info->num_outputs]
= (ubyte)fulldecl->Semantic.SemanticName;
info->output_semantic_index[info->num_outputs]
= (ubyte)fulldecl->Semantic.SemanticIndex;
info->output_semantic_name[i] = (ubyte)fulldecl->Semantic.SemanticName;
info->output_semantic_index[i] = (ubyte)fulldecl->Semantic.SemanticIndex;
info->num_outputs++;
}
@@ -137,6 +133,9 @@ tgsi_scan_shader(const struct tgsi_token *tokens,
}
}
assert( info->file_max[TGSI_FILE_INPUT] + 1 == info->num_inputs );
assert( info->file_max[TGSI_FILE_OUTPUT] + 1 == info->num_outputs );
info->uses_kill = (info->opcode_count[TGSI_OPCODE_KIL] ||
info->opcode_count[TGSI_OPCODE_KILP]);
src/gallium/auxiliary/translate/translate_sse.c
+1 -1
View File
@@ -404,7 +404,7 @@ static boolean build_vertex_emit( struct translate_sse *p,
struct x86_reg srcEAX = x86_make_reg(file_REG32, reg_CX);
struct x86_reg countEBP = x86_make_reg(file_REG32, reg_BP);
struct x86_reg translateESI = x86_make_reg(file_REG32, reg_SI);
uint8_t *fixup, *label;
int fixup, label;
unsigned j;
p->func = func;
src/gallium/auxiliary/util/p_debug.c
+3 -1
View File
@@ -104,7 +104,7 @@ void _debug_break(void)
__asm("int3");
#elif (defined(__i386__) || defined(__386__)) && defined(__MSC__)
_asm {int 3};
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) && !defined(WINCE)
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
EngDebugBreak();
#else
abort();
@@ -413,6 +413,7 @@ char *pf_sprint_name( char *str, enum pipe_format format )
}
#ifdef DEBUG
void debug_print_format(const char *msg, unsigned fmt )
{
char fmtstr[80];
@@ -421,3 +422,4 @@ void debug_print_format(const char *msg, unsigned fmt )
debug_printf("%s: %s\n", msg, fmtstr);
}
#endif
src/gallium/auxiliary/util/p_debug_mem.c
+6 -1
View File
@@ -34,9 +34,11 @@
#include "pipe/p_config.h"
#ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
#if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
#include <windows.h>
#include <winddi.h>
#elif defined(PIPE_SUBSYSTEM_WINDOWS_MINIPORT)
#include <wdm.h>
#else
#include <stdio.h>
#include <stdlib.h>
@@ -52,6 +54,9 @@
#if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) && !defined(WINCE)
#define real_malloc(_size) EngAllocMem(0, _size, 'D3AG')
#define real_free(_ptr) EngFreeMem(_ptr)
#elif defined(PIPE_SUBSYSTEM_WINDOWS_MINIPORT)
#define real_malloc(_size) ExAllocatePool(0, _size)
#define real_free(_ptr) ExFreePool(_ptr)
#else
#define real_malloc(_size) malloc(_size)
#define real_free(_ptr) free(_ptr)
src/gallium/auxiliary/util/p_tile.c
+12 -12
View File
@@ -385,7 +385,7 @@ z16_get_tile_rgba(ushort *src,
/*** PIPE_FORMAT_U_L8 ***/
/*** PIPE_FORMAT_L8_UNORM ***/
static void
l8_get_tile_rgba(ubyte *src,
@@ -408,7 +408,7 @@ l8_get_tile_rgba(ubyte *src,
}
/*** PIPE_FORMAT_U_A8 ***/
/*** PIPE_FORMAT_A8_UNORM ***/
static void
a8_get_tile_rgba(ubyte *src,
@@ -476,7 +476,7 @@ r16g16b16a16_put_tile_rgba(short *dst,
/*** PIPE_FORMAT_U_I8 ***/
/*** PIPE_FORMAT_I8_UNORM ***/
static void
i8_get_tile_rgba(ubyte *src,
@@ -499,7 +499,7 @@ i8_get_tile_rgba(ubyte *src,
}
/*** PIPE_FORMAT_U_A8_L8 ***/
/*** PIPE_FORMAT_A8L8_UNORM ***/
static void
a8_l8_get_tile_rgba(ushort *src,
@@ -708,16 +708,16 @@ pipe_get_tile_rgba(struct pipe_context *pipe,
case PIPE_FORMAT_R5G6B5_UNORM:
r5g6b5_get_tile_rgba((ushort *) packed, w, h, p, dst_stride);
break;
case PIPE_FORMAT_U_L8:
case PIPE_FORMAT_L8_UNORM:
l8_get_tile_rgba((ubyte *) packed, w, h, p, dst_stride);
break;
case PIPE_FORMAT_U_A8:
case PIPE_FORMAT_A8_UNORM:
a8_get_tile_rgba((ubyte *) packed, w, h, p, dst_stride);
break;
case PIPE_FORMAT_U_I8:
case PIPE_FORMAT_I8_UNORM:
i8_get_tile_rgba((ubyte *) packed, w, h, p, dst_stride);
break;
case PIPE_FORMAT_U_A8_L8:
case PIPE_FORMAT_A8L8_UNORM:
a8_l8_get_tile_rgba((ushort *) packed, w, h, p, dst_stride);
break;
case PIPE_FORMAT_R16G16B16A16_SNORM:
@@ -787,16 +787,16 @@ pipe_put_tile_rgba(struct pipe_context *pipe,
break;
case PIPE_FORMAT_R8G8B8A8_UNORM:
break;
case PIPE_FORMAT_U_L8:
case PIPE_FORMAT_L8_UNORM:
/*l8_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);*/
break;
case PIPE_FORMAT_U_A8:
case PIPE_FORMAT_A8_UNORM:
/*a8_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);*/
break;
case PIPE_FORMAT_U_I8:
case PIPE_FORMAT_I8_UNORM:
/*i8_put_tile_rgba((ubyte *) packed, w, h, p, src_stride);*/
break;
case PIPE_FORMAT_U_A8_L8:
case PIPE_FORMAT_A8L8_UNORM:
/*a8_l8_put_tile_rgba((ushort *) packed, w, h, p, src_stride);*/
break;
case PIPE_FORMAT_R16G16B16A16_SNORM:
src/gallium/auxiliary/util/u_blit.c
+2
View File
@@ -295,6 +295,8 @@ util_blit_pixels(struct blit_state *ctx,
src, srcLeft, srcTop, /* src */
srcW, srcH); /* size */
pipe->texture_update(pipe, tex, 0, 1 << 0);
/* save state (restored below) */
cso_save_blend(ctx->cso);
cso_save_depth_stencil_alpha(ctx->cso);
src/gallium/auxiliary/util/u_gen_mipmap.c
+17 -14
View File
@@ -493,18 +493,21 @@ format_to_type_comps(enum pipe_format pformat,
*datatype = USHORT_5_6_5;
*comps = 3;
return;
case PIPE_FORMAT_U_L8:
case PIPE_FORMAT_U_A8:
case PIPE_FORMAT_U_I8:
case PIPE_FORMAT_L8_UNORM:
case PIPE_FORMAT_A8_UNORM:
case PIPE_FORMAT_I8_UNORM:
*datatype = UBYTE;
*comps = 1;
return;
case PIPE_FORMAT_U_A8_L8:
case PIPE_FORMAT_A8L8_UNORM:
*datatype = UBYTE;
*comps = 2;
return;
default:
assert(0);
*datatype = UBYTE;
*comps = 0;
break;
}
}
@@ -775,23 +778,23 @@ set_vertex_data(struct gen_mipmap_state *ctx, float width, float height)
{
void *buf;
ctx->vertices[0][0][0] = -0.5f; /*x*/
ctx->vertices[0][0][1] = -0.5f; /*y*/
ctx->vertices[0][0][0] = 0.0f; /*x*/
ctx->vertices[0][0][1] = 0.0f; /*y*/
ctx->vertices[0][1][0] = 0.0f; /*s*/
ctx->vertices[0][1][1] = 0.0f; /*t*/
ctx->vertices[1][0][0] = width - 0.5f; /*x*/
ctx->vertices[1][0][1] = -0.5f; /*y*/
ctx->vertices[1][1][0] = 1.0f; /*s*/
ctx->vertices[1][1][1] = 0.0f; /*t*/
ctx->vertices[1][0][0] = width;
ctx->vertices[1][0][1] = 0.0f;
ctx->vertices[1][1][0] = 1.0f;
ctx->vertices[1][1][1] = 0.0f;
ctx->vertices[2][0][0] = width - 0.5f;
ctx->vertices[2][0][1] = height - 0.5f;
ctx->vertices[2][0][0] = width;
ctx->vertices[2][0][1] = height;
ctx->vertices[2][1][0] = 1.0f;
ctx->vertices[2][1][1] = 1.0f;
ctx->vertices[3][0][0] = -0.5f;
ctx->vertices[3][0][1] = height - 0.5f;
ctx->vertices[3][0][0] = 0.0f;
ctx->vertices[3][0][1] = height;
ctx->vertices[3][1][0] = 0.0f;
ctx->vertices[3][1][1] = 1.0f;
src/gallium/auxiliary/util/u_time.c
+3 -3
View File
@@ -37,11 +37,11 @@
#if defined(PIPE_OS_LINUX)
#include <sys/time.h>
#elif defined(PIPE_OS_WINDOWS)
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
#include <windows.h>
#if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
#include <winddi.h>
#endif
#elif defined(PIPE_SUBSYSTEM_WINDOWS_USER)
#include <windows.h>
#else
#error Unsupported OS
#endif
src/gallium/drivers/i915simple/i915_debug_fp.c
+1 -2
View File
@@ -333,12 +333,11 @@ void
i915_disassemble_program(struct debug_stream *stream,
const unsigned * program, unsigned sz)
{
unsigned size = program[0] & 0x1ff;
unsigned i;
PRINTF(stream, "\t\tBEGIN\n");
assert(size + 2 == sz);
assert((program[0] & 0x1ff) + 2 == sz);
program++;
for (i = 1; i < sz; i += 3, program += 3) {
src/gallium/drivers/i915simple/i915_screen.c
+5 -4
View File
@@ -154,10 +154,10 @@ i915_is_format_supported( struct pipe_screen *screen,
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_A8_L8,
PIPE_FORMAT_L8_UNORM,
PIPE_FORMAT_A8_UNORM,
PIPE_FORMAT_I8_UNORM,
PIPE_FORMAT_A8L8_UNORM,
PIPE_FORMAT_YCBCR,
PIPE_FORMAT_YCBCR_REV,
PIPE_FORMAT_S8Z24_UNORM,
@@ -182,6 +182,7 @@ i915_is_format_supported( struct pipe_screen *screen,
break;
default:
assert(0);
return FALSE;
}
for (i = 0; list[i] != PIPE_FORMAT_NONE; i++) {
src/gallium/drivers/i915simple/i915_state_sampler.c
+4 -4
View File
@@ -131,13 +131,13 @@ static uint
translate_texture_format(enum pipe_format pipeFormat)
{
switch (pipeFormat) {
case PIPE_FORMAT_U_L8:
case PIPE_FORMAT_L8_UNORM:
return MAPSURF_8BIT | MT_8BIT_L8;
case PIPE_FORMAT_U_I8:
case PIPE_FORMAT_I8_UNORM:
return MAPSURF_8BIT | MT_8BIT_I8;
case PIPE_FORMAT_U_A8:
case PIPE_FORMAT_A8_UNORM:
return MAPSURF_8BIT | MT_8BIT_A8;
case PIPE_FORMAT_U_A8_L8:
case PIPE_FORMAT_A8L8_UNORM:
return MAPSURF_16BIT | MT_16BIT_AY88;
case PIPE_FORMAT_R5G6B5_UNORM:
return MAPSURF_16BIT | MT_16BIT_RGB565;
src/gallium/drivers/i965simple/brw_screen.c
+12 -12
View File
@@ -141,13 +141,13 @@ brw_is_format_supported( struct pipe_screen *screen,
#if 0
/* XXX: This is broken -- rewrite if still needed. */
static const unsigned tex_supported[] = {
PIPE_FORMAT_U_R8_G8_B8_A8,
PIPE_FORMAT_U_A8_R8_G8_B8,
PIPE_FORMAT_U_R5_G6_B5,
PIPE_FORMAT_U_L8,
PIPE_FORMAT_U_A8,
PIPE_FORMAT_U_I8,
PIPE_FORMAT_U_L8_A8,
PIPE_FORMAT_R8G8B8A8_UNORM,
PIPE_FORMAT_A8R8G8B8_UNORM,
PIPE_FORMAT_R5G6B5_UNORM,
PIPE_FORMAT_L8_UNORM,
PIPE_FORMAT_A8_UNORM,
PIPE_FORMAT_I8_UNORM,
PIPE_FORMAT_L8A8_UNORM,
PIPE_FORMAT_YCBCR,
PIPE_FORMAT_YCBCR_REV,
PIPE_FORMAT_S8_Z24,
@@ -157,16 +157,16 @@ brw_is_format_supported( struct pipe_screen *screen,
/* Actually a lot more than this - add later:
*/
static const unsigned render_supported[] = {
PIPE_FORMAT_U_A8_R8_G8_B8,
PIPE_FORMAT_U_R5_G6_B5,
PIPE_FORMAT_A8R8G8B8_UNORM,
PIPE_FORMAT_R5G6B5_UNORM,
};
/*
*/
static const unsigned z_stencil_supported[] = {
PIPE_FORMAT_U_Z16,
PIPE_FORMAT_U_Z32,
PIPE_FORMAT_S8_Z24,
PIPE_FORMAT_Z16_UNORM,
PIPE_FORMAT_Z32_UNORM,
PIPE_FORMAT_S8Z24_UNORM,
};
switch (type) {
src/gallium/drivers/i965simple/brw_wm_surface_state.c
+4 -4
View File
@@ -57,16 +57,16 @@ static unsigned translate_tex_target( enum pipe_texture_target target )
static unsigned translate_tex_format( enum pipe_format pipe_format )
{
switch( pipe_format ) {
case PIPE_FORMAT_U_L8:
case PIPE_FORMAT_L8_UNORM:
return BRW_SURFACEFORMAT_L8_UNORM;
case PIPE_FORMAT_U_I8:
case PIPE_FORMAT_I8_UNORM:
return BRW_SURFACEFORMAT_I8_UNORM;
case PIPE_FORMAT_U_A8:
case PIPE_FORMAT_A8_UNORM:
return BRW_SURFACEFORMAT_A8_UNORM;
case PIPE_FORMAT_U_A8_L8:
case PIPE_FORMAT_A8L8_UNORM:
return BRW_SURFACEFORMAT_L8A8_UNORM;
case PIPE_FORMAT_R8G8B8_UNORM:
src/gallium/drivers/softpipe/sp_context.c
+1 -3
View File
@@ -122,7 +122,7 @@ static void softpipe_destroy( struct pipe_context *pipe )
struct pipe_context *
softpipe_create( struct pipe_screen *screen,
struct pipe_winsys *pipe_winsys,
struct softpipe_winsys *softpipe_winsys )
void *unused )
{
struct softpipe_context *softpipe = CALLOC_STRUCT(softpipe_context);
uint i;
@@ -212,8 +212,6 @@ softpipe_create( struct pipe_screen *screen,
softpipe->quad.colormask = sp_quad_colormask_stage(softpipe);
softpipe->quad.output = sp_quad_output_stage(softpipe);
softpipe->winsys = softpipe_winsys;
/*
* Create drawing context and plug our rendering stage into it.
*/
src/gallium/drivers/softpipe/sp_context.h
-2
View File
@@ -57,8 +57,6 @@ struct sp_vertex_shader;
struct softpipe_context {
struct pipe_context pipe; /**< base class */
struct softpipe_winsys *winsys; /**< window system interface */
/* The most recent drawing state as set by the driver:
*/
src/gallium/drivers/softpipe/sp_prim_setup.c
+2
View File
@@ -150,6 +150,8 @@ static void reset_stipple_counter( struct draw_stage *stage )
static void render_destroy( struct draw_stage *stage )
{
struct setup_stage *ssetup = setup_stage(stage);
setup_destroy_context(ssetup->setup);
FREE( stage );
}
src/gallium/drivers/softpipe/sp_quad_stencil.c
+2 -2
View File
@@ -243,7 +243,7 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
stencilVals[j] = tile->data.depth32[y][x] & 0xff;
}
break;
case PIPE_FORMAT_U_S8:
case PIPE_FORMAT_S8_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
@@ -311,7 +311,7 @@ stencil_test_quad(struct quad_stage *qs, struct quad_header *quad)
tile->data.depth32[y][x] = z24s8;
}
break;
case PIPE_FORMAT_U_S8:
case PIPE_FORMAT_S8_UNORM:
for (j = 0; j < QUAD_SIZE; j++) {
int x = quad->x0 % TILE_SIZE + (j & 1);
int y = quad->y0 % TILE_SIZE + (j >> 1);
src/gallium/drivers/softpipe/sp_state_fs.c
+1 -2
View File
@@ -82,10 +82,9 @@ softpipe_bind_fs_state(struct pipe_context *pipe, void *fs)
void
softpipe_delete_fs_state(struct pipe_context *pipe, void *fs)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
struct sp_fragment_shader *state = fs;
assert(fs != softpipe->fs);
assert(fs != softpipe_context(pipe)->fs);
state->delete( state );
}
src/gallium/drivers/softpipe/sp_tex_sample.c
+14
View File
@@ -1051,5 +1051,19 @@ sp_get_samples(struct tgsi_sampler *sampler,
default:
assert(0);
}
#if 0 /* DEBUG */
{
int i;
printf("Sampled at %f, %f, %f:\n", s[0], t[0], p[0]);
for (i = 0; i < 4; i++) {
printf("Frag %d: %f %f %f %f\n", i,
rgba[0][i],
rgba[1][i],
rgba[2][i],
rgba[3][i]);
}
}
#endif
}
src/gallium/drivers/softpipe/sp_tile_cache.c
+7 -7
View File
@@ -131,7 +131,7 @@ sp_destroy_tile_cache(struct softpipe_tile_cache *tc)
uint pos;
for (pos = 0; pos < NUM_ENTRIES; pos++) {
//assert(tc->entries[pos].x < 0);
/*assert(tc->entries[pos].x < 0);*/
}
if (tc->surface) {
pipe_surface_reference(&tc->surface, NULL);
@@ -168,7 +168,7 @@ sp_tile_cache_set_surface(struct softpipe_tile_cache *tc,
tc->depth_stencil = (ps->format == PIPE_FORMAT_S8Z24_UNORM ||
ps->format == PIPE_FORMAT_Z16_UNORM ||
ps->format == PIPE_FORMAT_Z32_UNORM ||
ps->format == PIPE_FORMAT_U_S8);
ps->format == PIPE_FORMAT_S8_UNORM);
}
}
@@ -332,8 +332,8 @@ sp_tile_cache_flush_clear(struct pipe_context *pipe,
for (x = 0; x < w; x += TILE_SIZE) {
if (is_clear_flag_set(tc->clear_flags, x, y)) {
pipe_put_tile_raw(pipe, ps,
x, y, TILE_SIZE, TILE_SIZE,
tc->tile.data.color32, 0/*STRIDE*/);
x, y, TILE_SIZE, TILE_SIZE,
tc->tile.data.color32, 0/*STRIDE*/);
/* do this? */
clear_clear_flag(tc->clear_flags, x, y);
@@ -367,8 +367,8 @@ sp_flush_tile_cache(struct softpipe_context *softpipe,
if (tile->x >= 0) {
if (tc->depth_stencil) {
pipe_put_tile_raw(pipe, ps,
tile->x, tile->y, TILE_SIZE, TILE_SIZE,
tile->data.depth32, 0/*STRIDE*/);
tile->x, tile->y, TILE_SIZE, TILE_SIZE,
tile->data.depth32, 0/*STRIDE*/);
}
else {
pipe_put_tile_rgba(pipe, ps,
@@ -385,7 +385,7 @@ sp_flush_tile_cache(struct softpipe_context *softpipe,
#endif
}
else if (tc->texture) {
/* caching a texture, mark all entries as embpy */
/* caching a texture, mark all entries as empty */
for (pos = 0; pos < NUM_ENTRIES; pos++) {
tc->entries[pos].x = -1;
}
src/gallium/drivers/softpipe/sp_winsys.h
+1 -1
View File
@@ -59,7 +59,7 @@ struct pipe_context;
struct pipe_context *softpipe_create( struct pipe_screen *,
struct pipe_winsys *,
struct softpipe_winsys * );
void *unused );
struct pipe_screen *
src/gallium/include/pipe/p_config.h
+9
View File
@@ -106,7 +106,16 @@
#if defined(PIPE_SUBSYSTEM_KERNEL)
#define PIPE_SUBSYSTEM_WINDOWS_DISPLAY
#endif
#if 0 /* FIXME */
#define PIPE_SUBSYSTEM_WINDOWS_MINIPORT
#endif
#if 0 /* FIXME */
#define PIPE_SUBSYSTEM_WINDOWS_CE
#endif
#if defined(PIPE_SUBSYSTEM_USER)
#define PIPE_SUBSYSTEM_WINDOWS_USER
#endif
#endif /* PIPE_OS_WINDOWS */
#endif /* P_CONFIG_H_ */
src/gallium/include/pipe/p_defines.h
+2 -2
View File
@@ -192,7 +192,7 @@ enum pipe_texture_target {
#define PIPE_BUFFER_USAGE_VERTEX (1 << 5)
#define PIPE_BUFFER_USAGE_INDEX (1 << 6)
#define PIPE_BUFFER_USAGE_CONSTANT (1 << 7)
/** Pipe driver custam usage flags should be greater or equal to this value */
/** Pipe driver custom usage flags should be greater or equal to this value */
#define PIPE_BUFFER_USAGE_CUSTOM (1 << 16)
@@ -268,7 +268,7 @@ enum pipe_texture_target {
#define PIPE_CAP_MAX_POINT_WIDTH_AA 17
#define PIPE_CAP_MAX_TEXTURE_ANISOTROPY 18
#define PIPE_CAP_MAX_TEXTURE_LOD_BIAS 19
#define PIPE_CAP_BITMAP_TEXCOORD_BIAS 20
#ifdef __cplusplus
}
src/gallium/include/pipe/p_format.h
+10 -9
View File
@@ -238,10 +238,10 @@ enum pipe_format {
PIPE_FORMAT_A1R5G5B5_UNORM = _PIPE_FORMAT_RGBAZS_1 ( _PIPE_FORMAT_ARGB, 1, 5, 5, 5, PIPE_FORMAT_TYPE_UNORM ),
PIPE_FORMAT_A4R4G4B4_UNORM = _PIPE_FORMAT_RGBAZS_1 ( _PIPE_FORMAT_ARGB, 4, 4, 4, 4, PIPE_FORMAT_TYPE_UNORM ),
PIPE_FORMAT_R5G6B5_UNORM = _PIPE_FORMAT_RGBAZS_1 ( _PIPE_FORMAT_RGB1, 5, 6, 5, 0, PIPE_FORMAT_TYPE_UNORM ),
PIPE_FORMAT_U_L8 = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RRR1, 1, 1, 1, 0, PIPE_FORMAT_TYPE_UNORM ), /**< ubyte luminance */
PIPE_FORMAT_U_A8 = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_000R, 0, 0, 0, 1, PIPE_FORMAT_TYPE_UNORM ), /**< ubyte alpha */
PIPE_FORMAT_U_I8 = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RRRR, 1, 1, 1, 1, PIPE_FORMAT_TYPE_UNORM ), /**< ubyte intensity */
PIPE_FORMAT_U_A8_L8 = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RRRG, 1, 1, 1, 1, PIPE_FORMAT_TYPE_UNORM ), /**< ubyte alpha, luminance */
PIPE_FORMAT_L8_UNORM = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RRR1, 1, 1, 1, 0, PIPE_FORMAT_TYPE_UNORM ), /**< ubyte luminance */
PIPE_FORMAT_A8_UNORM = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_000R, 0, 0, 0, 1, PIPE_FORMAT_TYPE_UNORM ), /**< ubyte alpha */
PIPE_FORMAT_I8_UNORM = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RRRR, 1, 1, 1, 1, PIPE_FORMAT_TYPE_UNORM ), /**< ubyte intensity */
PIPE_FORMAT_A8L8_UNORM = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_RRRG, 1, 1, 1, 1, PIPE_FORMAT_TYPE_UNORM ), /**< ubyte alpha, luminance */
PIPE_FORMAT_YCBCR = _PIPE_FORMAT_YCBCR( 0 ),
PIPE_FORMAT_YCBCR_REV = _PIPE_FORMAT_YCBCR( 1 ),
PIPE_FORMAT_Z16_UNORM = _PIPE_FORMAT_RGBAZS_8 ( _PIPE_FORMAT_Z000, 2, 0, 0, 0, PIPE_FORMAT_TYPE_UNORM ),
@@ -327,11 +327,12 @@ enum pipe_format {
};
/**
* Unsigned 8-bit stencil format.
* XXX should remove this, but S8_UNORM is a poor name
*/
#define PIPE_FORMAT_U_S8 PIPE_FORMAT_S8_UNORM
/** XXX remove these deprecated names */
#define PIPE_FORMAT_U_L8 PIPE_FORMAT_L8_UNORM
#define PIPE_FORMAT_U_A8 PIPE_FORMAT_A8_UNORM
#define PIPE_FORMAT_U_I8 PIPE_FORMAT_I8_UNORM
#define PIPE_FORMAT_U_A8_L8 PIPE_FORMAT_A8L8_UNORM
#define PIPE_FORMAT_U_S8 PIPE_FORMAT_S8_UNORM
/**
src/gallium/include/pipe/p_inlines.h
+50
View File
@@ -129,6 +129,56 @@ pipe_texture_release(struct pipe_texture **ptr)
}
/**
* Convenience wrappers for winsys buffer functions.
*/
static INLINE struct pipe_buffer *
pipe_buffer_create( struct pipe_context *pipe,
unsigned alignment, unsigned usage, unsigned size )
{
return pipe->winsys->buffer_create(pipe->winsys, alignment, usage, size);
}
static INLINE struct pipe_buffer *
pipe_user_buffer_create( struct pipe_context *pipe, void *ptr, unsigned size )
{
return pipe->winsys->user_buffer_create(pipe->winsys, ptr, size);
}
static INLINE void
pipe_buffer_destroy( struct pipe_context *pipe, struct pipe_buffer *buf )
{
pipe->winsys->buffer_destroy(pipe->winsys, buf);
}
static INLINE void *
pipe_buffer_map(struct pipe_context *pipe,
struct pipe_buffer *buf,
unsigned usage)
{
return pipe->winsys->buffer_map(pipe->winsys, buf, usage);
}
static INLINE void
pipe_buffer_unmap(struct pipe_context *pipe,
struct pipe_buffer *buf)
{
pipe->winsys->buffer_unmap(pipe->winsys, buf);
}
/* XXX when we're using this everywhere, get rid of
* pipe_buffer_reference() above.
*/
static INLINE void
pipe_reference_buffer(struct pipe_context *pipe,
struct pipe_buffer **ptr,
struct pipe_buffer *buf)
{
pipe_buffer_reference(pipe->winsys, ptr, buf);
}
#ifdef __cplusplus
}
#endif
src/gallium/include/pipe/p_util.h
+36 -32
View File
@@ -41,7 +41,9 @@ extern "C" {
#endif
#if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) && defined(DEBUG) /* memory debugging */
#if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY) && defined(DEBUG)
/* memory debugging */
#include "p_debug.h"
@@ -54,9 +56,7 @@ extern "C" {
#define REALLOC( _ptr, _old_size, _size ) \
debug_realloc( __FILE__, __LINE__, __FUNCTION__, _ptr, _old_size, _size )
#else
#if defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
void * __stdcall
EngAllocMem(
@@ -68,17 +68,33 @@ void __stdcall
EngFreeMem(
void *Mem );
static INLINE void *
MALLOC( unsigned size )
{
#ifdef WINCE
/* TODO: Need to abstract this */
return malloc( size );
#else
return EngAllocMem( 0, size, 'D3AG' );
#endif
}
#define MALLOC( _size ) EngAllocMem( 0, _size, 'D3AG' )
#define _FREE( _ptr ) EngFreeMem( _ptr )
#elif defined(PIPE_SUBSYSTEM_WINDOWS_MINIPORT)
void *
ExAllocatePool(
unsigned long PoolType,
size_t NumberOfBytes);
void
ExFreePool(void *P);
#define MALLOC(_size) ExAllocatePool(0, _size)
#define _FREE(_ptr) ExFreePool(_ptr)
#else
#define MALLOC( SIZE ) malloc( SIZE )
#define CALLOC( COUNT, SIZE ) calloc( COUNT, SIZE )
#define FREE( PTR ) free( PTR )
#define REALLOC( OLDPTR, OLDSIZE, NEWSIZE ) realloc( OLDPTR, NEWSIZE )
#endif
#ifndef CALLOC
static INLINE void *
CALLOC( unsigned count, unsigned size )
{
@@ -88,20 +104,19 @@ CALLOC( unsigned count, unsigned size )
}
return ptr;
}
#endif /* !CALLOC */
#ifndef FREE
static INLINE void
FREE( void *ptr )
{
if( ptr ) {
#ifdef WINCE
/* TODO: Need to abstract this */
free( ptr );
#else
EngFreeMem( ptr );
#endif
_FREE( ptr );
}
}
#endif /* !FREE */
#ifndef REALLOC
static INLINE void *
REALLOC( void *old_ptr, unsigned old_size, unsigned new_size )
{
@@ -118,19 +133,8 @@ REALLOC( void *old_ptr, unsigned old_size, unsigned new_size )
FREE( old_ptr );
return new_ptr;
}
#endif /* !REALLOC */
#else /* !PIPE_SUBSYSTEM_WINDOWS_DISPLAY */
#define MALLOC( SIZE ) malloc( SIZE )
#define CALLOC( COUNT, SIZE ) calloc( COUNT, SIZE )
#define FREE( PTR ) free( PTR )
#define REALLOC( OLDPTR, OLDSIZE, NEWSIZE ) realloc( OLDPTR, NEWSIZE )
#endif /* !PIPE_SUBSYSTEM_WINDOWS_DISPLAY */
#endif /* !DEBUG */
#define MALLOC_STRUCT(T) (struct T *) MALLOC(sizeof(struct T))
src/gallium/winsys/xlib/xm_winsys.c
+152 -181
View File
@@ -37,6 +37,7 @@
#include "xmesaP.h"
#undef ASSERT
#undef Elements
#include "pipe/p_winsys.h"
#include "pipe/p_format.h"
@@ -57,6 +58,7 @@
/**
* Subclass of pipe_buffer for Xlib winsys.
* Low-level OS/window system memory buffer
*/
struct xm_buffer
@@ -73,12 +75,10 @@ struct xm_buffer
#endif
};
#if defined(USE_XSHM) && !defined(XFree86Server)
# define XSHM_ENABLED(b) ((b)->shm)
#else
# define XSHM_ENABLED(b) 0
#endif
/**
* Subclass of pipe_surface for Xlib winsys
*/
struct xmesa_surface
{
struct pipe_surface surface;
@@ -89,17 +89,8 @@ struct xmesa_surface
/**
* Derived from softpipe_winsys.
* We just need one extra field which indicates the pixel format to use for
* drawing surfaces so that we're compatible with the XVisual/window format.
* Subclass of pipe_winsys for Xlib winsys
*/
struct xmesa_softpipe_winsys
{
struct softpipe_winsys spws;
enum pipe_format pixelformat;
};
struct xmesa_pipe_winsys
{
struct pipe_winsys base;
@@ -108,28 +99,16 @@ struct xmesa_pipe_winsys
};
static void alloc_shm_ximage(struct xm_buffer *b, struct xmesa_buffer *xmb,
unsigned width, unsigned height);
/** Cast wrapper */
static INLINE struct xmesa_surface *
xmesa_surface(struct pipe_surface *ps)
{
// assert(0);
return (struct xmesa_surface *) ps;
}
/** cast wrapper */
static INLINE struct xmesa_softpipe_winsys *
xmesa_softpipe_winsys(struct softpipe_winsys *spws)
{
return (struct xmesa_softpipe_winsys *) spws;
}
/**
* Turn the softpipe opaque buffer pointer into a dri_bufmgr opaque
* buffer pointer...
*/
/** Cast wrapper */
static INLINE struct xm_buffer *
xm_buffer( struct pipe_buffer *buf )
{
@@ -137,6 +116,130 @@ xm_buffer( struct pipe_buffer *buf )
}
/**
* X Shared Memory Image extension code
*/
#if defined(USE_XSHM) && !defined(XFree86Server)
#define XSHM_ENABLED(b) ((b)->shm)
static volatile int mesaXErrorFlag = 0;
/**
* Catches potential Xlib errors.
*/
static int
mesaHandleXError(XMesaDisplay *dpy, XErrorEvent *event)
{
(void) dpy;
(void) event;
mesaXErrorFlag = 1;
return 0;
}
static GLboolean alloc_shm(struct xm_buffer *buf, unsigned size)
{
XShmSegmentInfo *const shminfo = & buf->shminfo;
shminfo->shmid = shmget(IPC_PRIVATE, size, IPC_CREAT|0777);
if (shminfo->shmid < 0) {
return GL_FALSE;
}
shminfo->shmaddr = (char *) shmat(shminfo->shmid, 0, 0);
if (shminfo->shmaddr == (char *) -1) {
shmctl(shminfo->shmid, IPC_RMID, 0);
return GL_FALSE;
}
shminfo->readOnly = False;
return GL_TRUE;
}
/**
* Allocate a shared memory XImage back buffer for the given XMesaBuffer.
*/
static void
alloc_shm_ximage(struct xm_buffer *b, struct xmesa_buffer *xmb,
unsigned width, unsigned height)
{
/*
* We have to do a _lot_ of error checking here to be sure we can
* really use the XSHM extension. It seems different servers trigger
* errors at different points if the extension won't work. Therefore
* we have to be very careful...
*/
#if 0
GC gc;
#endif
int (*old_handler)(XMesaDisplay *, XErrorEvent *);
b->tempImage = XShmCreateImage(xmb->xm_visual->display,
xmb->xm_visual->visinfo->visual,
xmb->xm_visual->visinfo->depth,
ZPixmap,
NULL,
&b->shminfo,
width, height);
if (b->tempImage == NULL) {
b->shm = 0;
return;
}
mesaXErrorFlag = 0;
old_handler = XSetErrorHandler(mesaHandleXError);
/* This may trigger the X protocol error we're ready to catch: */
XShmAttach(xmb->xm_visual->display, &b->shminfo);
XSync(xmb->xm_visual->display, False);
if (mesaXErrorFlag) {
/* we are on a remote display, this error is normal, don't print it */
XFlush(xmb->xm_visual->display);
mesaXErrorFlag = 0;
XDestroyImage(b->tempImage);
b->tempImage = NULL;
b->shm = 0;
(void) XSetErrorHandler(old_handler);
return;
}
/* Finally, try an XShmPutImage to be really sure the extension works */
#if 0
gc = XCreateGC(xmb->xm_visual->display, xmb->drawable, 0, NULL);
XShmPutImage(xmb->xm_visual->display, xmb->drawable, gc,
b->tempImage, 0, 0, 0, 0, 1, 1 /*one pixel*/, False);
XSync(xmb->xm_visual->display, False);
XFreeGC(xmb->xm_visual->display, gc);
(void) XSetErrorHandler(old_handler);
if (mesaXErrorFlag) {
XFlush(xmb->xm_visual->display);
mesaXErrorFlag = 0;
XDestroyImage(b->tempImage);
b->tempImage = NULL;
b->shm = 0;
return;
}
#endif
}
#else
#define XSHM_ENABLED(b) 0
static void
alloc_shm_ximage(struct xm_buffer *b, struct xmesa_buffer *xmb,
unsigned width, unsigned height)
{
b->shm = 0;
}
#endif /* USE_XSHM */
/* Most callbacks map direcly onto dri_bufmgr operations:
*/
@@ -313,119 +416,6 @@ xm_get_name(struct pipe_winsys *pws)
}
#if defined(USE_XSHM) && !defined(XFree86Server)
static volatile int mesaXErrorFlag = 0;
/**
* Catches potential Xlib errors.
*/
static int
mesaHandleXError(XMesaDisplay *dpy, XErrorEvent *event)
{
(void) dpy;
(void) event;
mesaXErrorFlag = 1;
return 0;
}
static GLboolean alloc_shm(struct xm_buffer *buf, unsigned size)
{
XShmSegmentInfo *const shminfo = & buf->shminfo;
shminfo->shmid = shmget(IPC_PRIVATE, size, IPC_CREAT|0777);
if (shminfo->shmid < 0) {
return GL_FALSE;
}
shminfo->shmaddr = (char *) shmat(shminfo->shmid, 0, 0);
if (shminfo->shmaddr == (char *) -1) {
shmctl(shminfo->shmid, IPC_RMID, 0);
return GL_FALSE;
}
shminfo->readOnly = False;
return GL_TRUE;
}
/**
* Allocate a shared memory XImage back buffer for the given XMesaBuffer.
*/
static void
alloc_shm_ximage(struct xm_buffer *b, struct xmesa_buffer *xmb,
unsigned width, unsigned height)
{
/*
* We have to do a _lot_ of error checking here to be sure we can
* really use the XSHM extension. It seems different servers trigger
* errors at different points if the extension won't work. Therefore
* we have to be very careful...
*/
#if 0
GC gc;
#endif
int (*old_handler)(XMesaDisplay *, XErrorEvent *);
b->tempImage = XShmCreateImage(xmb->xm_visual->display,
xmb->xm_visual->visinfo->visual,
xmb->xm_visual->visinfo->depth,
ZPixmap,
NULL,
&b->shminfo,
width, height);
if (b->tempImage == NULL) {
b->shm = 0;
return;
}
mesaXErrorFlag = 0;
old_handler = XSetErrorHandler(mesaHandleXError);
/* This may trigger the X protocol error we're ready to catch: */
XShmAttach(xmb->xm_visual->display, &b->shminfo);
XSync(xmb->xm_visual->display, False);
if (mesaXErrorFlag) {
/* we are on a remote display, this error is normal, don't print it */
XFlush(xmb->xm_visual->display);
mesaXErrorFlag = 0;
XDestroyImage(b->tempImage);
b->tempImage = NULL;
b->shm = 0;
(void) XSetErrorHandler(old_handler);
return;
}
/* Finally, try an XShmPutImage to be really sure the extension works */
#if 0
gc = XCreateGC(xmb->xm_visual->display, xmb->drawable, 0, NULL);
XShmPutImage(xmb->xm_visual->display, xmb->drawable, gc,
b->tempImage, 0, 0, 0, 0, 1, 1 /*one pixel*/, False);
XSync(xmb->xm_visual->display, False);
XFreeGC(xmb->xm_visual->display, gc);
(void) XSetErrorHandler(old_handler);
if (mesaXErrorFlag) {
XFlush(xmb->xm_visual->display);
mesaXErrorFlag = 0;
XDestroyImage(b->tempImage);
b->tempImage = NULL;
b->shm = 0;
return;
}
#endif
}
#else
static void
alloc_shm_ximage(struct xm_buffer *b, struct xmesa_buffer *xmb,
unsigned width, unsigned height)
{
b->shm = 0;
}
#endif
static struct pipe_buffer *
xm_buffer_create(struct pipe_winsys *pws,
unsigned alignment,
@@ -525,8 +515,7 @@ xm_surface_alloc_storage(struct pipe_winsys *winsys,
/**
* Called via pipe->surface_alloc() to create new surfaces (textures,
* renderbuffers, etc.
* Called via winsys->surface_alloc() to create new surfaces.
*/
static struct pipe_surface *
xm_surface_alloc(struct pipe_winsys *ws)
@@ -610,10 +599,19 @@ xmesa_get_pipe_winsys_aub(struct xmesa_visual *xm_vis)
{
static struct xmesa_pipe_winsys *ws = NULL;
if (!ws && getenv("XM_AUB")) {
if (!ws) {
ws = (struct xmesa_pipe_winsys *) xmesa_create_pipe_winsys_aub();
}
else if (!ws) {
return &ws->base;
}
static struct pipe_winsys *
xmesa_get_pipe_winsys(struct xmesa_visual *xm_vis)
{
static struct xmesa_pipe_winsys *ws = NULL;
if (!ws) {
ws = CALLOC_STRUCT(xmesa_pipe_winsys);
ws->xm_visual = xm_vis;
@@ -644,45 +642,19 @@ xmesa_get_pipe_winsys_aub(struct xmesa_visual *xm_vis)
}
/**
* 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.
*/
static boolean
xmesa_is_format_supported(struct softpipe_winsys *sws,
enum pipe_format format)
{
struct xmesa_softpipe_winsys *xmws = xmesa_softpipe_winsys(sws);
return (format == xmws->pixelformat);
}
/**
* Return pointer to a softpipe_winsys object.
*/
static struct softpipe_winsys *
xmesa_get_softpipe_winsys(uint pixelformat)
{
struct xmesa_softpipe_winsys *xmws
= CALLOC_STRUCT(xmesa_softpipe_winsys);
if (!xmws)
return NULL;
xmws->spws.is_format_supported = xmesa_is_format_supported;
xmws->pixelformat = pixelformat;
return &xmws->spws;
}
struct pipe_context *
xmesa_create_pipe_context(XMesaContext xmesa, uint pixelformat)
{
struct pipe_winsys *pws = xmesa_get_pipe_winsys_aub(xmesa->xm_visual);
struct pipe_winsys *pws;
struct pipe_context *pipe;
if (getenv("XM_AUB")) {
pws = xmesa_get_pipe_winsys_aub(xmesa->xm_visual);
}
else {
pws = xmesa_get_pipe_winsys(xmesa->xm_visual);
}
#ifdef GALLIUM_CELL
if (!getenv("GALLIUM_NOCELL")) {
struct cell_winsys *cws = cell_get_winsys(pixelformat);
@@ -693,10 +665,9 @@ xmesa_create_pipe_context(XMesaContext xmesa, uint pixelformat)
else
#endif
{
struct softpipe_winsys *spws = xmesa_get_softpipe_winsys(pixelformat);
struct pipe_screen *screen = softpipe_create_screen(pws);
pipe = softpipe_create(screen, pws, spws);
pipe = softpipe_create(screen, pws, NULL);
}
if (pipe)
src/mesa/main/context.c
Regular → Executable
+7 -3
View File
@@ -1504,15 +1504,19 @@ _mesa_make_current( GLcontext *newCtx, GLframebuffer *drawBuffer,
* or not bound to a user-created FBO.
*/
if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
_mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
/* fix up the fb fields - these will end up wrong otherwise
if the DRIdrawable changes, and everything relies on them.
This is a bit messy (same as needed in _mesa_BindFramebufferEXT) */
* if the DRIdrawable changes, and everything relies on them.
* This is a bit messy (same as needed in _mesa_BindFramebufferEXT)
*/
int i;
GLenum buffers[MAX_DRAW_BUFFERS];
_mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
buffers[i] = newCtx->Color.DrawBuffer[i];
}
_mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers, buffers, NULL);
}
if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
src/mesa/main/texstate.c
+6 -1
View File
@@ -238,6 +238,9 @@ calculate_derived_texenv( struct gl_tex_env_combine_state *state,
return;
}
if (mode == GL_REPLACE_EXT)
mode = GL_REPLACE;
switch (mode) {
case GL_REPLACE:
case GL_MODULATE:
@@ -340,7 +343,9 @@ _mesa_TexEnvfv( GLenum target, GLenum pname, const GLfloat *param )
switch (pname) {
case GL_TEXTURE_ENV_MODE:
{
const GLenum mode = (GLenum) (GLint) *param;
GLenum mode = (GLenum) (GLint) *param;
if (mode == GL_REPLACE_EXT)
mode = GL_REPLACE;
if (texUnit->EnvMode == mode)
return;
if (mode == GL_MODULATE ||
src/mesa/state_tracker/st_atom_blend.c
+5 -10
View File
@@ -223,15 +223,10 @@ update_blend( struct st_context *st )
const struct st_tracked_state st_update_blend = {
.name = "st_update_blend",
.dirty = {
.mesa = (_NEW_COLOR), /* XXX _NEW_BLEND someday? */
.st = 0,
"st_update_blend", /* name */
{ /* dirty */
(_NEW_COLOR), /* XXX _NEW_BLEND someday? */ /* mesa */
0, /* st */
},
.update = update_blend
update_blend, /* update */
};
src/mesa/state_tracker/st_atom_clip.c
+5 -10
View File
@@ -62,15 +62,10 @@ static void update_clip( struct st_context *st )
const struct st_tracked_state st_update_clip = {
.name = "st_update_clip",
.dirty = {
.mesa = (_NEW_TRANSFORM),
.st = 0,
"st_update_clip", /* name */
{ /* dirty */
(_NEW_TRANSFORM), /* mesa */
0, /* st */
},
.update = update_clip
update_clip /* update */
};
src/mesa/state_tracker/st_atom_constbuf.c
+17 -17
View File
@@ -36,7 +36,6 @@
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_winsys.h"
#include "pipe/p_inlines.h"
#include "st_context.h"
@@ -54,7 +53,7 @@ void st_upload_constants( struct st_context *st,
struct gl_program_parameter_list *params,
unsigned id)
{
struct pipe_winsys *ws = st->pipe->winsys;
struct pipe_context *pipe = st->pipe;
struct pipe_constant_buffer *cbuf = &st->state.constants[id];
assert(id == PIPE_SHADER_VERTEX || id == PIPE_SHADER_FRAGMENT);
@@ -74,8 +73,8 @@ void st_upload_constants( struct st_context *st,
/* We always need to get a new buffer, to keep the drivers simple and
* avoid gratuitous rendering synchronization.
*/
pipe_buffer_reference( ws, &cbuf->buffer, NULL );
cbuf->buffer = ws->buffer_create( ws, 1, PIPE_BUFFER_USAGE_CONSTANT,
pipe_reference_buffer(pipe, &cbuf->buffer, NULL );
cbuf->buffer = pipe_buffer_create(pipe, 1, PIPE_BUFFER_USAGE_CONSTANT,
paramBytes );
if (0)
@@ -87,9 +86,10 @@ void st_upload_constants( struct st_context *st,
/* load Mesa constants into the constant buffer */
if (cbuf->buffer) {
memcpy(ws->buffer_map(ws, cbuf->buffer, PIPE_BUFFER_USAGE_CPU_WRITE),
params->ParameterValues, paramBytes);
ws->buffer_unmap(ws, cbuf->buffer);
void *map = pipe_buffer_map(pipe, cbuf->buffer,
PIPE_BUFFER_USAGE_CPU_WRITE);
memcpy(map, params->ParameterValues, paramBytes);
pipe_buffer_unmap(pipe, cbuf->buffer);
}
cbuf->size = paramBytes;
@@ -113,12 +113,12 @@ static void update_vs_constants(struct st_context *st )
}
const struct st_tracked_state st_update_vs_constants = {
.name = "st_update_vs_constants",
.dirty = {
.mesa = 0, /* set dynamically above */
.st = ST_NEW_VERTEX_PROGRAM,
"st_update_vs_constants", /* name */
{ /* dirty */
0, /* set dynamically above */ /* mesa */
ST_NEW_VERTEX_PROGRAM, /* st */
},
.update = update_vs_constants
update_vs_constants /* update */
};
/* Fragment shader:
@@ -132,11 +132,11 @@ static void update_fs_constants(struct st_context *st )
}
const struct st_tracked_state st_update_fs_constants = {
.name = "st_update_fs_constants",
.dirty = {
.mesa = 0, /* set dynamically above */
.st = ST_NEW_FRAGMENT_PROGRAM,
"st_update_fs_constants", /* name */
{ /* dirty */
0, /* set dynamically above */ /* mesa */
ST_NEW_FRAGMENT_PROGRAM, /* st */
},
.update = update_fs_constants
update_fs_constants /* update */
};
src/mesa/state_tracker/st_atom_depth.c
+5 -5
View File
@@ -142,10 +142,10 @@ update_depth_stencil_alpha(struct st_context *st)
const struct st_tracked_state st_update_depth_stencil_alpha = {
.name = "st_update_depth_stencil",
.dirty = {
.mesa = (_NEW_DEPTH|_NEW_STENCIL|_NEW_COLOR),
.st = 0,
"st_update_depth_stencil", /* name */
{ /* dirty */
(_NEW_DEPTH|_NEW_STENCIL|_NEW_COLOR), /* mesa */
0, /* st */
},
.update = update_depth_stencil_alpha
update_depth_stencil_alpha /* update */
};
src/mesa/state_tracker/st_atom_fixedfunction.c
+5 -5
View File
@@ -55,12 +55,12 @@ static void update_tnl( struct st_context *st )
const struct st_tracked_state st_update_tnl = {
.name = "st_update_tnl",
.dirty = {
.mesa = TNL_FIXED_FUNCTION_STATE_FLAGS,
.st = 0
"st_update_tnl", /* name */
{ /* dirty */
TNL_FIXED_FUNCTION_STATE_FLAGS, /* mesa */
0 /* st */
},
.update = update_tnl
update_tnl /* update */
};
src/mesa/state_tracker/st_atom_framebuffer.c
+5 -5
View File
@@ -96,11 +96,11 @@ update_framebuffer_state( struct st_context *st )
const struct st_tracked_state st_update_framebuffer = {
.name = "st_update_framebuffer",
.dirty = {
.mesa = _NEW_BUFFERS,
.st = 0,
"st_update_framebuffer", /* name */
{ /* dirty */
_NEW_BUFFERS, /* mesa */
0, /* st */
},
.update = update_framebuffer_state
update_framebuffer_state /* update */
};
src/mesa/state_tracker/st_atom_pixeltransfer.c
+5 -5
View File
@@ -463,10 +463,10 @@ update_pixel_transfer(struct st_context *st)
const struct st_tracked_state st_update_pixel_transfer = {
.name = "st_update_pixel_transfer",
.dirty = {
.mesa = _NEW_PIXEL | _NEW_COLOR_MATRIX,
.st = 0,
"st_update_pixel_transfer", /* name */
{ /* dirty */
_NEW_PIXEL | _NEW_COLOR_MATRIX, /* mesa */
0, /* st */
},
.update = update_pixel_transfer
update_pixel_transfer /* update */
};
src/mesa/state_tracker/st_atom_rasterizer.c
+6 -6
View File
@@ -267,11 +267,11 @@ static void update_raster_state( struct st_context *st )
}
const struct st_tracked_state st_update_rasterizer = {
.name = "st_update_rasterizer",
.dirty = {
.mesa = (_NEW_LIGHT | _NEW_POLYGON | _NEW_LINE | _NEW_SCISSOR |
_NEW_POINT | _NEW_BUFFERS | _NEW_MULTISAMPLE),
.st = 0,
"st_update_rasterizer", /* name */
{ /* dirty */
(_NEW_LIGHT | _NEW_POLYGON | _NEW_LINE | _NEW_SCISSOR | /* mesa */
_NEW_POINT | _NEW_BUFFERS | _NEW_MULTISAMPLE),
0, /* st */
},
.update = update_raster_state
update_raster_state /* update */
};
src/mesa/state_tracker/st_atom_sampler.c
+11 -21
View File
@@ -32,11 +32,14 @@
*/
#include "main/macros.h"
#include "st_context.h"
#include "st_atom.h"
#include "st_program.h"
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "cso_cache/cso_context.h"
@@ -147,17 +150,9 @@ update_samplers(struct st_context *st)
sampler->normalized_coords = 1;
sampler->lod_bias = st->ctx->Texture.Unit[su].LodBias;
#if 1
sampler->min_lod = (texobj->MinLod) < 0.0 ? 0.0 : texobj->MinLod;
sampler->max_lod = texobj->MaxLod;
#else
/* min/max lod should really be as follows (untested).
* Also, calculate_first_last_level() needs to be overhauled
* since today's hardware had real support for LOD clamping.
*/
sampler->min_lod = MAX2(texobj->BaseLevel, texobj->MinLod);
sampler->max_lod = MIN2(texobj->MaxLevel, texobj->MaxLod);
#endif
sampler->min_lod = MAX2(0.0f, texobj->MinLod);
sampler->max_lod = MIN2(texobj->MaxLevel - texobj->BaseLevel,
texobj->MaxLod);
sampler->border_color[0] = texobj->BorderColor[RCOMP];
sampler->border_color[1] = texobj->BorderColor[GCOMP];
@@ -193,15 +188,10 @@ update_samplers(struct st_context *st)
const struct st_tracked_state st_update_sampler = {
.name = "st_update_sampler",
.dirty = {
.mesa = _NEW_TEXTURE,
.st = 0,
"st_update_sampler", /* name */
{ /* dirty */
_NEW_TEXTURE, /* mesa */
0, /* st */
},
.update = update_samplers
update_samplers /* update */
};
src/mesa/state_tracker/st_atom_scissor.c
+5 -10
View File
@@ -83,15 +83,10 @@ update_scissor( struct st_context *st )
const struct st_tracked_state st_update_scissor = {
.name = "st_update_scissor",
.dirty = {
.mesa = (_NEW_SCISSOR | _NEW_BUFFERS),
.st = 0,
"st_update_scissor", /* name */
{ /* dirty */
(_NEW_SCISSOR | _NEW_BUFFERS), /* mesa */
0, /* st */
},
.update = update_scissor
update_scissor /* update */
};
src/mesa/state_tracker/st_atom_shader.c
+5 -5
View File
@@ -281,10 +281,10 @@ update_linkage( struct st_context *st )
const struct st_tracked_state st_update_shader = {
.name = "st_update_shader",
.dirty = {
.mesa = 0,
.st = ST_NEW_VERTEX_PROGRAM | ST_NEW_FRAGMENT_PROGRAM
"st_update_shader", /* name */
{ /* dirty */
0, /* mesa */
ST_NEW_VERTEX_PROGRAM | ST_NEW_FRAGMENT_PROGRAM /* st */
},
.update = update_linkage
update_linkage /* update */
};
src/mesa/state_tracker/st_atom_stipple.c
+5 -5
View File
@@ -54,10 +54,10 @@ update_stipple( struct st_context *st )
const struct st_tracked_state st_update_polygon_stipple = {
.name = "st_update_polygon_stipple",
.dirty = {
.mesa = (_NEW_POLYGONSTIPPLE),
.st = 0,
"st_update_polygon_stipple", /* name */
{ /* dirty */
(_NEW_POLYGONSTIPPLE), /* mesa */
0, /* st */
},
.update = update_stipple
update_stipple /* update */
};
src/mesa/state_tracker/st_atom_texture.c
+7 -10
View File
@@ -90,6 +90,8 @@ update_textures(struct st_context *st)
}
st->state.num_textures = su + 1;
stObj->teximage_realloc = TRUE;
}
pt = st_get_stobj_texture(stObj);
@@ -111,15 +113,10 @@ update_textures(struct st_context *st)
const struct st_tracked_state st_update_texture = {
.name = "st_update_texture",
.dirty = {
.mesa = _NEW_TEXTURE,
.st = ST_NEW_FRAGMENT_PROGRAM,
"st_update_texture", /* name */
{ /* dirty */
_NEW_TEXTURE, /* mesa */
ST_NEW_FRAGMENT_PROGRAM, /* st */
},
.update = update_textures
update_textures /* update */
};
src/mesa/state_tracker/st_atom_viewport.c
+5 -5
View File
@@ -82,10 +82,10 @@ update_viewport( struct st_context *st )
const struct st_tracked_state st_update_viewport = {
.name = "st_update_viewport",
.dirty = {
.mesa = _NEW_BUFFERS | _NEW_VIEWPORT,
.st = 0,
"st_update_viewport", /* name */
{ /* dirty */
_NEW_BUFFERS | _NEW_VIEWPORT, /* mesa */
0, /* st */
},
.update = update_viewport
update_viewport /* update */
};
src/mesa/state_tracker/st_cb_bitmap.c
+123 -174
View File
@@ -50,7 +50,6 @@
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "pipe/p_winsys.h"
#include "util/p_tile.h"
#include "util/u_draw_quad.h"
#include "util/u_simple_shaders.h"
@@ -90,10 +89,14 @@ struct bitmap_cache
GLint xpos, ypos;
/** Bounds of region used in window coords */
GLint xmin, ymin, xmax, ymax;
struct pipe_texture *texture;
struct pipe_surface *surf;
GLboolean empty;
/** An I8 texture image: */
GLubyte buffer[BITMAP_CACHE_HEIGHT][BITMAP_CACHE_WIDTH];
ubyte *buffer;
};
@@ -220,76 +223,37 @@ combined_bitmap_fragment_program(GLcontext *ctx)
/**
* Create a texture which represents a bitmap image.
* Copy user-provide bitmap bits into texture buffer, expanding
* bits into texels.
* "On" bits will set texels to 0xff.
* "Off" bits will not modify texels.
* Note that the image is actually going to be upside down in
* the texture. We deal with that with texcoords.
*/
static struct pipe_texture *
make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
const struct gl_pixelstore_attrib *unpack,
const GLubyte *bitmap)
static void
unpack_bitmap(struct st_context *st,
GLint px, GLint py, GLsizei width, GLsizei height,
const struct gl_pixelstore_attrib *unpack,
const GLubyte *bitmap,
ubyte *destBuffer, uint destStride)
{
struct pipe_context *pipe = ctx->st->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_surface *surface;
uint format = 0, cpp, comp;
ubyte *dest;
struct pipe_texture *pt;
int row, col;
GLint row, col;
/* find a texture format we know */
if (screen->is_format_supported( screen, PIPE_FORMAT_U_I8, PIPE_TEXTURE )) {
format = PIPE_FORMAT_U_I8;
cpp = 1;
comp = 0;
}
else if (screen->is_format_supported( screen, PIPE_FORMAT_A8R8G8B8_UNORM, PIPE_TEXTURE )) {
format = PIPE_FORMAT_A8R8G8B8_UNORM;
cpp = 4;
comp = 3; /* alpha channel */ /*XXX little-endian dependency */
}
else {
/* XXX support more formats */
assert( 0 );
}
/* PBO source... */
bitmap = _mesa_map_bitmap_pbo(ctx, unpack, bitmap);
if (!bitmap) {
return NULL;
}
/**
* Create texture to hold bitmap pattern.
*/
pt = st_texture_create(ctx->st, PIPE_TEXTURE_2D, format, 0, width, height,
1, 0);
if (!pt) {
_mesa_unmap_bitmap_pbo(ctx, unpack);
return NULL;
}
surface = screen->get_tex_surface(screen, pt, 0, 0, 0);
/* map texture surface */
dest = pipe_surface_map(surface);
/* Put image into texture surface.
* Note that the image is actually going to be upside down in
* the texture. We deal with that with texcoords.
*/
#define SET_PIXEL(COL, ROW) \
destBuffer[(py + (ROW)) * destStride + px + (COL)] = 0x0;
for (row = 0; row < height; row++) {
const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
ubyte *destRow = dest + row * surface->pitch * cpp;
if (unpack->LsbFirst) {
/* Lsb first */
GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
for (col = 0; col < width; col++) {
/* set texel to 255 if bit is set */
destRow[comp] = (*src & mask) ? 0x0 : 0xff;
destRow += cpp;
if (*src & mask) {
SET_PIXEL(col, row);
}
if (mask == 128U) {
src++;
@@ -309,9 +273,9 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
for (col = 0; col < width; col++) {
/* set texel to 255 if bit is set */
destRow[comp] =(*src & mask) ? 0x0 : 0xff;
destRow += cpp;
if (*src & mask) {
SET_PIXEL(col, row);
}
if (mask == 1U) {
src++;
@@ -329,6 +293,50 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
} /* row */
#undef SET_PIXEL
}
/**
* Create a texture which represents a bitmap image.
*/
static struct pipe_texture *
make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
const struct gl_pixelstore_attrib *unpack,
const GLubyte *bitmap)
{
struct pipe_context *pipe = ctx->st->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_surface *surface;
ubyte *dest;
struct pipe_texture *pt;
/* PBO source... */
bitmap = _mesa_map_bitmap_pbo(ctx, unpack, bitmap);
if (!bitmap) {
return NULL;
}
/**
* Create texture to hold bitmap pattern.
*/
pt = st_texture_create(ctx->st, PIPE_TEXTURE_2D, ctx->st->bitmap.tex_format,
0, width, height, 1, 0);
if (!pt) {
_mesa_unmap_bitmap_pbo(ctx, unpack);
return NULL;
}
surface = screen->get_tex_surface(screen, pt, 0, 0, 0);
/* map texture surface */
dest = pipe_surface_map(surface);
/* Put image into texture surface */
memset(dest, 0xff, height * surface->pitch);
unpack_bitmap(ctx->st, 0, 0, width, height, unpack, bitmap,
dest, surface->pitch);
_mesa_unmap_bitmap_pbo(ctx, unpack);
/* Release surface */
@@ -336,8 +344,6 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
pipe_surface_reference(&surface, NULL);
pipe->texture_update(pipe, pt, 0, 0x1);
pt->format = format;
return pt;
}
@@ -365,9 +371,8 @@ setup_bitmap_vertex_data(struct st_context *st,
void *buf;
if (!st->bitmap.vbuf) {
st->bitmap.vbuf = pipe->winsys->buffer_create(pipe->winsys, 32,
PIPE_BUFFER_USAGE_VERTEX,
sizeof(st->bitmap.vertices));
st->bitmap.vbuf = pipe_buffer_create(pipe, 32, PIPE_BUFFER_USAGE_VERTEX,
sizeof(st->bitmap.vertices));
}
/* Positions are in clip coords since we need to do clipping in case
@@ -406,10 +411,9 @@ setup_bitmap_vertex_data(struct st_context *st,
}
/* put vertex data into vbuf */
buf = pipe->winsys->buffer_map(pipe->winsys, st->bitmap.vbuf,
PIPE_BUFFER_USAGE_CPU_WRITE);
buf = pipe_buffer_map(pipe, st->bitmap.vbuf, PIPE_BUFFER_USAGE_CPU_WRITE);
memcpy(buf, st->bitmap.vertices, sizeof(st->bitmap.vertices));
pipe->winsys->buffer_unmap(pipe->winsys, st->bitmap.vbuf);
pipe_buffer_unmap(pipe, st->bitmap.vbuf);
}
@@ -516,47 +520,35 @@ draw_bitmap_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
static void
reset_cache(struct st_context *st)
{
memset(st->bitmap.cache->buffer, 0xff, sizeof(st->bitmap.cache->buffer));
st->bitmap.cache->empty = GL_TRUE;
st->bitmap.cache->xmin = 1000000;
st->bitmap.cache->xmax = -1000000;
st->bitmap.cache->ymin = 1000000;
st->bitmap.cache->ymax = -1000000;
}
static void
init_bitmap_cache(struct st_context *st)
{
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
enum pipe_format format;
struct bitmap_cache *cache = st->bitmap.cache;
st->bitmap.cache = CALLOC_STRUCT(bitmap_cache);
if (!st->bitmap.cache)
return;
//memset(cache->buffer, 0xff, sizeof(cache->buffer));
cache->empty = GL_TRUE;
/* find a usable texture format */
if (screen->is_format_supported(screen, PIPE_FORMAT_U_I8, PIPE_TEXTURE)) {
format = PIPE_FORMAT_U_I8;
}
else {
/* XXX support more formats */
assert(0);
}
cache->xmin = 1000000;
cache->xmax = -1000000;
cache->ymin = 1000000;
cache->ymax = -1000000;
st->bitmap.cache->texture
= st_texture_create(st, PIPE_TEXTURE_2D, format, 0,
BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT, 1, 0);
if (!st->bitmap.cache->texture) {
FREE(st->bitmap.cache);
st->bitmap.cache = NULL;
return;
}
assert(!cache->texture);
reset_cache(st);
/* allocate a new texture */
cache->texture = st_texture_create(st, PIPE_TEXTURE_2D,
st->bitmap.tex_format, 0,
BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,
1, 0);
/* Map the texture surface.
* Subsequent glBitmap calls will write into the texture image.
*/
cache->surf = screen->get_tex_surface(screen, cache->texture, 0, 0, 0);
cache->buffer = pipe_surface_map(cache->surf);
/* init image to all 0xff */
memset(cache->buffer, 0xff, BITMAP_CACHE_WIDTH * BITMAP_CACHE_HEIGHT);
}
@@ -570,9 +562,6 @@ st_flush_bitmap_cache(struct st_context *st)
if (st->ctx->DrawBuffer) {
struct bitmap_cache *cache = st->bitmap.cache;
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_surface *surf;
void *dest;
assert(cache->xmin <= cache->xmax);
/*
@@ -582,18 +571,13 @@ st_flush_bitmap_cache(struct st_context *st)
cache->xpos, cache->ypos);
*/
/* update the texture map image */
surf = screen->get_tex_surface(screen, cache->texture, 0, 0, 0);
dest = pipe_surface_map(surf);
memcpy(dest, cache->buffer, sizeof(cache->buffer));
pipe_surface_unmap(surf);
pipe_surface_reference(&surf, NULL);
/* flush in case the previous texture contents haven't been
* used yet. XXX this is not ideal! Revisit.
/* The texture surface has been mapped until now.
* So unmap and release the texture surface before drawing.
*/
st->pipe->flush( st->pipe, 0x0, NULL );
pipe_surface_unmap(cache->surf);
pipe_surface_reference(&cache->surf, NULL);
/* XXX is this needed? */
pipe->texture_update(pipe, cache->texture, 0, 0x1);
draw_bitmap_quad(st->ctx,
@@ -602,6 +586,9 @@ st_flush_bitmap_cache(struct st_context *st)
st->ctx->Current.RasterPos[2],
BITMAP_CACHE_WIDTH, BITMAP_CACHE_HEIGHT,
cache->texture);
/* release/free the texture */
pipe_texture_reference(&cache->texture, NULL);
}
reset_cache(st);
}
@@ -619,7 +606,6 @@ accum_bitmap(struct st_context *st,
const GLubyte *bitmap )
{
struct bitmap_cache *cache = st->bitmap.cache;
int row, col;
int px = -999, py;
if (width > BITMAP_CACHE_WIDTH ||
@@ -658,60 +644,8 @@ accum_bitmap(struct st_context *st,
if (y + height > cache->ymax)
cache->ymax = y + height;
/* XXX try to combine this code with code in make_bitmap_texture() */
#define SET_PIXEL(COL, ROW) \
cache->buffer[py + (ROW)][px + (COL)] = 0x0;
for (row = 0; row < height; row++) {
const GLubyte *src = (const GLubyte *) _mesa_image_address2d(unpack,
bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, row, 0);
if (unpack->LsbFirst) {
/* Lsb first */
GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
for (col = 0; col < width; col++) {
if (*src & mask) {
SET_PIXEL(col, row);
}
if (mask == 128U) {
src++;
mask = 1U;
}
else {
mask = mask << 1;
}
}
/* get ready for next row */
if (mask != 1)
src++;
}
else {
/* Msb first */
GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
for (col = 0; col < width; col++) {
if (*src & mask) {
SET_PIXEL(col, row);
}
if (mask == 1U) {
src++;
mask = 128U;
}
else {
mask = mask >> 1;
}
}
/* get ready for next row */
if (mask != 128)
src++;
}
} /* row */
unpack_bitmap(st, px, py, width, height, unpack, bitmap,
cache->buffer, BITMAP_CACHE_WIDTH);
return GL_TRUE; /* accumulated */
}
@@ -750,6 +684,7 @@ st_Bitmap(GLcontext *ctx, GLint x, GLint y, GLsizei width, GLsizei height,
assert(pt->target == PIPE_TEXTURE_2D);
draw_bitmap_quad(ctx, x, y, ctx->Current.RasterPos[2],
width, height, pt);
/* release/free the texture */
pipe_texture_reference(&pt, NULL);
}
}
@@ -768,6 +703,8 @@ void
st_init_bitmap(struct st_context *st)
{
struct pipe_sampler_state *sampler = &st->bitmap.sampler;
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
/* init sampler state once */
memset(sampler, 0, sizeof(*sampler));
@@ -784,7 +721,19 @@ st_init_bitmap(struct st_context *st)
st->bitmap.rasterizer.gl_rasterization_rules = 1;
st->bitmap.rasterizer.bypass_vs = 1;
init_bitmap_cache(st);
/* find a usable texture format */
if (screen->is_format_supported(screen, PIPE_FORMAT_I8_UNORM, PIPE_TEXTURE)) {
st->bitmap.tex_format = PIPE_FORMAT_I8_UNORM;
}
else {
/* XXX support more formats */
assert(0);
}
/* alloc bitmap cache object */
st->bitmap.cache = CALLOC_STRUCT(bitmap_cache);
reset_cache(st);
}
@@ -809,7 +758,7 @@ st_destroy_bitmap(struct st_context *st)
}
if (st->bitmap.vbuf) {
pipe->winsys->buffer_destroy(pipe->winsys, st->bitmap.vbuf);
pipe_buffer_destroy(pipe, st->bitmap.vbuf);
st->bitmap.vbuf = NULL;
}
src/mesa/state_tracker/st_cb_bufferobjects.c
+9 -13
View File
@@ -35,7 +35,6 @@
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_winsys.h"
#include "pipe/p_inlines.h"
@@ -79,7 +78,7 @@ st_bufferobj_free(GLcontext *ctx, struct gl_buffer_object *obj)
struct st_buffer_object *st_obj = st_buffer_object(obj);
if (st_obj->buffer)
pipe_buffer_reference(pipe->winsys, &st_obj->buffer, NULL);
pipe_reference_buffer(pipe, &st_obj->buffer, NULL);
free(st_obj);
}
@@ -106,10 +105,9 @@ st_bufferobj_subdata(GLcontext *ctx,
if (offset >= st_obj->size || size > (st_obj->size - offset))
return;
map = pipe->winsys->buffer_map(pipe->winsys, st_obj->buffer,
PIPE_BUFFER_USAGE_CPU_WRITE);
map = pipe_buffer_map(pipe, st_obj->buffer, PIPE_BUFFER_USAGE_CPU_WRITE);
memcpy(map + offset, data, size);
pipe->winsys->buffer_unmap(pipe->winsys, st_obj->buffer);
pipe_buffer_unmap(pipe, st_obj->buffer);
}
@@ -130,10 +128,9 @@ st_bufferobj_get_subdata(GLcontext *ctx,
if (offset >= st_obj->size || size > (st_obj->size - offset))
return;
map = pipe->winsys->buffer_map(pipe->winsys, st_obj->buffer,
PIPE_BUFFER_USAGE_CPU_READ);
map = pipe_buffer_map(pipe, st_obj->buffer, PIPE_BUFFER_USAGE_CPU_READ);
memcpy(data, map + offset, size);
pipe->winsys->buffer_unmap(pipe->winsys, st_obj->buffer);
pipe_buffer_unmap(pipe, st_obj->buffer);
}
@@ -174,10 +171,9 @@ st_bufferobj_data(GLcontext *ctx,
buffer_usage = 0;
}
pipe_buffer_reference( pipe->winsys, &st_obj->buffer, NULL );
pipe_reference_buffer( pipe, &st_obj->buffer, NULL );
st_obj->buffer = pipe->winsys->buffer_create( pipe->winsys, 32, buffer_usage,
size );
st_obj->buffer = pipe_buffer_create( pipe, 32, buffer_usage, size );
st_obj->size = size;
@@ -211,7 +207,7 @@ st_bufferobj_map(GLcontext *ctx, GLenum target, GLenum access,
break;
}
obj->Pointer = pipe->winsys->buffer_map(pipe->winsys, st_obj->buffer, flags);
obj->Pointer = pipe_buffer_map(pipe, st_obj->buffer, flags);
return obj->Pointer;
}
@@ -225,7 +221,7 @@ st_bufferobj_unmap(GLcontext *ctx, GLenum target, struct gl_buffer_object *obj)
struct pipe_context *pipe = st_context(ctx)->pipe;
struct st_buffer_object *st_obj = st_buffer_object(obj);
pipe->winsys->buffer_unmap(pipe->winsys, st_obj->buffer);
pipe_buffer_unmap(pipe, st_obj->buffer);
obj->Pointer = NULL;
return GL_TRUE;
}
src/mesa/state_tracker/st_cb_clear.c
+7 -9
View File
@@ -34,8 +34,8 @@
#include "main/glheader.h"
#include "main/macros.h"
#include "shader/prog_instruction.h"
#include "st_atom.h"
#include "st_context.h"
#include "st_atom.h"
#include "st_cb_accum.h"
#include "st_cb_clear.h"
#include "st_cb_fbo.h"
@@ -45,9 +45,9 @@
#include "st_mesa_to_tgsi.h"
#include "pipe/p_context.h"
#include "pipe/p_inlines.h"
#include "pipe/p_state.h"
#include "pipe/p_defines.h"
#include "pipe/p_winsys.h"
#include "util/u_pack_color.h"
#include "util/u_simple_shaders.h"
#include "util/u_draw_quad.h"
@@ -106,7 +106,7 @@ st_destroy_clear(struct st_context *st)
st->clear.vs = NULL;
}
if (st->clear.vbuf) {
pipe->winsys->buffer_destroy(pipe->winsys, st->clear.vbuf);
pipe_buffer_destroy(pipe, st->clear.vbuf);
st->clear.vbuf = NULL;
}
}
@@ -142,9 +142,8 @@ draw_quad(GLcontext *ctx,
void *buf;
if (!st->clear.vbuf) {
st->clear.vbuf = pipe->winsys->buffer_create(pipe->winsys, 32,
PIPE_BUFFER_USAGE_VERTEX,
sizeof(st->clear.vertices));
st->clear.vbuf = pipe_buffer_create(pipe, 32, PIPE_BUFFER_USAGE_VERTEX,
sizeof(st->clear.vertices));
}
/* positions */
@@ -171,10 +170,9 @@ draw_quad(GLcontext *ctx,
}
/* put vertex data into vbuf */
buf = pipe->winsys->buffer_map(pipe->winsys, st->clear.vbuf,
PIPE_BUFFER_USAGE_CPU_WRITE);
buf = pipe_buffer_map(pipe, st->clear.vbuf, PIPE_BUFFER_USAGE_CPU_WRITE);
memcpy(buf, st->clear.vertices, sizeof(st->clear.vertices));
pipe->winsys->buffer_unmap(pipe->winsys, st->clear.vbuf);
pipe_buffer_unmap(pipe, st->clear.vbuf);
/* draw */
util_draw_vertex_buffer(pipe, st->clear.vbuf,
src/mesa/state_tracker/st_cb_drawpixels.c
+5 -8
View File
@@ -55,7 +55,6 @@
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "pipe/p_winsys.h"
#include "util/p_tile.h"
#include "util/u_draw_quad.h"
#include "shader/prog_instruction.h"
@@ -483,20 +482,18 @@ draw_quad(GLcontext *ctx, GLfloat x0, GLfloat y0, GLfloat z,
ubyte *map;
/* allocate/load buffer object with vertex data */
buf = pipe->winsys->buffer_create(pipe->winsys, 32,
PIPE_BUFFER_USAGE_VERTEX,
sizeof(verts));
map = pipe->winsys->buffer_map(pipe->winsys, buf,
PIPE_BUFFER_USAGE_CPU_WRITE);
buf = pipe_buffer_create(pipe,32, PIPE_BUFFER_USAGE_VERTEX,
sizeof(verts));
map = pipe_buffer_map(pipe, buf, PIPE_BUFFER_USAGE_CPU_WRITE);
memcpy(map, verts, sizeof(verts));
pipe->winsys->buffer_unmap(pipe->winsys, buf);
pipe_buffer_unmap(pipe, buf);
util_draw_vertex_buffer(pipe, buf,
PIPE_PRIM_QUADS,
4, /* verts */
3); /* attribs/vert */
pipe->winsys->buffer_destroy(pipe->winsys, buf);
pipe_buffer_destroy(pipe, buf);
}
}
src/mesa/state_tracker/st_cb_fbo.c
+1 -1
View File
@@ -105,7 +105,7 @@ st_renderbuffer_alloc_storage(GLcontext * ctx, struct gl_renderbuffer *rb,
}
else if (strb->surface->buffer) {
/* release/discard the old surface buffer */
pipe_buffer_reference(pipe->winsys, &strb->surface->buffer, NULL);
pipe_reference_buffer(pipe, &strb->surface->buffer, NULL);
}
/* Determine surface format here */
src/mesa/state_tracker/st_cb_strings.c
+6 -6
View File
@@ -53,21 +53,21 @@ st_get_string(GLcontext * ctx, GLenum name)
const char *vendor = screen->get_vendor( screen );
const char *tungsten = "Tungsten Graphics, Inc.";
/* Tungsten developed the state_tracker module (and much of
* Mesa), but the driver itself may come from elsewhere. The
* additional string allows "and XyzCorp" to reflect this.
/* Tungsten Graphics, Inc. developed the state_tracker module
* (and much of Mesa), but the driver itself may come from elsewhere.
* The additional string allows "and XyzCorp" to reflect this.
*/
if (vendor && strcmp(vendor, tungsten) != 0)
snprintf(st->vendor, sizeof(st->vendor),
util_snprintf(st->vendor, sizeof(st->vendor),
"%s and %s", tungsten, vendor);
else
snprintf(st->vendor, sizeof(st->vendor), "%s", tungsten);
util_snprintf(st->vendor, sizeof(st->vendor), "%s", tungsten);
return (GLubyte *) st->vendor;
}
case GL_RENDERER:
snprintf(st->renderer, sizeof(st->renderer), "Gallium %s, %s on %s",
util_snprintf(st->renderer, sizeof(st->renderer), "Gallium %s, %s on %s",
ST_VERSION_STRING,
screen->get_name( screen ),
screen->winsys->get_name( screen->winsys ));
src/mesa/state_tracker/st_cb_texture.c
+28 -34
View File
@@ -494,6 +494,10 @@ st_TexImage(GLcontext * ctx,
strip_texture_border(border, &width, &height, &depth,
unpack, &unpackNB);
unpack = &unpackNB;
texImage->Width = width;
texImage->Height = height;
texImage->Depth = depth;
texImage->Border = 0;
border = 0;
}
@@ -552,15 +556,17 @@ st_TexImage(GLcontext * ctx,
* waiting on any outstanding fences.
*/
if (stObj->pt &&
/*stObj->pt->first_level == level &&*/
stObj->pt->last_level == level &&
stObj->pt->target != PIPE_TEXTURE_CUBE &&
!st_texture_match_image(stObj->pt, &stImage->base,
stImage->face, stImage->level)) {
(stObj->teximage_realloc ||
(/*stObj->pt->first_level == level &&*/
stObj->pt->last_level == level &&
stObj->pt->target != PIPE_TEXTURE_CUBE &&
!st_texture_match_image(stObj->pt, &stImage->base,
stImage->face, stImage->level)))) {
DBG("release it\n");
pipe_texture_release(&stObj->pt);
assert(!stObj->pt);
stObj->teximage_realloc = FALSE;
}
if (!stObj->pt) {
@@ -1338,8 +1344,6 @@ static void
calculate_first_last_level(struct st_texture_object *stObj)
{
struct gl_texture_object *tObj = &stObj->base;
const struct gl_texture_image *const baseImage =
tObj->Image[0][tObj->BaseLevel];
/* These must be signed values. MinLod and MaxLod can be negative numbers,
* and having firstLevel and lastLevel as signed prevents the need for
@@ -1362,7 +1366,7 @@ calculate_first_last_level(struct st_texture_object *stObj)
}
else {
firstLevel = 0;
lastLevel = MIN2(tObj->MaxLevel - tObj->BaseLevel, baseImage->MaxLog2);
lastLevel = MIN2(tObj->MaxLevel, tObj->Image[0][0]->WidthLog2);
}
break;
case GL_TEXTURE_RECTANGLE_NV:
@@ -1444,17 +1448,6 @@ st_finalize_texture(GLcontext *ctx,
calculate_first_last_level(stObj);
firstImage = st_texture_image(stObj->base.Image[0][stObj->base.BaseLevel]);
#if 0
/* Fallback case:
*/
if (firstImage->base.Border) {
if (stObj->pt) {
pipe_texture_release(&stObj->pt);
}
return GL_FALSE;
}
#endif
/* If both firstImage and stObj point to a texture which can contain
* all active images, favour firstImage. Note that because of the
* completeness requirement, we know that the image dimensions
@@ -1478,24 +1471,25 @@ st_finalize_texture(GLcontext *ctx,
cpp = firstImage->base.TexFormat->TexelBytes;
}
/* Check texture can hold all active levels. Check texture matches
* target, imageFormat, etc.
/* If we already have a gallium texture, check that it matches the texture
* object's format, target, size, num_levels, etc.
*/
if (stObj->pt &&
(stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
stObj->pt->format !=
st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat) ||
stObj->pt->last_level != stObj->lastLevel ||
stObj->pt->width[0] != firstImage->base.Width2 ||
stObj->pt->height[0] != firstImage->base.Height2 ||
stObj->pt->depth[0] != firstImage->base.Depth2 ||
stObj->pt->cpp != cpp ||
stObj->pt->compressed != firstImage->base.IsCompressed)) {
pipe_texture_release(&stObj->pt);
if (stObj->pt) {
const enum pipe_format fmt =
st_mesa_format_to_pipe_format(firstImage->base.TexFormat->MesaFormat);
if (stObj->pt->target != gl_target_to_pipe(stObj->base.Target) ||
stObj->pt->format != fmt ||
stObj->pt->last_level < stObj->lastLevel ||
stObj->pt->width[0] != firstImage->base.Width2 ||
stObj->pt->height[0] != firstImage->base.Height2 ||
stObj->pt->depth[0] != firstImage->base.Depth2 ||
stObj->pt->cpp != cpp ||
stObj->pt->compressed != firstImage->base.IsCompressed) {
pipe_texture_release(&stObj->pt);
}
}
/* May need to create a new texture:
/* May need to create a new gallium texture:
*/
if (!stObj->pt) {
stObj->pt = st_texture_create(ctx->st,
src/mesa/state_tracker/st_context.c
+1 -3
View File
@@ -55,7 +55,6 @@
#include "st_gen_mipmap.h"
#include "st_program.h"
#include "pipe/p_context.h"
#include "pipe/p_winsys.h"
#include "pipe/p_inlines.h"
#include "draw/draw_context.h"
#include "cso_cache/cso_cache.h"
@@ -157,7 +156,6 @@ struct st_context *st_create_context(struct pipe_context *pipe,
static void st_destroy_context_priv( struct st_context *st )
{
struct pipe_winsys *ws = st->pipe->winsys;
uint i;
draw_destroy(st->draw);
@@ -172,7 +170,7 @@ static void st_destroy_context_priv( struct st_context *st )
for (i = 0; i < Elements(st->state.constants); i++) {
if (st->state.constants[i].buffer) {
pipe_buffer_reference(ws, &st->state.constants[i].buffer, NULL);
pipe_reference_buffer(st->pipe, &st->state.constants[i].buffer, NULL);
}
}
src/mesa/state_tracker/st_context.h
+1
View File
@@ -145,6 +145,7 @@ struct st_context
struct pipe_rasterizer_state rasterizer;
struct pipe_sampler_state sampler;
struct pipe_shader_state vert_shader;
enum pipe_format tex_format;
void *vs;
float vertices[4][3][4]; /**< vertex pos + color + texcoord */
struct pipe_buffer *vbuf;
src/mesa/state_tracker/st_draw.c
+25 -34
View File
@@ -35,15 +35,14 @@
#include "vbo/vbo.h"
#include "st_atom.h"
#include "st_context.h"
#include "st_atom.h"
#include "st_cb_bufferobjects.h"
#include "st_draw.h"
#include "st_program.h"
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_winsys.h"
#include "pipe/p_inlines.h"
#include "draw/draw_private.h"
@@ -219,8 +218,7 @@ setup_edgeflags(GLcontext *ctx, GLenum primMode, GLint start, GLint count,
if (!vec)
return NULL;
map = pipe->winsys->buffer_map(pipe->winsys, stobj->buffer,
PIPE_BUFFER_USAGE_CPU_READ);
map = pipe_buffer_map(pipe, stobj->buffer, PIPE_BUFFER_USAGE_CPU_READ);
map = ADD_POINTERS(map, array->Ptr);
for (i = 0; i < count; i++) {
@@ -230,7 +228,7 @@ setup_edgeflags(GLcontext *ctx, GLenum primMode, GLint start, GLint count,
map += array->StrideB;
}
pipe->winsys->buffer_unmap(pipe->winsys, stobj->buffer);
pipe_buffer_unmap(pipe, stobj->buffer);
pipe->set_edgeflags(pipe, vec);
@@ -260,7 +258,6 @@ st_draw_vbo(GLcontext *ctx,
GLuint max_index)
{
struct pipe_context *pipe = ctx->st->pipe;
struct pipe_winsys *winsys = pipe->winsys;
const struct st_vertex_program *vp;
const struct pipe_shader_state *vs;
struct pipe_vertex_buffer vbuffer[PIPE_MAX_SHADER_INPUTS];
@@ -292,7 +289,7 @@ st_draw_vbo(GLcontext *ctx,
assert(stobj->buffer);
vbuffer[attr].buffer = NULL;
pipe_buffer_reference(winsys, &vbuffer[attr].buffer, stobj->buffer);
pipe_reference_buffer(pipe, &vbuffer[attr].buffer, stobj->buffer);
vbuffer[attr].buffer_offset = (unsigned) arrays[0]->Ptr;/* in bytes */
velements[attr].src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
assert(velements[attr].src_offset <= 2048); /* 11-bit field */
@@ -310,9 +307,8 @@ st_draw_vbo(GLcontext *ctx,
/* wrap user data */
vbuffer[attr].buffer
= winsys->user_buffer_create(winsys,
(void *) arrays[mesaAttr]->Ptr,
bytes);
= pipe_user_buffer_create(pipe, (void *) arrays[mesaAttr]->Ptr,
bytes);
vbuffer[attr].buffer_offset = 0;
velements[attr].src_offset = 0;
}
@@ -358,14 +354,13 @@ st_draw_vbo(GLcontext *ctx,
if (bufobj && bufobj->Name) {
/* elements/indexes are in a real VBO */
struct st_buffer_object *stobj = st_buffer_object(bufobj);
pipe_buffer_reference(winsys, &indexBuf, stobj->buffer);
pipe_reference_buffer(pipe, &indexBuf, stobj->buffer);
indexOffset = (unsigned) ib->ptr / indexSize;
}
else {
/* element/indicies are in user space memory */
indexBuf = winsys->user_buffer_create(winsys,
(void *) ib->ptr,
ib->count * indexSize);
indexBuf = pipe_user_buffer_create(pipe, (void *) ib->ptr,
ib->count * indexSize);
indexOffset = 0;
}
@@ -380,7 +375,7 @@ st_draw_vbo(GLcontext *ctx,
prims[i].start + indexOffset, prims[i].count);
}
pipe_buffer_reference(winsys, &indexBuf, NULL);
pipe_reference_buffer(pipe, &indexBuf, NULL);
}
else {
/* non-indexed */
@@ -396,7 +391,7 @@ st_draw_vbo(GLcontext *ctx,
/* unreference buffers (frees wrapped user-space buffer objects) */
for (attr = 0; attr < vp->num_inputs; attr++) {
pipe_buffer_reference(winsys, &vbuffer[attr].buffer, NULL);
pipe_reference_buffer(pipe, &vbuffer[attr].buffer, NULL);
assert(!vbuffer[attr].buffer);
}
pipe->set_vertex_buffers(pipe, vp->num_inputs, vbuffer);
@@ -458,7 +453,6 @@ st_feedback_draw_vbo(GLcontext *ctx,
struct st_context *st = ctx->st;
struct pipe_context *pipe = st->pipe;
struct draw_context *draw = st->draw;
struct pipe_winsys *winsys = pipe->winsys;
const struct st_vertex_program *vp;
const struct pipe_shader_state *vs;
struct pipe_buffer *index_buffer_handle = 0;
@@ -509,7 +503,7 @@ st_feedback_draw_vbo(GLcontext *ctx,
assert(stobj->buffer);
vbuffers[attr].buffer = NULL;
pipe_buffer_reference(winsys, &vbuffers[attr].buffer, stobj->buffer);
pipe_reference_buffer(pipe, &vbuffers[attr].buffer, stobj->buffer);
vbuffers[attr].buffer_offset = (unsigned) arrays[0]->Ptr;/* in bytes */
velements[attr].src_offset = arrays[mesaAttr]->Ptr - arrays[0]->Ptr;
}
@@ -521,9 +515,8 @@ st_feedback_draw_vbo(GLcontext *ctx,
/* wrap user data */
vbuffers[attr].buffer
= winsys->user_buffer_create(winsys,
(void *) arrays[mesaAttr]->Ptr,
bytes);
= pipe_user_buffer_create(pipe, (void *) arrays[mesaAttr]->Ptr,
bytes);
vbuffers[attr].buffer_offset = 0;
velements[attr].src_offset = 0;
}
@@ -544,9 +537,8 @@ st_feedback_draw_vbo(GLcontext *ctx,
#endif
/* map the attrib buffer */
map = pipe->winsys->buffer_map(pipe->winsys,
vbuffers[attr].buffer,
PIPE_BUFFER_USAGE_CPU_READ);
map = pipe_buffer_map(pipe, vbuffers[attr].buffer,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_vertex_buffer(draw, attr, map);
}
@@ -557,9 +549,10 @@ st_feedback_draw_vbo(GLcontext *ctx,
unsigned indexSize;
struct gl_buffer_object *bufobj = ib->obj;
struct st_buffer_object *stobj = st_buffer_object(bufobj);
index_buffer_handle = stobj->buffer;
void *map;
index_buffer_handle = stobj->buffer;
switch (ib->type) {
case GL_UNSIGNED_INT:
indexSize = 4;
@@ -572,9 +565,8 @@ st_feedback_draw_vbo(GLcontext *ctx,
return;
}
map = pipe->winsys->buffer_map(pipe->winsys,
index_buffer_handle,
PIPE_BUFFER_USAGE_CPU_READ);
map = pipe_buffer_map(pipe, index_buffer_handle,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_element_buffer(draw, indexSize, map);
}
else {
@@ -584,7 +576,7 @@ st_feedback_draw_vbo(GLcontext *ctx,
/* map constant buffers */
mapped_constants = winsys->buffer_map(winsys,
mapped_constants = pipe_buffer_map(pipe,
st->state.constants[PIPE_SHADER_VERTEX].buffer,
PIPE_BUFFER_USAGE_CPU_READ);
draw_set_mapped_constant_buffer(st->draw, mapped_constants);
@@ -597,21 +589,20 @@ st_feedback_draw_vbo(GLcontext *ctx,
/* unmap constant buffers */
winsys->buffer_unmap(winsys, st->state.constants[PIPE_SHADER_VERTEX].buffer);
pipe_buffer_unmap(pipe, st->state.constants[PIPE_SHADER_VERTEX].buffer);
/*
* unmap vertex/index buffers
*/
for (i = 0; i < PIPE_MAX_ATTRIBS; i++) {
if (draw->pt.vertex_buffer[i].buffer) {
pipe->winsys->buffer_unmap(pipe->winsys,
draw->pt.vertex_buffer[i].buffer);
pipe_buffer_reference(winsys, &draw->pt.vertex_buffer[i].buffer, NULL);
pipe_buffer_unmap(pipe, draw->pt.vertex_buffer[i].buffer);
pipe_reference_buffer(pipe, &draw->pt.vertex_buffer[i].buffer, NULL);
draw_set_mapped_vertex_buffer(draw, i, NULL);
}
}
if (ib) {
pipe->winsys->buffer_unmap(pipe->winsys, index_buffer_handle);
pipe_buffer_unmap(pipe, index_buffer_handle);
draw_set_mapped_element_buffer(draw, 0, NULL);
}
}
src/mesa/state_tracker/st_extensions.c
+14 -14
View File
@@ -38,17 +38,17 @@
#include "st_extensions.h"
static int min(int a, int b)
static int _min(int a, int b)
{
return (a < b) ? a : b;
}
static int max(int a, int b)
static int _max(int a, int b)
{
return (a > b) ? a : b;
}
static int clamp(int a, int min, int max)
static int _clamp(int a, int min, int max)
{
if (a < min)
return min;
@@ -69,42 +69,42 @@ void st_init_limits(struct st_context *st)
struct gl_constants *c = &st->ctx->Const;
c->MaxTextureLevels
= min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS),
MAX_TEXTURE_LEVELS);
c->Max3DTextureLevels
= min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS),
MAX_3D_TEXTURE_LEVELS);
c->MaxCubeTextureLevels
= min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS),
MAX_CUBE_TEXTURE_LEVELS);
c->MaxTextureRectSize
= min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);
= _min(1 << (c->MaxTextureLevels - 1), MAX_TEXTURE_RECT_SIZE);
c->MaxTextureUnits
= c->MaxTextureImageUnits
= c->MaxTextureCoordUnits
= min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS),
= _min(screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS),
MAX_TEXTURE_IMAGE_UNITS);
c->MaxDrawBuffers
= clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
= _clamp(screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS),
1, MAX_DRAW_BUFFERS);
c->MaxLineWidth
= max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH));
= _max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH));
c->MaxLineWidthAA
= max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH_AA));
= _max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_LINE_WIDTH_AA));
c->MaxPointSize
= max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH));
= _max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH));
c->MaxPointSizeAA
= max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA));
= _max(1.0, screen->get_paramf(screen, PIPE_CAP_MAX_POINT_WIDTH_AA));
c->MaxTextureMaxAnisotropy
= max(2.0, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY));
= _max(2.0, screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_ANISOTROPY));
c->MaxTextureLodBias
= screen->get_paramf(screen, PIPE_CAP_MAX_TEXTURE_LOD_BIAS);
src/mesa/state_tracker/st_format.c
+16 -16
View File
@@ -261,13 +261,13 @@ st_mesa_format_to_pipe_format(GLuint mesaFormat)
case MESA_FORMAT_RGB565:
return PIPE_FORMAT_R5G6B5_UNORM;
case MESA_FORMAT_AL88:
return PIPE_FORMAT_U_A8_L8;
return PIPE_FORMAT_A8L8_UNORM;
case MESA_FORMAT_A8:
return PIPE_FORMAT_U_A8;
return PIPE_FORMAT_A8_UNORM;
case MESA_FORMAT_L8:
return PIPE_FORMAT_U_L8;
return PIPE_FORMAT_L8_UNORM;
case MESA_FORMAT_I8:
return PIPE_FORMAT_U_I8;
return PIPE_FORMAT_I8_UNORM;
case MESA_FORMAT_Z16:
return PIPE_FORMAT_Z16_UNORM;
case MESA_FORMAT_Z32:
@@ -409,8 +409,8 @@ st_choose_format(struct pipe_context *pipe, GLint internalFormat,
case GL_ALPHA12:
case GL_ALPHA16:
case GL_COMPRESSED_ALPHA:
if (screen->is_format_supported( screen, PIPE_FORMAT_U_A8, surfType ))
return PIPE_FORMAT_U_A8;
if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, surfType ))
return PIPE_FORMAT_A8_UNORM;
return default_rgba_format( screen, surfType );
case 1:
@@ -420,8 +420,8 @@ st_choose_format(struct pipe_context *pipe, GLint internalFormat,
case GL_LUMINANCE12:
case GL_LUMINANCE16:
case GL_COMPRESSED_LUMINANCE:
if (screen->is_format_supported( screen, PIPE_FORMAT_U_L8, surfType ))
return PIPE_FORMAT_U_L8;
if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, surfType ))
return PIPE_FORMAT_L8_UNORM;
return default_rgba_format( screen, surfType );
case 2:
@@ -433,8 +433,8 @@ st_choose_format(struct pipe_context *pipe, GLint internalFormat,
case GL_LUMINANCE12_ALPHA12:
case GL_LUMINANCE16_ALPHA16:
case GL_COMPRESSED_LUMINANCE_ALPHA:
if (screen->is_format_supported( screen, PIPE_FORMAT_U_A8_L8, surfType ))
return PIPE_FORMAT_U_A8_L8;
if (screen->is_format_supported( screen, PIPE_FORMAT_A8L8_UNORM, surfType ))
return PIPE_FORMAT_A8L8_UNORM;
return default_rgba_format( screen, surfType );
case GL_INTENSITY:
@@ -443,8 +443,8 @@ st_choose_format(struct pipe_context *pipe, GLint internalFormat,
case GL_INTENSITY12:
case GL_INTENSITY16:
case GL_COMPRESSED_INTENSITY:
if (screen->is_format_supported( screen, PIPE_FORMAT_U_I8, surfType ))
return PIPE_FORMAT_U_I8;
if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, surfType ))
return PIPE_FORMAT_I8_UNORM;
return default_rgba_format( screen, surfType );
case GL_YCBCR_MESA:
@@ -547,13 +547,13 @@ translate_gallium_format_to_mesa_format(enum pipe_format format)
return &_mesa_texformat_argb4444;
case PIPE_FORMAT_R5G6B5_UNORM:
return &_mesa_texformat_rgb565;
case PIPE_FORMAT_U_A8_L8:
case PIPE_FORMAT_A8L8_UNORM:
return &_mesa_texformat_al88;
case PIPE_FORMAT_U_A8:
case PIPE_FORMAT_A8_UNORM:
return &_mesa_texformat_a8;
case PIPE_FORMAT_U_L8:
case PIPE_FORMAT_L8_UNORM:
return &_mesa_texformat_l8;
case PIPE_FORMAT_U_I8:
case PIPE_FORMAT_I8_UNORM:
return &_mesa_texformat_i8;
case PIPE_FORMAT_Z16_UNORM:
return &_mesa_texformat_z16;
src/mesa/state_tracker/st_gen_mipmap.c
+6 -8
View File
@@ -36,7 +36,6 @@
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_inlines.h"
#include "pipe/p_winsys.h"
#include "util/u_gen_mipmap.h"
#include "cso_cache/cso_cache.h"
@@ -105,7 +104,6 @@ fallback_generate_mipmap(GLcontext *ctx, GLenum target,
{
struct pipe_context *pipe = ctx->st->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_winsys *ws = pipe->winsys;
struct pipe_texture *pt = st_get_texobj_texture(texObj);
const uint baseLevel = texObj->BaseLevel;
const uint lastLevel = pt->last_level;
@@ -128,11 +126,11 @@ fallback_generate_mipmap(GLcontext *ctx, GLenum target,
srcSurf = screen->get_tex_surface(screen, pt, face, srcLevel, zslice);
dstSurf = screen->get_tex_surface(screen, pt, face, dstLevel, zslice);
srcData = (ubyte *) ws->buffer_map(ws, srcSurf->buffer,
PIPE_BUFFER_USAGE_CPU_READ)
srcData = (ubyte *) pipe_buffer_map(pipe, srcSurf->buffer,
PIPE_BUFFER_USAGE_CPU_READ)
+ srcSurf->offset;
dstData = (ubyte *) ws->buffer_map(ws, dstSurf->buffer,
PIPE_BUFFER_USAGE_CPU_WRITE)
dstData = (ubyte *) pipe_buffer_map(pipe, dstSurf->buffer,
PIPE_BUFFER_USAGE_CPU_WRITE)
+ dstSurf->offset;
_mesa_generate_mipmap_level(target, datatype, comps,
@@ -144,8 +142,8 @@ fallback_generate_mipmap(GLcontext *ctx, GLenum target,
dstSurf->pitch * dstSurf->cpp, /* stride in bytes */
dstData);
ws->buffer_unmap(ws, srcSurf->buffer);
ws->buffer_unmap(ws, dstSurf->buffer);
pipe_buffer_unmap(pipe, srcSurf->buffer);
pipe_buffer_unmap(pipe, dstSurf->buffer);
pipe_surface_reference(&srcSurf, NULL);
pipe_surface_reference(&dstSurf, NULL);
src/mesa/state_tracker/st_mesa_to_tgsi.c
+1 -1
View File
@@ -805,7 +805,7 @@ tgsi_translate_mesa_program(
{
GLboolean tempsUsed[MAX_PROGRAM_TEMPS + 1];
GLboolean inside_range = GL_FALSE;
GLuint start_range;
GLuint start_range = 0;
find_temporaries(program, tempsUsed);
tempsUsed[MAX_PROGRAM_TEMPS] = GL_FALSE;
src/mesa/state_tracker/st_program.h
+2 -2
View File
@@ -101,14 +101,14 @@ struct st_vertex_program
};
static inline struct st_fragment_program *
static INLINE struct st_fragment_program *
st_fragment_program( struct gl_fragment_program *fp )
{
return (struct st_fragment_program *)fp;
}
static inline struct st_vertex_program *
static INLINE struct st_vertex_program *
st_vertex_program( struct gl_vertex_program *vp )
{
return (struct st_vertex_program *)vp;
src/mesa/state_tracker/st_texobj.c
-102
View File
@@ -1,102 +0,0 @@
/**************************************************************************
*
* 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 "imports.h"
#include "texformat.h"
#include "st_context.h"
#include "st_texobj.h"
#include "pipe/p_defines.h"
/**
* Create a pipe_texture_object from a Mesa texture object.
* Eventually, gl_texture_object may be derived from this...
*/
struct pipe_texture_object *
create_texture_object(struct gl_texture_object *texObj)
{
struct pipe_texture_object *pto;
const struct gl_texture_image *texImage;
pto = calloc(1, sizeof(*pto));
if (!pto)
return NULL;
/* XXX: Member not defined. Comment-out to get it compile. */
/*assert(texObj->Complete);*/
switch (texObj->Target) {
case GL_TEXTURE_1D:
pto->type = PIPE_TEXTURE_1D;
break;
case GL_TEXTURE_2D:
pto->type = PIPE_TEXTURE_2D;
break;
case GL_TEXTURE_3D:
pto->type = PIPE_TEXTURE_3D;
break;
case GL_TEXTURE_CUBE_MAP:
pto->type = PIPE_TEXTURE_CUBE;
break;
default:
assert(0);
return NULL;
}
texImage = texObj->Image[0][texObj->BaseLevel];
assert(texImage);
switch (texImage->TexFormat->MesaFormat) {
case MESA_FORMAT_RGBA8888:
pto->format = PIPE_FORMAT_U_R8_G8_B8_A8;
break;
case MESA_FORMAT_RGB565:
pto->format = PIPE_FORMAT_U_R5_G6_B5;
break;
/* XXX fill in more formats */
default:
assert(0);
return NULL;
}
pto->width = texImage->Width;
pto->height = texImage->Height;
pto->depth = texImage->Depth;
/* XXX verify this */
pto->mipmapped = texObj->Image[0][texObj->BaseLevel + 1] != NULL;
return pto;
}
src/mesa/state_tracker/st_texobj.h
-41
View File
@@ -1,41 +0,0 @@
/**************************************************************************
*
* 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
*/
#ifndef ST_TEXOBJ_H
#define ST_TEXOBJ_H 1
extern struct pipe_texture_object *
create_texture_object(struct gl_texture_object *texObj);
#endif /* ST_TEXOBJ_H */
src/mesa/state_tracker/st_texture.c
-1
View File
@@ -38,7 +38,6 @@
#include "pipe/p_inlines.h"
#include "pipe/p_util.h"
#include "pipe/p_inlines.h"
#include "pipe/p_winsys.h"
#define DBG if(0) printf
src/mesa/state_tracker/st_texture.h
+1 -3
View File
@@ -68,9 +68,7 @@ struct st_texture_object
*/
struct pipe_texture *pt;
GLboolean imageOverride;
GLint depthOverride;
GLuint pitchOverride;
GLboolean teximage_realloc;
};