andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

dmx: Delete unused GLX visual matching code.

Browse Source 
Kristian deleted this API from the rest of the server in 2007, in commit
7d74690536.

Signed-off-by: Jamey Sharp <jamey@minilop.net>
Reviewed-by: Kristian Høgsberg <krh@bitplanet.net>
This commit is contained in:
Jamey Sharp 2010-05-25 13:10:05 -07:00
parent 0a3e6b0345
commit a715de7f11
5 changed files with 1 additions and 458 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
hw/dmx/dmxinit.c
View File

@ -69,12 +69,6 @@
#include "dmx_glxvisuals.h"
#include <X11/extensions/Xext.h>
#include <X11/extensions/extutil.h>
extern void GlxSetVisualConfigs(
int nconfigs,
__GLXvisualConfig *configs,
void **configprivs
);
#endif /* GLXEXT */
/* Global variables available to all Xserver/hw/dmx routines. */
@ -768,9 +762,6 @@ void InitOutput(ScreenInfo *pScreenInfo, int argc, char *argv[])
}
}
/* Hand out the glx configs to glx extension */
GlxSetVisualConfigs(nconfigs, configs, (void**)configprivs);
XFlush(dmxScreen->beDisplay);
}
}

40
hw/dmx/glxProxy/glxext.c
View File

