#include <regionstr.h>
#include <resource.h>
#include <GL/gl.h>
#include <GL/glxint.h>
#include <GL/glxtokens.h>
#include <scrnintstr.h>
#include <config.h>
#include <glxserver.h>
#include <glxscreens.h>
#include <glxdrawable.h>
#include <glxcontext.h>
#include <glxext.h>
#include <glxutil.h>
#include "xf86glxint.h"
#include "context.h"
#include "xmesaP.h"
#include <GL/xf86glx.h>
#include "context.h"
#if 0
#define DEBUG
#include <GL/internal/glcore.h>
#undef DEBUG
#else
#include <GL/internal/glcore.h>
#endif
__GLXscreenInfo __glDDXScreenInfo = {
__MESA_screenProbe,
__MESA_createContext,
__MESA_createBuffer,
NULL,
NULL,
0,
0,
"Vendor String",
"Version String",
"Extensions String",
NULL
};
__GLXextensionInfo __glDDXExtensionInfo = {
GL_CORE_MESA,
__MESA_resetExtension,
__MESA_initVisuals,
__MESA_setVisualConfigs
};
static __MESA_screen MESAScreens[MAXSCREENS];
static int numConfigs = 0;
static __GLXvisualConfig *visualConfigs = NULL;
static void **visualPrivates = NULL;
static int count_bits(unsigned int n)
{
int bits = 0;
while (n > 0) {
if (n & 1) bits++;
n >>= 1;
}
return bits;
}
static XMesaVisual find_mesa_visual(int screen, VisualID vid)
{
XMesaVisual xm_vis = NULL;
__MESA_screen *pMScr = &MESAScreens[screen];
int i;
for (i = 0; i < pMScr->num_vis; i++) {
if (pMScr->glx_vis[i].vid == vid) {
xm_vis = pMScr->xm_vis[i];
break;
}
}
return xm_vis;
}
#define NUM_FALLBACK_CONFIGS 5
static __GLXvisualConfig FallbackConfigs[NUM_FALLBACK_CONFIGS] = {
{
-1,
-1,
True,
-1, -1, -1, 0,
-1, -1, -1, 0,
0, 0, 0, 0,
True,
False,
-1,
16,
0,
0,
0,
GLX_NONE,
GLX_NONE,
0, 0, 0, 0,
0
},
{
-1,
-1,
True,
-1, -1, -1, 0,
-1, -1, -1, 0,
16, 16, 16, 0,
True,
False,
-1,
16,
8,
0,
0,
GLX_NONE,
GLX_NONE,
0, 0, 0, 0,
0
},
{
-1,
-1,
True,
-1, -1, -1, 8,
-1, -1, -1, -1,
16, 16, 16, 16,
True,
False,
-1,
16,
8,
0,
0,
GLX_NONE,
GLX_NONE,
0, 0, 0, 0,
0
},
{
-1,
-1,
True,
-1, -1, -1, 8,
-1, -1, -1, -1,
16, 16, 16, 16,
False,
False,
-1,
16,
8,
0,
0,
GLX_NONE,
GLX_NONE,
0, 0, 0, 0,
0
},
{
-1,
-1,
False,
-1, -1, -1, 0,
-1, -1, -1, 0,
0, 0, 0, 0,
True,
False,
-1,
16,
0,
0,
0,
GLX_NONE,
GLX_NONE,
0, 0, 0, 0,
0
},
};
static Bool init_visuals(int *nvisualp, VisualPtr *visualp,
VisualID *defaultVisp,
int ndepth, DepthPtr pdepth,
int rootDepth)
{
int numRGBconfigs;
int numCIconfigs;
int numVisuals = *nvisualp;
int numNewVisuals;
int numNewConfigs;
VisualPtr pVisual = *visualp;
VisualPtr pVisualNew = NULL;
VisualID *orig_vid = NULL;
__GLXvisualConfig *glXVisualPtr = NULL;
__GLXvisualConfig *pNewVisualConfigs = NULL;
void **glXVisualPriv;
void **pNewVisualPriv;
int found_default;
int i, j, k;
if (numConfigs > 0)
numNewConfigs = numConfigs;
else
numNewConfigs = NUM_FALLBACK_CONFIGS;
pNewVisualConfigs = (__GLXvisualConfig *)
__glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig));
if (!pNewVisualConfigs) {
return FALSE;
}
pNewVisualPriv = (void **) __glXMalloc(numNewConfigs * sizeof(void *));
if (!pNewVisualPriv) {
__glXFree(pNewVisualConfigs);
return FALSE;
}
if (numConfigs == 0) {
memcpy(pNewVisualConfigs, FallbackConfigs,
NUM_FALLBACK_CONFIGS * sizeof(__GLXvisualConfig));
memset(pNewVisualPriv, 0, NUM_FALLBACK_CONFIGS * sizeof(void *));
}
else {
for (i = 0; i < numConfigs; i++) {
pNewVisualConfigs[i] = visualConfigs[i];
pNewVisualPriv[i] = visualPrivates[i];
}
}
numRGBconfigs = 0;
numCIconfigs = 0;
for (i = 0; i < numNewConfigs; i++) {
if (pNewVisualConfigs[i].rgba)
numRGBconfigs++;
else
numCIconfigs++;
}
numNewVisuals = 0;
for (i = 0; i < numVisuals; i++) {
numNewVisuals +=
(pVisual[i].class == TrueColor || pVisual[i].class == DirectColor)
? numRGBconfigs : numCIconfigs;
}
visualConfigs = NULL;
numConfigs = 0;
orig_vid = (VisualID *)__glXMalloc(numNewVisuals * sizeof(VisualID));
if (!orig_vid) {
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
return FALSE;
}
glXVisualPtr = (__GLXvisualConfig *)__glXMalloc(numNewVisuals *
sizeof(__GLXvisualConfig));
if (!glXVisualPtr) {
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
return FALSE;
}
glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
if (!glXVisualPriv) {
__glXFree(glXVisualPtr);
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
return FALSE;
}
pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
if (!pVisualNew) {
__glXFree(glXVisualPriv);
__glXFree(glXVisualPtr);
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
return FALSE;
}
found_default = FALSE;
for (i = j = 0; i < numVisuals; i++) {
int is_rgb = (pVisual[i].class == TrueColor ||
pVisual[i].class == DirectColor);
for (k = 0; k < numNewConfigs; k++) {
if (pNewVisualConfigs[k].rgba != is_rgb)
continue;
pVisualNew[j] = pVisual[i];
pVisualNew[j].vid = FakeClientID(0);
if (!found_default && pVisual[i].vid == *defaultVisp) {
*defaultVisp = pVisualNew[j].vid;
found_default = TRUE;
}
orig_vid[j] = pVisual[i].vid;
glXVisualPtr[j] = pNewVisualConfigs[k];
glXVisualPtr[j].vid = pVisualNew[j].vid;
if (glXVisualPtr[j].class == -1) {
glXVisualPtr[j].class = pVisual[i].class;
glXVisualPtr[j].redSize = count_bits(pVisual[i].redMask);
glXVisualPtr[j].greenSize = count_bits(pVisual[i].greenMask);
glXVisualPtr[j].blueSize = count_bits(pVisual[i].blueMask);
glXVisualPtr[j].alphaSize = glXVisualPtr[j].alphaSize;
glXVisualPtr[j].redMask = pVisual[i].redMask;
glXVisualPtr[j].greenMask = pVisual[i].greenMask;
glXVisualPtr[j].blueMask = pVisual[i].blueMask;
glXVisualPtr[j].alphaMask = glXVisualPtr[j].alphaMask;
if (is_rgb) {
glXVisualPtr[j].bufferSize = glXVisualPtr[j].redSize +
glXVisualPtr[j].greenSize +
glXVisualPtr[j].blueSize +
glXVisualPtr[j].alphaSize;
} else {
glXVisualPtr[j].bufferSize = rootDepth;
}
}
glXVisualPriv[j] = pNewVisualPriv[k];
j++;
}
}
assert(j <= numNewVisuals);
MESAScreens[screenInfo.numScreens-1].num_vis = numNewVisuals;
MESAScreens[screenInfo.numScreens-1].glx_vis = glXVisualPtr;
MESAScreens[screenInfo.numScreens-1].private = glXVisualPriv;
for (i = 0; i < ndepth; i++) {
int numVids = 0;
VisualID *pVids = NULL;
int k, n = 0;
for (j = 0; j < pdepth[i].numVids; j++)
for (k = 0; k < numNewVisuals; k++)
if (pdepth[i].vids[j] == orig_vid[k])
numVids++;
pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
for (j = 0; j < pdepth[i].numVids; j++)
for (k = 0; k < numNewVisuals; k++)
if (pdepth[i].vids[j] == orig_vid[k])
pVids[n++] = pVisualNew[k].vid;
__glXFree(pdepth[i].vids);
pdepth[i].vids = pVids;
pdepth[i].numVids = numVids;
}
*nvisualp = numNewVisuals;
*visualp = pVisualNew;
__glXFree(pVisual);
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
if (visualPrivates)
xfree(visualPrivates);
visualPrivates = NULL;
return TRUE;
}
void __MESA_setVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
void **privates)
{
(void)kernel8;
(void)DitherValues;
numConfigs = nconfigs;
visualConfigs = configs;
visualPrivates = privates;
}
Bool __MESA_initVisuals(VisualPtr *visualp, DepthPtr *depthp,
int *nvisualp, int *ndepthp, int *rootDepthp,
VisualID *defaultVisp, unsigned long sizes,
int bitsPerRGB)
{
return init_visuals(nvisualp, visualp, defaultVisp,
*ndepthp, *depthp, *rootDepthp);
}
static void fixup_visuals(int screen)
{
ScreenPtr pScreen = screenInfo.screens[screen];
__MESA_screen *pMScr = &MESAScreens[screen];
__GLXvisualConfig *pGLXVis = pMScr->glx_vis;
VisualPtr pVis;
int i, j;
for (i = 0; i < pMScr->num_vis; i++, pGLXVis++) {
pVis = pScreen->visuals;
for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
if (pVis->class == pGLXVis->class &&
pVis->nplanes == (pGLXVis->bufferSize - pGLXVis->alphaSize)) {
pGLXVis->redMask = pVis->redMask;
pGLXVis->greenMask = pVis->greenMask;
pGLXVis->blueMask = pVis->blueMask;
pGLXVis->redSize = count_bits(pGLXVis->redMask);
pGLXVis->greenSize = count_bits(pGLXVis->greenMask);
pGLXVis->blueSize = count_bits(pGLXVis->blueMask);
}
}
}
}
static void init_screen_visuals(int screen)
{
ScreenPtr pScreen = screenInfo.screens[screen];
__GLXvisualConfig *pGLXVis = MESAScreens[screen].glx_vis;
XMesaVisual *pXMesaVisual;
VisualPtr pVis;
int *used;
int i, j;
pXMesaVisual = (XMesaVisual *)__glXMalloc(MESAScreens[screen].num_vis *
sizeof(XMesaVisual));
__glXMemset(pXMesaVisual, 0,
MESAScreens[screen].num_vis * sizeof(XMesaVisual));
used = (int *)__glXMalloc(pScreen->numVisuals * sizeof(int));
__glXMemset(used, 0, pScreen->numVisuals * sizeof(int));
for (i = 0; i < MESAScreens[screen].num_vis; i++, pGLXVis++) {
pVis = pScreen->visuals;
for (j = 0; j < pScreen->numVisuals; j++, pVis++) {
if (pVis->class == pGLXVis->class &&
pVis->nplanes == (pGLXVis->bufferSize - pGLXVis->alphaSize) &&
!used[j]) {
if (pVis->redMask == pGLXVis->redMask &&
pVis->greenMask == pGLXVis->greenMask &&
pVis->blueMask == pGLXVis->blueMask) {
pXMesaVisual[i] =
XMesaCreateVisual(pScreen,
pVis,
pGLXVis->rgba,
(pGLXVis->alphaSize > 0),
pGLXVis->doubleBuffer,
pGLXVis->stereo,
GL_TRUE,
pGLXVis->depthSize,
pGLXVis->stencilSize,
pGLXVis->accumRedSize,
pGLXVis->accumGreenSize,
pGLXVis->accumBlueSize,
pGLXVis->accumAlphaSize,
0,
pGLXVis->level,
pGLXVis->visualRating );
pGLXVis->vid = pVis->vid;
used[j] = 1;
break;
}
}
}
}
__glXFree(used);
MESAScreens[screen].xm_vis = pXMesaVisual;
}
Bool __MESA_screenProbe(int screen)
{
__glDDXScreenInfo.pGlxVisual = MESAScreens[screen].glx_vis;
__glDDXScreenInfo.pVisualPriv = MESAScreens[screen].private;
__glDDXScreenInfo.numVisuals =
__glDDXScreenInfo.numUsableVisuals = MESAScreens[screen].num_vis;
__glDDXScreenInfo.createContext = __MESA_createContext;
fixup_visuals(screen);
init_screen_visuals(screen);
return TRUE;
}
extern void __MESA_resetExtension(void)
{
int i, j;
XMesaReset();
for (i = 0; i < screenInfo.numScreens; i++) {
for (j = 0; j < MESAScreens[i].num_vis; j++) {
if (MESAScreens[i].xm_vis[j]) {
XMesaDestroyVisual(MESAScreens[i].xm_vis[j]);
MESAScreens[i].xm_vis[j] = NULL;
}
}
__glXFree(MESAScreens[i].glx_vis);
MESAScreens[i].glx_vis = NULL;
__glXFree(MESAScreens[i].private);
MESAScreens[i].private = NULL;
__glXFree(MESAScreens[i].xm_vis);
MESAScreens[i].xm_vis = NULL;
MESAScreens[i].num_vis = 0;
}
__glDDXScreenInfo.pGlxVisual = NULL;
}
void __MESA_createBuffer(__GLXdrawablePrivate *glxPriv)
{
DrawablePtr pDraw = glxPriv->pDraw;
XMesaVisual xm_vis = find_mesa_visual(pDraw->pScreen->myNum,
glxPriv->pGlxVisual->vid);
__GLdrawablePrivate *glPriv = &glxPriv->glPriv;
__MESA_buffer buf;
buf = (__MESA_buffer)__glXMalloc(sizeof(struct __MESA_bufferRec));
if (glxPriv->type == DRAWABLE_WINDOW) {
buf->xm_buf = (void *)XMesaCreateWindowBuffer(xm_vis,
(WindowPtr)pDraw);
} else {
buf->xm_buf = (void *)XMesaCreatePixmapBuffer(xm_vis,
(PixmapPtr)pDraw, 0);
}
buf->fbresize = glPriv->frontBuffer.resize;
glPriv->frontBuffer.resize = __MESA_resizeBuffers;
buf->fbswap = glxPriv->swapBuffers;
glxPriv->swapBuffers = __MESA_swapBuffers;
glPriv->private = (void *)buf;
glPriv->freePrivate = __MESA_destroyBuffer;
}
GLboolean __MESA_resizeBuffers(__GLdrawableBuffer *buffer,
GLint x, GLint y,
GLuint width, GLuint height,
__GLdrawablePrivate *glPriv,
GLuint bufferMask)
{
__MESA_buffer buf = (__MESA_buffer)glPriv->private;
if (buf->xm_buf)
XMesaResizeBuffers(buf->xm_buf);
return (*buf->fbresize)(buffer, x, y, width, height, glPriv, bufferMask);
}
GLboolean __MESA_swapBuffers(__GLXdrawablePrivate *glxPriv)
{
__MESA_buffer buf = (__MESA_buffer)glxPriv->glPriv.private;
XMesaSwapBuffers(buf->xm_buf);
return GL_TRUE;
}
void __MESA_destroyBuffer(__GLdrawablePrivate *glPriv)
{
__MESA_buffer buf = (__MESA_buffer)glPriv->private;
__GLXdrawablePrivate *glxPriv = (__GLXdrawablePrivate *)glPriv->other;
if (buf->xm_buf)
XMesaDestroyBuffer(buf->xm_buf);
glxPriv->swapBuffers = buf->fbswap;
glPriv->frontBuffer.resize = buf->fbresize;
__glXFree(glPriv->private);
glPriv->private = NULL;
}
__GLinterface *__MESA_createContext(__GLimports *imports,
__GLcontextModes *modes,
__GLinterface *shareGC)
{
__GLcontext *gl_ctx = NULL;
__GLcontext *m_share = NULL;
__GLXcontext *glxc = (__GLXcontext *)imports->other;
XMesaVisual xm_vis;
if (shareGC)
m_share = (__GLcontext *)shareGC;
xm_vis = find_mesa_visual(glxc->pScreen->myNum, glxc->pGlxVisual->vid);
if (xm_vis) {
XMesaContext xmshare = m_share ? m_share->DriverCtx : 0;
XMesaContext xmctx = XMesaCreateContext(xm_vis, xmshare);
gl_ctx = xmctx ? xmctx->gl_ctx : 0;
}
if (!gl_ctx)
return NULL;
gl_ctx->imports = *imports;
gl_ctx->exports.destroyContext = __MESA_destroyContext;
gl_ctx->exports.loseCurrent = __MESA_loseCurrent;
gl_ctx->exports.makeCurrent = __MESA_makeCurrent;
gl_ctx->exports.shareContext = __MESA_shareContext;
gl_ctx->exports.copyContext = __MESA_copyContext;
gl_ctx->exports.forceCurrent = __MESA_forceCurrent;
gl_ctx->exports.notifyResize = __MESA_notifyResize;
gl_ctx->exports.notifyDestroy = __MESA_notifyDestroy;
gl_ctx->exports.notifySwapBuffers = __MESA_notifySwapBuffers;
gl_ctx->exports.dispatchExec = __MESA_dispatchExec;
gl_ctx->exports.beginDispatchOverride = __MESA_beginDispatchOverride;
gl_ctx->exports.endDispatchOverride = __MESA_endDispatchOverride;
return (__GLinterface *)gl_ctx;
}
GLboolean __MESA_destroyContext(__GLcontext *gc)
{
XMesaContext xmesa = (XMesaContext) gc->DriverCtx;
XMesaDestroyContext( xmesa );
return GL_TRUE;
}
GLboolean __MESA_loseCurrent(__GLcontext *gc)
{
XMesaContext xmesa = (XMesaContext) gc->DriverCtx;
__glXLastContext = NULL;
return XMesaLoseCurrent(xmesa);
}
GLboolean __MESA_makeCurrent(__GLcontext *gc)
{
__GLdrawablePrivate *drawPriv = gc->imports.getDrawablePrivate( gc );
__MESA_buffer drawBuf = (__MESA_buffer)drawPriv->private;
__GLdrawablePrivate *readPriv = gc->imports.getReadablePrivate( gc );
__MESA_buffer readBuf = (__MESA_buffer)readPriv->private;
XMesaContext xmesa = (XMesaContext) gc->DriverCtx;
return XMesaMakeCurrent2(xmesa, drawBuf->xm_buf, readBuf->xm_buf);
}
GLboolean __MESA_shareContext(__GLcontext *gc, __GLcontext *gcShare)
{
ErrorF("__MESA_shareContext\n");
return GL_FALSE;
}
GLboolean __MESA_copyContext(__GLcontext *dst, const __GLcontext *src,
GLuint mask)
{
XMesaContext xm_dst = (XMesaContext) dst->DriverCtx;
const XMesaContext xm_src = (XMesaContext) src->DriverCtx;
_mesa_copy_context(xm_src->gl_ctx, xm_dst->gl_ctx, mask);
return GL_TRUE;
}
GLboolean __MESA_forceCurrent(__GLcontext *gc)
{
XMesaContext xmesa = (XMesaContext) gc->DriverCtx;
return XMesaForceCurrent(xmesa);
}
GLboolean __MESA_notifyResize(__GLcontext *gc)
{
ErrorF("__MESA_notifyResize\n");
return GL_FALSE;
}
void __MESA_notifyDestroy(__GLcontext *gc)
{
ErrorF("__MESA_notifyDestroy\n");
return;
}
void __MESA_notifySwapBuffers(__GLcontext *gc)
{
_mesa_notifySwapBuffers(gc);
}
struct __GLdispatchStateRec *__MESA_dispatchExec(__GLcontext *gc)
{
ErrorF("__MESA_dispatchExec\n");
return NULL;
}
void __MESA_beginDispatchOverride(__GLcontext *gc)
{
ErrorF("__MESA_beginDispatchOverride\n");
return;
}
void __MESA_endDispatchOverride(__GLcontext *gc)
{
ErrorF("__MESA_endDispatchOverride\n");
return;
}
GLint __glEvalComputeK(GLenum target)
{
switch (target) {
case GL_MAP1_VERTEX_4:
case GL_MAP1_COLOR_4:
case GL_MAP1_TEXTURE_COORD_4:
case GL_MAP2_VERTEX_4:
case GL_MAP2_COLOR_4:
case GL_MAP2_TEXTURE_COORD_4:
return 4;
case GL_MAP1_VERTEX_3:
case GL_MAP1_TEXTURE_COORD_3:
case GL_MAP1_NORMAL:
case GL_MAP2_VERTEX_3:
case GL_MAP2_TEXTURE_COORD_3:
case GL_MAP2_NORMAL:
return 3;
case GL_MAP1_TEXTURE_COORD_2:
case GL_MAP2_TEXTURE_COORD_2:
return 2;
case GL_MAP1_TEXTURE_COORD_1:
case GL_MAP2_TEXTURE_COORD_1:
case GL_MAP1_INDEX:
case GL_MAP2_INDEX:
return 1;
default:
return 0;
}
}
GLuint __glFloorLog2(GLuint val)
{
int c = 0;
while (val > 1) {
c++;
val >>= 1;
}
return c;
}