#ifdef __CYGWIN__
#undef WIN32
#undef __WIN32__
#endif
#include "xm_api.h"
#include "main/context.h"
#include "main/framebuffer.h"
#include "state_tracker/st_public.h"
#include "state_tracker/st_context.h"
#include "pipe/p_defines.h"
#include "pipe/p_screen.h"
#include "pipe/p_context.h"
#include "trace/tr_screen.h"
#include "trace/tr_context.h"
#include "trace/tr_texture.h"
#include "xm_winsys.h"
#include <GL/glx.h>
static struct xm_driver driver;
void xmesa_set_driver( const struct xm_driver *templ )
{
driver = *templ;
}
pipe_mutex _xmesa_lock;
static struct pipe_screen *_screen = NULL;
static struct pipe_screen *screen = NULL;
static int host_byte_order( void )
{
int i = 1;
char *cptr = (char *) &i;
return (*cptr==1) ? LSBFirst : MSBFirst;
}
int xmesa_check_for_xshm( Display *display )
{
#if defined(USE_XSHM)
int major, minor, ignore;
Bool pixmaps;
if (getenv("SP_NO_RAST"))
return 0;
if (getenv("MESA_NOSHM")) {
return 0;
}
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
}
static int
bits_per_pixel( XMesaVisual xmv )
{
Display *dpy = xmv->display;
XVisualInfo * visinfo = xmv->visinfo;
XImage *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;
XDestroyImage( img );
return bitsPerPixel;
}
static GLboolean WindowExistsFlag;
static int window_exists_err_handler( Display* dpy, XErrorEvent* xerr )
{
(void) dpy;
if (xerr->error_code == BadWindow) {
WindowExistsFlag = GL_FALSE;
}
return 0;
}
static GLboolean window_exists( Display *dpy, Window win )
{
XWindowAttributes wa;
int (*old_handler)( Display*, XErrorEvent* );
WindowExistsFlag = GL_TRUE;
old_handler = XSetErrorHandler(window_exists_err_handler);
XGetWindowAttributes( dpy, win, &wa );
XSetErrorHandler(old_handler);
return WindowExistsFlag;
}
static Status
get_drawable_size( Display *dpy, Drawable d, uint *width, uint *height )
{
Window root;
Status stat;
int xpos, ypos;
unsigned int w, h, bw, depth;
stat = XGetGeometry(dpy, d, &root, &xpos, &ypos, &w, &h, &bw, &depth);
*width = w;
*height = h;
return stat;
}
void
xmesa_get_window_size(Display *dpy, XMesaBuffer b,
GLuint *width, GLuint *height)
{
Status stat;
pipe_mutex_lock(_xmesa_lock);
XSync(b->xm_visual->display, 0);
stat = get_drawable_size(dpy, b->drawable, width, height);
pipe_mutex_unlock(_xmesa_lock);
if (!stat) {
_mesa_warning(NULL, "XGetGeometry failed!\n");
*width = *height = 1;
}
}
#define GET_REDMASK(__v) __v->mesa_visual.redMask
#define GET_GREENMASK(__v) __v->mesa_visual.greenMask
#define GET_BLUEMASK(__v) __v->mesa_visual.blueMask
static GLuint
choose_pixel_format(XMesaVisual v)
{
boolean native_byte_order = (host_byte_order() ==
ImageByteOrder(v->display));
if ( GET_REDMASK(v) == 0x0000ff
&& GET_GREENMASK(v) == 0x00ff00
&& GET_BLUEMASK(v) == 0xff0000
&& v->BitsPerPixel == 32) {
if (native_byte_order) {
return PIPE_FORMAT_R8G8B8A8_UNORM;
}
else {
return PIPE_FORMAT_A8B8G8R8_UNORM;
}
}
else if ( GET_REDMASK(v) == 0xff0000
&& GET_GREENMASK(v) == 0x00ff00
&& GET_BLUEMASK(v) == 0x0000ff
&& v->BitsPerPixel == 32) {
if (native_byte_order) {
return PIPE_FORMAT_B8G8R8A8_UNORM;
}
else {
return PIPE_FORMAT_A8R8G8B8_UNORM;
}
}
else if ( GET_REDMASK(v) == 0x0000ff00
&& GET_GREENMASK(v) == 0x00ff0000
&& GET_BLUEMASK(v) == 0xff000000
&& v->BitsPerPixel == 32) {
if (native_byte_order) {
return PIPE_FORMAT_A8R8G8B8_UNORM;
}
else {
return PIPE_FORMAT_B8G8R8A8_UNORM;
}
}
else if ( GET_REDMASK(v) == 0xf800
&& GET_GREENMASK(v) == 0x07e0
&& GET_BLUEMASK(v) == 0x001f
&& native_byte_order
&& v->BitsPerPixel == 16) {
return PIPE_FORMAT_B5G6R5_UNORM;
}
assert(0);
return 0;
}
static void
xmesa_choose_z_stencil_format(int depth, int stencil,
enum pipe_format *depthFormat,
enum pipe_format *stencilFormat)
{
const enum pipe_texture_target target = PIPE_TEXTURE_2D;
const unsigned tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
const unsigned geom_flags = (PIPE_TEXTURE_GEOM_NON_SQUARE |
PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO);
enum pipe_format formats[8];
int count, i;
count = 0;
if (depth <= 16 && stencil == 0) {
formats[count++] = PIPE_FORMAT_Z16_UNORM;
}
if (depth <= 24 && stencil == 0) {
formats[count++] = PIPE_FORMAT_X8Z24_UNORM;
formats[count++] = PIPE_FORMAT_Z24X8_UNORM;
}
if (depth <= 24 && stencil <= 8) {
formats[count++] = PIPE_FORMAT_S8Z24_UNORM;
formats[count++] = PIPE_FORMAT_Z24S8_UNORM;
}
if (depth <= 32 && stencil == 0) {
formats[count++] = PIPE_FORMAT_Z32_UNORM;
}
*depthFormat = PIPE_FORMAT_NONE;
for (i = 0; i < count; i++) {
if (screen->is_format_supported(screen, formats[i],
target, tex_usage, geom_flags)) {
*depthFormat = formats[i];
break;
}
}
if (stencil) {
*stencilFormat = *depthFormat;
}
else {
*stencilFormat = PIPE_FORMAT_NONE;
}
}
XMesaBuffer XMesaBufferList = NULL;
static XMesaBuffer
create_xmesa_buffer(Drawable d, BufferType type,
XMesaVisual vis, Colormap cmap)
{
XMesaBuffer b;
GLframebuffer *fb;
enum pipe_format colorFormat, depthFormat, stencilFormat;
uint width, height;
ASSERT(type == WINDOW || type == PIXMAP || type == PBUFFER);
b = (XMesaBuffer) CALLOC_STRUCT(xmesa_buffer);
if (!b)
return NULL;
b->drawable = d;
b->xm_visual = vis;
b->type = type;
b->cmap = cmap;
colorFormat = choose_pixel_format(vis);
xmesa_choose_z_stencil_format(vis->mesa_visual.depthBits,
vis->mesa_visual.stencilBits,
&depthFormat, &stencilFormat);
get_drawable_size(vis->display, d, &width, &height);
b->stfb = st_create_framebuffer(&vis->mesa_visual,
colorFormat, depthFormat, stencilFormat,
width, height,
(void *) b);
fb = &b->stfb->Base;
b->tempImage = XCreateImage(vis->display,
vis->visinfo->visual,
vis->visinfo->depth,
ZPixmap, 0,
NULL,
0, 0,
32,
0);
b->TextureTarget = 0;
b->TextureFormat = GLX_TEXTURE_FORMAT_NONE_EXT;
b->TextureMipmap = 0;
b->Next = XMesaBufferList;
XMesaBufferList = b;
return b;
}
XMesaBuffer
xmesa_find_buffer(Display *dpy, Colormap cmap, XMesaBuffer notThis)
{
XMesaBuffer b;
for (b = XMesaBufferList; b; b = b->Next) {
if (b->xm_visual->display == dpy &&
b->cmap == cmap &&
b != notThis) {
return b;
}
}
return NULL;
}
static void
xmesa_free_buffer(XMesaBuffer buffer)
{
XMesaBuffer prev = NULL, b;
for (b = XMesaBufferList; b; b = b->Next) {
if (b == buffer) {
struct gl_framebuffer *fb = &buffer->stfb->Base;
if (prev)
prev->Next = buffer->Next;
else
XMesaBufferList = buffer->Next;
fb->DeletePending = GL_TRUE;
b->drawable = 0;
buffer->tempImage->data = NULL;
XDestroyImage(buffer->tempImage);
_mesa_reference_framebuffer(&fb, NULL);
XFreeGC(b->xm_visual->display, b->gc);
free(buffer);
return;
}
prev = b;
}
_mesa_problem(NULL,"xmesa_free_buffer() - buffer not found\n");
}
static GLboolean
initialize_visual_and_buffer(XMesaVisual v, XMesaBuffer b,
GLboolean rgb_flag, Drawable window,
Colormap cmap)
{
ASSERT(!b || b->xm_visual == v);
v->BitsPerPixel = bits_per_pixel(v);
assert(v->BitsPerPixel > 0);
if (rgb_flag == GL_FALSE) {
return GL_FALSE;
}
else {
const int xclass = v->mesa_visual.visualType;
if (xclass != GLX_TRUE_COLOR && xclass == !GLX_DIRECT_COLOR) {
_mesa_warning(NULL,
"XMesa: RGB mode rendering not supported in given visual.\n");
return GL_FALSE;
}
v->mesa_visual.indexBits = 0;
if (v->BitsPerPixel == 32) {
v->mesa_visual.alphaBits = 8;
}
}
if (_mesa_getenv("MESA_INFO")) {
printf("X/Mesa visual = %p\n", (void *) v);
printf("X/Mesa level = %d\n", v->mesa_visual.level);
printf("X/Mesa depth = %d\n", v->visinfo->depth);
printf("X/Mesa bits per pixel = %d\n", v->BitsPerPixel);
}
if (b && window) {
ASSERT(b->drawable == window);
if (v->mesa_visual.doubleBufferMode) {
b->shm = xmesa_check_for_xshm( v->display );
}
b->gc = XCreateGC( v->display, window, 0, NULL );
XSetFunction( v->display, b->gc, GXcopy );
}
return GL_TRUE;
}
#define NUM_VISUAL_TYPES 6
static GLint
xmesa_convert_from_x_visual_type( int visualType )
{
static const int glx_visual_types[ NUM_VISUAL_TYPES ] = {
GLX_STATIC_GRAY, GLX_GRAY_SCALE,
GLX_STATIC_COLOR, GLX_PSEUDO_COLOR,
GLX_TRUE_COLOR, GLX_DIRECT_COLOR
};
return ( (unsigned) visualType < NUM_VISUAL_TYPES )
? glx_visual_types[ visualType ] : GLX_NONE;
}
PUBLIC
XMesaVisual XMesaCreateVisual( Display *display,
XVisualInfo * 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 )
{
XMesaVisual v;
GLint red_bits, green_bits, blue_bits, alpha_bits;
xmesa_init();
if (_mesa_getenv("MESA_XSYNC")) {
XSynchronize( display, 1 );
}
v = (XMesaVisual) CALLOC_STRUCT(xmesa_visual);
if (!v) {
return NULL;
}
v->display = display;
v->visinfo = (XVisualInfo *) MALLOC(sizeof(*visinfo));
if (!v->visinfo) {
free(v);
return NULL;
}
memcpy(v->visinfo, visinfo, sizeof(*visinfo));
v->ximage_flag = ximage_flag;
v->mesa_visual.redMask = visinfo->red_mask;
v->mesa_visual.greenMask = visinfo->green_mask;
v->mesa_visual.blueMask = visinfo->blue_mask;
v->mesa_visual.visualID = visinfo->visualid;
v->mesa_visual.screen = visinfo->screen;
#if !(defined(__cplusplus) || defined(c_plusplus))
v->mesa_visual.visualType = xmesa_convert_from_x_visual_type(visinfo->class);
#else
v->mesa_visual.visualType = xmesa_convert_from_x_visual_type(visinfo->c_class);
#endif
v->mesa_visual.visualRating = visualCaveat;
if (alpha_flag)
v->mesa_visual.alphaBits = 8;
(void) initialize_visual_and_buffer( 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));
}
else {
int depth;
depth = v->visinfo->depth;
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 == v->visinfo->depth );
}
alpha_bits = v->mesa_visual.alphaBits;
}
_mesa_initialize_visual( &v->mesa_visual,
db_flag, stereo_flag,
red_bits, green_bits,
blue_bits, alpha_bits,
depth_size,
stencil_size,
accum_red_size, accum_green_size,
accum_blue_size, accum_alpha_size,
0 );
v->mesa_visual.level = level;
return v;
}
PUBLIC
void XMesaDestroyVisual( XMesaVisual v )
{
free(v->visinfo);
free(v);
}
void
xmesa_init(void)
{
static GLboolean firstTime = GL_TRUE;
if (firstTime) {
pipe_mutex_init(_xmesa_lock);
_screen = driver.create_pipe_screen();
screen = trace_screen_create( _screen );
firstTime = GL_FALSE;
}
}
PUBLIC
XMesaContext XMesaCreateContext( XMesaVisual v, XMesaContext share_list )
{
struct pipe_context *pipe = NULL;
XMesaContext c;
GLcontext *mesaCtx;
uint pf;
xmesa_init();
c = (XMesaContext) CALLOC_STRUCT(xmesa_context);
if (!c)
return NULL;
pf = choose_pixel_format(v);
assert(pf);
c->xm_visual = v;
c->xm_buffer = NULL;
c->xm_read_buffer = NULL;
if (screen == NULL)
goto fail;
pipe = screen->context_create(screen, (void *) c);
if (pipe == NULL)
goto fail;
c->st = st_create_context(pipe,
&v->mesa_visual,
share_list ? share_list->st : NULL);
if (c->st == NULL)
goto fail;
mesaCtx = c->st->ctx;
c->st->ctx->DriverCtx = c;
return c;
fail:
if (c->st)
st_destroy_context(c->st);
else if (pipe)
pipe->destroy(pipe);
free(c);
return NULL;
}
PUBLIC
void XMesaDestroyContext( XMesaContext c )
{
st_destroy_context(c->st);
free(c);
}
PUBLIC XMesaBuffer
XMesaCreateWindowBuffer(XMesaVisual v, Window w)
{
XWindowAttributes attr;
XMesaBuffer b;
Colormap cmap;
int depth;
assert(v);
assert(w);
XGetWindowAttributes( v->display, w, &attr );
depth = attr.depth;
if (v->visinfo->depth != depth) {
_mesa_warning(NULL, "XMesaCreateWindowBuffer: depth mismatch between visual (%d) and window (%d)!\n",
v->visinfo->depth, depth);
return NULL;
}
if (attr.colormap) {
cmap = attr.colormap;
}
else {
_mesa_warning(NULL, "Window %u has no colormap!\n", (unsigned int) w);
cmap = XCreateColormap(v->display, w, attr.visual, AllocNone);
}
b = create_xmesa_buffer((Drawable) w, WINDOW, v, cmap);
if (!b)
return NULL;
if (!initialize_visual_and_buffer( v, b, v->mesa_visual.rgbMode,
(Drawable) w, cmap )) {
xmesa_free_buffer(b);
return NULL;
}
return b;
}
PUBLIC XMesaBuffer
XMesaCreatePixmapBuffer(XMesaVisual v, Pixmap p, Colormap cmap)
{
XMesaBuffer b;
assert(v);
b = create_xmesa_buffer((Drawable) p, PIXMAP, v, cmap);
if (!b)
return NULL;
if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
(Drawable) p, cmap)) {
xmesa_free_buffer(b);
return NULL;
}
return b;
}
XMesaBuffer
XMesaCreatePixmapTextureBuffer(XMesaVisual v, Pixmap p,
Colormap cmap,
int format, int target, int mipmap)
{
GET_CURRENT_CONTEXT(ctx);
XMesaBuffer b;
GLuint width, height;
assert(v);
b = create_xmesa_buffer((Drawable) p, PIXMAP, v, cmap);
if (!b)
return NULL;
xmesa_get_window_size(v->display, b, &width, &height);
_mesa_resize_framebuffer(NULL, &(b->stfb->Base), width, height);
if (target == 0) {
if (ctx->Extensions.ARB_texture_non_power_of_two) {
target = GLX_TEXTURE_2D_EXT;
}
else if ( _mesa_bitcount(width) == 1
&& _mesa_bitcount(height) == 1) {
if (height == 1) {
target = GLX_TEXTURE_1D_EXT;
}
else {
target = GLX_TEXTURE_2D_EXT;
}
}
else if (ctx->Extensions.NV_texture_rectangle) {
target = GLX_TEXTURE_RECTANGLE_EXT;
}
else {
XMesaDestroyBuffer(b);
return 0;
}
}
b->TextureTarget = target;
b->TextureFormat = format;
b->TextureMipmap = mipmap;
if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
(Drawable) p, cmap)) {
xmesa_free_buffer(b);
return NULL;
}
return b;
}
XMesaBuffer
XMesaCreatePBuffer(XMesaVisual v, Colormap cmap,
unsigned int width, unsigned int height)
{
Window root;
Drawable drawable;
XMesaBuffer b;
root = RootWindow( v->display, v->visinfo->screen );
drawable = XCreatePixmap(v->display, root, width, height,
v->visinfo->depth);
if (!drawable)
return NULL;
b = create_xmesa_buffer(drawable, PBUFFER, v, cmap);
if (!b)
return NULL;
if (!initialize_visual_and_buffer(v, b, v->mesa_visual.rgbMode,
drawable, cmap)) {
xmesa_free_buffer(b);
return NULL;
}
return b;
}
PUBLIC void
XMesaDestroyBuffer(XMesaBuffer b)
{
xmesa_free_buffer(b);
}
void
xmesa_check_and_update_buffer_size(XMesaContext xmctx, XMesaBuffer drawBuffer)
{
GLuint width, height;
xmesa_get_window_size(drawBuffer->xm_visual->display, drawBuffer, &width, &height);
st_resize_framebuffer(drawBuffer->stfb, width, height);
}
PUBLIC
GLboolean XMesaMakeCurrent2( XMesaContext c, XMesaBuffer drawBuffer,
XMesaBuffer readBuffer )
{
XMesaContext old_ctx = XMesaGetCurrentContext();
if (old_ctx && old_ctx != c) {
XMesaFlush(old_ctx);
old_ctx->xm_buffer = NULL;
old_ctx->xm_read_buffer = NULL;
}
if (c) {
if (!drawBuffer || !readBuffer)
return GL_FALSE;
if (c == old_ctx &&
c->xm_buffer == drawBuffer &&
c->xm_read_buffer == readBuffer)
return GL_TRUE;
c->xm_buffer = drawBuffer;
c->xm_read_buffer = readBuffer;
st_make_current(c->st, drawBuffer->stfb, readBuffer->stfb);
xmesa_check_and_update_buffer_size(c, drawBuffer);
if (readBuffer != drawBuffer)
xmesa_check_and_update_buffer_size(c, readBuffer);
drawBuffer->wasCurrent = GL_TRUE;
}
else {
st_make_current( NULL, NULL, NULL );
}
return GL_TRUE;
}
GLboolean XMesaUnbindContext( XMesaContext c )
{
return GL_TRUE;
}
XMesaContext XMesaGetCurrentContext( void )
{
GET_CURRENT_CONTEXT(ctx);
if (ctx) {
XMesaContext xmesa = xmesa_context(ctx);
return xmesa;
}
else {
return 0;
}
}
PUBLIC
void XMesaSwapBuffers( XMesaBuffer b )
{
struct pipe_surface *frontLeftSurf;
st_swapbuffers(b->stfb, &frontLeftSurf, NULL);
if (frontLeftSurf) {
if (_screen != screen) {
struct trace_surface *tr_surf = trace_surface( frontLeftSurf );
struct pipe_surface *surf = tr_surf->surface;
frontLeftSurf = surf;
}
driver.display_surface(b, frontLeftSurf);
}
xmesa_check_and_update_buffer_size(NULL, b);
}
void XMesaCopySubBuffer( XMesaBuffer b, int x, int y, int width, int height )
{
struct pipe_surface *surf_front;
struct pipe_surface *surf_back;
struct pipe_context *pipe = NULL;
st_get_framebuffer_surface(b->stfb, ST_SURFACE_FRONT_LEFT, &surf_front);
st_get_framebuffer_surface(b->stfb, ST_SURFACE_BACK_LEFT, &surf_back);
if (!surf_front || !surf_back)
return;
assert(pipe);
pipe->surface_copy(pipe,
surf_front, x, y,
surf_back, x, y,
width, height);
}
void XMesaFlush( XMesaContext c )
{
if (c && c->xm_visual->display) {
st_finish(c->st);
XSync( c->xm_visual->display, False );
}
}
XMesaBuffer XMesaFindBuffer( Display *dpy, Drawable d )
{
XMesaBuffer b;
for (b = XMesaBufferList; b; b = b->Next) {
if (b->drawable == d && b->xm_visual->display == dpy) {
return b;
}
}
return NULL;
}
void xmesa_destroy_buffers_on_display(Display *dpy)
{
XMesaBuffer b, next;
for (b = XMesaBufferList; b; b = next) {
next = b->Next;
if (b->xm_visual->display == dpy) {
xmesa_free_buffer(b);
}
}
}
void XMesaGarbageCollect( void )
{
XMesaBuffer b, next;
for (b=XMesaBufferList; b; b=next) {
next = b->Next;
if (b->xm_visual &&
b->xm_visual->display &&
b->drawable &&
b->type == WINDOW) {
XSync(b->xm_visual->display, False);
if (!window_exists( b->xm_visual->display, b->drawable )) {
XMesaDestroyBuffer( b );
}
}
}
}
PUBLIC void
XMesaBindTexImage(Display *dpy, XMesaBuffer drawable, int buffer,
const int *attrib_list)
{
}
PUBLIC void
XMesaReleaseTexImage(Display *dpy, XMesaBuffer drawable, int buffer)
{
}