@ -367,46 +367,6 @@ Bool __glXCoreType(void)
/************************************************************************/
void GlxSetVisualConfigs(int nconfigs,
__GLXvisualConfig *configs, void **privates)
{
glxSetVisualConfigs(nconfigs, configs, privates);
}
static miInitVisualsProcPtr saveInitVisualsProc;
Bool GlxInitVisuals(VisualPtr *visualp, DepthPtr *depthp,
int *nvisualp, int *ndepthp,
int *rootDepthp, VisualID *defaultVisp,
unsigned long sizes, int bitsPerRGB,
int preferredVis)
{
Bool ret;
if (saveInitVisualsProc) {
ret = saveInitVisualsProc(visualp, depthp, nvisualp, ndepthp,
rootDepthp, defaultVisp, sizes, bitsPerRGB,
preferredVis);
if (!ret)
return False;
}
glxInitVisuals(nvisualp, visualp, defaultVisp, *ndepthp, *depthp,*rootDepthp);
return True;
}
void
GlxWrapInitVisuals(miInitVisualsProcPtr *initVisProc)
{
if (dmxGLXProxy) {
saveInitVisualsProc = *initVisProc;
*initVisProc = GlxInitVisuals;
}
}
/************************************************************************/
void __glXFlushContextCache(void)
{
__glXLastContext = 0;

14
hw/dmx/glxProxy/glxext.h
View File

@ -74,19 +74,5 @@ extern void GlxExtensionInit(void);
extern Bool __glXCoreType(void);
extern int GlxInitVisuals(
#if NeedFunctionPrototypes
VisualPtr * visualp,
DepthPtr * depthp,
int * nvisualp,
int * ndepthp,
int * rootDepthp,
VisualID * defaultVisp,
unsigned long sizes,
int bitsPerRGB,
int preferredVis
#endif
);
#endif /* _glxext_h_ */

388
hw/dmx/glxProxy/glxvisuals.c
View File

@ -32,16 +32,8 @@
#include <dmx-config.h>
#endif
#include <assert.h>
#include "dmx.h"
#include "glxserver.h"
#include "glxutil.h"
#include "dmx_glxvisuals.h"
#include <stdlib.h>
static int numConfigs = 0;
static __GLXvisualConfig *visualConfigs = NULL;
static void **visualPrivates = NULL;
#include "glxvisuals.h"
int glxVisualsMatch( __GLXvisualConfig *v1, __GLXvisualConfig *v2 )
{
@ -158,381 +150,3 @@ VisualPtr glxMatchVisual( ScreenPtr pScreen, VisualPtr pVisual, ScreenPtr pMatch
return 0;
}
void glxSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
void **privates)
{
numConfigs = nconfigs;
visualConfigs = configs;
visualPrivates = privates;
}
static int count_bits(unsigned int n)
{
int bits = 0;
while (n > 0) {
if (n & 1) bits++;
n >>= 1;
}
return bits;
}
static VisualID FindClosestVisual( VisualPtr pVisual, int rootDepth,
DepthPtr pdepth, int ndepths,
VisualPtr pNewVisual, int numNewVisuals)
{
int d, v;
VisualPtr vis;
/*
* find the first visual with the same or deeper depth
* of the same class.
*/
for (d=0; d<ndepths; d++) {
if (pdepth[d].depth >= rootDepth) {
for (v=0; v<pdepth[d].numVids; v++) {
/* find the new visual structure */
vis = pNewVisual;
while( pdepth[d].vids[v] != vis->vid ) vis++;
if (vis->class == pVisual->class) {
return pdepth[d].vids[v];
}
}
}
}
/*
* did not find any.
* try to look for the same class only.
*/
for (d=0; d<ndepths; d++) {
for (v=0; v<pdepth[d].numVids; v++) {
/* find the new visual structure */
vis = pNewVisual;
while( pdepth[d].vids[v] != vis->vid ) vis++;
if (vis->class == pVisual->class) {
return pdepth[d].vids[v];
}
}
}
/*
* if not found - just take the first visual
*/
return pdepth[0].vids[0];
}
Bool glxInitVisuals(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;
dmxGlxVisualPrivate **pNewVisualPriv;
int found_default;
int i, j, k;
int numGLXvis = 0;
GLint *isGLXvis;
if (numConfigs > 0)
numNewConfigs = numConfigs;
else
return False;
MAXSCREENSALLOC(__glXActiveScreens);
if (!__glXActiveScreens)
return False;
/* Alloc space for the list of new GLX visuals */
pNewVisualConfigs = (__GLXvisualConfig *)
__glXMalloc(numNewConfigs * sizeof(__GLXvisualConfig));
if (!pNewVisualConfigs) {
return FALSE;
}
/* Alloc space for the list of new GLX visual privates */
pNewVisualPriv = (dmxGlxVisualPrivate **) __glXMalloc(numNewConfigs * sizeof(dmxGlxVisualPrivate *));
if (!pNewVisualPriv) {
__glXFree(pNewVisualConfigs);
return FALSE;
}
/* copy driver's visual config info */
for (i = 0; i < numConfigs; i++) {
pNewVisualConfigs[i] = visualConfigs[i];
pNewVisualPriv[i] = (dmxGlxVisualPrivate *)visualPrivates[i];
}
#if 1
/* FIXME: This is a hack to workaround a hang in xtest caused by a
* mismatch between what the front end (i.e., DMX) server calculates
* for the visual configs and what the back-end servers have.
*/
{
int numTCRGBconfigs = 0;
int numDCRGBconfigs = 0;
numRGBconfigs = 0;
numCIconfigs = 0;
for (i = 0; i < numNewConfigs; i++) {
if (pNewVisualConfigs[i].rgba) {
if (pNewVisualConfigs[i].class == TrueColor)
numTCRGBconfigs++;
else
numDCRGBconfigs++;
numRGBconfigs++;
} else
numCIconfigs++;
}
/* Count the total number of visuals to compute */
numNewVisuals = 0;
for (i = 0; i < numVisuals; i++) {
numNewVisuals +=
(pVisual[i].class == TrueColor) ? numTCRGBconfigs :
(pVisual[i].class == DirectColor) ? numDCRGBconfigs :
numCIconfigs;
}
}
#else
/* Count the number of RGB and CI visual configs */
numRGBconfigs = 0;
numCIconfigs = 0;
for (i = 0; i < numNewConfigs; i++) {
if (pNewVisualConfigs[i].rgba)
numRGBconfigs++;
else
numCIconfigs++;
}
/* Count the total number of visuals to compute */
numNewVisuals = 0;
for (i = 0; i < numVisuals; i++) {
numNewVisuals +=
(pVisual[i].class == TrueColor || pVisual[i].class == DirectColor)
? numRGBconfigs : numCIconfigs;
}
#endif
/* Reset variables for use with the next screen/driver's visual configs */
visualConfigs = NULL;
numConfigs = 0;
/* Alloc temp space for the list of orig VisualIDs for each new visual */
orig_vid = (VisualID *)__glXMalloc(numNewVisuals * sizeof(VisualID));
if (!orig_vid) {
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
return FALSE;
}
/* Alloc space for the list of glXVisuals */
glXVisualPtr = (__GLXvisualConfig *)__glXMalloc(numNewVisuals *
sizeof(__GLXvisualConfig));
if (!glXVisualPtr) {
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
return FALSE;
}
/* Alloc space for the list of glXVisualPrivates */
glXVisualPriv = (void **)__glXMalloc(numNewVisuals * sizeof(void *));
if (!glXVisualPriv) {
__glXFree(glXVisualPtr);
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
return FALSE;
}
/* Alloc space for the new list of the X server's visuals */
pVisualNew = (VisualPtr)__glXMalloc(numNewVisuals * sizeof(VisualRec));
if (!pVisualNew) {
__glXFree(glXVisualPriv);
__glXFree(glXVisualPtr);
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
return FALSE;
}
isGLXvis = (GLint *) __glXMalloc(numNewVisuals * sizeof(GLint));
if (!isGLXvis) {
__glXFree(glXVisualPriv);
__glXFree(glXVisualPtr);
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
__glXFree(pVisualNew);
return FALSE;
}
/* Initialize the new visuals */
found_default = FALSE;
for (i = j = 0; i < numVisuals; i++) {
for (k = 0; k < numNewConfigs; k++) {
int new_depth;
int depth;
int d,v;
/* find the depth of the new visual config */
new_depth = pNewVisualPriv[k]->x_visual_depth;
/* find the depth of the original visual */
depth = 0;
d = 0;
while( (depth==0) && (d < ndepth) ) {
v = 0;
while( (depth==0) && (v < pdepth[d].numVids) ) {
if (pdepth[d].vids[v] == pVisual[i].vid) {
depth = pdepth[d].depth;
}
v++;
}
d++;
}
/* check that the visual has the same class and depth
* as the new config
*/
if ( pVisual[i].class != pNewVisualPriv[k]->x_visual_class ||
(depth != new_depth) )
continue;
/* Initialize the new visual */
pVisualNew[j] = pVisual[i];
pVisualNew[j].vid = FakeClientID(0);
/* Check for the default visual */
if (!found_default && pVisual[i].vid == *defaultVisp) {
*defaultVisp = pVisualNew[j].vid;
found_default = TRUE;
}
/* Save the old VisualID */
orig_vid[j] = pVisual[i].vid;
/* Initialize the glXVisual */
glXVisualPtr[j] = pNewVisualConfigs[k];
glXVisualPtr[j].vid = pVisualNew[j].vid;
/*
* If the class is -1, then assume the X visual information
* is identical to what GLX needs, and take them from the X
* visual. NOTE: if class != -1, then all other fields MUST
* be initialized.
*/
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;
glXVisualPtr[j].bufferSize = rootDepth;
}
/* Save the device-dependent private for this visual */
glXVisualPriv[j] = pNewVisualPriv[k];
isGLXvis[j] = glxMatchGLXVisualInConfigList( &glXVisualPtr[j],
dmxScreens[screenInfo.numScreens-1].glxVisuals,
dmxScreens[screenInfo.numScreens-1].numGlxVisuals );
if (isGLXvis[j]) numGLXvis++;
j++;
}
}
assert(j <= numNewVisuals);
numNewVisuals = j; /* correct number of new visuals */
/* Save the GLX visuals in the screen structure */
__glXActiveScreens[screenInfo.numScreens-1].numVisuals = numNewVisuals;
__glXActiveScreens[screenInfo.numScreens-1].numGLXVisuals = numGLXvis;
__glXActiveScreens[screenInfo.numScreens-1].isGLXvis = isGLXvis;
__glXActiveScreens[screenInfo.numScreens-1].pGlxVisual = glXVisualPtr;
/* Set up depth's VisualIDs */
for (i = 0; i < ndepth; i++) {
int numVids = 0;
VisualID *pVids = NULL;
int k, n = 0;
/* Count the new number of VisualIDs at this depth */
for (j = 0; j < pdepth[i].numVids; j++)
for (k = 0; k < numNewVisuals; k++)
if (pdepth[i].vids[j] == orig_vid[k])
numVids++;
/* Allocate a new list of VisualIDs for this depth */
pVids = (VisualID *)__glXMalloc(numVids * sizeof(VisualID));
/* Initialize the new list of VisualIDs for this depth */
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;
/* Update this depth's list of VisualIDs */
__glXFree(pdepth[i].vids);
pdepth[i].vids = pVids;
pdepth[i].numVids = numVids;
}
/*
* if the default visual was rejected - need to choose new
* default visual !
*/
if ( !found_default ) {
for (i=0; i<numVisuals; i++)
if (pVisual[i].vid == *defaultVisp)
break;
if (i < numVisuals) {
*defaultVisp = FindClosestVisual( &pVisual[i], rootDepth, pdepth, ndepth, pVisualNew, numNewVisuals );
}
}
/* Update the X server's visuals */
*nvisualp = numNewVisuals;
*visualp = pVisualNew;
/* Free the old list of the X server's visuals */
__glXFree(pVisual);
/* Clean up temporary allocations */
__glXFree(orig_vid);
__glXFree(pNewVisualPriv);
__glXFree(pNewVisualConfigs);
/* Free the private list created by DDX HW driver */
free(visualPrivates);
visualPrivates = NULL;
return TRUE;
}

8
hw/dmx/glxProxy/glxvisuals.h
View File

@ -39,12 +39,4 @@ VisualID glxMatchVisualInConfigList( ScreenPtr pScreen, VisualPtr pVisual, __GLX
VisualPtr glxMatchVisual( ScreenPtr pScreen, VisualPtr pVisual, ScreenPtr pMatchScreen );
void glxSetVisualConfigs(int nconfigs, __GLXvisualConfig *configs,
void **privates);
Bool glxInitVisuals(int *nvisualp, VisualPtr *visualp,
VisualID *defaultVisp,
int ndepth, DepthPtr pdepth,
int rootDepth);
#endif