#ifdef __CYGWIN__
#undef WIN32
#undef __WIN32__
#endif
#include "glxheader.h"
#include "GL/xmesa.h"
#include "xmesaP.h"
#include "context.h"
#include "extensions.h"
#include "glthread.h"
#include "imports.h"
#include "matrix.h"
#include "mmath.h"
#include "mtypes.h"
#include "macros.h"
#include "texformat.h"
#include "texstore.h"
#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "array_cache/acache.h"
#include "tnl/tnl.h"
#ifndef GLX_NONE_EXT
#define GLX_NONE_EXT 0x8000
#endif
_glthread_Mutex _xmesa_lock;
static short hpcr_rgbTbl[3][256] = {
{
16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31,
32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
},
{
16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31,
32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39,
32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239
},
{
32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 37, 38, 38, 39, 39,
40, 40, 41, 41, 42, 42, 43, 43, 44, 44, 45, 45, 46, 46, 47, 47,
48, 48, 49, 49, 50, 50, 51, 51, 52, 52, 53, 53, 54, 54, 55, 55,
56, 56, 57, 57, 58, 58, 59, 59, 60, 60, 61, 61, 62, 62, 63, 63,
64, 64, 65, 65, 66, 66, 67, 67, 68, 68, 69, 69, 70, 70, 71, 71,
72, 72, 73, 73, 74, 74, 75, 75, 76, 76, 77, 77, 78, 78, 79, 79,
80, 80, 81, 81, 82, 82, 83, 83, 84, 84, 85, 85, 86, 86, 87, 87,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95,
96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223
}
};
#ifndef XFree86Server
static int host_byte_order( void )
{
int i = 1;
char *cptr = (char *) &i;
return (*cptr==1) ? LSBFirst : MSBFirst;
}
#endif
#if !defined(XFree86Server) && defined(USE_XSHM)
static volatile int mesaXErrorFlag = 0;
static int mesaHandleXError( XMesaDisplay *dpy, XErrorEvent *event )
{
(void) dpy;
(void) event;
mesaXErrorFlag = 1;
return 0;
}
#endif
#ifndef XFree86Server
static int check_for_xshm( XMesaDisplay *display )
{
#ifdef USE_XSHM
int major, minor, ignore;
Bool pixmaps;
if (XQueryExtension( display, "MIT-SHM", &ignore, &ignore, &ignore )) {
if (XShmQueryVersion( display, &major, &minor, &pixmaps )==True) {
return (pixmaps==True) ? 2 : 1;
}
else {
return 0;
}
}
else {
return 0;
}
#else
return 0;
#endif
}
#endif
static void get_drawable_size( XMesaDisplay *dpy, XMesaDrawable d,
unsigned int *width, unsigned int *height)
{
#ifdef XFree86Server
(void) dpy;
*width = d->width;
*height = d->height;
#else
Window root;
int x, y;
unsigned int bw, depth;
_glthread_LOCK_MUTEX(_xmesa_lock);
XGetGeometry( dpy, d, &root, &x, &y, width, height, &bw, &depth );
_glthread_UNLOCK_MUTEX(_xmesa_lock);
#endif
}
static GLint gamma_adjust( GLfloat gamma, GLint value, GLint max )
{
if (gamma == 1.0) {
return value;
}
else {
double x = (double) value / (double) max;
return IROUND_POS((GLfloat) max * _mesa_pow(x, 1.0F/gamma));
}
}
#ifdef XFree86Server
static int bits_per_pixel( XMesaVisual xmv )
{
XMesaVisualInfo visinfo = xmv->visinfo;
const int depth = visinfo->nplanes;
int i;
for (i = 0; i < screenInfo.numPixmapFormats; i++) {
if (screenInfo.formats[i].depth == depth)
return screenInfo.formats[i].bitsPerPixel;
}
return depth;
}
#else
static int bits_per_pixel( XMesaVisual xmv )
{
XMesaDisplay *dpy = xmv->display;
XMesaVisualInfo visinfo = xmv->visinfo;
XMesaImage *img;
int bitsPerPixel;
img = XCreateImage( dpy, visinfo->visual, visinfo->depth,
ZPixmap, 0,
(char*) MALLOC(8),
1, 1,
32,
0
);
assert(img);
bitsPerPixel = img->bits_per_pixel;
FREE( img->data );
img->data = NULL;
XMesaDestroyImage( img );
return bitsPerPixel;
}
#endif
#ifndef XFree86Server
static GLboolean WindowExistsFlag;
static int window_exists_err_handler( XMesaDisplay* dpy, XErrorEvent* xerr )
{
(void) dpy;
if (xerr->error_code == BadWindow) {
WindowExistsFlag = GL_FALSE;
}
return 0;
}
static GLboolean window_exists( XMesaDisplay *dpy, Window win )
{
XWindowAttributes wa;
int (*old_handler)( XMesaDisplay*, XErrorEvent* );
WindowExistsFlag = GL_TRUE;
old_handler = XSetErrorHandler(window_exists_err_handler);
XGetWindowAttributes( dpy, win, &wa );
XSetErrorHandler(old_handler);
return WindowExistsFlag;
}
#endif
static XMesaBuffer XMesaBufferList = NULL;
static XMesaBuffer alloc_xmesa_buffer(void)
{
XMesaBuffer b = (XMesaBuffer) CALLOC_STRUCT(xmesa_buffer);
if (b) {
b->Next = XMesaBufferList;
XMesaBufferList = b;
}
return b;
}
static XMesaBuffer find_xmesa_buffer(XMesaDisplay *dpy,
XMesaColormap cmap,
XMesaBuffer notThis)
{
XMesaBuffer b;
for (b=XMesaBufferList; b; b=b->Next) {
if (b->display==dpy && b->cmap==cmap && b!=notThis) {
return b;
}
}
return NULL;
}
static void free_xmesa_buffer(int client, XMesaBuffer buffer)
{
XMesaBuffer prev = NULL, b;
(void) client;
for (b=XMesaBufferList; b; b=b->Next) {
if (b==buffer) {
if (prev)
prev->Next = buffer->Next;
else
XMesaBufferList = buffer->Next;
if (buffer->num_alloced>0) {
if (!find_xmesa_buffer(buffer->display, buffer->cmap, buffer)) {
#ifdef XFree86Server
(void)FreeColors(buffer->cmap, client,
buffer->num_alloced, buffer->alloced_colors,
0);
#else
XFreeColors(buffer->display, buffer->cmap,
buffer->alloced_colors, buffer->num_alloced, 0);
#endif
}
}
_mesa_free_framebuffer_data(&buffer->mesa_buffer);
FREE(buffer);
return;
}
prev = b;
}
_mesa_problem(NULL,"free_xmesa_buffer() - buffer not found\n");
}
static void copy_colortable_info(XMesaBuffer dst, const XMesaBuffer src)
{
MEMCPY(dst->color_table, src->color_table, sizeof(src->color_table));
MEMCPY(dst->pixel_to_r, src->pixel_to_r, sizeof(src->pixel_to_r));
MEMCPY(dst->pixel_to_g, src->pixel_to_g, sizeof(src->pixel_to_g));
MEMCPY(dst->pixel_to_b, src->pixel_to_b, sizeof(src->pixel_to_b));
dst->num_alloced = src->num_alloced;
MEMCPY(dst->alloced_colors, src->alloced_colors,
sizeof(src->alloced_colors));
}
static int bitcount( unsigned long n )
{
int bits;
for (bits=0; n>0; n=n>>1) {
if (n&1) {
bits++;
}
}
return bits;
}
#ifndef XFree86Server
static GLboolean alloc_shm_back_buffer( XMesaBuffer b )
{
#ifdef USE_XSHM
GC gc;
int (*old_handler)( XMesaDisplay *, XErrorEvent * );
b->backimage = XShmCreateImage( b->xm_visual->display,
b->xm_visual->visinfo->visual,
b->xm_visual->visinfo->depth,
ZPixmap, NULL, &b->shminfo,
b->width, b->height );
if (b->backimage == NULL) {
_mesa_warning(NULL, "alloc_back_buffer: Shared memory error (XShmCreateImage), disabling.");
b->shm = 0;
return GL_FALSE;
}
b->shminfo.shmid = shmget( IPC_PRIVATE, b->backimage->bytes_per_line
* b->backimage->height, IPC_CREAT|0777 );
if (b->shminfo.shmid < 0) {
_mesa_warning(NULL, "shmget failed while allocating back buffer");
XDestroyImage( b->backimage );
b->backimage = NULL;
_mesa_warning(NULL, "alloc_back_buffer: Shared memory error (shmget), disabling.");
b->shm = 0;
return GL_FALSE;
}
b->shminfo.shmaddr = b->backimage->data
= (char*)shmat( b->shminfo.shmid, 0, 0 );
if (b->shminfo.shmaddr == (char *) -1) {
_mesa_warning(NULL, "shmat() failed while allocating back buffer");
XDestroyImage( b->backimage );
shmctl( b->shminfo.shmid, IPC_RMID, 0 );
b->backimage = NULL;
_mesa_warning(NULL, "alloc_back_buffer: Shared memory error (shmat), disabling.");
b->shm = 0;
return GL_FALSE;
}
b->shminfo.readOnly = False;
mesaXErrorFlag = 0;
old_handler = XSetErrorHandler( mesaHandleXError );
XShmAttach( b->xm_visual->display, &b->shminfo );
XSync( b->xm_visual->display, False );
if (mesaXErrorFlag) {
XFlush( b->xm_visual->display );
mesaXErrorFlag = 0;
XDestroyImage( b->backimage );
shmdt( b->shminfo.shmaddr );
shmctl( b->shminfo.shmid, IPC_RMID, 0 );
b->backimage = NULL;
b->shm = 0;
(void) XSetErrorHandler( old_handler );
return GL_FALSE;
}
shmctl( b->shminfo.shmid, IPC_RMID, 0 );
gc = XCreateGC( b->xm_visual->display, b->frontbuffer, 0, NULL );
XShmPutImage( b->xm_visual->display, b->frontbuffer, gc,
b->backimage, 0, 0, 0, 0, 1, 1 , False );
XSync( b->xm_visual->display, False );
XFreeGC( b->xm_visual->display, gc );
(void) XSetErrorHandler( old_handler );
if (mesaXErrorFlag) {
XFlush( b->xm_visual->display );
mesaXErrorFlag = 0;
XDestroyImage( b->backimage );
shmdt( b->shminfo.shmaddr );
shmctl( b->shminfo.shmid, IPC_RMID, 0 );
b->backimage = NULL;
b->shm = 0;
return GL_FALSE;
}
if (b->backimage) {
int height = b->backimage->height;
b->ximage_width1 = b->backimage->bytes_per_line;
b->ximage_origin1 = (GLubyte *) b->backimage->data
+ b->ximage_width1 * (height-1);
b->ximage_width2 = b->backimage->bytes_per_line / 2;
b->ximage_origin2 = (GLushort *) b->backimage->data
+ b->ximage_width2 * (height-1);
b->ximage_width3 = b->backimage->bytes_per_line;
b->ximage_origin3 = (GLubyte *) b->backimage->data
+ b->ximage_width3 * (height-1);
b->ximage_width4 = b->backimage->width;
b->ximage_origin4 = (GLuint *) b->backimage->data
+ b->ximage_width4 * (height-1);
}
return GL_TRUE;
#else
return GL_FALSE;
#endif
}
#endif
void xmesa_alloc_back_buffer( XMesaBuffer b )
{
if (b->db_state==BACK_XIMAGE) {
if (b->backimage) {
#if defined(USE_XSHM) && !defined(XFree86Server)
if (b->shm) {
XShmDetach( b->xm_visual->display, &b->shminfo );
XDestroyImage( b->backimage );
shmdt( b->shminfo.shmaddr );
}
else
#endif
XMesaDestroyImage( b->backimage );
b->backimage = NULL;
}
#ifdef XFree86Server
{
b->backimage = XMesaCreateImage(b->xm_visual->BitsPerPixel,
b->width, b->height, NULL);
#else
if (b->shm==0 || alloc_shm_back_buffer(b)==GL_FALSE) {
b->backimage = XCreateImage( b->xm_visual->display,
b->xm_visual->visinfo->visual,
GET_VISUAL_DEPTH(b->xm_visual),
ZPixmap, 0,
NULL, b->width, b->height,
8, 0 );
#endif
if (!b->backimage) {
_mesa_warning(NULL, "alloc_back_buffer: XCreateImage failed.");
}
b->backimage->data = (char *) MALLOC( b->backimage->height
* b->backimage->bytes_per_line );
if (!b->backimage->data) {
_mesa_warning(NULL, "alloc_back_buffer: MALLOC failed.");
XMesaDestroyImage( b->backimage );
b->backimage = NULL;
}
}
b->backpixmap = None;
}
else if (b->db_state==BACK_PIXMAP) {
XMesaPixmap old_pixmap = b->backpixmap;
if (b->backpixmap) {
XMesaFreePixmap( b->xm_visual->display, b->backpixmap );
}
b->backpixmap = XMesaCreatePixmap( b->xm_visual->display, b->frontbuffer,
b->width, b->height,
GET_VISUAL_DEPTH(b->xm_visual) );
b->backimage = NULL;
if (b->buffer==(XMesaDrawable)old_pixmap) {
b->buffer = (XMesaDrawable)b->backpixmap;
}
}
}
static void
noFaultXAllocColor( int client,
XMesaDisplay *dpy,
XMesaColormap cmap,
int cmapSize,
XMesaColor *color,
int *exact, int *alloced )
{
#ifdef XFree86Server
Pixel *ppixIn;
xrgb *ctable;
#else
static Display *prevDisplay = NULL;
static XMesaColormap prevCmap = 0;
static int prevCmapSize = 0;
static XMesaColor *ctable = NULL;
#endif
XMesaColor subColor;
int i, bestmatch;
double mindist;
(void) client;
#ifdef XFree86Server
if (AllocColor(cmap,
&color->red, &color->green, &color->blue,
&color->pixel,
client) == Success) {
#else
if (XAllocColor(dpy, cmap, color)) {
#endif
*exact = 1;
*alloced = 1;
return;
}
#ifdef XFree86Server
ppixIn = (Pixel *) MALLOC(cmapSize * sizeof(Pixel));
ctable = (xrgb *) MALLOC(cmapSize * sizeof(xrgb));
for (i = 0; i < cmapSize; i++) {
ppixIn[i] = i;
}
QueryColors(cmap, cmapSize, ppixIn, ctable);
#else
if (prevDisplay != dpy || prevCmap != cmap
|| prevCmapSize != cmapSize || !ctable) {
if (ctable)
FREE(ctable);
ctable = (XMesaColor *) MALLOC(cmapSize * sizeof(XMesaColor));
assert(ctable);
for (i = 0; i < cmapSize; i++) {
ctable[i].pixel = i;
}
XQueryColors(dpy, cmap, ctable, cmapSize);
prevDisplay = dpy;
prevCmap = cmap;
prevCmapSize = cmapSize;
}
#endif
bestmatch = -1;
mindist = 0.0;
for (i = 0; i < cmapSize; i++) {
double dr = 0.30 * ((double) color->red - (double) ctable[i].red);
double dg = 0.59 * ((double) color->green - (double) ctable[i].green);
double db = 0.11 * ((double) color->blue - (double) ctable[i].blue);
double dist = dr * dr + dg * dg + db * db;
if (bestmatch < 0 || dist < mindist) {
bestmatch = i;
mindist = dist;
}
}
subColor.red = ctable[bestmatch].red;
subColor.green = ctable[bestmatch].green;
subColor.blue = ctable[bestmatch].blue;
#ifdef XFree86Server
if (AllocColor(cmap,
&subColor.red, &subColor.green, &subColor.blue,
&subColor.pixel,
client) == Success) {
#else
if (XAllocColor(dpy, cmap, &subColor)) {
#endif
*alloced = 1;
}
else {
subColor.pixel = (unsigned long) bestmatch;
subColor.red = ctable[bestmatch].red;
subColor.green = ctable[bestmatch].green;
subColor.blue = ctable[bestmatch].blue;
subColor.flags = DoRed | DoGreen | DoBlue;
*alloced = 0;
}
#ifdef XFree86Server
FREE(ppixIn);
FREE(ctable);
#else
#endif
*color = subColor;
*exact = 0;
}
static GLboolean setup_grayscale( int client, XMesaVisual v,
XMesaBuffer buffer, XMesaColormap cmap )
{
if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) {
return GL_FALSE;
}
if (buffer) {
XMesaBuffer prevBuffer;
if (!cmap) {
return GL_FALSE;
}
prevBuffer = find_xmesa_buffer(v->display, cmap, buffer);
if (prevBuffer &&
(buffer->xm_visual->mesa_visual.rgbMode ==
prevBuffer->xm_visual->mesa_visual.rgbMode)) {
copy_colortable_info(buffer, prevBuffer);
}
else {
int gray;
int colorsfailed = 0;
for (gray=0;gray<256;gray++) {
GLint r = gamma_adjust( v->RedGamma, gray, 255 );
GLint g = gamma_adjust( v->GreenGamma, gray, 255 );
GLint b = gamma_adjust( v->BlueGamma, gray, 255 );
int exact, alloced;
XMesaColor xcol;
xcol.red = (r << 8) | r;
xcol.green = (g << 8) | g;
xcol.blue = (b << 8) | b;
noFaultXAllocColor( client, v->display,
cmap, GET_COLORMAP_SIZE(v),
&xcol, &exact, &alloced );
if (!exact) {
colorsfailed++;
}
if (alloced) {
assert(buffer->num_alloced<256);
buffer->alloced_colors[buffer->num_alloced] = xcol.pixel;
buffer->num_alloced++;
}
buffer->color_table[gray] = xcol.pixel;
assert(xcol.pixel < 65536);
buffer->pixel_to_r[xcol.pixel] = gray;
buffer->pixel_to_g[xcol.pixel] = gray;
buffer->pixel_to_b[xcol.pixel] = gray;
}
if (colorsfailed && _mesa_getenv("MESA_DEBUG")) {
_mesa_warning(NULL,
"Note: %d out of 256 needed colors do not match exactly.\n",
colorsfailed );
}
}
}
v->dithered_pf = PF_GRAYSCALE;
v->undithered_pf = PF_GRAYSCALE;
return GL_TRUE;
}
static GLboolean setup_dithered_color( int client, XMesaVisual v,
XMesaBuffer buffer, XMesaColormap cmap )
{
(void) DitherValues;
if (GET_VISUAL_DEPTH(v)<4 || GET_VISUAL_DEPTH(v)>16) {
return GL_FALSE;
}
if (buffer) {
XMesaBuffer prevBuffer;
if (!cmap) {
return GL_FALSE;
}
prevBuffer = find_xmesa_buffer(v->display, cmap, buffer);
if (prevBuffer &&
(buffer->xm_visual->mesa_visual.rgbMode ==
prevBuffer->xm_visual->mesa_visual.rgbMode)) {
copy_colortable_info(buffer, prevBuffer);
}
else {
int r, g, b, i;
int colorsfailed = 0;
for (r = 0; r < DITH_R; r++) {
for (g = 0; g < DITH_G; g++) {
for (b = 0; b < DITH_B; b++) {
XMesaColor xcol;
int exact, alloced;
xcol.red =gamma_adjust(v->RedGamma, r*65535/(DITH_R-1),65535);
xcol.green=gamma_adjust(v->GreenGamma, g*65535/(DITH_G-1),65535);
xcol.blue =gamma_adjust(v->BlueGamma, b*65535/(DITH_B-1),65535);
noFaultXAllocColor( client, v->display,
cmap, GET_COLORMAP_SIZE(v),
&xcol, &exact, &alloced );
if (!exact) {
colorsfailed++;
}
if (alloced) {
assert(buffer->num_alloced<256);
buffer->alloced_colors[buffer->num_alloced] = xcol.pixel;
buffer->num_alloced++;
}
i = DITH_MIX( r, g, b );
assert(i < 576);
buffer->color_table[i] = xcol.pixel;
assert(xcol.pixel < 65536);
buffer->pixel_to_r[xcol.pixel] = r * 255 / (DITH_R-1);
buffer->pixel_to_g[xcol.pixel] = g * 255 / (DITH_G-1);
buffer->pixel_to_b[xcol.pixel] = b * 255 / (DITH_B-1);
}
}
}
if (colorsfailed && _mesa_getenv("MESA_DEBUG")) {
_mesa_warning(NULL,
"Note: %d out of %d needed colors do not match exactly.\n",
colorsfailed, DITH_R * DITH_G * DITH_B );
}
}
}
v->dithered_pf = PF_DITHER;
v->undithered_pf = PF_LOOKUP;
return GL_TRUE;
}
static void setup_8bit_hpcr( XMesaVisual v )
{
int i;
double g;
g = 1.0 / v->RedGamma;
for (i=0; i<256; i++) {
GLint red = IROUND_POS(255.0 * _mesa_pow( hpcr_rgbTbl[0][i]/255.0, g ));
v->hpcr_rgbTbl[0][i] = CLAMP( red, 16, 239 );
}
g = 1.0 / v->GreenGamma;
for (i=0; i<256; i++) {
GLint green = IROUND_POS(255.0 * _mesa_pow( hpcr_rgbTbl[1][i]/255.0, g ));
v->hpcr_rgbTbl[1][i] = CLAMP( green, 16, 239 );
}
g = 1.0 / v->BlueGamma;
for (i=0; i<256; i++) {
GLint blue = IROUND_POS(255.0 * _mesa_pow( hpcr_rgbTbl[2][i]/255.0, g ));
v->hpcr_rgbTbl[2][i] = CLAMP( blue, 32, 223 );
}
v->undithered_pf = PF_HPCR;
v->dithered_pf = PF_HPCR;
v->hpcr_clear_flag = _mesa_getenv("MESA_HPCR_CLEAR") ? GL_TRUE : GL_FALSE;
if (v->hpcr_clear_flag) {
v->hpcr_clear_pixmap = XMesaCreatePixmap(v->display,
DefaultRootWindow(v->display),
16, 2, 8);
#ifndef XFree86Server
v->hpcr_clear_ximage = XGetImage(v->display, v->hpcr_clear_pixmap,
0, 0, 16, 2, AllPlanes, ZPixmap);
#endif
}
}
static void setup_truecolor( XMesaVisual v, XMesaBuffer buffer,
XMesaColormap cmap )
{
unsigned long rmask, gmask, bmask;
(void) buffer;
(void) cmap;
v->rshift = 0;
rmask = GET_REDMASK(v);
while ((rmask & 1)==0) {
v->rshift++;
rmask = rmask >> 1;
}
v->gshift = 0;
gmask = GET_GREENMASK(v);
while ((gmask & 1)==0) {
v->gshift++;
gmask = gmask >> 1;
}
v->bshift = 0;
bmask = GET_BLUEMASK(v);
while ((bmask & 1)==0) {
v->bshift++;
bmask = bmask >> 1;
}
{
static GLubyte kernel[16] = {
0*16, 8*16, 2*16, 10*16,
12*16, 4*16, 14*16, 6*16,
3*16, 11*16, 1*16, 9*16,
15*16, 7*16, 13*16, 5*16,
};
GLint rBits = bitcount(rmask);
GLint gBits = bitcount(gmask);
GLint bBits = bitcount(bmask);
GLint maxBits;
GLuint i;
for (i=0; i<=rmask; i++)
v->PixelToR[i] = (unsigned char) ((i * 255) / rmask);
for (i=0; i<=gmask; i++)
v->PixelToG[i] = (unsigned char) ((i * 255) / gmask);
for (i=0; i<=bmask; i++)
v->PixelToB[i] = (unsigned char) ((i * 255) / bmask);
for (i=0;i<256;i++) {
GLint r = gamma_adjust(v->RedGamma, i, 255);
GLint g = gamma_adjust(v->GreenGamma, i, 255);
GLint b = gamma_adjust(v->BlueGamma, i, 255);
v->RtoPixel[i] = (r >> (8-rBits)) << v->rshift;
v->GtoPixel[i] = (g >> (8-gBits)) << v->gshift;
v->BtoPixel[i] = (b >> (8-bBits)) << v->bshift;
}
for (i=256;i<512;i++) {
v->RtoPixel[i] = v->RtoPixel[255];
v->GtoPixel[i] = v->GtoPixel[255];
v->BtoPixel[i] = v->BtoPixel[255];
}
maxBits = rBits;
if (gBits > maxBits) maxBits = gBits;
if (bBits > maxBits) maxBits = bBits;
for (i=0;i<16;i++) {
v->Kernel[i] = kernel[i] >> maxBits;
}
v->undithered_pf = PF_TRUECOLOR;
v->dithered_pf = (GET_VISUAL_DEPTH(v)<24) ? PF_TRUEDITHER : PF_TRUECOLOR;
}
if ( GET_REDMASK(v) ==0x0000ff
&& GET_GREENMASK(v)==0x00ff00
&& GET_BLUEMASK(v) ==0xff0000
&& CHECK_BYTE_ORDER(v)
&& v->BitsPerPixel==32
&& sizeof(GLuint)==4
&& v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
v->undithered_pf = v->dithered_pf = PF_8A8B8G8R;
}
else if (GET_REDMASK(v) ==0xff0000
&& GET_GREENMASK(v)==0x00ff00
&& GET_BLUEMASK(v) ==0x0000ff
&& CHECK_BYTE_ORDER(v)
&& v->BitsPerPixel==32
&& sizeof(GLuint)==4
&& v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
v->undithered_pf = v->dithered_pf = PF_8R8G8B;
}
else if (GET_REDMASK(v) ==0xff0000
&& GET_GREENMASK(v)==0x00ff00
&& GET_BLUEMASK(v) ==0x0000ff
&& CHECK_BYTE_ORDER(v)
&& v->BitsPerPixel==24
&& sizeof(GLuint)==4
&& v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
v->undithered_pf = v->dithered_pf = PF_8R8G8B24;
}
else if (GET_REDMASK(v) ==0xf800
&& GET_GREENMASK(v)==0x07e0
&& GET_BLUEMASK(v) ==0x001f
&& CHECK_BYTE_ORDER(v)
&& v->BitsPerPixel==16
&& sizeof(GLushort)==2
&& v->RedGamma==1.0 && v->GreenGamma==1.0 && v->BlueGamma==1.0) {
v->undithered_pf = PF_5R6G5B;
v->dithered_pf = PF_DITHER_5R6G5B;
}
else if (GET_REDMASK(v) ==0xe0
&& GET_GREENMASK(v)==0x1c
&& GET_BLUEMASK(v) ==0x03
&& CHECK_FOR_HPCR(v)) {
setup_8bit_hpcr( v );
}
}
static void setup_monochrome( XMesaVisual v, XMesaBuffer b )
{
(void) b;
v->dithered_pf = v->undithered_pf = PF_1BIT;
v->bitFlip = (GET_BLACK_PIXEL(v) != 0);
}
static GLboolean initialize_visual_and_buffer( int client,
XMesaVisual v,
XMesaBuffer b,
GLboolean rgb_flag,
XMesaDrawable window,
XMesaColormap cmap )
{
#ifndef XFree86Server
XGCValues gcvalues;
#endif
if (b) {
assert(b->xm_visual == v);
}
v->BitsPerPixel = bits_per_pixel(v);
assert(v->BitsPerPixel > 0);
if (rgb_flag==GL_FALSE) {
v->dithered_pf = v->undithered_pf = PF_INDEX;
v->index_bits = GET_VISUAL_DEPTH(v);
}
else {
const int xclass = v->mesa_visual.visualType;
if (xclass == GLX_TRUE_COLOR || xclass == GLX_DIRECT_COLOR) {
setup_truecolor( v, b, cmap );
}
else if (xclass == GLX_STATIC_GRAY && GET_VISUAL_DEPTH(v) == 1) {
setup_monochrome( v, b );
}
else if (xclass == GLX_GRAY_SCALE || xclass == GLX_STATIC_GRAY) {
if (!setup_grayscale( client, v, b, cmap )) {
return GL_FALSE;
}
}
else if ((xclass == GLX_PSEUDO_COLOR || xclass == GLX_STATIC_COLOR)
&& GET_VISUAL_DEPTH(v)>=4 && GET_VISUAL_DEPTH(v)<=16) {
if (!setup_dithered_color( client, v, b, cmap )) {
return GL_FALSE;
}
}
else {
_mesa_warning(NULL, "XMesa: RGB mode rendering not supported in given visual.");
return GL_FALSE;
}
v->index_bits = 0;
if (_mesa_getenv("MESA_NO_DITHER")) {
v->dithered_pf = v->undithered_pf;
}
}
if (_mesa_getenv("MESA_INFO")) {
_mesa_printf("X/Mesa visual = %p\n", (void *) v);
_mesa_printf("X/Mesa dithered pf = %u\n", v->dithered_pf);
_mesa_printf("X/Mesa undithered pf = %u\n", v->undithered_pf);
_mesa_printf("X/Mesa level = %d\n", v->level);
_mesa_printf("X/Mesa depth = %d\n", GET_VISUAL_DEPTH(v));
_mesa_printf("X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
}
if (b && window) {
unsigned int w, h;
get_drawable_size( v->display, window, &w, &h );
b->width = w;
b->height = h;
b->frontbuffer = window;
if (v->mesa_visual.doubleBufferMode) {
#ifndef XFree86Server
b->shm = check_for_xshm( v->display );
#endif
xmesa_alloc_back_buffer( b );
if (b->db_state==BACK_PIXMAP) {
b->buffer = (XMesaDrawable)b->backpixmap;
}
else {
b->buffer = XIMAGE;
}
}
else {
b->buffer = b->frontbuffer;
}
#ifdef XFree86Server
b->gc = CreateScratchGC(v->display, window->depth);
#else
b->gc = XCreateGC( v->display, window, 0, NULL );
#endif
XMesaSetFunction( v->display, b->gc, GXcopy );
#ifdef XFree86Server
b->cleargc = CreateScratchGC(v->display, window->depth);
#else
b->cleargc = XCreateGC( v->display, window, 0, NULL );
#endif
XMesaSetFunction( v->display, b->cleargc, GXcopy );
#ifdef XFree86Server
b->swapgc = CreateScratchGC(v->display, window->depth);
{
CARD32 v[1];
v[0] = FALSE;
dixChangeGC(NullClient, b->swapgc, GCGraphicsExposures, v, NULL);
}
#else
gcvalues.graphics_exposures = False;
b->swapgc = XCreateGC( v->display, window,
GCGraphicsExposures, &gcvalues);
#endif
XMesaSetFunction( v->display, b->swapgc, GXcopy );
if (v->hpcr_clear_flag && b->buffer!=XIMAGE) {
int i;
for (i=0; i<16; i++)
{
XMesaPutPixel(v->hpcr_clear_ximage, i, 0, 0);
XMesaPutPixel(v->hpcr_clear_ximage, i, 1, 0);
}
XMesaPutImage(b->display, (XMesaDrawable)v->hpcr_clear_pixmap,
b->cleargc, v->hpcr_clear_ximage, 0, 0, 0, 0, 16, 2);
XMesaSetFillStyle( v->display, b->cleargc, FillTiled);
XMesaSetTile( v->display, b->cleargc, v->hpcr_clear_pixmap );
}
#ifdef XFree86Server
b->rowimage = XMesaCreateImage(GET_VISUAL_DEPTH(v), MAX_WIDTH, 1,
(char *)MALLOC(MAX_WIDTH*4));
#else
b->rowimage = XCreateImage( v->display,
v->visinfo->visual,
v->visinfo->depth,
ZPixmap, 0,
(char*) MALLOC(MAX_WIDTH*4),
MAX_WIDTH, 1,
32,
0 );
#endif
}
return GL_TRUE;
}
unsigned long
xmesa_color_to_pixel( XMesaContext xmesa, GLubyte r, GLubyte g, GLubyte b, GLubyte a,
GLuint pixelFormat)
{
switch (pixelFormat) {
case PF_INDEX:
return 0;
case PF_TRUECOLOR:
{
unsigned long p;
PACK_TRUECOLOR( p, r, g, b );
return p;
}
case PF_8A8B8G8R:
return PACK_8A8B8G8R( r, g, b, a );
case PF_8R8G8B:
case PF_8R8G8B24:
return PACK_8R8G8B( r, g, b );
case PF_5R6G5B:
return PACK_5R6G5B( r, g, b );
case PF_DITHER:
{
DITHER_SETUP;
return DITHER( 1, 0, r, g, b );
}
case PF_1BIT:
return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip;
case PF_HPCR:
return DITHER_HPCR(1, 1, r, g, b);
case PF_LOOKUP:
{
LOOKUP_SETUP;
return LOOKUP( r, g, b );
}
case PF_GRAYSCALE:
return GRAY_RGB( r, g, b );
case PF_TRUEDITHER:
case PF_DITHER_5R6G5B:
{
unsigned long p;
PACK_TRUEDITHER(p, 1, 0, r, g, b);
return p;
}
default:
_mesa_problem(NULL, "Bad pixel format in xmesa_color_to_pixel");
}
return 0;
}
XMesaVisual XMesaCreateVisual( XMesaDisplay *display,
XMesaVisualInfo visinfo,
GLboolean rgb_flag,
GLboolean alpha_flag,
GLboolean db_flag,
GLboolean stereo_flag,
GLboolean ximage_flag,
GLint depth_size,
GLint stencil_size,
GLint accum_red_size,
GLint accum_green_size,
GLint accum_blue_size,
GLint accum_alpha_size,
GLint num_samples,
GLint level,
GLint visualCaveat )
{
char *gamma;
XMesaVisual v;
GLint red_bits, green_bits, blue_bits, alpha_bits;
if (_mesa_getenv("MESA_XSYNC")) {
#ifdef XFree86Server
#else
XSynchronize( display, 1 );
#endif
}
v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual);
if (!v) {
return NULL;
}
v->display = display;
#ifdef XFree86Server
v->visinfo = visinfo;
#else
v->visinfo = (XVisualInfo *) MALLOC(sizeof(*visinfo));
if(!v->visinfo) {
FREE(v);
return NULL;
}
MEMCPY(v->visinfo, visinfo, sizeof(*visinfo));
#endif
#ifdef XFree86Server
{
PixmapFormatRec *format;
for (format = screenInfo.formats;
format->depth != display->rootDepth;
format++)
;
v->screen_depth = format->bitsPerPixel;
}
#endif
gamma = _mesa_getenv("MESA_GAMMA");
if (gamma) {
v->RedGamma = v->GreenGamma = v->BlueGamma = 0.0;
sscanf( gamma, "%f %f %f", &v->RedGamma, &v->GreenGamma, &v->BlueGamma );
if (v->RedGamma<=0.0) v->RedGamma = 1.0;
if (v->GreenGamma<=0.0) v->GreenGamma = v->RedGamma;
if (v->BlueGamma<=0.0) v->BlueGamma = v->RedGamma;
}
else {
v->RedGamma = v->GreenGamma = v->BlueGamma = 1.0;
}
v->ximage_flag = ximage_flag;
v->level = level;
v->VisualCaveat = visualCaveat;
(void) initialize_visual_and_buffer( 0, v, NULL, rgb_flag, 0, 0 );
{
const int xclass = v->mesa_visual.visualType;
if (xclass == GLX_TRUE_COLOR || xclass == GLX_DIRECT_COLOR) {
red_bits = _mesa_bitcount(GET_REDMASK(v));
green_bits = _mesa_bitcount(GET_GREENMASK(v));
blue_bits = _mesa_bitcount(GET_BLUEMASK(v));
alpha_bits = 0;
}
else {
int depth;
depth = GET_VISUAL_DEPTH(v);
red_bits = depth / 3;
depth -= red_bits;
green_bits = depth / 2;
depth -= green_bits;
blue_bits = depth;
alpha_bits = 0;
assert( red_bits + green_bits + blue_bits == GET_VISUAL_DEPTH(v) );
}
}
if (alpha_flag && alpha_bits == 0)
alpha_bits = 8;
_mesa_initialize_visual( &v->mesa_visual,
rgb_flag, db_flag, stereo_flag,
red_bits, green_bits,
blue_bits, alpha_bits,
v->index_bits,
depth_size,
stencil_size,
accum_red_size, accum_green_size,
accum_blue_size, accum_alpha_size,
0 );
return v;
}
void XMesaSetVisualDisplay( XMesaDisplay *dpy, XMesaVisual v )
{
v->display = dpy;
}
void XMesaDestroyVisual( XMesaVisual v )
{
#ifndef XFree86Server
FREE(v->visinfo);
#endif
FREE(v);
}
XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
{
static GLboolean firstTime = GL_TRUE;
XMesaContext c;
GLcontext *ctx;
GLboolean direct = GL_TRUE;
if (firstTime) {
_glthread_INIT_MUTEX(_xmesa_lock);
firstTime = GL_FALSE;
}
c = (XMesaContext) CALLOC_STRUCT(xmesa_context);
if (!c) {
return NULL;
}
ctx = c->gl_ctx = _mesa_create_context( &v->mesa_visual,
share_list ? share_list->gl_ctx : (GLcontext *) NULL,
(void *) c, direct);
if (!c->gl_ctx) {
FREE(c);
return NULL;
}
_mesa_enable_sw_extensions(ctx);
_mesa_enable_1_3_extensions(ctx);
_mesa_enable_1_4_extensions(ctx);
if (CHECK_BYTE_ORDER(v)) {
c->swapbytes = GL_FALSE;
}
else {
c->swapbytes = GL_TRUE;
}
c->xm_visual = v;
c->xm_draw_buffer = NULL;
c->xm_read_buffer = NULL;
c->xm_buffer = NULL;
c->display = v->display;
c->pixelformat = v->dithered_pf;
ctx->Driver.UpdateState = xmesa_update_state;
_swrast_CreateContext( ctx );
_ac_CreateContext( ctx );
_tnl_CreateContext( ctx );
_swsetup_CreateContext( ctx );
xmesa_register_swrast_functions( ctx );
xmesa_init_pointers( ctx );
return c;
}
void XMesaDestroyContext( XMesaContext c )
{
#ifdef FX
if (c->xm_draw_buffer && c->xm_buffer->FXctx)
fxMesaDestroyContext(c->xm_draw_buffer->FXctx);
#endif
if (c->gl_ctx) {
_swsetup_DestroyContext( c->gl_ctx );
_swrast_DestroyContext( c->gl_ctx );
_tnl_DestroyContext( c->gl_ctx );
_ac_DestroyContext( c->gl_ctx );
_mesa_destroy_context( c->gl_ctx );
}
FREE( c );
}
XMesaBuffer XMesaCreateWindowBuffer2( XMesaVisual v, XMesaWindow w,
XMesaContext c )
{
#ifndef XFree86Server
XWindowAttributes attr;
#endif
#ifdef FX
char *fxEnvVar;
#endif
int client = 0;
XMesaBuffer b = alloc_xmesa_buffer();
if (!b) {
return NULL;
}
(void) c;
#ifdef XFree86Server
client = CLIENT_ID(((XMesaDrawable)w)->id);
#endif
assert(v);
#ifdef XFree86Server
if (GET_VISUAL_DEPTH(v) != ((XMesaDrawable)w)->depth) {
#else
XGetWindowAttributes( v->display, w, &attr );
if (GET_VISUAL_DEPTH(v) != attr.depth) {
#endif
_mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual and window!\n");
return NULL;
}
b->xm_visual = v;
b->type = WINDOW;
b->display = v->display;
#ifdef XFree86Server
b->cmap = (ColormapPtr)LookupIDByType(wColormap(w), RT_COLORMAP);
#else
if (attr.colormap) {
b->cmap = attr.colormap;
}
else {
_mesa_warning(NULL, "Window %u has no colormap!\n", (unsigned int) w);
b->cmap = XCreateColormap(v->display, w, attr.visual, AllocNone);
}
#endif
if (v->mesa_visual.doubleBufferMode) {
if (v->ximage_flag) {
b->db_state = BACK_XIMAGE;
}
else {
b->db_state = BACK_PIXMAP;
}
}
else {
b->db_state = 0;
}
_mesa_initialize_framebuffer(&b->mesa_buffer,
&v->mesa_visual,
v->mesa_visual.depthBits > 0,
v->mesa_visual.stencilBits > 0,
v->mesa_visual.accumRedBits > 0,
v->mesa_visual.alphaBits > 0 );
if (!initialize_visual_and_buffer( client, v, b, v->mesa_visual.rgbMode,
(XMesaDrawable)w, b->cmap )) {
free_xmesa_buffer(client, b);
return NULL;
}
#ifdef FX
fxEnvVar = _mesa_getenv("MESA_GLX_FX");
if (fxEnvVar) {
if (fxEnvVar[0]!='d') {
int attribs[100];
int numAttribs = 0;
int hw;
if (v->mesa_visual.depthBits > 0) {
attribs[numAttribs++] = FXMESA_DEPTH_SIZE;
attribs[numAttribs++] = 1;
}
if (v->mesa_visual.doubleBufferMode) {
attribs[numAttribs++] = FXMESA_DOUBLEBUFFER;
}
if (v->mesa_visual.accumRedBits > 0) {
attribs[numAttribs++] = FXMESA_ACCUM_SIZE;
attribs[numAttribs++] = v->mesa_visual.accumRedBits;
}
if (v->mesa_visual.stencilBits > 0) {
attribs[numAttribs++] = FXMESA_STENCIL_SIZE;
attribs[numAttribs++] = v->mesa_visual.stencilBits;
}
if (v->mesa_visual.alphaBits > 0) {
attribs[numAttribs++] = FXMESA_ALPHA_SIZE;
attribs[numAttribs++] = 1;
}
if (c->gl_ctx) {
#define FXMESA_SHARE_CONTEXT 990099
attribs[numAttribs++] = FXMESA_SHARE_CONTEXT;
attribs[numAttribs++] = (int) c->gl_ctx;
}
attribs[numAttribs++] = FXMESA_NONE;
if ((hw = fxQueryHardware())==GR_SSTTYPE_VOODOO) {
b->FXctx = fxMesaCreateBestContext(0, b->width, b->height, attribs);
if ((v->undithered_pf!=PF_INDEX) && (b->backimage)) {
b->FXisHackUsable = b->FXctx ? GL_TRUE : GL_FALSE;
if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
b->FXwindowHack = b->FXctx ? GL_TRUE : GL_FALSE;
else
b->FXwindowHack = GL_FALSE;
}
}
else {
if (fxEnvVar[0]=='w' || fxEnvVar[0]=='W')
b->FXctx = fxMesaCreateContext(w, GR_RESOLUTION_NONE,
GR_REFRESH_75Hz, attribs);
else
b->FXctx = fxMesaCreateBestContext(0, b->width, b->height, attribs);
b->FXisHackUsable = GL_FALSE;
b->FXwindowHack = GL_FALSE;
}
}
}
else {
_mesa_warning(NULL, "WARNING: This Mesa Library includes the Glide driver but\n");
_mesa_warning(NULL, " you have not defined the MESA_GLX_FX env. var.\n");
_mesa_warning(NULL, " (check the README.3DFX file for more information).\n\n");
_mesa_warning(NULL, " you can disable this message with a 'export MESA_GLX_FX=disable'.\n");
}
#endif
return b;
}
XMesaBuffer XMesaCreateWindowBuffer( XMesaVisual v, XMesaWindow w )
{
return XMesaCreateWindowBuffer2( v, w, NULL );
}
XMesaBuffer XMesaCreatePixmapBuffer( XMesaVisual v,
XMesaPixmap p, XMesaColormap cmap )
{
int client = 0;
XMesaBuffer b = alloc_xmesa_buffer();
if (!b) {
return NULL;
}
#ifdef XFree86Server
client = CLIENT_ID(((XMesaDrawable)p)->id);
#endif
assert(v);
b->xm_visual = v;
b->type = PIXMAP;
b->display = v->display;
b->cmap = cmap;
if (v->mesa_visual.doubleBufferMode) {
if (v->ximage_flag) {
b->db_state = BACK_XIMAGE;
}
else {
b->db_state = BACK_PIXMAP;
}
}
else {
b->db_state = 0;
}
_mesa_initialize_framebuffer(&b->mesa_buffer,
&v->mesa_visual,
v->mesa_visual.depthBits > 0,
v->mesa_visual.stencilBits > 0,
v->mesa_visual.accumRedBits +
v->mesa_visual.accumGreenBits +
v->mesa_visual.accumBlueBits > 0,
v->mesa_visual.alphaBits > 0 );
if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode,
(XMesaDrawable)p, cmap)) {
free_xmesa_buffer(client, b);
return NULL;
}
return b;
}
XMesaBuffer XMesaCreatePBuffer( XMesaVisual v, XMesaColormap cmap,
unsigned int width, unsigned int height )
{
#ifdef XFree86Server
return 0;
#else
int client = 0;
XMesaWindow root;
XMesaDrawable drawable;
XMesaBuffer b = alloc_xmesa_buffer();
if (!b) {
return NULL;
}
b->xm_visual = v;
b->type = PBUFFER;
b->display = v->display;
b->cmap = cmap;
root = RootWindow( v->display, v->visinfo->screen );
drawable = XCreatePixmap( v->display, root, width, height, v->visinfo->depth );
if (v->mesa_visual.doubleBufferMode) {
if (v->ximage_flag) {
b->db_state = BACK_XIMAGE;
}
else {
b->db_state = BACK_PIXMAP;
}
}
else {
b->db_state = 0;
}
_mesa_initialize_framebuffer(&b->mesa_buffer,
&v->mesa_visual,
v->mesa_visual.depthBits > 0,
v->mesa_visual.stencilBits > 0,
v->mesa_visual.accumRedBits +
v->mesa_visual.accumGreenBits +
v->mesa_visual.accumBlueBits > 0,
v->mesa_visual.alphaBits > 0 );
if (!initialize_visual_and_buffer(client, v, b, v->mesa_visual.rgbMode,
drawable, cmap)) {
free_xmesa_buffer(client, b);
return NULL;
}
return b;
#endif
}
void XMesaDestroyBuffer( XMesaBuffer b )
{
int client = 0;
#ifdef XFree86Server
if (b->frontbuffer)
client = CLIENT_ID(b->frontbuffer->id);
#endif
if (b->gc) XMesaFreeGC( b->xm_visual->display, b->gc );
if (b->cleargc) XMesaFreeGC( b->xm_visual->display, b->cleargc );
if (b->swapgc) XMesaFreeGC( b->xm_visual->display, b->swapgc );
if (b->backimage) {
#if defined(USE_XSHM) && !defined(XFree86Server)
if (b->shm) {
XShmDetach( b->xm_visual->display, &b->shminfo );
XDestroyImage( b->backimage );
shmdt( b->shminfo.shmaddr );
}
else
#endif
XMesaDestroyImage( b->backimage );
}
if (b->backpixmap) {
XMesaFreePixmap( b->xm_visual->display, b->backpixmap );
if (b->xm_visual->hpcr_clear_flag) {
XMesaFreePixmap( b->xm_visual->display,
b->xm_visual->hpcr_clear_pixmap );
XMesaDestroyImage( b->xm_visual->hpcr_clear_ximage );
}
}
if (b->rowimage) {
FREE( b->rowimage->data );
b->rowimage->data = NULL;
XMesaDestroyImage( b->rowimage );
}
free_xmesa_buffer(client, b);
}
GLboolean XMesaMakeCurrent( XMesaContext c, XMesaBuffer b )
{
return XMesaMakeCurrent2( c, b, b );
}
GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
XMesaBuffer readBuffer )
{
if (c) {
if (!drawBuffer || !readBuffer)
return GL_FALSE;
#ifdef FX
if (drawBuffer->FXctx) {
fxMesaMakeCurrent(drawBuffer->FXctx);
c->xm_draw_buffer = drawBuffer;
c->xm_read_buffer = readBuffer;
c->xm_buffer = drawBuffer;
return GL_TRUE;
}
#endif
if (c->gl_ctx == _mesa_get_current_context()
&& c->xm_draw_buffer == drawBuffer
&& c->xm_read_buffer == readBuffer
&& c->xm_draw_buffer->wasCurrent) {
return GL_TRUE;
}
c->xm_draw_buffer = drawBuffer;
c->xm_read_buffer = readBuffer;
c->xm_buffer = drawBuffer;
_mesa_make_current2(c->gl_ctx,
&drawBuffer->mesa_buffer,
&readBuffer->mesa_buffer);
if (c->gl_ctx->Viewport.Width == 0) {
_mesa_Viewport( 0, 0, drawBuffer->width, drawBuffer->height );
c->gl_ctx->Scissor.Width = drawBuffer->width;
c->gl_ctx->Scissor.Height = drawBuffer->height;
}
if (c->xm_visual->mesa_visual.rgbMode) {
c->clearpixel = xmesa_color_to_pixel( c,
c->clearcolor[0],
c->clearcolor[1],
c->clearcolor[2],
c->clearcolor[3],
c->xm_visual->undithered_pf);
XMesaSetForeground(c->display, c->xm_draw_buffer->cleargc, c->clearpixel);
}
c->xm_draw_buffer->wasCurrent = GL_TRUE;
}
else {
_mesa_make_current2( NULL, NULL, NULL );
}
return GL_TRUE;
}
GLboolean XMesaUnbindContext( XMesaContext c )
{
return GL_TRUE;
}
XMesaContext XMesaGetCurrentContext( void )
{
GET_CURRENT_CONTEXT(ctx);
if (ctx) {
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
return xmesa;
}
else {
return 0;
}
}
XMesaBuffer XMesaGetCurrentBuffer( void )
{
GET_CURRENT_CONTEXT(ctx);
if (ctx) {
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
return xmesa->xm_draw_buffer;
}
else {
return 0;
}
}
XMesaBuffer XMesaGetCurrentReadBuffer( void )
{
GET_CURRENT_CONTEXT(ctx);
if (ctx) {
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
return xmesa->xm_read_buffer;
}
else {
return 0;
}
}
GLboolean XMesaForceCurrent(XMesaContext c)
{
if (c) {
if (c->gl_ctx != _mesa_get_current_context()) {
_mesa_make_current(c->gl_ctx, &c->xm_draw_buffer->mesa_buffer);
}
}
else {
_mesa_make_current(NULL, NULL);
}
return GL_TRUE;
}
GLboolean XMesaLoseCurrent(XMesaContext c)
{
(void) c;
_mesa_make_current(NULL, NULL);
return GL_TRUE;
}
GLboolean XMesaSetFXmode( GLint mode )
{
#ifdef FX
const char *fx = _mesa_getenv("MESA_GLX_FX");
if (fx && fx[0] != 'd') {
GET_CURRENT_CONTEXT(ctx);
GrHwConfiguration hw;
if (!FX_grSstQueryHardware(&hw)) {
return GL_FALSE;
}
if (hw.num_sst < 1) {
return GL_FALSE;
}
if (ctx) {
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
if (mode == XMESA_FX_WINDOW) {
if (xmesa->xm_draw_buffer->FXisHackUsable) {
FX_grSstControl(GR_CONTROL_DEACTIVATE);
xmesa->xm_draw_buffer->FXwindowHack = GL_TRUE;
return GL_TRUE;
}
}
else if (mode == XMESA_FX_FULLSCREEN) {
FX_grSstControl(GR_CONTROL_ACTIVATE);
xmesa->xm_draw_buffer->FXwindowHack = GL_FALSE;
return GL_TRUE;
}
else {
}
}
}
#else
(void) mode;
#endif
return GL_FALSE;
}
#ifdef FX
static void FXgetImage( XMesaBuffer b )
{
GET_CURRENT_CONTEXT(ctx);
static unsigned short pixbuf[MAX_WIDTH];
GLuint x, y;
int xpos, ypos;
XMesaWindow root;
unsigned int bw, depth, width, height;
XMesaContext xmesa = (XMesaContext) ctx->DriverCtx;
#ifdef XFree86Server
x = b->frontbuffer->x;
y = b->frontbuffer->y;
width = b->frontbuffer->width;
height = b->frontbuffer->height;
depth = b->frontbuffer->depth;
#else
XGetGeometry( b->xm_visual->display, b->frontbuffer,
&root, &xpos, &ypos, &width, &height, &bw, &depth);
#endif
if (b->width != width || b->height != height) {
b->width = MIN2((int)width, b->FXctx->width);
b->height = MIN2((int)height, b->FXctx->height);
if (b->width & 1)
b->width--;
xmesa_alloc_back_buffer( b );
}
grLfbWriteColorFormat(GR_COLORFORMAT_ARGB);
if (b->xm_visual->undithered_pf==PF_5R6G5B) {
grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
0, b->FXctx->height - b->height,
b->width, b->height,
b->width * sizeof(GLushort),
b->backimage->data);
}
else if (b->xm_visual->dithered_pf==PF_DITHER
&& GET_VISUAL_DEPTH(b->xm_visual)==8) {
for (y=0;y<b->height;y++) {
GLubyte *ptr = (GLubyte*) b->backimage->data
+ b->backimage->bytes_per_line * y;
XDITHER_SETUP(y);
grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
0, b->FXctx->height-(b->height-y),
b->width, 1,
0,
pixbuf );
for (x=0;x<b->width;x++) {
GLubyte r = (pixbuf[x] & 0xf800) >> 8;
GLubyte g = (pixbuf[x] & 0x07e0) >> 3;
GLubyte b = (pixbuf[x] & 0x001f) << 3;
*ptr++ = XDITHER( x, r, g, b);
}
}
}
else {
for (y=0;y<b->height;y++) {
grLfbReadRegion( GR_BUFFER_FRONTBUFFER,
0, b->FXctx->height-(b->height-y),
b->width, 1,
0,
pixbuf );
for (x=0;x<b->width;x++) {
XMesaPutPixel(b->backimage,x,y,
xmesa_color_to_pixel(xmesa,
(pixbuf[x] & 0xf800) >> 8,
(pixbuf[x] & 0x07e0) >> 3,
(pixbuf[x] & 0x001f) << 3,
0xff,
b->xm_visual->undithered_pf));
}
}
}
grLfbWriteColorFormat(GR_COLORFORMAT_ABGR);
}
#endif
void XMesaSwapBuffers( XMesaBuffer b )
{
GET_CURRENT_CONTEXT(ctx);
if (ctx && ctx->DrawBuffer == &(b->mesa_buffer))
_mesa_notifySwapBuffers(ctx);
if (b->db_state) {
#ifdef FX
if (b->FXctx) {
fxMesaSwapBuffers();
if (b->FXwindowHack)
FXgetImage(b);
else
return;
}
#endif
if (b->backimage) {
#if defined(USE_XSHM) && !defined(XFree86Server)
if (b->shm) {
XShmPutImage( b->xm_visual->display, b->frontbuffer,
b->swapgc,
b->backimage, 0, 0,
0, 0, b->width, b->height, False );
}
else
#endif
{
XMesaPutImage( b->xm_visual->display, b->frontbuffer,
b->swapgc,
b->backimage, 0, 0,
0, 0, b->width, b->height );
}
}
else {
XMesaCopyArea( b->xm_visual->display,
b->backpixmap,
b->frontbuffer,
b->swapgc,
0, 0, b->width, b->height,
0, 0
);
}
}
#if !defined(XFree86Server)
XSync( b->xm_visual->display, False );
#endif
}
void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height )
{
GET_CURRENT_CONTEXT(ctx);
if (ctx && ctx->DrawBuffer == &(b->mesa_buffer))
_mesa_notifySwapBuffers(ctx);
if (b->db_state) {
int yTop = b->height - y - height;
#ifdef FX
if (b->FXctx) {
fxMesaSwapBuffers();
if (b->FXwindowHack)
FXgetImage(b);
else
return;
}
#endif
if (b->backimage) {
#if defined(USE_XSHM) && !defined(XFree86Server)
if (b->shm) {
XShmPutImage( b->xm_visual->display, b->frontbuffer,
b->swapgc,
b->backimage, x, yTop,
x, yTop, width, height, False );
}
else
#endif
{
XMesaPutImage( b->xm_visual->display, b->frontbuffer,
b->swapgc,
b->backimage, x, yTop,
x, yTop, width, height );
}
}
else {
XMesaCopyArea( b->xm_visual->display,
b->backpixmap,
b->frontbuffer,
b->swapgc,
x, yTop, width, height,
x, yTop
);
}
}
}
GLboolean XMesaGetBackBuffer( XMesaBuffer b,
XMesaPixmap *pixmap,
XMesaImage **ximage )
{
if (b->db_state) {
if (pixmap) *pixmap = b->backpixmap;
if (ximage) *ximage = b->backimage;
return GL_TRUE;
}
else {
*pixmap = 0;
*ximage = NULL;
return GL_FALSE;
}
}
GLboolean XMesaGetDepthBuffer( XMesaBuffer b, GLint *width, GLint *height,
GLint *bytesPerValue, void **buffer )
{
if (!b->mesa_buffer.DepthBuffer) {
*width = 0;
*height = 0;
*bytesPerValue = 0;
*buffer = 0;
return GL_FALSE;
}
else {
*width = b->mesa_buffer.Width;
*height = b->mesa_buffer.Height;
*bytesPerValue = sizeof(GLdepth);
*buffer = b->mesa_buffer.DepthBuffer;
return GL_TRUE;
}
}
void XMesaFlush( XMesaContext c )
{
if (c && c->xm_visual) {
#ifdef XFree86Server
#else
XSync( c->xm_visual->display, False );
#endif
}
}
const char *XMesaGetString( XMesaContext c, int name )
{
(void) c;
if (name==XMESA_VERSION) {
return "5.0.1";
}
else if (name==XMESA_EXTENSIONS) {
return "";
}
else {
return NULL;
}
}
XMesaBuffer XMesaFindBuffer( XMesaDisplay *dpy, XMesaDrawable d )
{
XMesaBuffer b;
for (b=XMesaBufferList; b; b=b->Next) {
if (b->frontbuffer==d && b->display==dpy) {
return b;
}
}
return NULL;
}
void XMesaGarbageCollect( void )
{
XMesaBuffer b, next;
for (b=XMesaBufferList; b; b=next) {
next = b->Next;
if (b->display && b->frontbuffer && b->type == WINDOW) {
#ifdef XFree86Server
#else
XSync(b->display, False);
if (!window_exists( b->display, b->frontbuffer )) {
XMesaDestroyBuffer( b );
}
#endif
}
}
}
void XMesaReset( void )
{
while (XMesaBufferList)
XMesaDestroyBuffer(XMesaBufferList);
XMesaBufferList = NULL;
}
unsigned long XMesaDitherColor( XMesaContext xmesa, GLint x, GLint y,
GLfloat red, GLfloat green,
GLfloat blue, GLfloat alpha )
{
GLint r = (GLint) (red * 255.0F);
GLint g = (GLint) (green * 255.0F);
GLint b = (GLint) (blue * 255.0F);
GLint a = (GLint) (alpha * 255.0F);
switch (xmesa->pixelformat) {
case PF_INDEX:
return 0;
case PF_TRUECOLOR:
{
unsigned long p;
PACK_TRUECOLOR( p, r, g, b );
return p;
}
case PF_8A8B8G8R:
return PACK_8A8B8G8R( r, g, b, a );
case PF_8R8G8B:
return PACK_8R8G8B( r, g, b );
case PF_5R6G5B:
return PACK_5R6G5B( r, g, b );
case PF_DITHER:
{
DITHER_SETUP;
return DITHER( x, y, r, g, b );
}
case PF_1BIT:
return ((r+g+b) > 382) ^ xmesa->xm_visual->bitFlip;
case PF_HPCR:
return DITHER_HPCR(x, y, r, g, b);
case PF_LOOKUP:
{
LOOKUP_SETUP;
return LOOKUP( r, g, b );
}
case PF_GRAYSCALE:
return GRAY_RGB( r, g, b );
case PF_DITHER_5R6G5B:
case PF_TRUEDITHER:
{
unsigned long p;
PACK_TRUEDITHER(p, x, y, r, g, b);
return p;
}
default:
_mesa_problem(NULL, "Bad pixel format in XMesaDitherColor");
}
return 0;
}
void XMesaResizeBuffers( XMesaBuffer b )
{
xmesa_resize_buffers( &(b->mesa_buffer) );
}