Merge branch 'master' into mpx
Conflicts: Xext/EVI.c Xext/appgroup.c Xext/cup.c Xext/mitmisc.c Xext/sampleEVI.c dix/window.c
This commit is contained in:
commit
8190ef8754
3
.gitignore
vendored
3
.gitignore
vendored
|
@ -24,6 +24,7 @@ config.sub
|
|||
configure
|
||||
configure.lineno
|
||||
depcomp
|
||||
doltcompile
|
||||
install-sh
|
||||
libtool
|
||||
ltmain.sh
|
||||
|
@ -277,6 +278,8 @@ hw/xprint/doc/Xprt.1x
|
|||
hw/xprint/doc/Xprt.man
|
||||
hw/xprint/dpmsstubs-wrapper.c
|
||||
hw/xprint/miinitext-wrapper.c
|
||||
hw/xquartz/xpr/Xquartz
|
||||
hw/xquartz/xpr/Xquartz.1
|
||||
include/dix-config.h
|
||||
include/kdrive-config.h
|
||||
include/xgl-config.h
|
||||
|
|
|
@ -317,9 +317,10 @@ createFBConfigsForVisual(__GLXscreen *screen, ScreenPtr pScreen,
|
|||
for (back = numBack - 1; back >= 0; back--)
|
||||
for (depth = 0; depth < numDepth; depth++)
|
||||
for (stencil = 0; stencil < numStencil; stencil++) {
|
||||
config->next = xalloc(sizeof *config);
|
||||
config->next = xcalloc(sizeof(*config), 1);
|
||||
config = config->next;
|
||||
|
||||
config->visualRating = GLX_NONE;
|
||||
config->visualType = glx_visual_types[visual->class];
|
||||
config->xRenderable = GL_TRUE;
|
||||
config->drawableType = GLX_WINDOW_BIT | GLX_PIXMAP_BIT;
|
||||
|
@ -431,6 +432,7 @@ __glXMesaScreenProbe(ScreenPtr pScreen)
|
|||
screen->base.destroy = __glXMesaScreenDestroy;
|
||||
screen->base.createContext = __glXMesaScreenCreateContext;
|
||||
screen->base.createDrawable = __glXMesaScreenCreateDrawable;
|
||||
screen->base.swapInterval = NULL;
|
||||
screen->base.pScreen = pScreen;
|
||||
|
||||
return &screen->base;
|
||||
|
|
|
@ -488,7 +488,7 @@ addMinimalSet(__GLXscreen *pGlxScreen)
|
|||
continue;
|
||||
|
||||
pGlxScreen->visuals[j] = config;
|
||||
config->visualID = visuals[j].vid;
|
||||
config->visualID = visuals[i].vid;
|
||||
j++;
|
||||
}
|
||||
|
||||
|
|
|
@ -9,11 +9,6 @@ if XTRAP
|
|||
XTRAP_DIR=XTrap
|
||||
endif
|
||||
|
||||
if CFB
|
||||
CFB_DIR=cfb
|
||||
CFB32_DIR=cfb32
|
||||
endif
|
||||
|
||||
if AFB
|
||||
AFB_DIR=afb
|
||||
endif
|
||||
|
@ -50,8 +45,6 @@ SUBDIRS = \
|
|||
$(DBE_DIR) \
|
||||
$(MFB_DIR) \
|
||||
$(AFB_DIR) \
|
||||
$(CFB_DIR) \
|
||||
$(CFB32_DIR) \
|
||||
$(RECORD_DIR) \
|
||||
xfixes \
|
||||
damageext \
|
||||
|
@ -96,8 +89,6 @@ DIST_SUBDIRS = \
|
|||
dbe \
|
||||
mfb \
|
||||
afb \
|
||||
cfb \
|
||||
cfb32 \
|
||||
record \
|
||||
xfixes \
|
||||
damageext \
|
||||
|
|
200
Xext/EVI.c
200
Xext/EVI.c
|
@ -1,200 +0,0 @@
|
|||
/************************************************************
|
||||
Copyright (c) 1997 by Silicon Graphics Computer Systems, Inc.
|
||||
Permission to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose and without
|
||||
fee is hereby granted, provided that the above copyright
|
||||
notice appear in all copies and that both that copyright
|
||||
notice and this permission notice appear in supporting
|
||||
documentation, and that the name of Silicon Graphics not be
|
||||
used in advertising or publicity pertaining to distribution
|
||||
of the software without specific prior written permission.
|
||||
Silicon Graphics makes no representation about the suitability
|
||||
of this software for any purpose. It is provided "as is"
|
||||
without any express or implied warranty.
|
||||
SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
|
||||
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
|
||||
GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
|
||||
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
||||
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
********************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "dixstruct.h"
|
||||
#include "extnsionst.h"
|
||||
#include "dix.h"
|
||||
#define _XEVI_SERVER_
|
||||
#include <X11/extensions/XEVIstr.h>
|
||||
#include "EVIstruct.h"
|
||||
#include "modinit.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
static EviPrivPtr eviPriv;
|
||||
|
||||
static int
|
||||
ProcEVIQueryVersion(ClientPtr client)
|
||||
{
|
||||
/* REQUEST(xEVIQueryVersionReq); */
|
||||
xEVIQueryVersionReply rep;
|
||||
int n;
|
||||
REQUEST_SIZE_MATCH (xEVIQueryVersionReq);
|
||||
rep.type = X_Reply;
|
||||
rep.length = 0;
|
||||
rep.sequenceNumber = client->sequence;
|
||||
rep.majorVersion = XEVI_MAJOR_VERSION;
|
||||
rep.minorVersion = XEVI_MAJOR_VERSION;
|
||||
if (client->swapped) {
|
||||
swaps(&rep.sequenceNumber, n);
|
||||
swapl(&rep.length, n);
|
||||
swaps(&rep.majorVersion, n);
|
||||
swaps(&rep.minorVersion, n);
|
||||
}
|
||||
WriteToClient(client, sizeof (xEVIQueryVersionReply), (char *)&rep);
|
||||
return (client->noClientException);
|
||||
}
|
||||
#define swapEviInfo(eviInfo, l) \
|
||||
{ \
|
||||
int l1 = l; \
|
||||
xExtendedVisualInfo *eviInfo1 = eviInfo; \
|
||||
while (l1-- > 0) { \
|
||||
swapl(&eviInfo1->core_visual_id, n); \
|
||||
swapl(&eviInfo1->transparency_value, n); \
|
||||
swaps(&eviInfo1->num_colormap_conflicts, n); \
|
||||
eviInfo1++; \
|
||||
} \
|
||||
}
|
||||
#define swapVisual(visual, l) \
|
||||
{ \
|
||||
int l1 = l; \
|
||||
VisualID32 *visual1 = visual; \
|
||||
while (l1-- > 0) { \
|
||||
swapl(visual1, n); \
|
||||
visual1++; \
|
||||
} \
|
||||
}
|
||||
|
||||
static int
|
||||
ProcEVIGetVisualInfo(ClientPtr client)
|
||||
{
|
||||
REQUEST(xEVIGetVisualInfoReq);
|
||||
xEVIGetVisualInfoReply rep;
|
||||
int i, n, n_conflict, n_info, sz_info, sz_conflict;
|
||||
VisualID32 *conflict;
|
||||
unsigned int total_visuals = 0;
|
||||
xExtendedVisualInfo *eviInfo;
|
||||
int status;
|
||||
|
||||
/*
|
||||
* do this first, otherwise REQUEST_FIXED_SIZE can overflow. we assume
|
||||
* here that you don't have more than 2^32 visuals over all your screens;
|
||||
* this seems like a safe assumption.
|
||||
*/
|
||||
for (i = 0; i < screenInfo.numScreens; i++)
|
||||
total_visuals += screenInfo.screens[i]->numVisuals;
|
||||
if (stuff->n_visual > total_visuals)
|
||||
return BadValue;
|
||||
|
||||
REQUEST_FIXED_SIZE(xEVIGetVisualInfoReq, stuff->n_visual * sz_VisualID32);
|
||||
status = eviPriv->getVisualInfo((VisualID32 *)&stuff[1], (int)stuff->n_visual,
|
||||
&eviInfo, &n_info, &conflict, &n_conflict);
|
||||
if (status != Success)
|
||||
return status;
|
||||
sz_info = n_info * sz_xExtendedVisualInfo;
|
||||
sz_conflict = n_conflict * sz_VisualID32;
|
||||
rep.type = X_Reply;
|
||||
rep.n_info = n_info;
|
||||
rep.n_conflicts = n_conflict;
|
||||
rep.sequenceNumber = client->sequence;
|
||||
rep.length = (sz_info + sz_conflict) >> 2;
|
||||
if (client->swapped) {
|
||||
swaps(&rep.sequenceNumber, n);
|
||||
swapl(&rep.length, n);
|
||||
swapl(&rep.n_info, n);
|
||||
swapl(&rep.n_conflicts, n);
|
||||
swapEviInfo(eviInfo, n_info);
|
||||
swapVisual(conflict, n_conflict);
|
||||
}
|
||||
WriteToClient(client, sz_xEVIGetVisualInfoReply, (char *)&rep);
|
||||
WriteToClient(client, sz_info, (char *)eviInfo);
|
||||
WriteToClient(client, sz_conflict, (char *)conflict);
|
||||
eviPriv->freeVisualInfo(eviInfo, conflict);
|
||||
return (client->noClientException);
|
||||
}
|
||||
|
||||
static int
|
||||
ProcEVIDispatch(ClientPtr client)
|
||||
{
|
||||
REQUEST(xReq);
|
||||
switch (stuff->data) {
|
||||
case X_EVIQueryVersion:
|
||||
return ProcEVIQueryVersion (client);
|
||||
case X_EVIGetVisualInfo:
|
||||
return ProcEVIGetVisualInfo (client);
|
||||
default:
|
||||
return BadRequest;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
SProcEVIQueryVersion(ClientPtr client)
|
||||
{
|
||||
REQUEST(xEVIQueryVersionReq);
|
||||
int n;
|
||||
swaps(&stuff->length, n);
|
||||
return ProcEVIQueryVersion(client);
|
||||
}
|
||||
|
||||
static int
|
||||
SProcEVIGetVisualInfo(ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
REQUEST(xEVIGetVisualInfoReq);
|
||||
swaps(&stuff->length, n);
|
||||
return ProcEVIGetVisualInfo(client);
|
||||
}
|
||||
|
||||
static int
|
||||
SProcEVIDispatch(ClientPtr client)
|
||||
{
|
||||
REQUEST(xReq);
|
||||
switch (stuff->data)
|
||||
{
|
||||
case X_EVIQueryVersion:
|
||||
return SProcEVIQueryVersion (client);
|
||||
case X_EVIGetVisualInfo:
|
||||
return SProcEVIGetVisualInfo (client);
|
||||
default:
|
||||
return BadRequest;
|
||||
}
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
static void
|
||||
EVIResetProc(ExtensionEntry *extEntry)
|
||||
{
|
||||
eviDDXReset();
|
||||
}
|
||||
|
||||
/****************
|
||||
* XEVIExtensionInit
|
||||
*
|
||||
* Called from InitExtensions in main() or from QueryExtension() if the
|
||||
* extension is dynamically loaded.
|
||||
*
|
||||
****************/
|
||||
void
|
||||
EVIExtensionInit(INITARGS)
|
||||
{
|
||||
if (AddExtension(EVINAME, 0, 0,
|
||||
ProcEVIDispatch, SProcEVIDispatch,
|
||||
EVIResetProc, StandardMinorOpcode)) {
|
||||
eviPriv = eviDDXInit();
|
||||
}
|
||||
}
|
|
@ -29,7 +29,6 @@ BUILTIN_SRCS = \
|
|||
# Sources always included in libXextmodule.la & libXext.la
|
||||
MODULE_SRCS = \
|
||||
bigreq.c \
|
||||
mitmisc.c \
|
||||
shape.c \
|
||||
sync.c \
|
||||
xcmisc.c
|
||||
|
@ -106,25 +105,6 @@ if XPRINT
|
|||
BUILTIN_SRCS += $(XPRINT_SRCS)
|
||||
endif
|
||||
|
||||
# AppGroup
|
||||
APPGROUP_SRCS = appgroup.c appgroup.h
|
||||
if APPGROUP
|
||||
BUILTIN_SRCS += $(APPGROUP_SRCS)
|
||||
endif
|
||||
|
||||
# Colormap Utilization Protocol: Less flashing when switching between
|
||||
# PsuedoColor apps and better sharing of limited colormap slots
|
||||
CUP_SRCS = cup.c
|
||||
if CUP
|
||||
MODULE_SRCS += $(CUP_SRCS)
|
||||
endif
|
||||
|
||||
# Extended Visual Information
|
||||
EVI_SRCS = EVI.c sampleEVI.c EVIstruct.h
|
||||
if EVI
|
||||
MODULE_SRCS += $(EVI_SRCS)
|
||||
endif
|
||||
|
||||
# Multi-buffering extension
|
||||
MULTIBUFFER_SRCS = mbuf.c
|
||||
EXTRA_MULTIBUFFER_SRCS = mbufbf.c mbufpx.c
|
||||
|
@ -171,9 +151,6 @@ EXTRA_DIST = \
|
|||
$(XINERAMA_SRCS) \
|
||||
$(XEVIE_SRCS) \
|
||||
$(XPRINT_SRCS) \
|
||||
$(APPGROUP_SRCS) \
|
||||
$(CUP_SRCS) \
|
||||
$(EVI_SRCS) \
|
||||
$(MULTIBUFFER_SRCS) \
|
||||
$(EXTRA_MULTIBUFFER_SRCS) \
|
||||
$(FONTCACHE_SRCS) \
|
||||
|
|
775
Xext/appgroup.c
775
Xext/appgroup.c
|
@ -1,775 +0,0 @@
|
|||
/*
|
||||
Copyright 1996, 1998, 2001 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall
|
||||
not be used in advertising or otherwise to promote the sale, use or
|
||||
other dealings in this Software without prior written authorization
|
||||
from The Open Group.
|
||||
*/
|
||||
|
||||
#define NEED_REPLIES
|
||||
#define NEED_EVENTS
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "misc.h"
|
||||
#include "dixstruct.h"
|
||||
#include "extnsionst.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
#include "colormapst.h"
|
||||
#include "servermd.h"
|
||||
#define _XAG_SERVER_
|
||||
#include <X11/extensions/Xagstr.h>
|
||||
#include "xacestr.h"
|
||||
#include "securitysrv.h"
|
||||
#include <X11/Xfuncproto.h>
|
||||
|
||||
#define XSERV_t
|
||||
#include <X11/Xtrans/Xtrans.h>
|
||||
#include "../os/osdep.h"
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#include "modinit.h"
|
||||
#include "appgroup.h"
|
||||
|
||||
typedef struct _AppGroupRec {
|
||||
struct _AppGroupRec* next;
|
||||
XID appgroupId;
|
||||
ClientPtr* clients;
|
||||
int nclients;
|
||||
ClientPtr leader;
|
||||
Bool single_screen;
|
||||
Window default_root;
|
||||
VisualID root_visual;
|
||||
Colormap default_colormap;
|
||||
Pixel black_pixel;
|
||||
Pixel white_pixel;
|
||||
xConnSetupPrefix connSetupPrefix;
|
||||
char* ConnectionInfo;
|
||||
} AppGroupRec, *AppGroupPtr;
|
||||
|
||||
static int ProcXagDispatch(ClientPtr client);
|
||||
static int SProcXagDispatch(ClientPtr client);
|
||||
static void XagResetProc(ExtensionEntry* extEntry);
|
||||
|
||||
static int XagCallbackRefCount = 0;
|
||||
|
||||
static RESTYPE RT_APPGROUP;
|
||||
static AppGroupPtr appGrpList = NULL;
|
||||
|
||||
extern xConnSetupPrefix connSetupPrefix;
|
||||
extern char* ConnectionInfo;
|
||||
extern int connBlockScreenStart;
|
||||
|
||||
static
|
||||
int XagAppGroupFree(
|
||||
pointer what,
|
||||
XID id) /* unused */
|
||||
{
|
||||
int i;
|
||||
AppGroupPtr pAppGrp = (AppGroupPtr) what;
|
||||
|
||||
if (pAppGrp->leader)
|
||||
for (i = 0; i < pAppGrp->nclients; i++) {
|
||||
if (pAppGrp->clients[i] == NULL) continue;
|
||||
CloseDownClient (pAppGrp->clients[i]);
|
||||
}
|
||||
|
||||
if (pAppGrp == appGrpList)
|
||||
appGrpList = appGrpList->next;
|
||||
else {
|
||||
AppGroupPtr tpAppGrp;
|
||||
for (tpAppGrp = appGrpList;
|
||||
tpAppGrp->next != NULL;
|
||||
tpAppGrp = tpAppGrp->next) {
|
||||
if (tpAppGrp->next == pAppGrp) {
|
||||
tpAppGrp->next = tpAppGrp->next->next;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
(void) xfree (pAppGrp->clients);
|
||||
(void) xfree (pAppGrp->ConnectionInfo);
|
||||
(void) xfree (what);
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void XagClientStateChange(
|
||||
CallbackListPtr* pcbl,
|
||||
pointer nulldata,
|
||||
pointer calldata)
|
||||
{
|
||||
NewClientInfoRec* pci = (NewClientInfoRec*) calldata;
|
||||
ClientPtr pClient = pci->client;
|
||||
AppGroupPtr pAppGrp = pClient->appgroup;
|
||||
int slot;
|
||||
|
||||
if (!pAppGrp)
|
||||
return;
|
||||
|
||||
switch (pClient->clientState) {
|
||||
case ClientStateAuthenticating:
|
||||
case ClientStateRunning:
|
||||
case ClientStateCheckingSecurity:
|
||||
break;
|
||||
|
||||
case ClientStateInitial:
|
||||
case ClientStateCheckedSecurity:
|
||||
slot = -1;
|
||||
/* see the comment above about Initial vs. CheckedSecurity */
|
||||
if (pAppGrp->nclients != 0) {
|
||||
/* if this client already in AppGroup, don't add it again */
|
||||
int i;
|
||||
for (i = 0; i < pAppGrp->nclients; i++)
|
||||
if (pClient == pAppGrp->clients[i]) return;
|
||||
if (slot == -1 && pAppGrp->clients[i] == NULL)
|
||||
slot = i;
|
||||
}
|
||||
if (slot == -1) {
|
||||
slot = pAppGrp->nclients++;
|
||||
pAppGrp->clients = (ClientPtr*) xrealloc (pAppGrp->clients,
|
||||
pAppGrp->nclients * sizeof (ClientPtr));
|
||||
}
|
||||
pAppGrp->clients[slot] = pClient;
|
||||
pClient->appgroup = pAppGrp;
|
||||
break;
|
||||
|
||||
case ClientStateGone:
|
||||
case ClientStateRetained: /* client disconnected, dump it */
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < pAppGrp->nclients; i++)
|
||||
if (pAppGrp->clients[i] == pClient) {
|
||||
pAppGrp->clients[i] = NULL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
pClient->appgroup = NULL; /* redundant, pClient will be freed */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
static
|
||||
void XagResetProc(
|
||||
ExtensionEntry* extEntry)
|
||||
{
|
||||
DeleteCallback (&ClientStateCallback, XagClientStateChange, NULL);
|
||||
XagCallbackRefCount = 0;
|
||||
while (appGrpList) XagAppGroupFree ((pointer) appGrpList, 0);
|
||||
}
|
||||
|
||||
static
|
||||
int ProcXagQueryVersion(
|
||||
ClientPtr client)
|
||||
{
|
||||
/* REQUEST (xXagQueryVersionReq); */
|
||||
xXagQueryVersionReply rep;
|
||||
int n;
|
||||
|
||||
REQUEST_SIZE_MATCH (xXagQueryVersionReq);
|
||||
rep.type = X_Reply;
|
||||
rep.length = 0;
|
||||
rep.sequence_number = client->sequence;
|
||||
rep.server_major_version = XAG_MAJOR_VERSION;
|
||||
rep.server_minor_version = XAG_MINOR_VERSION;
|
||||
if (client->swapped) {
|
||||
swaps (&rep.sequence_number, n);
|
||||
swapl (&rep.length, n);
|
||||
swaps (&rep.server_major_version, n);
|
||||
swaps (&rep.server_minor_version, n);
|
||||
}
|
||||
WriteToClient (client, sizeof (xXagQueryVersionReply), (char *)&rep);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static
|
||||
void ProcessAttr(
|
||||
AppGroupPtr pAppGrp,
|
||||
ClientPtr client,
|
||||
unsigned int attrib_mask,
|
||||
CARD32* attribs)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i <= XagNappGroupLeader; i++) {
|
||||
switch (attrib_mask & (1 << i)) {
|
||||
case XagSingleScreenMask:
|
||||
pAppGrp->single_screen = *attribs;
|
||||
break;
|
||||
case XagDefaultRootMask:
|
||||
pAppGrp->default_root = *attribs;
|
||||
break;
|
||||
case XagRootVisualMask:
|
||||
pAppGrp->root_visual = *attribs;
|
||||
break;
|
||||
case XagDefaultColormapMask:
|
||||
pAppGrp->default_colormap = *attribs;
|
||||
break;
|
||||
case XagBlackPixelMask:
|
||||
pAppGrp->black_pixel = *attribs;
|
||||
break;
|
||||
case XagWhitePixelMask:
|
||||
pAppGrp->white_pixel = *attribs;
|
||||
break;
|
||||
case XagAppGroupLeaderMask:
|
||||
pAppGrp->leader = client;
|
||||
break;
|
||||
default: continue;
|
||||
}
|
||||
attribs++;
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
void CreateConnectionInfo(
|
||||
AppGroupPtr pAppGrp)
|
||||
{
|
||||
xWindowRoot* rootp;
|
||||
xWindowRoot* roots[MAXSCREENS];
|
||||
unsigned int rootlens[MAXSCREENS];
|
||||
xDepth* depth;
|
||||
int olen;
|
||||
int snum, i;
|
||||
|
||||
rootp = (xWindowRoot*) (ConnectionInfo + connBlockScreenStart);
|
||||
for (snum = 0; snum < screenInfo.numScreens; snum++) {
|
||||
|
||||
rootlens[snum] = sizeof (xWindowRoot);
|
||||
roots[snum] = rootp;
|
||||
|
||||
depth = (xDepth*) (rootp + 1);
|
||||
for (i = 0; i < rootp->nDepths; i++) {
|
||||
rootlens[snum] += sizeof (xDepth) +
|
||||
depth->nVisuals * sizeof (xVisualType);
|
||||
depth = (xDepth *)(((char*)(depth + 1)) +
|
||||
depth->nVisuals * sizeof (xVisualType));
|
||||
}
|
||||
rootp = (xWindowRoot*) depth;
|
||||
}
|
||||
snum = 0;
|
||||
if (pAppGrp->default_root) {
|
||||
for (; snum < screenInfo.numVideoScreens; snum++) {
|
||||
if (roots[snum]->windowId == pAppGrp->default_root)
|
||||
break;
|
||||
}
|
||||
}
|
||||
olen = connBlockScreenStart + rootlens[snum];
|
||||
for (i = screenInfo.numVideoScreens; i < screenInfo.numScreens; i++)
|
||||
olen += rootlens[i];
|
||||
pAppGrp->ConnectionInfo = (char*) xalloc (olen);
|
||||
if (!pAppGrp->ConnectionInfo)
|
||||
return;
|
||||
memmove (pAppGrp->ConnectionInfo, ConnectionInfo, connBlockScreenStart);
|
||||
((xConnSetup*) (pAppGrp->ConnectionInfo))->numRoots =
|
||||
1 + screenInfo.numScreens - screenInfo.numVideoScreens;
|
||||
memmove (pAppGrp->ConnectionInfo + connBlockScreenStart,
|
||||
(void*) roots[snum], rootlens[snum]);
|
||||
rootp = (xWindowRoot*) (pAppGrp->ConnectionInfo + connBlockScreenStart);
|
||||
if (pAppGrp->default_colormap) {
|
||||
rootp->defaultColormap = pAppGrp->default_colormap;
|
||||
rootp->whitePixel = pAppGrp->white_pixel;
|
||||
rootp->blackPixel = pAppGrp->black_pixel;
|
||||
}
|
||||
if (pAppGrp->root_visual)
|
||||
rootp->rootVisualID = pAppGrp->root_visual;
|
||||
rootp = (xWindowRoot*) (((char*)rootp) + rootlens[snum]);
|
||||
for (i = screenInfo.numVideoScreens; i < screenInfo.numScreens; i++) {
|
||||
memmove ((void*) rootp, (void*) roots[i], rootlens[i]);
|
||||
rootp = (xWindowRoot*) (((char*) rootp) + rootlens[i]);
|
||||
}
|
||||
pAppGrp->connSetupPrefix = connSetupPrefix;
|
||||
pAppGrp->connSetupPrefix.length = olen >> 2;
|
||||
}
|
||||
|
||||
static
|
||||
AppGroupPtr CreateAppGroup(
|
||||
ClientPtr client,
|
||||
XID appgroupId,
|
||||
unsigned int attrib_mask,
|
||||
CARD32* attribs)
|
||||
{
|
||||
AppGroupPtr pAppGrp;
|
||||
|
||||
pAppGrp = (AppGroupPtr) xalloc (sizeof(AppGroupRec));
|
||||
if (pAppGrp) {
|
||||
pAppGrp->next = appGrpList;
|
||||
appGrpList = pAppGrp;
|
||||
pAppGrp->appgroupId = appgroupId;
|
||||
pAppGrp->clients = (ClientPtr*) xalloc (0);
|
||||
pAppGrp->nclients = 0;
|
||||
pAppGrp->leader = NULL;
|
||||
pAppGrp->default_root = 0;
|
||||
pAppGrp->root_visual = 0;
|
||||
pAppGrp->default_colormap = 0;
|
||||
pAppGrp->black_pixel = -1;
|
||||
pAppGrp->white_pixel = -1;
|
||||
pAppGrp->ConnectionInfo = NULL;
|
||||
ProcessAttr (pAppGrp, client, attrib_mask, attribs);
|
||||
}
|
||||
return pAppGrp;
|
||||
}
|
||||
|
||||
static
|
||||
int AttrValidate(
|
||||
ClientPtr client,
|
||||
int attrib_mask,
|
||||
AppGroupPtr pAppGrp)
|
||||
{
|
||||
WindowPtr pWin;
|
||||
int idepth, ivids, found, rc;
|
||||
ScreenPtr pScreen;
|
||||
DepthPtr pDepth;
|
||||
ColormapPtr pColormap;
|
||||
|
||||
rc = dixLookupWindow(&pWin, pAppGrp->default_root, client,
|
||||
DixGetAttrAccess);
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
pScreen = pWin->drawable.pScreen;
|
||||
if (WindowTable[pScreen->myNum]->drawable.id != pAppGrp->default_root)
|
||||
return BadWindow;
|
||||
pDepth = pScreen->allowedDepths;
|
||||
if (pAppGrp->root_visual) {
|
||||
found = FALSE;
|
||||
for (idepth = 0; idepth < pScreen->numDepths; idepth++, pDepth++) {
|
||||
for (ivids = 0; ivids < pDepth->numVids; ivids++) {
|
||||
if (pAppGrp->root_visual == pDepth->vids[ivids]) {
|
||||
found = TRUE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!found)
|
||||
return BadMatch;
|
||||
}
|
||||
if (pAppGrp->default_colormap) {
|
||||
|
||||
rc = dixLookupResource((pointer *)&pColormap, pAppGrp->default_colormap,
|
||||
RT_COLORMAP, client, DixUseAccess);
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
if (pColormap->pScreen != pScreen)
|
||||
return BadColor;
|
||||
if (pColormap->pVisual->vid != (pAppGrp->root_visual ? pAppGrp->root_visual : pScreen->rootVisual))
|
||||
return BadMatch;
|
||||
}
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static int ProcXagCreate (
|
||||
ClientPtr client)
|
||||
{
|
||||
REQUEST (xXagCreateReq);
|
||||
AppGroupPtr pAppGrp;
|
||||
int ret;
|
||||
|
||||
REQUEST_AT_LEAST_SIZE (xXagCreateReq);
|
||||
|
||||
LEGAL_NEW_RESOURCE (stuff->app_group, client);
|
||||
pAppGrp = CreateAppGroup (client, stuff->app_group,
|
||||
stuff->attrib_mask, (CARD32*) &stuff[1]);
|
||||
if (!pAppGrp)
|
||||
return BadAlloc;
|
||||
ret = AttrValidate (client, stuff->attrib_mask, pAppGrp);
|
||||
if (ret != Success) {
|
||||
XagAppGroupFree ((pointer)pAppGrp, (XID)0);
|
||||
return ret;
|
||||
}
|
||||
if (pAppGrp->single_screen) {
|
||||
CreateConnectionInfo (pAppGrp);
|
||||
if (!pAppGrp->ConnectionInfo)
|
||||
return BadAlloc;
|
||||
}
|
||||
if (!AddResource (stuff->app_group, RT_APPGROUP, (pointer)pAppGrp))
|
||||
return BadAlloc;
|
||||
if (XagCallbackRefCount++ == 0)
|
||||
(void) AddCallback (&ClientStateCallback, XagClientStateChange, NULL);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static int ProcXagDestroy(
|
||||
ClientPtr client)
|
||||
{
|
||||
AppGroupPtr pAppGrp;
|
||||
REQUEST (xXagDestroyReq);
|
||||
|
||||
REQUEST_SIZE_MATCH (xXagDestroyReq);
|
||||
pAppGrp = (AppGroupPtr)SecurityLookupIDByType (client,
|
||||
(XID)stuff->app_group, RT_APPGROUP, DixReadAccess);
|
||||
if (!pAppGrp) return XagBadAppGroup;
|
||||
FreeResource ((XID)stuff->app_group, RT_NONE);
|
||||
if (--XagCallbackRefCount == 0)
|
||||
(void) DeleteCallback (&ClientStateCallback, XagClientStateChange, NULL);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static
|
||||
int ProcXagGetAttr(
|
||||
ClientPtr client)
|
||||
{
|
||||
AppGroupPtr pAppGrp;
|
||||
REQUEST (xXagGetAttrReq);
|
||||
xXagGetAttrReply rep;
|
||||
int n;
|
||||
|
||||
REQUEST_SIZE_MATCH (xXagGetAttrReq);
|
||||
pAppGrp = (AppGroupPtr)SecurityLookupIDByType (client,
|
||||
(XID)stuff->app_group, RT_APPGROUP, DixReadAccess);
|
||||
if (!pAppGrp) return XagBadAppGroup;
|
||||
rep.type = X_Reply;
|
||||
rep.length = 0;
|
||||
rep.sequence_number = client->sequence;
|
||||
rep.default_root = pAppGrp->default_root;
|
||||
rep.root_visual = pAppGrp->root_visual;
|
||||
rep.default_colormap = pAppGrp->default_colormap;
|
||||
rep.black_pixel = pAppGrp->black_pixel;
|
||||
rep.white_pixel = pAppGrp->white_pixel;
|
||||
rep.single_screen = pAppGrp->single_screen;
|
||||
rep.app_group_leader = (pAppGrp->leader) ? 1 : 0;
|
||||
if (client->swapped) {
|
||||
swaps (&rep.sequence_number, n);
|
||||
swapl (&rep.length, n);
|
||||
swapl (&rep.default_root, n);
|
||||
swapl (&rep.root_visual, n);
|
||||
swapl (&rep.default_colormap, n);
|
||||
swapl (&rep.black_pixel, n);
|
||||
swapl (&rep.white_pixel, n);
|
||||
}
|
||||
WriteToClient (client, sizeof (xXagGetAttrReply), (char *)&rep);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static
|
||||
int ProcXagQuery(
|
||||
ClientPtr client)
|
||||
{
|
||||
ClientPtr pClient;
|
||||
AppGroupPtr pAppGrp;
|
||||
REQUEST (xXagQueryReq);
|
||||
int n, rc;
|
||||
|
||||
REQUEST_SIZE_MATCH (xXagQueryReq);
|
||||
rc = dixLookupClient(&pClient, stuff->resource, client, DixGetAttrAccess);
|
||||
if (rc != Success)
|
||||
return rc;
|
||||
|
||||
for (pAppGrp = appGrpList; pAppGrp != NULL; pAppGrp = pAppGrp->next)
|
||||
for (n = 0; n < pAppGrp->nclients; n++)
|
||||
if (pAppGrp->clients[n] == pClient) {
|
||||
xXagQueryReply rep;
|
||||
|
||||
rep.type = X_Reply;
|
||||
rep.length = 0;
|
||||
rep.sequence_number = client->sequence;
|
||||
rep.app_group = pAppGrp->appgroupId;
|
||||
if (client->swapped) {
|
||||
swaps (&rep.sequence_number, n);
|
||||
swapl (&rep.length, n);
|
||||
swapl (&rep.app_group, n);
|
||||
}
|
||||
WriteToClient (client, sizeof (xXagQueryReply), (char *)&rep);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
return BadMatch;
|
||||
}
|
||||
|
||||
static
|
||||
int ProcXagCreateAssoc(
|
||||
ClientPtr client)
|
||||
{
|
||||
REQUEST (xXagCreateAssocReq);
|
||||
|
||||
REQUEST_SIZE_MATCH (xXagCreateAssocReq);
|
||||
#ifdef WIN32
|
||||
if (stuff->window_type != XagWindowTypeWin32)
|
||||
#else
|
||||
if (stuff->window_type != XagWindowTypeX11)
|
||||
#endif
|
||||
return BadMatch;
|
||||
#if defined(WIN32) || defined(__CYGWIN__) /* and Mac, etc */
|
||||
if (!LocalClient (client))
|
||||
return BadAccess;
|
||||
#endif
|
||||
|
||||
/* Macintosh, OS/2, and MS-Windows servers have some work to do here */
|
||||
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static
|
||||
int ProcXagDestroyAssoc(
|
||||
ClientPtr client)
|
||||
{
|
||||
/* REQUEST (xXagDestroyAssocReq); */
|
||||
|
||||
REQUEST_SIZE_MATCH (xXagDestroyAssocReq);
|
||||
/* Macintosh, OS/2, and MS-Windows servers have some work to do here */
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static
|
||||
int ProcXagDispatch (
|
||||
ClientPtr client)
|
||||
{
|
||||
REQUEST (xReq);
|
||||
switch (stuff->data)
|
||||
{
|
||||
case X_XagQueryVersion:
|
||||
return ProcXagQueryVersion (client);
|
||||
case X_XagCreate:
|
||||
return ProcXagCreate (client);
|
||||
case X_XagDestroy:
|
||||
return ProcXagDestroy (client);
|
||||
case X_XagGetAttr:
|
||||
return ProcXagGetAttr (client);
|
||||
case X_XagQuery:
|
||||
return ProcXagQuery (client);
|
||||
case X_XagCreateAssoc:
|
||||
return ProcXagCreateAssoc (client);
|
||||
case X_XagDestroyAssoc:
|
||||
return ProcXagDestroyAssoc (client);
|
||||
default:
|
||||
return BadRequest;
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXagQueryVersion(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
REQUEST(xXagQueryVersionReq);
|
||||
swaps(&stuff->length, n);
|
||||
return ProcXagQueryVersion(client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXagCreate(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
REQUEST (xXagCreateReq);
|
||||
swaps (&stuff->length, n);
|
||||
REQUEST_AT_LEAST_SIZE (xXagCreateReq);
|
||||
swapl (&stuff->app_group, n);
|
||||
swapl (&stuff->attrib_mask, n);
|
||||
SwapRestL (stuff);
|
||||
return ProcXagCreate (client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXagDestroy(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
REQUEST (xXagDestroyReq);
|
||||
swaps (&stuff->length, n);
|
||||
REQUEST_SIZE_MATCH (xXagDestroyReq);
|
||||
swapl (&stuff->app_group, n);
|
||||
return ProcXagDestroy (client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXagGetAttr(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
REQUEST (xXagGetAttrReq);
|
||||
swaps (&stuff->length, n);
|
||||
REQUEST_SIZE_MATCH (xXagGetAttrReq);
|
||||
swapl (&stuff->app_group, n);
|
||||
return ProcXagGetAttr (client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXagQuery(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
REQUEST (xXagQueryReq);
|
||||
swaps (&stuff->length, n);
|
||||
REQUEST_SIZE_MATCH (xXagQueryReq);
|
||||
swapl (&stuff->resource, n);
|
||||
return ProcXagQuery (client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXagCreateAssoc(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
REQUEST (xXagCreateAssocReq);
|
||||
swaps (&stuff->length, n);
|
||||
REQUEST_SIZE_MATCH (xXagCreateAssocReq);
|
||||
swapl (&stuff->window, n);
|
||||
swapl (&stuff->window_type, n);
|
||||
swaps (&stuff->system_window_len, n);
|
||||
return ProcXagCreateAssoc (client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXagDestroyAssoc(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
REQUEST (xXagDestroyAssocReq);
|
||||
swaps (&stuff->length, n);
|
||||
REQUEST_SIZE_MATCH (xXagDestroyAssocReq);
|
||||
swapl (&stuff->window, n);
|
||||
return ProcXagDestroyAssoc (client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXagDispatch(
|
||||
ClientPtr client)
|
||||
{
|
||||
REQUEST(xReq);
|
||||
switch (stuff->data)
|
||||
{
|
||||
case X_XagQueryVersion:
|
||||
return SProcXagQueryVersion (client);
|
||||
case X_XagCreate:
|
||||
return SProcXagCreate (client);
|
||||
case X_XagDestroy:
|
||||
return SProcXagDestroy (client);
|
||||
case X_XagGetAttr:
|
||||
return SProcXagGetAttr (client);
|
||||
case X_XagQuery:
|
||||
return SProcXagQuery (client);
|
||||
case X_XagCreateAssoc:
|
||||
return SProcXagCreateAssoc (client);
|
||||
case X_XagDestroyAssoc:
|
||||
return SProcXagDestroyAssoc (client);
|
||||
default:
|
||||
return BadRequest;
|
||||
}
|
||||
}
|
||||
|
||||
Colormap XagDefaultColormap(
|
||||
ClientPtr client)
|
||||
{
|
||||
return (client->appgroup ? client->appgroup->default_colormap : None);
|
||||
}
|
||||
|
||||
VisualID XagRootVisual(
|
||||
ClientPtr client)
|
||||
{
|
||||
return (client->appgroup ? client->appgroup->root_visual : 0);
|
||||
}
|
||||
|
||||
ClientPtr XagLeader(
|
||||
ClientPtr client)
|
||||
{
|
||||
return (client->appgroup ? client->appgroup->leader : NULL);
|
||||
}
|
||||
|
||||
/*
|
||||
* Return whether the Map request event should be sent to the appgroup leader.
|
||||
* We don't want to send it to the leader when the window is on a different
|
||||
* screen, e.g. a print screen.
|
||||
*/
|
||||
Bool XagIsControlledRoot(
|
||||
ClientPtr client,
|
||||
WindowPtr pParent)
|
||||
{
|
||||
if (client->appgroup) {
|
||||
if (client->appgroup->single_screen &&
|
||||
pParent->drawable.id == client->appgroup->default_root)
|
||||
return TRUE;
|
||||
else if (!pParent->parent)
|
||||
return TRUE;
|
||||
else
|
||||
return FALSE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void XagConnectionInfo(
|
||||
ClientPtr client,
|
||||
xConnSetupPrefix** conn_prefix,
|
||||
char** conn_info,
|
||||
int* num_screen)
|
||||
{
|
||||
if (client->appgroup && client->appgroup->ConnectionInfo) {
|
||||
*conn_prefix = &client->appgroup->connSetupPrefix;
|
||||
*conn_info = client->appgroup->ConnectionInfo;
|
||||
*num_screen = ((xConnSetup*)(client->appgroup->ConnectionInfo))->numRoots;
|
||||
}
|
||||
}
|
||||
|
||||
XID XagId(
|
||||
ClientPtr client)
|
||||
{
|
||||
return (client->appgroup ? client->appgroup->appgroupId : 0);
|
||||
}
|
||||
|
||||
static void XagCallClientStateChange(
|
||||
CallbackListPtr *pcbl,
|
||||
pointer nulldata,
|
||||
pointer calldata)
|
||||
{
|
||||
XaceAuthAvailRec* rec = (XaceAuthAvailRec*) calldata;
|
||||
ClientPtr pClient = rec->client;
|
||||
|
||||
if (!pClient->appgroup) {
|
||||
SecurityAuthorizationPtr pAuth;
|
||||
XID authId = rec->authId;
|
||||
|
||||
/* can't use SecurityLookupIDByType here -- client
|
||||
* security state hasn't been setup yet.
|
||||
*/
|
||||
pAuth = (SecurityAuthorizationPtr)LookupIDByType(authId,
|
||||
SecurityAuthorizationResType);
|
||||
if (!pAuth)
|
||||
return;
|
||||
|
||||
pClient->appgroup = (AppGroupPtr)LookupIDByType(pAuth->group,
|
||||
RT_APPGROUP);
|
||||
}
|
||||
|
||||
if (pClient->appgroup) {
|
||||
NewClientInfoRec clientinfo;
|
||||
|
||||
clientinfo.client = pClient;
|
||||
XagClientStateChange (NULL, NULL, (pointer)&clientinfo);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
XagExtensionInit(INITARGS)
|
||||
{
|
||||
if (AddExtension (XAGNAME,
|
||||
0,
|
||||
XagNumberErrors,
|
||||
ProcXagDispatch,
|
||||
SProcXagDispatch,
|
||||
XagResetProc,
|
||||
StandardMinorOpcode)) {
|
||||
RT_APPGROUP = CreateNewResourceType (XagAppGroupFree);
|
||||
XaceRegisterCallback(XACE_AUTH_AVAIL, XagCallClientStateChange, NULL);
|
||||
}
|
||||
}
|
|
@ -1,67 +0,0 @@
|
|||
/*
|
||||
Copyright 1996, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall
|
||||
not be used in advertising or otherwise to promote the sale, use or
|
||||
other dealings in this Software without prior written authorization
|
||||
from The Open Group.
|
||||
*/
|
||||
|
||||
#ifndef _APPGROUP_SRV_H_
|
||||
#define _APPGROUP_SRV_H_
|
||||
|
||||
#include <X11/Xfuncproto.h>
|
||||
|
||||
_XFUNCPROTOBEGIN
|
||||
|
||||
extern void XagConnectionInfo(
|
||||
ClientPtr /* client */,
|
||||
xConnSetupPrefix** /* conn_prefix */,
|
||||
char** /* conn_info */,
|
||||
int* /* num_screens */
|
||||
);
|
||||
|
||||
extern VisualID XagRootVisual(
|
||||
ClientPtr /* client */
|
||||
);
|
||||
|
||||
extern Colormap XagDefaultColormap(
|
||||
ClientPtr /* client */
|
||||
);
|
||||
|
||||
extern ClientPtr XagLeader(
|
||||
ClientPtr /* client */
|
||||
);
|
||||
|
||||
extern Bool XagIsControlledRoot (
|
||||
ClientPtr /* client */,
|
||||
WindowPtr /* pParent */
|
||||
);
|
||||
|
||||
extern XID XagId (
|
||||
ClientPtr /* client */
|
||||
);
|
||||
|
||||
_XFUNCPROTOEND
|
||||
|
||||
#endif /* _APPGROUP_SRV_H_ */
|
||||
|
||||
|
||||
|
342
Xext/cup.c
342
Xext/cup.c
|
@ -1,342 +0,0 @@
|
|||
/*
|
||||
|
||||
Copyright 1997, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
*/
|
||||
|
||||
#define NEED_REPLIES
|
||||
#define NEED_EVENTS
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "misc.h"
|
||||
#include "dixstruct.h"
|
||||
#include "extnsionst.h"
|
||||
#include "colormapst.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "servermd.h"
|
||||
#include "swapreq.h"
|
||||
#define _XCUP_SERVER_
|
||||
#include <X11/extensions/Xcupstr.h>
|
||||
#include <X11/Xfuncproto.h>
|
||||
|
||||
#include "../os/osdep.h"
|
||||
|
||||
#include "modinit.h"
|
||||
|
||||
static int ProcDispatch(ClientPtr client);
|
||||
static int SProcDispatch(ClientPtr client);
|
||||
static void ResetProc(ExtensionEntry* extEntry);
|
||||
|
||||
#if defined(WIN32) || defined(TESTWIN32)
|
||||
#define HAVE_SPECIAL_DESKTOP_COLORS
|
||||
#endif
|
||||
|
||||
static xColorItem citems[] = {
|
||||
#ifndef HAVE_SPECIAL_DESKTOP_COLORS
|
||||
#define CUP_BLACK_PIXEL 0
|
||||
#define CUP_WHITE_PIXEL 1
|
||||
/* pix red green blue */
|
||||
{ 0, 0, 0, 0, 0, 0 },
|
||||
{ 1, 0xffff, 0xffff, 0xffff, 0, 0 }
|
||||
#else
|
||||
#ifndef WIN32
|
||||
/*
|
||||
This approximates the MS-Windows desktop colormap for testing
|
||||
purposes but has black and white pixels in the typical Unix
|
||||
locations, which should be switched if necessary if your system
|
||||
has blackPixel and whitePixel swapped. No entries are provided
|
||||
for colormap entries 254 and 255 because AllocColor/FindColor
|
||||
will reuse entries zero and one.
|
||||
*/
|
||||
{ 0, 0, 0, 0, 0, 0 },
|
||||
{ 1, 0xffff, 0xffff, 0xffff, 0, 0 },
|
||||
{ 2, 0x8000, 0, 0, 0, 0 },
|
||||
{ 3, 0, 0x8000, 0, 0, 0 },
|
||||
{ 4, 0x8000, 0x8000, 0, 0, 0 },
|
||||
{ 5, 0, 0, 0x8000, 0, 0 },
|
||||
{ 6, 0x8000, 0, 0x8000, 0, 0 },
|
||||
{ 7, 0, 0x8000, 0x8000, 0, 0 },
|
||||
{ 8, 0xc000, 0xc000, 0xc000, 0, 0 },
|
||||
{ 9, 0xc000, 0xdc00, 0xc000, 0, 0 },
|
||||
{ 246, 0xa000, 0xa000, 0xa000, 0, 0 },
|
||||
{ 247, 0x8000, 0x8000, 0x8000, 0, 0 },
|
||||
{ 248, 0xffff, 0, 0, 0, 0 },
|
||||
{ 249, 0, 0xffff, 0, 0, 0 },
|
||||
{ 250, 0xffff, 0xffff, 0, 0, 0 },
|
||||
{ 251, 0, 0, 0xffff, 0, 0 },
|
||||
{ 252, 0xffff, 0, 0xffff, 0, 0 },
|
||||
{ 253, 0, 0xffff, 0xffff, 0, 0 }
|
||||
#else
|
||||
/*
|
||||
this is the MS-Windows desktop, adjusted for X's 16-bit color
|
||||
specifications.
|
||||
*/
|
||||
{ 0, 0, 0, 0, 0, 0 },
|
||||
{ 1, 0x8000, 0, 0, 0, 0 },
|
||||
{ 2, 0, 0x8000, 0, 0, 0 },
|
||||
{ 3, 0x8000, 0x8000, 0, 0, 0 },
|
||||
{ 4, 0, 0, 0x8000, 0, 0 },
|
||||
{ 5, 0x8000, 0, 0x8000, 0, 0 },
|
||||
{ 6, 0, 0x8000, 0x8000, 0, 0 },
|
||||
{ 7, 0xc000, 0xc000, 0xc000, 0, 0 },
|
||||
{ 8, 0xc000, 0xdc00, 0xc000, 0, 0 },
|
||||
{ 9, 0xa600, 0xca00, 0xf000, 0, 0 },
|
||||
{ 246, 0xff00, 0xfb00, 0xf000, 0, 0 },
|
||||
{ 247, 0xa000, 0xa000, 0xa400, 0, 0 },
|
||||
{ 248, 0x8000, 0x8000, 0x8000, 0, 0 },
|
||||
{ 249, 0xff00, 0, 0, 0, 0 },
|
||||
{ 250, 0, 0xff00, 0, 0, 0 },
|
||||
{ 251, 0xff00, 0xff00, 0, 0, 0 },
|
||||
{ 252, 0, 0, 0xff00, 0, 0 },
|
||||
{ 253, 0xff00, 0, 0xff00, 0, 0 },
|
||||
{ 254, 0, 0xff00, 0xff00, 0, 0 },
|
||||
{ 255, 0xff00, 0xff00, 0xff00, 0, 0 }
|
||||
#endif
|
||||
#endif
|
||||
};
|
||||
#define NUM_DESKTOP_COLORS (sizeof citems / sizeof citems[0])
|
||||
|
||||
void
|
||||
XcupExtensionInit (INITARGS)
|
||||
{
|
||||
(void) AddExtension (XCUPNAME,
|
||||
0,
|
||||
XcupNumberErrors,
|
||||
ProcDispatch,
|
||||
SProcDispatch,
|
||||
ResetProc,
|
||||
StandardMinorOpcode);
|
||||
|
||||
/* PC servers initialize the desktop colors (citems) here! */
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
static
|
||||
void ResetProc(
|
||||
ExtensionEntry* extEntry)
|
||||
{
|
||||
}
|
||||
|
||||
static
|
||||
int ProcQueryVersion(
|
||||
ClientPtr client)
|
||||
{
|
||||
/* REQUEST (xXcupQueryVersionReq); */
|
||||
xXcupQueryVersionReply rep;
|
||||
int n;
|
||||
|
||||
REQUEST_SIZE_MATCH (xXcupQueryVersionReq);
|
||||
rep.type = X_Reply;
|
||||
rep.length = 0;
|
||||
rep.sequence_number = client->sequence;
|
||||
rep.server_major_version = XCUP_MAJOR_VERSION;
|
||||
rep.server_minor_version = XCUP_MINOR_VERSION;
|
||||
if (client->swapped) {
|
||||
swaps (&rep.sequence_number, n);
|
||||
swapl (&rep.length, n);
|
||||
swaps (&rep.server_major_version, n);
|
||||
swaps (&rep.server_minor_version, n);
|
||||
}
|
||||
WriteToClient (client, sizeof (xXcupQueryVersionReply), (char *)&rep);
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static
|
||||
int ProcGetReservedColormapEntries(
|
||||
ClientPtr client)
|
||||
{
|
||||
REQUEST (xXcupGetReservedColormapEntriesReq);
|
||||
xXcupGetReservedColormapEntriesReply rep;
|
||||
xColorItem* cptr;
|
||||
int n;
|
||||
|
||||
REQUEST_SIZE_MATCH (xXcupGetReservedColormapEntriesReq);
|
||||
|
||||
if (stuff->screen >= screenInfo.numScreens)
|
||||
return BadValue;
|
||||
|
||||
#ifndef HAVE_SPECIAL_DESKTOP_COLORS
|
||||
citems[CUP_BLACK_PIXEL].pixel =
|
||||
screenInfo.screens[stuff->screen]->blackPixel;
|
||||
citems[CUP_WHITE_PIXEL].pixel =
|
||||
screenInfo.screens[stuff->screen]->whitePixel;
|
||||
#endif
|
||||
|
||||
rep.type = X_Reply;
|
||||
rep.sequence_number = client->sequence;
|
||||
rep.length = NUM_DESKTOP_COLORS * 3;
|
||||
if (client->swapped) {
|
||||
swaps (&rep.sequence_number, n);
|
||||
swapl (&rep.length, n);
|
||||
}
|
||||
WriteToClient (client, sizeof (xXcupGetReservedColormapEntriesReply), (char *)&rep);
|
||||
for (n = 0, cptr = citems; n < NUM_DESKTOP_COLORS; n++, cptr++) {
|
||||
if (client->swapped) SwapColorItem (cptr);
|
||||
WriteToClient (client, SIZEOF(xColorItem), (char *)cptr);
|
||||
}
|
||||
return client->noClientException;
|
||||
}
|
||||
|
||||
static
|
||||
int ProcStoreColors(
|
||||
ClientPtr client)
|
||||
{
|
||||
REQUEST (xXcupStoreColorsReq);
|
||||
ColormapPtr pcmp;
|
||||
int rc;
|
||||
|
||||
REQUEST_AT_LEAST_SIZE (xXcupStoreColorsReq);
|
||||
rc = dixLookupResource((pointer *)&pcmp, stuff->cmap, RT_COLORMAP,
|
||||
client, DixAddAccess);
|
||||
|
||||
if (rc == Success) {
|
||||
int ncolors, n;
|
||||
xXcupStoreColorsReply rep;
|
||||
xColorItem* cptr;
|
||||
|
||||
if (!(pcmp->class & DynamicClass))
|
||||
return BadMatch;
|
||||
|
||||
ncolors = (client->req_len << 2) - SIZEOF (xXcupStoreColorsReq);
|
||||
if (ncolors % SIZEOF(xColorItem))
|
||||
return BadLength;
|
||||
|
||||
ncolors /= SIZEOF (xColorItem);
|
||||
|
||||
|
||||
for (n = 0, cptr = (xColorItem*) &stuff[1]; n < ncolors; n++) {
|
||||
Pixel pixel = cptr->pixel;
|
||||
|
||||
if (AllocColor (pcmp,
|
||||
&cptr->red, &cptr->green, &cptr->blue,
|
||||
&pixel, client->index) == Success) {
|
||||
cptr->pixel = pixel;
|
||||
cptr->flags = 0x08;
|
||||
} else
|
||||
cptr->flags = 0;
|
||||
cptr = (xColorItem*) (((char*)cptr) + SIZEOF(xColorItem));
|
||||
}
|
||||
|
||||
rep.type = X_Reply;
|
||||
rep.sequence_number = client->sequence;
|
||||
rep.length = ncolors * 3;
|
||||
if (client->swapped) {
|
||||
swaps (&rep.sequence_number, n);
|
||||
swapl (&rep.length, n);
|
||||
}
|
||||
WriteToClient (client, sizeof (xXcupGetReservedColormapEntriesReply), (char *)&rep);
|
||||
for (n = 0, cptr = (xColorItem*) &stuff[1]; n < ncolors; n++) {
|
||||
if (client->swapped) SwapColorItem (cptr);
|
||||
WriteToClient (client, SIZEOF(xColorItem), (char *)cptr);
|
||||
cptr = (xColorItem*) (((char*)cptr) + SIZEOF(xColorItem));
|
||||
}
|
||||
return client->noClientException;
|
||||
} else {
|
||||
client->errorValue = stuff->cmap;
|
||||
return (rc == BadValue) ? BadColor : rc;
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
int ProcDispatch(
|
||||
ClientPtr client)
|
||||
{
|
||||
REQUEST (xReq);
|
||||
switch (stuff->data)
|
||||
{
|
||||
case X_XcupQueryVersion:
|
||||
return ProcQueryVersion (client);
|
||||
case X_XcupGetReservedColormapEntries:
|
||||
return ProcGetReservedColormapEntries (client);
|
||||
case X_XcupStoreColors:
|
||||
return ProcStoreColors (client);
|
||||
default:
|
||||
return BadRequest;
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
int SProcQueryVersion(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
|
||||
REQUEST(xXcupQueryVersionReq);
|
||||
swaps(&stuff->length, n);
|
||||
return ProcQueryVersion(client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcGetReservedColormapEntries(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
|
||||
REQUEST (xXcupGetReservedColormapEntriesReq);
|
||||
swaps (&stuff->length, n);
|
||||
swapl (&stuff->screen, n);
|
||||
REQUEST_AT_LEAST_SIZE (xXcupGetReservedColormapEntriesReq);
|
||||
return ProcGetReservedColormapEntries (client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcXcupStoreColors(
|
||||
ClientPtr client)
|
||||
{
|
||||
int n;
|
||||
int count;
|
||||
xColorItem* pItem;
|
||||
|
||||
REQUEST (xXcupStoreColorsReq);
|
||||
swaps (&stuff->length, n);
|
||||
REQUEST_AT_LEAST_SIZE (xXcupStoreColorsReq);
|
||||
swapl(&stuff->cmap, n);
|
||||
pItem = (xColorItem*) &stuff[1];
|
||||
for(count = LengthRestB(stuff)/sizeof(xColorItem); --count >= 0; )
|
||||
SwapColorItem(pItem++);
|
||||
return ProcStoreColors (client);
|
||||
}
|
||||
|
||||
static
|
||||
int SProcDispatch(
|
||||
ClientPtr client)
|
||||
{
|
||||
REQUEST(xReq);
|
||||
switch (stuff->data)
|
||||
{
|
||||
case X_XcupQueryVersion:
|
||||
return SProcQueryVersion (client);
|
||||
case X_XcupGetReservedColormapEntries:
|
||||
return SProcGetReservedColormapEntries (client);
|
||||
case X_XcupStoreColors:
|
||||
return SProcXcupStoreColors (client);
|
||||
default:
|
||||
return BadRequest;
|
||||
}
|
||||
}
|
||||
|
||||
|
155
Xext/mitmisc.c
155
Xext/mitmisc.c
|
@ -1,155 +0,0 @@
|
|||
/************************************************************
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
********************************************************/
|
||||
|
||||
/* RANDOM CRUFT! THIS HAS NO OFFICIAL X CONSORTIUM OR X PROJECT TEAM BLESSING */
|
||||
|
||||
|
||||
#define NEED_EVENTS
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "misc.h"
|
||||
#include "os.h"
|
||||
#include "dixstruct.h"
|
||||
#include "extnsionst.h"
|
||||
#define _MITMISC_SERVER_
|
||||
#include <X11/extensions/mitmiscstr.h>
|
||||
#include "modinit.h"
|
||||
|
||||
static void MITResetProc(
|
||||
ExtensionEntry * /* extEntry */
|
||||
);
|
||||
|
||||
static DISPATCH_PROC(ProcMITDispatch);
|
||||
static DISPATCH_PROC(ProcMITGetBugMode);
|
||||
static DISPATCH_PROC(ProcMITSetBugMode);
|
||||
static DISPATCH_PROC(SProcMITDispatch);
|
||||
static DISPATCH_PROC(SProcMITGetBugMode);
|
||||
static DISPATCH_PROC(SProcMITSetBugMode);
|
||||
|
||||
void
|
||||
MITMiscExtensionInit(INITARGS)
|
||||
{
|
||||
AddExtension(MITMISCNAME, 0, 0,
|
||||
ProcMITDispatch, SProcMITDispatch,
|
||||
MITResetProc, StandardMinorOpcode);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
static void
|
||||
MITResetProc (extEntry)
|
||||
ExtensionEntry *extEntry;
|
||||
{
|
||||
}
|
||||
|
||||
static int
|
||||
ProcMITSetBugMode(client)
|
||||
ClientPtr client;
|
||||
{
|
||||
REQUEST(xMITSetBugModeReq);
|
||||
|
||||
REQUEST_SIZE_MATCH(xMITSetBugModeReq);
|
||||
if (stuff->onOff != xFalse)
|
||||
return BadRequest;
|
||||
return(client->noClientException);
|
||||
}
|
||||
|
||||
static int
|
||||
ProcMITGetBugMode(client)
|
||||
ClientPtr client;
|
||||
{
|
||||
xMITGetBugModeReply rep;
|
||||
int n;
|
||||
|
||||
REQUEST_SIZE_MATCH(xMITGetBugModeReq);
|
||||
rep.type = X_Reply;
|
||||
rep.length = 0;
|
||||
rep.sequenceNumber = client->sequence;
|
||||
rep.onOff = FALSE;
|
||||
if (client->swapped) {
|
||||
swaps(&rep.sequenceNumber, n);
|
||||
swapl(&rep.length, n);
|
||||
}
|
||||
WriteToClient(client, sizeof(xMITGetBugModeReply), (char *)&rep);
|
||||
return(client->noClientException);
|
||||
}
|
||||
|
||||
static int
|
||||
ProcMITDispatch (client)
|
||||
ClientPtr client;
|
||||
{
|
||||
REQUEST(xReq);
|
||||
switch (stuff->data)
|
||||
{
|
||||
case X_MITSetBugMode:
|
||||
return ProcMITSetBugMode(client);
|
||||
case X_MITGetBugMode:
|
||||
return ProcMITGetBugMode(client);
|
||||
default:
|
||||
return BadRequest;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
SProcMITSetBugMode(client)
|
||||
ClientPtr client;
|
||||
{
|
||||
int n;
|
||||
REQUEST(xMITSetBugModeReq);
|
||||
|
||||
swaps(&stuff->length, n);
|
||||
return ProcMITSetBugMode(client);
|
||||
}
|
||||
|
||||
static int
|
||||
SProcMITGetBugMode(client)
|
||||
ClientPtr client;
|
||||
{
|
||||
int n;
|
||||
REQUEST(xMITGetBugModeReq);
|
||||
|
||||
swaps(&stuff->length, n);
|
||||
return ProcMITGetBugMode(client);
|
||||
}
|
||||
|
||||
static int
|
||||
SProcMITDispatch (client)
|
||||
ClientPtr client;
|
||||
{
|
||||
REQUEST(xReq);
|
||||
switch (stuff->data)
|
||||
{
|
||||
case X_MITSetBugMode:
|
||||
return SProcMITSetBugMode(client);
|
||||
case X_MITGetBugMode:
|
||||
return SProcMITGetBugMode(client);
|
||||
default:
|
||||
return BadRequest;
|
||||
}
|
||||
}
|
123
Xext/sampleEVI.c
123
Xext/sampleEVI.c
|
@ -1,123 +0,0 @@
|
|||
/************************************************************
|
||||
Copyright (c) 1997 by Silicon Graphics Computer Systems, Inc.
|
||||
Permission to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose and without
|
||||
fee is hereby granted, provided that the above copyright
|
||||
notice appear in all copies and that both that copyright
|
||||
notice and this permission notice appear in supporting
|
||||
documentation, and that the name of Silicon Graphics not be
|
||||
used in advertising or publicity pertaining to distribution
|
||||
of the software without specific prior written permission.
|
||||
Silicon Graphics makes no representation about the suitability
|
||||
of this software for any purpose. It is provided "as is"
|
||||
without any express or implied warranty.
|
||||
SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
|
||||
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
|
||||
GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
|
||||
DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
|
||||
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
|
||||
OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
||||
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
********************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "dixstruct.h"
|
||||
#include "extnsionst.h"
|
||||
#include "dix.h"
|
||||
#define _XEVI_SERVER_
|
||||
#include <X11/extensions/XEVIstr.h>
|
||||
#include "EVIstruct.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#if HAVE_STDINT_H
|
||||
#include <stdint.h>
|
||||
#elif !defined(UINT32_MAX)
|
||||
#define UINT32_MAX 0xffffffffU
|
||||
#endif
|
||||
|
||||
static int sampleGetVisualInfo(
|
||||
VisualID32 *visual,
|
||||
int n_visual,
|
||||
xExtendedVisualInfo **evi_rn,
|
||||
int *n_info_rn,
|
||||
VisualID32 **conflict_rn,
|
||||
int *n_conflict_rn)
|
||||
{
|
||||
unsigned int max_sz_evi;
|
||||
VisualID32 *temp_conflict;
|
||||
xExtendedVisualInfo *evi;
|
||||
unsigned int max_visuals = 0, max_sz_conflict, sz_conflict = 0;
|
||||
register int visualI, scrI, sz_evi = 0, conflictI, n_conflict;
|
||||
|
||||
if (n_visual > UINT32_MAX/(sz_xExtendedVisualInfo * screenInfo.numScreens))
|
||||
return BadAlloc;
|
||||
max_sz_evi = n_visual * sz_xExtendedVisualInfo * screenInfo.numScreens;
|
||||
|
||||
for (scrI = 0; scrI < screenInfo.numScreens; scrI++) {
|
||||
if (screenInfo.screens[scrI]->numVisuals > max_visuals)
|
||||
max_visuals = screenInfo.screens[scrI]->numVisuals;
|
||||
}
|
||||
|
||||
if (n_visual > UINT32_MAX/(sz_VisualID32 * screenInfo.numScreens
|
||||
* max_visuals))
|
||||
return BadAlloc;
|
||||
max_sz_conflict = n_visual * sz_VisualID32 * screenInfo.numScreens * max_visuals;
|
||||
|
||||
*evi_rn = evi = (xExtendedVisualInfo *)xalloc(max_sz_evi);
|
||||
if (!*evi_rn)
|
||||
return BadAlloc;
|
||||
|
||||
temp_conflict = (VisualID32 *)xalloc(max_sz_conflict);
|
||||
if (!temp_conflict) {
|
||||
xfree(*evi_rn);
|
||||
return BadAlloc;
|
||||
}
|
||||
|
||||
for (scrI = 0; scrI < screenInfo.numScreens; scrI++) {
|
||||
for (visualI = 0; visualI < n_visual; visualI++) {
|
||||
evi[sz_evi].core_visual_id = visual[visualI];
|
||||
evi[sz_evi].screen = scrI;
|
||||
evi[sz_evi].level = 0;
|
||||
evi[sz_evi].transparency_type = XEVI_TRANSPARENCY_NONE;
|
||||
evi[sz_evi].transparency_value = 0;
|
||||
evi[sz_evi].min_hw_colormaps = 1;
|
||||
evi[sz_evi].max_hw_colormaps = 1;
|
||||
evi[sz_evi].num_colormap_conflicts = n_conflict = 0;
|
||||
for (conflictI = 0; conflictI < n_conflict; conflictI++)
|
||||
temp_conflict[sz_conflict++] = visual[visualI];
|
||||
sz_evi++;
|
||||
}
|
||||
}
|
||||
*conflict_rn = temp_conflict;
|
||||
*n_conflict_rn = sz_conflict;
|
||||
*n_info_rn = sz_evi;
|
||||
return Success;
|
||||
}
|
||||
|
||||
static void sampleFreeVisualInfo(
|
||||
xExtendedVisualInfo *evi,
|
||||
VisualID32 *conflict)
|
||||
{
|
||||
if (evi)
|
||||
xfree(evi);
|
||||
if (conflict)
|
||||
xfree(conflict);
|
||||
}
|
||||
|
||||
EviPrivPtr eviDDXInit(void)
|
||||
{
|
||||
static EviPrivRec eviPriv;
|
||||
eviPriv.getVisualInfo = sampleGetVisualInfo;
|
||||
eviPriv.freeVisualInfo = sampleFreeVisualInfo;
|
||||
return &eviPriv;
|
||||
}
|
||||
|
||||
void eviDDXReset(void)
|
||||
{
|
||||
}
|
|
@ -38,9 +38,6 @@ in this Software without prior written authorization from The Open Group.
|
|||
#include "xacestr.h"
|
||||
#include "securitysrv.h"
|
||||
#include <X11/extensions/securstr.h>
|
||||
#ifdef XAPPGROUP
|
||||
#include "appgroup.h"
|
||||
#endif
|
||||
#include "modinit.h"
|
||||
|
||||
/* Extension stuff */
|
||||
|
@ -833,11 +830,6 @@ SecurityResource(CallbackListPtr *pcbl, pointer unused, pointer calldata)
|
|||
if (SecurityDoCheck(subj, obj, requested, allowed) == Success)
|
||||
return;
|
||||
|
||||
#ifdef XAPPGROUP
|
||||
if (rec->id == XagDefaultColormap(rec->client))
|
||||
return;
|
||||
#endif
|
||||
|
||||
SecurityAudit("Security: denied client %d access %x to resource 0x%x "
|
||||
"of client %d on request %s\n", rec->client->index,
|
||||
requested, rec->id, cid,
|
||||
|
|
|
@ -64,7 +64,7 @@ ProcXResQueryClients (ClientPtr client)
|
|||
|
||||
REQUEST_SIZE_MATCH(xXResQueryClientsReq);
|
||||
|
||||
current_clients = xalloc((currentMaxClients - 1) * sizeof(int));
|
||||
current_clients = xalloc(currentMaxClients * sizeof(int));
|
||||
|
||||
num_clients = 0;
|
||||
for(i = 0; i < currentMaxClients; i++) {
|
||||
|
|
172
acinclude.m4
172
acinclude.m4
|
@ -1,4 +1,150 @@
|
|||
##### http://autoconf-archive.cryp.to/ac_define_dir.html
|
||||
dnl dolt, a replacement for libtool
|
||||
dnl Copyright © 2007-2008 Josh Triplett <josh@freedesktop.org>
|
||||
dnl Copying and distribution of this file, with or without modification,
|
||||
dnl are permitted in any medium without royalty provided the copyright
|
||||
dnl notice and this notice are preserved.
|
||||
dnl
|
||||
dnl To use dolt, invoke the DOLT macro immediately after the libtool macros.
|
||||
dnl Optionally, copy this file into acinclude.m4, to avoid the need to have it
|
||||
dnl installed when running autoconf on your project.
|
||||
dnl
|
||||
dnl git snapshot: d91f2b4e9041538400e2703a2a6fbeecdb8ee27d
|
||||
AC_DEFUN([DOLT], [
|
||||
AC_REQUIRE([AC_CANONICAL_HOST])
|
||||
# dolt, a replacement for libtool
|
||||
# Josh Triplett <josh@freedesktop.org>
|
||||
AC_PATH_PROG(DOLT_BASH, bash)
|
||||
AC_MSG_CHECKING([if libtool sucks])
|
||||
AC_MSG_RESULT([yup, it does])
|
||||
AC_MSG_CHECKING([if dolt supports this host])
|
||||
dolt_supported=yes
|
||||
if test x$DOLT_BASH = x; then
|
||||
dolt_supported=no
|
||||
fi
|
||||
if test x$GCC != xyes; then
|
||||
dolt_supported=no
|
||||
fi
|
||||
case $host in
|
||||
i?86-*-linux*|x86_64-*-linux*|powerpc-*-linux*) ;;
|
||||
amd64-*-freebsd*|i?86-*-freebsd*|ia64-*-freebsd*) ;;
|
||||
*) dolt_supported=no ;;
|
||||
esac
|
||||
if test x$dolt_supported = xno ; then
|
||||
AC_MSG_RESULT([no, falling back to libtool])
|
||||
LTCOMPILE='$(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(COMPILE)'
|
||||
LTCXXCOMPILE='$(LIBTOOL) --tag=CXX $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CXXCOMPILE)'
|
||||
else
|
||||
AC_MSG_RESULT([yes, replacing libtool])
|
||||
|
||||
dnl Start writing out doltcompile.
|
||||
cat <<__DOLTCOMPILE__EOF__ >doltcompile
|
||||
#!$DOLT_BASH
|
||||
__DOLTCOMPILE__EOF__
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
args=("$[]@")
|
||||
for ((arg=0; arg<${#args@<:@@@:>@}; arg++)) ; do
|
||||
if test x"${args@<:@$arg@:>@}" = x-o ; then
|
||||
objarg=$((arg+1))
|
||||
break
|
||||
fi
|
||||
done
|
||||
if test x$objarg = x ; then
|
||||
echo 'Error: no -o on compiler command line' 1>&2
|
||||
exit 1
|
||||
fi
|
||||
lo="${args@<:@$objarg@:>@}"
|
||||
obj="${lo%.lo}"
|
||||
if test x"$lo" = x"$obj" ; then
|
||||
echo "Error: libtool object file name \"$lo\" does not end in .lo" 1>&2
|
||||
exit 1
|
||||
fi
|
||||
objbase="${obj##*/}"
|
||||
__DOLTCOMPILE__EOF__
|
||||
|
||||
dnl Write out shared compilation code.
|
||||
if test x$enable_shared = xyes; then
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
libobjdir="${obj%$objbase}.libs"
|
||||
if test ! -d "$libobjdir" ; then
|
||||
mkdir_out="$(mkdir "$libobjdir" 2>&1)"
|
||||
mkdir_ret=$?
|
||||
if test "$mkdir_ret" -ne 0 && test ! -d "$libobjdir" ; then
|
||||
echo "$mkdir_out" 1>&2
|
||||
exit $mkdir_ret
|
||||
fi
|
||||
fi
|
||||
pic_object="$libobjdir/$objbase.o"
|
||||
args@<:@$objarg@:>@="$pic_object"
|
||||
"${args@<:@@@:>@}" -fPIC -DPIC || exit $?
|
||||
__DOLTCOMPILE__EOF__
|
||||
fi
|
||||
|
||||
dnl Write out static compilation code.
|
||||
dnl Avoid duplicate compiler output if also building shared objects.
|
||||
if test x$enable_static = xyes; then
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
non_pic_object="$obj.o"
|
||||
args@<:@$objarg@:>@="$non_pic_object"
|
||||
__DOLTCOMPILE__EOF__
|
||||
if test x$enable_shared = xyes; then
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
"${args@<:@@@:>@}" >/dev/null 2>&1 || exit $?
|
||||
__DOLTCOMPILE__EOF__
|
||||
else
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
"${args@<:@@@:>@}" || exit $?
|
||||
__DOLTCOMPILE__EOF__
|
||||
fi
|
||||
fi
|
||||
|
||||
dnl Write out the code to write the .lo file.
|
||||
dnl The second line of the .lo file must match "^# Generated by .*libtool"
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
{
|
||||
echo "# $lo - a libtool object file"
|
||||
echo "# Generated by doltcompile, not libtool"
|
||||
__DOLTCOMPILE__EOF__
|
||||
|
||||
if test x$enable_shared = xyes; then
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
echo "pic_object='$pic_object'"
|
||||
__DOLTCOMPILE__EOF__
|
||||
else
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
echo pic_object=none
|
||||
__DOLTCOMPILE__EOF__
|
||||
fi
|
||||
|
||||
if test x$enable_static = xyes; then
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
echo "non_pic_object='$non_pic_object'"
|
||||
__DOLTCOMPILE__EOF__
|
||||
else
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
echo non_pic_object=none
|
||||
__DOLTCOMPILE__EOF__
|
||||
fi
|
||||
|
||||
cat <<'__DOLTCOMPILE__EOF__' >>doltcompile
|
||||
} > "$lo"
|
||||
__DOLTCOMPILE__EOF__
|
||||
|
||||
dnl Done writing out doltcompile; substitute it for libtool compilation.
|
||||
chmod +x doltcompile
|
||||
LTCOMPILE='$(top_builddir)/doltcompile $(COMPILE)'
|
||||
LTCXXCOMPILE='$(top_builddir)/doltcompile $(CXXCOMPILE)'
|
||||
fi
|
||||
AC_SUBST(LTCOMPILE)
|
||||
AC_SUBST(LTCXXCOMPILE)
|
||||
# end dolt
|
||||
])
|
||||
|
||||
|
||||
|
||||
|
||||
# ===========================================================================
|
||||
# http://autoconf-archive.cryp.to/ac_define_dir.html
|
||||
# ===========================================================================
|
||||
#
|
||||
# SYNOPSIS
|
||||
#
|
||||
|
@ -6,11 +152,11 @@
|
|||
#
|
||||
# DESCRIPTION
|
||||
#
|
||||
# This macro sets VARNAME to the expansion of the DIR variable,
|
||||
# taking care of fixing up ${prefix} and such.
|
||||
# This macro sets VARNAME to the expansion of the DIR variable, taking
|
||||
# care of fixing up ${prefix} and such.
|
||||
#
|
||||
# VARNAME is then offered as both an output variable and a C
|
||||
# preprocessor symbol.
|
||||
# VARNAME is then offered as both an output variable and a C preprocessor
|
||||
# symbol.
|
||||
#
|
||||
# Example:
|
||||
#
|
||||
|
@ -18,18 +164,18 @@
|
|||
#
|
||||
# LAST MODIFICATION
|
||||
#
|
||||
# 2006-10-13
|
||||
# 2008-04-12
|
||||
#
|
||||
# COPYLEFT
|
||||
#
|
||||
# Copyright (c) 2006 Stepan Kasal <kasal@ucw.cz>
|
||||
# Copyright (c) 2006 Andreas Schwab <schwab@suse.de>
|
||||
# Copyright (c) 2006 Guido U. Draheim <guidod@gmx.de>
|
||||
# Copyright (c) 2006 Alexandre Oliva
|
||||
# Copyright (c) 2008 Stepan Kasal <kasal@ucw.cz>
|
||||
# Copyright (c) 2008 Andreas Schwab <schwab@suse.de>
|
||||
# Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
|
||||
# Copyright (c) 2008 Alexandre Oliva
|
||||
#
|
||||
# Copying and distribution of this file, with or without
|
||||
# modification, are permitted in any medium without royalty provided
|
||||
# the copyright notice and this notice are preserved.
|
||||
# Copying and distribution of this file, with or without modification, are
|
||||
# permitted in any medium without royalty provided the copyright notice
|
||||
# and this notice are preserved.
|
||||
|
||||
AC_DEFUN([AC_DEFINE_DIR], [
|
||||
prefix_NONE=
|
||||
|
|
|
@ -1,21 +0,0 @@
|
|||
noinst_LTLIBRARIES = libcfb.la
|
||||
|
||||
include Makefile.am.inc
|
||||
|
||||
DISTCLEANFILES += cfbglrop8.c
|
||||
|
||||
libcfb_la_SOURCES = cfb8bit.c cfbteblt8.c cfbglrop8.c cfbpush8.c cfbrctstp8.c \
|
||||
$(libcfb_gen_sources) $(libcfb_common_sources)
|
||||
|
||||
libcfb_la_LIBADD = ../mfb/libmfb.la
|
||||
|
||||
AM_CFLAGS = -DPSZ=8 $(DIX_CFLAGS) $(PLATFORMDEFS)
|
||||
|
||||
INCLUDES = $(CFB_INCLUDES) -I$(top_srcdir)/hw/xfree86/os-support -I$(top_srcdir)/hw/xfree86/common
|
||||
|
||||
EXTRA_DIST = cfbline.c cfbfillarc.c cfbzerarc.c cfbblt.c cfbsolid.c \
|
||||
cfbtileodd.c cfbtile32.c cfb8line.c cfbply1rct.c cfbglblt8.c \
|
||||
cfb16.h cfb24.h cfb32.h cfb8bit.h cfbrrop.h \
|
||||
stip68kgnu.h stipmips.s stipsparc.s stipsprc32.s
|
||||
|
||||
sdk_HEADERS = cfb.h cfb32.h cfb16.h cfbmap.h cfbunmap.h cfbmskbits.h
|
|
@ -1,153 +0,0 @@
|
|||
libcfb_gen_sources = cfbseg.c cfbfillarcC.c cfbfillarcG.c cfbzerarcC.c cfbzerarcX.c cfbzerarcG.c \
|
||||
cfbbltC.c cfbbltX.c cfbbltO.c cfbbltG.c cfbsolidC.c cfbsolidX.c cfbsolidG.c cfbtileoddC.c \
|
||||
cfbtileoddG.c cfbtile32C.c cfbtile32G.c cfb8lineCO.c cfb8lineCP.c cfb8lineX.c cfb8lineG.c \
|
||||
cfb8segCS.c cfb8segC.c cfb8segX.c cfb8setG.c cfbply1rctC.c cfbply1rctG.c
|
||||
|
||||
DISTCLEANFILES = $(libcfb_gen_sources)
|
||||
|
||||
CFB_INCLUDES = -I$(top_srcdir)/mfb -I$(top_srcdir)/cfb
|
||||
|
||||
libcfb_common_sources = $(top_srcdir)/cfb/cfbgc.c $(top_srcdir)/cfb/cfbrrop.c \
|
||||
$(top_srcdir)/cfb/cfbwindow.c \
|
||||
$(top_srcdir)/cfb/cfbmskbits.c $(top_srcdir)/cfb/cfbpixmap.c \
|
||||
$(top_srcdir)/cfb/cfbbitblt.c $(top_srcdir)/cfb/cfbfillsp.c \
|
||||
$(top_srcdir)/cfb/cfbsetsp.c $(top_srcdir)/cfb/cfbscrinit.c \
|
||||
$(top_srcdir)/cfb/cfballpriv.c $(top_srcdir)/cfb/cfbgetsp.c \
|
||||
$(top_srcdir)/cfb/cfbfillrct.c $(top_srcdir)/cfb/cfbigblt8.c \
|
||||
$(top_srcdir)/cfb/cfbglblt8.c $(top_srcdir)/cfb/cfbtegblt.c \
|
||||
$(top_srcdir)/cfb/cfbpolypnt.c \
|
||||
$(top_srcdir)/cfb/cfbbres.c $(top_srcdir)/cfb/cfbline.c \
|
||||
$(top_srcdir)/cfb/cfbhrzvert.c $(top_srcdir)/cfb/cfbbresd.c \
|
||||
$(top_srcdir)/cfb/cfbimage.c $(top_srcdir)/cfb/cfbcppl.c \
|
||||
$(top_srcdir)/cfb/cfbcmap.c
|
||||
|
||||
cfbseg.c:
|
||||
echo "#define POLYSEGMENT" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbline.c\"" >> $@
|
||||
|
||||
cfbfillarcC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbfillarc.c\"" >> $@
|
||||
|
||||
cfbfillarcG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbfillarc.c\"" >> $@
|
||||
|
||||
cfbzerarcC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbzerarc.c\"" >> $@
|
||||
|
||||
cfbzerarcX.c:
|
||||
echo "#define RROP GXxor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbzerarc.c\"" >> $@
|
||||
|
||||
cfbzerarcG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbzerarc.c\"" >> $@
|
||||
|
||||
cfbbltC.c:
|
||||
echo "#define MROP Mcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbblt.c\"" >> $@
|
||||
|
||||
cfbbltX.c:
|
||||
echo "#define MROP Mxor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbblt.c\"" >> $@
|
||||
|
||||
cfbbltO.c:
|
||||
echo "#define MROP Mor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbblt.c\"" >> $@
|
||||
|
||||
cfbbltG.c:
|
||||
echo "#define MROP 0" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbblt.c\"" >> $@
|
||||
|
||||
cfbsolidC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbsolid.c\"" >> $@
|
||||
|
||||
cfbsolidX.c:
|
||||
echo "#define RROP GXxor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbsolid.c\"" >> $@
|
||||
|
||||
cfbsolidG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbsolid.c\"" >> $@
|
||||
|
||||
cfbtileoddC.c:
|
||||
echo "#define MROP Mcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbtileodd.c\"" >> $@
|
||||
|
||||
cfbtileoddG.c:
|
||||
echo "#define MROP 0" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbtileodd.c\"" >> $@
|
||||
|
||||
cfbtile32C.c:
|
||||
echo "#define MROP Mcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbtile32.c\"" >> $@
|
||||
|
||||
cfbtile32G.c:
|
||||
echo "#define MROP 0" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbtile32.c\"" >> $@
|
||||
|
||||
cfb8lineCO.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8lineCP.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#define PREVIOUS" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8lineX.c:
|
||||
echo "#define RROP GXxor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8lineG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8segCS.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#define POLYSEGMENT" >> $@
|
||||
echo "#define WIDTH_SHIFT" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8segC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#define POLYSEGMENT" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8segX.c:
|
||||
echo "#define RROP GXxor" > $@
|
||||
echo "#define POLYSEGMENT" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8setG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#define POLYSEGMENT" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfbply1rctC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbply1rct.c\"" >> $@
|
||||
|
||||
cfbply1rctG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbply1rct.c\"" >> $@
|
||||
|
||||
cfbglrop8.c:
|
||||
echo "#define GLYPHROP" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbglblt8.c\"" >> $@
|
||||
|
||||
|
||||
if XPRINT
|
||||
|
||||
PLATFORMDEFS = -DXFREE86
|
||||
|
||||
cfb8bit.o: compiler.h
|
||||
|
||||
compiler.h:
|
||||
echo "#include \"$(top_srcdir)/hw/xfree86/common/compiler.h\"" >> $@
|
||||
|
||||
endif
|
||||
|
93
cfb/cfb16.h
93
cfb/cfb16.h
|
@ -1,93 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1994-1998 The XFree86 Project, Inc. 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 THE
|
||||
* XFREE86 PROJECT 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.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifndef _CFB16_H_
|
||||
#define _CFB16_H_
|
||||
|
||||
/*
|
||||
* C's preprocessing language substitutes >text<, not values...
|
||||
*/
|
||||
|
||||
#ifdef OLDPSZ
|
||||
# undef OLDPSZ
|
||||
#endif
|
||||
|
||||
#ifdef PSZ
|
||||
|
||||
# if (PSZ == 8)
|
||||
# define OLDPSZ 8
|
||||
# endif
|
||||
|
||||
# if (PSZ == 16)
|
||||
# define OLDPSZ 16
|
||||
# endif
|
||||
|
||||
# if (PSZ == 24)
|
||||
# define OLDPSZ 24
|
||||
# endif
|
||||
|
||||
# if (PSZ == 32)
|
||||
# define OLDPSZ 32
|
||||
# endif
|
||||
|
||||
# ifndef OLDPSZ
|
||||
/* Maybe an #error here ? */
|
||||
# endif
|
||||
|
||||
# undef PSZ
|
||||
|
||||
#endif
|
||||
|
||||
#define PSZ 16
|
||||
#define CFB_PROTOTYPES_ONLY
|
||||
#include "cfb.h"
|
||||
#undef CFB_PROTOTYPES_ONLY
|
||||
#include "cfbunmap.h"
|
||||
|
||||
#undef PSZ
|
||||
#ifdef OLDPSZ
|
||||
|
||||
# if (OLDPSZ == 8)
|
||||
# define PSZ 8
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 16)
|
||||
# define PSZ 16
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 24)
|
||||
# define PSZ 24
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 32)
|
||||
# define PSZ 32
|
||||
# endif
|
||||
|
||||
# undef OLDPSZ
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* _CFB16_H_ */
|
97
cfb/cfb24.h
97
cfb/cfb24.h
|
@ -1,97 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1994-1998 The XFree86 Project, Inc. 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 THE
|
||||
* XFREE86 PROJECT 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.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#ifndef _CFB24_H_
|
||||
#define _CFB24_H_
|
||||
|
||||
/*
|
||||
* C's preprocessing language substitutes >text<, not values...
|
||||
*/
|
||||
|
||||
#ifdef OLDPSZ
|
||||
# undef OLDPSZ
|
||||
#endif
|
||||
|
||||
#ifdef PSZ
|
||||
|
||||
# if (PSZ == 8)
|
||||
# define OLDPSZ 8
|
||||
# endif
|
||||
|
||||
# if (PSZ == 16)
|
||||
# define OLDPSZ 16
|
||||
# endif
|
||||
|
||||
# if (PSZ == 24)
|
||||
# define OLDPSZ 24
|
||||
# endif
|
||||
|
||||
# if (PSZ == 32)
|
||||
# define OLDPSZ 32
|
||||
# endif
|
||||
|
||||
# ifndef OLDPSZ
|
||||
/* Maybe an #error here ? */
|
||||
# endif
|
||||
|
||||
# undef PSZ
|
||||
|
||||
#endif
|
||||
|
||||
#define PSZ 24
|
||||
#define CFB_PROTOTYPES_ONLY
|
||||
#include "cfb.h"
|
||||
#undef CFB_PROTOTYPES_ONLY
|
||||
#include "cfbunmap.h"
|
||||
|
||||
#undef PSZ
|
||||
#ifdef OLDPSZ
|
||||
|
||||
# if (OLDPSZ == 8)
|
||||
# define PSZ 8
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 16)
|
||||
# define PSZ 16
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 24)
|
||||
# define PSZ 24
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 32)
|
||||
# define PSZ 32
|
||||
# endif
|
||||
|
||||
# undef OLDPSZ
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* _CFB24_H_ */
|
93
cfb/cfb32.h
93
cfb/cfb32.h
|
@ -1,93 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1994-1998 The XFree86 Project, Inc. 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 THE
|
||||
* XFREE86 PROJECT 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.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifndef _CFB32_H_
|
||||
#define _CFB32_H_
|
||||
|
||||
/*
|
||||
* C's preprocessing language substitutes >text<, not values...
|
||||
*/
|
||||
|
||||
#ifdef OLDPSZ
|
||||
# undef OLDPSZ
|
||||
#endif
|
||||
|
||||
#ifdef PSZ
|
||||
|
||||
# if (PSZ == 8)
|
||||
# define OLDPSZ 8
|
||||
# endif
|
||||
|
||||
# if (PSZ == 16)
|
||||
# define OLDPSZ 16
|
||||
# endif
|
||||
|
||||
# if (PSZ == 24)
|
||||
# define OLDPSZ 24
|
||||
# endif
|
||||
|
||||
# if (PSZ == 32)
|
||||
# define OLDPSZ 32
|
||||
# endif
|
||||
|
||||
# ifndef OLDPSZ
|
||||
/* Maybe an #error here ? */
|
||||
# endif
|
||||
|
||||
# undef PSZ
|
||||
|
||||
#endif
|
||||
|
||||
#define PSZ 32
|
||||
#define CFB_PROTOTYPES_ONLY
|
||||
#include "cfb.h"
|
||||
#undef CFB_PROTOTYPES_ONLY
|
||||
#include "cfbunmap.h"
|
||||
|
||||
#undef PSZ
|
||||
#ifdef OLDPSZ
|
||||
|
||||
# if (OLDPSZ == 8)
|
||||
# define PSZ 8
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 16)
|
||||
# define PSZ 16
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 24)
|
||||
# define PSZ 24
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 32)
|
||||
# define PSZ 32
|
||||
# endif
|
||||
|
||||
# undef OLDPSZ
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* _CFB32_H_ */
|
469
cfb/cfb8bit.c
469
cfb/cfb8bit.c
|
@ -1,469 +0,0 @@
|
|||
/*
|
||||
|
||||
Copyright 1989, 1994, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall
|
||||
not be used in advertising or otherwise to promote the sale, use or
|
||||
other dealings in this Software without prior written authorization
|
||||
from The Open Group.
|
||||
|
||||
*/
|
||||
|
||||
/*
|
||||
* cfb8bit.c
|
||||
*
|
||||
* 8 bit color frame buffer utility routines
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
PixelGroup cfb8StippleMasks[NUM_MASKS] = {
|
||||
#if NUM_MASKS == 16
|
||||
0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
|
||||
0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
|
||||
0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
|
||||
0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff
|
||||
#else /* NUM_MASKS == 256 */
|
||||
0x0000000000000000, 0x00000000000000ff,
|
||||
0x000000000000ff00, 0x000000000000ffff,
|
||||
0x0000000000ff0000, 0x0000000000ff00ff,
|
||||
0x0000000000ffff00, 0x0000000000ffffff,
|
||||
0x00000000ff000000, 0x00000000ff0000ff,
|
||||
0x00000000ff00ff00, 0x00000000ff00ffff,
|
||||
0x00000000ffff0000, 0x00000000ffff00ff,
|
||||
0x00000000ffffff00, 0x00000000ffffffff,
|
||||
0x000000ff00000000, 0x000000ff000000ff,
|
||||
0x000000ff0000ff00, 0x000000ff0000ffff,
|
||||
0x000000ff00ff0000, 0x000000ff00ff00ff,
|
||||
0x000000ff00ffff00, 0x000000ff00ffffff,
|
||||
0x000000ffff000000, 0x000000ffff0000ff,
|
||||
0x000000ffff00ff00, 0x000000ffff00ffff,
|
||||
0x000000ffffff0000, 0x000000ffffff00ff,
|
||||
0x000000ffffffff00, 0x000000ffffffffff,
|
||||
0x0000ff0000000000, 0x0000ff00000000ff,
|
||||
0x0000ff000000ff00, 0x0000ff000000ffff,
|
||||
0x0000ff0000ff0000, 0x0000ff0000ff00ff,
|
||||
0x0000ff0000ffff00, 0x0000ff0000ffffff,
|
||||
0x0000ff00ff000000, 0x0000ff00ff0000ff,
|
||||
0x0000ff00ff00ff00, 0x0000ff00ff00ffff,
|
||||
0x0000ff00ffff0000, 0x0000ff00ffff00ff,
|
||||
0x0000ff00ffffff00, 0x0000ff00ffffffff,
|
||||
0x0000ffff00000000, 0x0000ffff000000ff,
|
||||
0x0000ffff0000ff00, 0x0000ffff0000ffff,
|
||||
0x0000ffff00ff0000, 0x0000ffff00ff00ff,
|
||||
0x0000ffff00ffff00, 0x0000ffff00ffffff,
|
||||
0x0000ffffff000000, 0x0000ffffff0000ff,
|
||||
0x0000ffffff00ff00, 0x0000ffffff00ffff,
|
||||
0x0000ffffffff0000, 0x0000ffffffff00ff,
|
||||
0x0000ffffffffff00, 0x0000ffffffffffff,
|
||||
0x00ff000000000000, 0x00ff0000000000ff,
|
||||
0x00ff00000000ff00, 0x00ff00000000ffff,
|
||||
0x00ff000000ff0000, 0x00ff000000ff00ff,
|
||||
0x00ff000000ffff00, 0x00ff000000ffffff,
|
||||
0x00ff0000ff000000, 0x00ff0000ff0000ff,
|
||||
0x00ff0000ff00ff00, 0x00ff0000ff00ffff,
|
||||
0x00ff0000ffff0000, 0x00ff0000ffff00ff,
|
||||
0x00ff0000ffffff00, 0x00ff0000ffffffff,
|
||||
0x00ff00ff00000000, 0x00ff00ff000000ff,
|
||||
0x00ff00ff0000ff00, 0x00ff00ff0000ffff,
|
||||
0x00ff00ff00ff0000, 0x00ff00ff00ff00ff,
|
||||
0x00ff00ff00ffff00, 0x00ff00ff00ffffff,
|
||||
0x00ff00ffff000000, 0x00ff00ffff0000ff,
|
||||
0x00ff00ffff00ff00, 0x00ff00ffff00ffff,
|
||||
0x00ff00ffffff0000, 0x00ff00ffffff00ff,
|
||||
0x00ff00ffffffff00, 0x00ff00ffffffffff,
|
||||
0x00ffff0000000000, 0x00ffff00000000ff,
|
||||
0x00ffff000000ff00, 0x00ffff000000ffff,
|
||||
0x00ffff0000ff0000, 0x00ffff0000ff00ff,
|
||||
0x00ffff0000ffff00, 0x00ffff0000ffffff,
|
||||
0x00ffff00ff000000, 0x00ffff00ff0000ff,
|
||||
0x00ffff00ff00ff00, 0x00ffff00ff00ffff,
|
||||
0x00ffff00ffff0000, 0x00ffff00ffff00ff,
|
||||
0x00ffff00ffffff00, 0x00ffff00ffffffff,
|
||||
0x00ffffff00000000, 0x00ffffff000000ff,
|
||||
0x00ffffff0000ff00, 0x00ffffff0000ffff,
|
||||
0x00ffffff00ff0000, 0x00ffffff00ff00ff,
|
||||
0x00ffffff00ffff00, 0x00ffffff00ffffff,
|
||||
0x00ffffffff000000, 0x00ffffffff0000ff,
|
||||
0x00ffffffff00ff00, 0x00ffffffff00ffff,
|
||||
0x00ffffffffff0000, 0x00ffffffffff00ff,
|
||||
0x00ffffffffffff00, 0x00ffffffffffffff,
|
||||
0xff00000000000000, 0xff000000000000ff,
|
||||
0xff0000000000ff00, 0xff0000000000ffff,
|
||||
0xff00000000ff0000, 0xff00000000ff00ff,
|
||||
0xff00000000ffff00, 0xff00000000ffffff,
|
||||
0xff000000ff000000, 0xff000000ff0000ff,
|
||||
0xff000000ff00ff00, 0xff000000ff00ffff,
|
||||
0xff000000ffff0000, 0xff000000ffff00ff,
|
||||
0xff000000ffffff00, 0xff000000ffffffff,
|
||||
0xff0000ff00000000, 0xff0000ff000000ff,
|
||||
0xff0000ff0000ff00, 0xff0000ff0000ffff,
|
||||
0xff0000ff00ff0000, 0xff0000ff00ff00ff,
|
||||
0xff0000ff00ffff00, 0xff0000ff00ffffff,
|
||||
0xff0000ffff000000, 0xff0000ffff0000ff,
|
||||
0xff0000ffff00ff00, 0xff0000ffff00ffff,
|
||||
0xff0000ffffff0000, 0xff0000ffffff00ff,
|
||||
0xff0000ffffffff00, 0xff0000ffffffffff,
|
||||
0xff00ff0000000000, 0xff00ff00000000ff,
|
||||
0xff00ff000000ff00, 0xff00ff000000ffff,
|
||||
0xff00ff0000ff0000, 0xff00ff0000ff00ff,
|
||||
0xff00ff0000ffff00, 0xff00ff0000ffffff,
|
||||
0xff00ff00ff000000, 0xff00ff00ff0000ff,
|
||||
0xff00ff00ff00ff00, 0xff00ff00ff00ffff,
|
||||
0xff00ff00ffff0000, 0xff00ff00ffff00ff,
|
||||
0xff00ff00ffffff00, 0xff00ff00ffffffff,
|
||||
0xff00ffff00000000, 0xff00ffff000000ff,
|
||||
0xff00ffff0000ff00, 0xff00ffff0000ffff,
|
||||
0xff00ffff00ff0000, 0xff00ffff00ff00ff,
|
||||
0xff00ffff00ffff00, 0xff00ffff00ffffff,
|
||||
0xff00ffffff000000, 0xff00ffffff0000ff,
|
||||
0xff00ffffff00ff00, 0xff00ffffff00ffff,
|
||||
0xff00ffffffff0000, 0xff00ffffffff00ff,
|
||||
0xff00ffffffffff00, 0xff00ffffffffffff,
|
||||
0xffff000000000000, 0xffff0000000000ff,
|
||||
0xffff00000000ff00, 0xffff00000000ffff,
|
||||
0xffff000000ff0000, 0xffff000000ff00ff,
|
||||
0xffff000000ffff00, 0xffff000000ffffff,
|
||||
0xffff0000ff000000, 0xffff0000ff0000ff,
|
||||
0xffff0000ff00ff00, 0xffff0000ff00ffff,
|
||||
0xffff0000ffff0000, 0xffff0000ffff00ff,
|
||||
0xffff0000ffffff00, 0xffff0000ffffffff,
|
||||
0xffff00ff00000000, 0xffff00ff000000ff,
|
||||
0xffff00ff0000ff00, 0xffff00ff0000ffff,
|
||||
0xffff00ff00ff0000, 0xffff00ff00ff00ff,
|
||||
0xffff00ff00ffff00, 0xffff00ff00ffffff,
|
||||
0xffff00ffff000000, 0xffff00ffff0000ff,
|
||||
0xffff00ffff00ff00, 0xffff00ffff00ffff,
|
||||
0xffff00ffffff0000, 0xffff00ffffff00ff,
|
||||
0xffff00ffffffff00, 0xffff00ffffffffff,
|
||||
0xffffff0000000000, 0xffffff00000000ff,
|
||||
0xffffff000000ff00, 0xffffff000000ffff,
|
||||
0xffffff0000ff0000, 0xffffff0000ff00ff,
|
||||
0xffffff0000ffff00, 0xffffff0000ffffff,
|
||||
0xffffff00ff000000, 0xffffff00ff0000ff,
|
||||
0xffffff00ff00ff00, 0xffffff00ff00ffff,
|
||||
0xffffff00ffff0000, 0xffffff00ffff00ff,
|
||||
0xffffff00ffffff00, 0xffffff00ffffffff,
|
||||
0xffffffff00000000, 0xffffffff000000ff,
|
||||
0xffffffff0000ff00, 0xffffffff0000ffff,
|
||||
0xffffffff00ff0000, 0xffffffff00ff00ff,
|
||||
0xffffffff00ffff00, 0xffffffff00ffffff,
|
||||
0xffffffffff000000, 0xffffffffff0000ff,
|
||||
0xffffffffff00ff00, 0xffffffffff00ffff,
|
||||
0xffffffffffff0000, 0xffffffffffff00ff,
|
||||
0xffffffffffffff00, 0xffffffffffffffff
|
||||
#endif
|
||||
};
|
||||
|
||||
int cfb8StippleMode, cfb8StippleAlu, cfb8StippleRRop;
|
||||
PixelGroup cfb8StippleFg, cfb8StippleBg, cfb8StipplePm;
|
||||
PixelGroup cfb8StippleAnd[NUM_MASKS], cfb8StippleXor[NUM_MASKS];
|
||||
|
||||
int
|
||||
cfb8SetStipple (alu, fg, planemask)
|
||||
int alu;
|
||||
CfbBits fg, planemask;
|
||||
{
|
||||
CfbBits and, xor, rrop;
|
||||
int s;
|
||||
CfbBits c;
|
||||
|
||||
cfb8StippleMode = FillStippled;
|
||||
cfb8StippleAlu = alu;
|
||||
cfb8StippleFg = fg & PMSK;
|
||||
cfb8StipplePm = planemask & PMSK;
|
||||
rrop = cfbReduceRasterOp (alu, fg, planemask, &and, &xor);
|
||||
cfb8StippleRRop = rrop;
|
||||
/*
|
||||
* create the appropriate pixel-fill bits for current
|
||||
* foreground
|
||||
*/
|
||||
for (s = 0; s < NUM_MASKS; s++)
|
||||
{
|
||||
c = cfb8StippleMasks[s];
|
||||
cfb8StippleAnd[s] = and | ~c;
|
||||
cfb8StippleXor[s] = xor & c;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
cfb8SetOpaqueStipple (alu, fg, bg, planemask)
|
||||
int alu;
|
||||
CfbBits fg, bg, planemask;
|
||||
{
|
||||
CfbBits andfg, xorfg, andbg, xorbg, rropfg, rropbg;
|
||||
int s;
|
||||
CfbBits c;
|
||||
|
||||
cfb8StippleMode = FillOpaqueStippled;
|
||||
cfb8StippleAlu = alu;
|
||||
cfb8StippleFg = fg & PMSK;
|
||||
cfb8StippleBg = bg & PMSK;
|
||||
cfb8StipplePm = planemask & PMSK;
|
||||
rropfg = cfbReduceRasterOp (alu, cfb8StippleFg, cfb8StipplePm, &andfg, &xorfg);
|
||||
rropbg = cfbReduceRasterOp (alu, cfb8StippleBg, cfb8StipplePm, &andbg, &xorbg);
|
||||
if (rropfg == rropbg)
|
||||
cfb8StippleRRop = rropfg;
|
||||
else
|
||||
cfb8StippleRRop = GXset;
|
||||
/*
|
||||
* create the appropriate pixel-fill bits for current
|
||||
* foreground
|
||||
*/
|
||||
for (s = 0; s < NUM_MASKS; s++)
|
||||
{
|
||||
c = cfb8StippleMasks[s];
|
||||
cfb8StippleAnd[s] = (andfg | ~c) & (andbg | c);
|
||||
cfb8StippleXor[s] = (xorfg & c) | (xorbg & ~c);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* a grungy little routine. This computes clip masks
|
||||
* for partial character blts. Returns rgnOUT if the
|
||||
* entire character is clipped; returns rgnIN if the entire
|
||||
* character is unclipped; returns rgnPART if a portion of
|
||||
* the character is visible. Computes clip masks for each
|
||||
* longword of the character -- and those with the
|
||||
* contents of the glyph to compute the visible bits.
|
||||
*/
|
||||
|
||||
#if PGSZ == 32
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
PixelGroup cfb8BitLenMasks[PGSZ] = {
|
||||
0xffffffff, 0x7fffffff, 0x3fffffff, 0x1fffffff,
|
||||
0x0fffffff, 0x07ffffff, 0x03ffffff, 0x01ffffff,
|
||||
0x00ffffff, 0x007fffff, 0x003fffff, 0x001fffff,
|
||||
0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff,
|
||||
0x0000ffff, 0x00007fff, 0x00003fff, 0x00001fff,
|
||||
0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff,
|
||||
0x000000ff, 0x0000007f, 0x0000003f, 0x0000001f,
|
||||
0x0000000f, 0x00000007, 0x00000003, 0x00000001,
|
||||
};
|
||||
#else
|
||||
PixelGroup cfb8BitLenMasks[PGSZ] = {
|
||||
0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8,
|
||||
0xfffffff0, 0xffffffe0, 0xffffffc0, 0xffffff80,
|
||||
0xffffff00, 0xfffffe00, 0xfffffc00, 0xfffff800,
|
||||
0xfffff000, 0xffffe000, 0xffffc000, 0xffff8000,
|
||||
0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000,
|
||||
0xfff00000, 0xffe00000, 0xffc00000, 0xff800000,
|
||||
0xff000000, 0xfe000000, 0xfc000000, 0xf8000000,
|
||||
0xf0000000, 0xe0000000, 0xc0000000, 0x80000000,
|
||||
};
|
||||
#endif /* BITMAP_BIT_ORDER */
|
||||
#else /* PGSZ == 64 */
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
PixelGroup cfb8BitLenMasks[PGSZ] = {
|
||||
0xffffffffffffffff, 0x7fffffffffffffff,
|
||||
0x3fffffffffffffff, 0x1fffffffffffffff,
|
||||
0x0fffffffffffffff, 0x07ffffffffffffff,
|
||||
0x03ffffffffffffff, 0x01ffffffffffffff,
|
||||
0x00ffffffffffffff, 0x007fffffffffffff,
|
||||
0x003fffffffffffff, 0x001fffffffffffff,
|
||||
0x000fffffffffffff, 0x0007ffffffffffff,
|
||||
0x0003ffffffffffff, 0x0001ffffffffffff,
|
||||
0x0000ffffffffffff, 0x00007fffffffffff,
|
||||
0x00003fffffffffff, 0x00001fffffffffff,
|
||||
0x00000fffffffffff, 0x000007ffffffffff,
|
||||
0x000003ffffffffff, 0x000001ffffffffff,
|
||||
0x000000ffffffffff, 0x0000007fffffffff,
|
||||
0x0000003fffffffff, 0x0000001fffffffff,
|
||||
0x0000000fffffffff, 0x00000007ffffffff,
|
||||
0x00000003ffffffff, 0x00000001ffffffff,
|
||||
0x00000000ffffffff, 0x000000007fffffff,
|
||||
0x000000003fffffff, 0x000000001fffffff,
|
||||
0x000000000fffffff, 0x0000000007ffffff,
|
||||
0x0000000003ffffff, 0x0000000001ffffff,
|
||||
0x0000000000ffffff, 0x00000000007fffff,
|
||||
0x00000000003fffff, 0x00000000001fffff,
|
||||
0x00000000000fffff, 0x000000000007ffff,
|
||||
0x000000000003ffff, 0x000000000001ffff,
|
||||
0x000000000000ffff, 0x0000000000007fff,
|
||||
0x0000000000003fff, 0x0000000000001fff,
|
||||
0x0000000000000fff, 0x00000000000007ff,
|
||||
0x00000000000003ff, 0x00000000000001ff,
|
||||
0x00000000000000ff, 0x000000000000007f,
|
||||
0x000000000000003f, 0x000000000000001f,
|
||||
0x000000000000000f, 0x0000000000000007,
|
||||
0x0000000000000003, 0x0000000000000001
|
||||
};
|
||||
#else
|
||||
PixelGroup cfb8BitLenMasks[PGSZ] = {
|
||||
0xffffffffffffffff, 0xfffffffffffffffe,
|
||||
0xfffffffffffffffc, 0xfffffffffffffff8,
|
||||
0xfffffffffffffff0, 0xffffffffffffffe0,
|
||||
0xffffffffffffffc0, 0xffffffffffffff80,
|
||||
0xffffffffffffff00, 0xfffffffffffffe00,
|
||||
0xfffffffffffffc00, 0xfffffffffffff800,
|
||||
0xfffffffffffff000, 0xffffffffffffe000,
|
||||
0xffffffffffffc000, 0xffffffffffff8000,
|
||||
0xffffffffffff0000, 0xfffffffffffe0000,
|
||||
0xfffffffffffc0000, 0xfffffffffff80000,
|
||||
0xfffffffffff00000, 0xffffffffffe00000,
|
||||
0xffffffffffc00000, 0xffffffffff800000,
|
||||
0xffffffffff000000, 0xfffffffffe000000,
|
||||
0xfffffffffc000000, 0xfffffffff8000000,
|
||||
0xfffffffff0000000, 0xffffffffe0000000,
|
||||
0xffffffffc0000000, 0xffffffff80000000,
|
||||
0xffffffff00000000, 0xfffffffe00000000,
|
||||
0xfffffffc00000000, 0xfffffff800000000,
|
||||
0xfffffff000000000, 0xffffffe000000000,
|
||||
0xffffffc000000000, 0xffffff8000000000,
|
||||
0xffffff0000000000, 0xfffffe0000000000,
|
||||
0xfffffc0000000000, 0xfffff80000000000,
|
||||
0xfffff00000000000, 0xffffe00000000000,
|
||||
0xffffc00000000000, 0xffff800000000000,
|
||||
0xffff000000000000, 0xfffe000000000000,
|
||||
0xfffc000000000000, 0xfff8000000000000,
|
||||
0xfff0000000000000, 0xffe0000000000000,
|
||||
0xffc0000000000000, 0xff80000000000000,
|
||||
0xff00000000000000, 0xfe00000000000000,
|
||||
0xfc00000000000000, 0xf800000000000000,
|
||||
0xf000000000000000, 0xe000000000000000,
|
||||
0xc000000000000000, 0x8000000000000000
|
||||
};
|
||||
#endif /* BITMAP_BIT_ORDER */
|
||||
#endif /* PGSZ */
|
||||
|
||||
|
||||
|
||||
int
|
||||
cfb8ComputeClipMasks32 (pBox, numRects, x, y, w, h, clips)
|
||||
BoxPtr pBox;
|
||||
int numRects;
|
||||
int x, y, w, h;
|
||||
CARD32 *clips;
|
||||
{
|
||||
int yBand, yBandBot;
|
||||
int ch;
|
||||
CfbBits clip;
|
||||
int partIN = FALSE, partOUT = FALSE;
|
||||
int result;
|
||||
|
||||
if (numRects == 0)
|
||||
return rgnOUT;
|
||||
while (numRects && pBox->y2 <= y)
|
||||
{
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
if (!numRects || pBox->y1 >= y + h)
|
||||
return rgnOUT;
|
||||
yBand = pBox->y1;
|
||||
while (numRects && pBox->y1 == yBand && pBox->x2 <= x)
|
||||
{
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
if (!numRects || pBox->y1 >= y + h)
|
||||
return rgnOUT;
|
||||
if (numRects &&
|
||||
x >= pBox->x1 &&
|
||||
x + w <= pBox->x2 &&
|
||||
y >= pBox->y1 &&
|
||||
y + h <= pBox->y2)
|
||||
{
|
||||
return rgnIN;
|
||||
}
|
||||
ch = 0;
|
||||
while (numRects && pBox->y1 < y + h)
|
||||
{
|
||||
yBand = pBox->y1;
|
||||
yBandBot = pBox->y2;
|
||||
while (ch < h && y + ch < yBand)
|
||||
{
|
||||
partOUT = TRUE;
|
||||
clips[ch++] = 0;
|
||||
}
|
||||
if (ch >= h)
|
||||
break;
|
||||
while (numRects && pBox->y1 == yBand && pBox->x2 <= x)
|
||||
{
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
if (!numRects)
|
||||
break;
|
||||
clip = 0;
|
||||
while (numRects && pBox->y1 == yBand && pBox->x1 < x + w)
|
||||
{
|
||||
if (x < pBox->x1)
|
||||
if (pBox->x2 < x + w)
|
||||
clip |= cfb8BitLenMasks[pBox->x1 - x] & ~cfb8BitLenMasks[pBox->x2 - x];
|
||||
else
|
||||
clip |= cfb8BitLenMasks[pBox->x1 - x];
|
||||
else
|
||||
if (pBox->x2 < x + w)
|
||||
clip |= ~cfb8BitLenMasks[pBox->x2 - x];
|
||||
else
|
||||
clip = ~0;
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
if (clip != 0)
|
||||
partIN = TRUE;
|
||||
if (clip != ~0)
|
||||
partOUT = TRUE;
|
||||
while (ch < h && y + ch < yBandBot)
|
||||
clips[ch++] = clip;
|
||||
while (numRects && pBox->y1 == yBand)
|
||||
{
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
}
|
||||
while (ch < h)
|
||||
{
|
||||
partOUT = TRUE;
|
||||
clips[ch++] = 0;
|
||||
}
|
||||
result = rgnOUT;
|
||||
if (partIN)
|
||||
{
|
||||
if (partOUT)
|
||||
result = rgnPART;
|
||||
else
|
||||
result = rgnIN;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
#endif /* PSZ == 8 */
|
1570
cfb/cfb8bit.h
1570
cfb/cfb8bit.h
File diff suppressed because it is too large
Load Diff
1503
cfb/cfb8line.c
1503
cfb/cfb8line.c
File diff suppressed because it is too large
Load Diff
|
@ -1,70 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1991, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "resource.h"
|
||||
#include "colormap.h"
|
||||
#include "colormapst.h"
|
||||
#include "cfb.h"
|
||||
#include "mi.h"
|
||||
#include "mistruct.h"
|
||||
#include "dix.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mibstore.h"
|
||||
|
||||
#if 1 || PSZ==8
|
||||
DevPrivateKey cfbGCPrivateKey = &cfbGCPrivateKey;
|
||||
#endif
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
DevPrivateKey cfbScreenPrivateKey = &cfbScreenPrivateKey;
|
||||
#endif
|
||||
|
||||
|
||||
Bool
|
||||
cfbAllocatePrivates(ScreenPtr pScreen, DevPrivateKey *gc_key)
|
||||
{
|
||||
if (!gc_key || !*gc_key)
|
||||
{
|
||||
if (!mfbAllocatePrivates(pScreen, &cfbGCPrivateKey))
|
||||
return FALSE;
|
||||
if (gc_key)
|
||||
*gc_key = cfbGCPrivateKey;
|
||||
}
|
||||
else
|
||||
{
|
||||
cfbGCPrivateKey = *gc_key;
|
||||
}
|
||||
return dixRequestPrivate(cfbGCPrivateKey, sizeof(cfbPrivGC));
|
||||
}
|
1455
cfb/cfbbitblt.c
1455
cfb/cfbbitblt.c
File diff suppressed because it is too large
Load Diff
933
cfb/cfbblt.c
933
cfb/cfbblt.c
|
@ -1,933 +0,0 @@
|
|||
/*
|
||||
* cfb copy area
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
Author: Keith Packard
|
||||
|
||||
*/
|
||||
|
||||
/* 24-bit bug fixes: Peter Wainwright, 1998/11/28 */
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
#include "fastblt.h"
|
||||
#include "mergerop.h"
|
||||
|
||||
#ifdef notdef /* XXX fails right now, walks off end of pixmaps */
|
||||
#if defined (FAST_UNALIGNED_READS) && PSZ == 8
|
||||
#define DO_UNALIGNED_BITBLT
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(FAST_MEMCPY) && (MROP == Mcopy) && PSZ == 8
|
||||
#define DO_MEMCPY
|
||||
#endif
|
||||
|
||||
/* ................................................. */
|
||||
/* SPECIAL CODE FOR 24 BITS by Peter Wainwright */
|
||||
|
||||
#if PSZ == 24 && (MROP) == 0
|
||||
|
||||
/* The default macros are defined in mergerop.h, and none of them are
|
||||
really appropriate for what we want to do.
|
||||
|
||||
There are two ways of fixing this: either define SLOW_24BIT_COPY
|
||||
to copy pixel by pixel, or (by default) use the following macros
|
||||
modified from mergerop.h
|
||||
|
||||
MROP_SOLID and MROP_MASK are defined for each of the operations,
|
||||
i.e. each value of MROP.
|
||||
|
||||
There are special cases for Mcopy, McopyInverted, Mxor, and Mor.
|
||||
There is a completely generic version for MROP=0, and a simplified
|
||||
generic version which works for (Mcopy|Mxor|MandReverse|Mor).
|
||||
|
||||
However, the generic version does not work for the 24-bit case
|
||||
because the pixels cannot be packed exactly into a machine word (32
|
||||
bits).
|
||||
|
||||
Alternative macros MROP_SOLID24 and MROP_MASK24 are provided for
|
||||
the 24-bit case. However, these each copy a single *pixel*, not a
|
||||
single machine word. They take an rvalue source pixel, an lvalue
|
||||
destination, and the pixel index. The latter is used to find the
|
||||
position of the pixel data within the two words *dst and *(dst+1).
|
||||
|
||||
Further macros MROP_SOLID24P and MROP_MASK24P are used to copy from
|
||||
an lvalue source to an lvalue destination. MROP_PIXEL24 is used to
|
||||
assemble the source pixel from the adjacent words *src and
|
||||
*(src+1), and this is then split between the destination words
|
||||
using the non-P macros above.
|
||||
|
||||
But we want to copy entire words for the sake of efficiency.
|
||||
Unfortunately if a plane mask is specified this must be shifted
|
||||
from one word to the next. Fortunately the pattern repeats after 3
|
||||
words, so we unroll the planemask here and redefine MROP_SOLID
|
||||
and MROP_MASK. */
|
||||
|
||||
|
||||
#endif /* MROP == 0 && PSZ == 24 */
|
||||
|
||||
/* ................................................. */
|
||||
|
||||
#if PSZ == 24
|
||||
#define BYPP 3
|
||||
#if PGSZ == 32
|
||||
#define P3W 4 /* pixels in 3 machine words */
|
||||
#define PAM 3 /* pixel align mask; PAM = P3W -1 */
|
||||
#define P2WSH 2
|
||||
#else
|
||||
#define P3W 8 /* pixels in 3 machine words */
|
||||
#define PAM 7 /* pixel align mask; PAM = P3W -1 */
|
||||
#define P2WSH 3
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void
|
||||
MROP_NAME(cfbDoBitblt)(
|
||||
DrawablePtr pSrc,
|
||||
DrawablePtr pDst,
|
||||
int alu,
|
||||
RegionPtr prgnDst,
|
||||
DDXPointPtr pptSrc,
|
||||
unsigned long planemask)
|
||||
{
|
||||
CfbBits *psrcBase, *pdstBase;
|
||||
/* start of src and dst bitmaps */
|
||||
int widthSrc, widthDst; /* add to get to same position in next line */
|
||||
|
||||
BoxPtr pbox;
|
||||
int nbox;
|
||||
|
||||
BoxPtr pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
|
||||
/* temporaries for shuffling rectangles */
|
||||
DDXPointPtr pptTmp, pptNew1, pptNew2;
|
||||
/* shuffling boxes entails shuffling the
|
||||
source points too */
|
||||
int w, h;
|
||||
int xdir; /* 1 = left right, -1 = right left/ */
|
||||
int ydir; /* 1 = top down, -1 = bottom up */
|
||||
|
||||
CfbBits *psrcLine, *pdstLine;
|
||||
/* pointers to line with current src and dst */
|
||||
register CfbBits *psrc;/* pointer to current src longword */
|
||||
register CfbBits *pdst;/* pointer to current dst longword */
|
||||
|
||||
MROP_DECLARE_REG()
|
||||
|
||||
/* following used for looping through a line */
|
||||
CfbBits startmask, endmask; /* masks for writing ends of dst */
|
||||
int nlMiddle; /* whole longwords in dst */
|
||||
int xoffSrc, xoffDst;
|
||||
register int nl; /* temp copy of nlMiddle */
|
||||
int careful;
|
||||
|
||||
#if (PSZ != 24) || (MROP != 0)
|
||||
register int leftShift, rightShift;
|
||||
register CfbBits bits;
|
||||
register CfbBits bits1;
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#ifdef DO_MEMCPY
|
||||
int w2;
|
||||
#endif
|
||||
|
||||
#if MROP == 0
|
||||
int widthSrcBytes = cfbGetByteWidth(pSrc);
|
||||
int widthDstBytes = cfbGetByteWidth(pDst);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
MROP_INITIALIZE(alu,planemask)
|
||||
|
||||
cfbGetLongWidthAndPointer (pSrc, widthSrc, psrcBase)
|
||||
|
||||
cfbGetLongWidthAndPointer (pDst, widthDst, pdstBase)
|
||||
|
||||
/* XXX we have to err on the side of safety when both are windows,
|
||||
* because we don't know if IncludeInferiors is being used.
|
||||
*/
|
||||
careful = ((pSrc == pDst) ||
|
||||
((pSrc->type == DRAWABLE_WINDOW) &&
|
||||
(pDst->type == DRAWABLE_WINDOW)));
|
||||
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
nbox = REGION_NUM_RECTS(prgnDst);
|
||||
|
||||
pboxNew1 = NULL;
|
||||
pptNew1 = NULL;
|
||||
pboxNew2 = NULL;
|
||||
pptNew2 = NULL;
|
||||
if (careful && (pptSrc->y < pbox->y1))
|
||||
{
|
||||
/* walk source botttom to top */
|
||||
ydir = -1;
|
||||
widthSrc = -widthSrc;
|
||||
widthDst = -widthDst;
|
||||
|
||||
if (nbox > 1)
|
||||
{
|
||||
/* keep ordering in each band, reverse order of bands */
|
||||
pboxNew1 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
|
||||
if(!pboxNew1)
|
||||
return;
|
||||
pptNew1 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
|
||||
if(!pptNew1)
|
||||
{
|
||||
xfree(pboxNew1);
|
||||
return;
|
||||
}
|
||||
pboxBase = pboxNext = pbox+nbox-1;
|
||||
while (pboxBase >= pbox)
|
||||
{
|
||||
while ((pboxNext >= pbox) &&
|
||||
(pboxBase->y1 == pboxNext->y1))
|
||||
pboxNext--;
|
||||
pboxTmp = pboxNext+1;
|
||||
pptTmp = pptSrc + (pboxTmp - pbox);
|
||||
while (pboxTmp <= pboxBase)
|
||||
{
|
||||
*pboxNew1++ = *pboxTmp++;
|
||||
*pptNew1++ = *pptTmp++;
|
||||
}
|
||||
pboxBase = pboxNext;
|
||||
}
|
||||
pboxNew1 -= nbox;
|
||||
pbox = pboxNew1;
|
||||
pptNew1 -= nbox;
|
||||
pptSrc = pptNew1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* walk source top to bottom */
|
||||
ydir = 1;
|
||||
}
|
||||
|
||||
if (careful && (pptSrc->x < pbox->x1))
|
||||
{
|
||||
/* walk source right to left */
|
||||
xdir = -1;
|
||||
|
||||
if (nbox > 1)
|
||||
{
|
||||
/* reverse order of rects in each band */
|
||||
pboxNew2 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
|
||||
pptNew2 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
|
||||
if(!pboxNew2 || !pptNew2)
|
||||
{
|
||||
if (pptNew2) xfree(pptNew2);
|
||||
if (pboxNew2) xfree(pboxNew2);
|
||||
if (pboxNew1)
|
||||
{
|
||||
xfree(pptNew1);
|
||||
xfree(pboxNew1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
pboxBase = pboxNext = pbox;
|
||||
while (pboxBase < pbox+nbox)
|
||||
{
|
||||
while ((pboxNext < pbox+nbox) &&
|
||||
(pboxNext->y1 == pboxBase->y1))
|
||||
pboxNext++;
|
||||
pboxTmp = pboxNext;
|
||||
pptTmp = pptSrc + (pboxTmp - pbox);
|
||||
while (pboxTmp != pboxBase)
|
||||
{
|
||||
*pboxNew2++ = *--pboxTmp;
|
||||
*pptNew2++ = *--pptTmp;
|
||||
}
|
||||
pboxBase = pboxNext;
|
||||
}
|
||||
pboxNew2 -= nbox;
|
||||
pbox = pboxNew2;
|
||||
pptNew2 -= nbox;
|
||||
pptSrc = pptNew2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* walk source left to right */
|
||||
xdir = 1;
|
||||
}
|
||||
|
||||
while(nbox--)
|
||||
{
|
||||
w = pbox->x2 - pbox->x1;
|
||||
h = pbox->y2 - pbox->y1;
|
||||
|
||||
#if PSZ == 24
|
||||
#ifdef DO_MEMCPY
|
||||
w2 = w * BYPP;
|
||||
#endif
|
||||
#endif
|
||||
if (ydir == -1) /* start at last scanline of rectangle */
|
||||
{
|
||||
psrcLine = psrcBase + ((pptSrc->y+h-1) * -widthSrc);
|
||||
pdstLine = pdstBase + ((pbox->y2-1) * -widthDst);
|
||||
}
|
||||
else /* start at first scanline */
|
||||
{
|
||||
psrcLine = psrcBase + (pptSrc->y * widthSrc);
|
||||
pdstLine = pdstBase + (pbox->y1 * widthDst);
|
||||
}
|
||||
#if PSZ == 24
|
||||
if (w == 1 && ((pbox->x1 & PAM) == 0 || (pbox->x1 & PAM) == PAM))
|
||||
#else
|
||||
if ((pbox->x1 & PIM) + w <= PPW)
|
||||
#endif
|
||||
{
|
||||
maskpartialbits (pbox->x1, w, endmask);
|
||||
startmask = 0;
|
||||
nlMiddle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(pbox->x1, w, startmask, endmask, nlMiddle);
|
||||
}
|
||||
|
||||
#if PSZ == 24
|
||||
#if 0
|
||||
nlMiddle = w - (pbox->x2 &PAM);;
|
||||
if(pbox->x1 & PAM){
|
||||
nlMiddle -= (PAM+1 - (pbox->x1 &PAM));
|
||||
}
|
||||
nlMiddle >>= P2WSH;
|
||||
if(nlMiddle < 0)
|
||||
nlMiddle = 0;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef DO_MEMCPY
|
||||
/* If the src and dst scanline don't overlap, do forward case. */
|
||||
|
||||
if ((xdir == 1) || (pptSrc->y != pbox->y1)
|
||||
|| (pptSrc->x + w <= pbox->x1))
|
||||
{
|
||||
#if PSZ == 24
|
||||
char *psrc = (char *) psrcLine + (pptSrc->x * BYPP);
|
||||
char *pdst = (char *) pdstLine + (pbox->x1 * BYPP);
|
||||
#else
|
||||
char *psrc = (char *) psrcLine + pptSrc->x;
|
||||
char *pdst = (char *) pdstLine + pbox->x1;
|
||||
#endif
|
||||
while (h--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
memcpy(pdst, psrc, w2);
|
||||
#else
|
||||
memcpy(pdst, psrc, w);
|
||||
#endif
|
||||
pdst += widthDst << PWSH;
|
||||
psrc += widthSrc << PWSH;
|
||||
}
|
||||
}
|
||||
#else /* ! DO_MEMCPY */
|
||||
if (xdir == 1)
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* Note: x is a pixel number; the byte offset is 3*x;
|
||||
therefore the offset within a word is (3*x) & 3 ==
|
||||
(4*x-x) & 3 == (-x) & 3. The offsets therefore
|
||||
DECREASE by 1 for each pixel.
|
||||
*/
|
||||
xoffSrc = ( - pptSrc->x) & PAM;
|
||||
xoffDst = ( - pbox->x1) & PAM;
|
||||
#if 1
|
||||
if((int)xoffSrc != (int)xoffDst /* Alignments must be same. */
|
||||
|| ((widthDstBytes & PAM) != (widthSrcBytes & PAM) && h > 1))
|
||||
#else
|
||||
if(1)
|
||||
#endif
|
||||
/* Width also must be same, if hight > 1 */
|
||||
{
|
||||
/* ...otherwise, pixel by pixel operation */
|
||||
while (h--)
|
||||
{
|
||||
register int i, si, sii, di;
|
||||
|
||||
for (i = 0, si = pptSrc->x, di = pbox->x1;
|
||||
i < w;
|
||||
i++, si++, di++) {
|
||||
psrc = psrcLine + ((si * BYPP) >> P2WSH);
|
||||
pdst = pdstLine + ((di * BYPP) >> P2WSH);
|
||||
sii = (si & 3);
|
||||
MROP_SOLID24P(psrc, pdst, sii, di);
|
||||
}
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
|
||||
#if PSZ == 24
|
||||
|
||||
#if MROP != 0
|
||||
xoffSrc = ( - pptSrc->x) & PAM;
|
||||
xoffDst = ( - pbox->x1) & PAM;
|
||||
#endif
|
||||
pdstLine += (pbox->x1 * BYPP) >> P2WSH;
|
||||
psrcLine += (pptSrc->x * BYPP) >> P2WSH;
|
||||
#else
|
||||
xoffSrc = pptSrc->x & PIM;
|
||||
xoffDst = pbox->x1 & PIM;
|
||||
pdstLine += (pbox->x1 >> PWSH);
|
||||
psrcLine += (pptSrc->x >> PWSH);
|
||||
#endif
|
||||
#ifdef DO_UNALIGNED_BITBLT
|
||||
nl = xoffSrc - xoffDst;
|
||||
psrcLine = (CfbBits *)
|
||||
(((unsigned char *) psrcLine) + nl);
|
||||
#else
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* alredy satisfied */
|
||||
#else
|
||||
if (xoffSrc == xoffDst)
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
register int index;
|
||||
register int im3;
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
#if PSZ == 24 && MROP == 0
|
||||
index = (int)(pdst - pdstBase);
|
||||
im3 = index % 3;
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
if (startmask)
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
*pdst = DoMaskMergeRop24u(*psrc, *pdst, startmask, im3);
|
||||
index++;
|
||||
im3 = index % 3;
|
||||
#else /* PSZ != 24 || MROP != 0 */
|
||||
*pdst = MROP_MASK(*psrc, *pdst, startmask);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
psrc++;
|
||||
pdst++;
|
||||
}
|
||||
|
||||
nl = nlMiddle;
|
||||
#ifdef LARGE_INSTRUCTION_CACHE
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
|
||||
psrc += nl & (UNROLL-1);
|
||||
pdst += nl & (UNROLL-1);
|
||||
|
||||
#if PSZ == 24 && MROP == 0
|
||||
#define BodyOdd(n) pdst[-n] = DoMergeRop24u(psrc[-n], pdst[-n], ((int)(pdst - n - pdstBase))%3);
|
||||
#define BodyEven(n) pdst[-n] = DoMergeRop24u(psrc[-n], pdst[-n], ((int)(pdst - n - pdstBase))%3);
|
||||
#else /* PSZ != 24 || MROP != 0 */
|
||||
#define BodyOdd(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
|
||||
#define BodyEven(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
|
||||
#define LoopReset \
|
||||
pdst += UNROLL; \
|
||||
psrc += UNROLL;
|
||||
|
||||
#else
|
||||
|
||||
#if PSZ == 24 && MROP == 0
|
||||
#define BodyOdd(n) *pdst = DoMergeRop24u(*psrc, *pdst, im3); pdst++; psrc++; index++; im3 = index % 3;
|
||||
#define BodyEven(n) BodyOdd(n)
|
||||
#else /* PSZ != 24 || MROP != 0 */
|
||||
#define BodyOdd(n) *pdst = MROP_SOLID (*psrc, *pdst); pdst++; psrc++;
|
||||
#define BodyEven(n) BodyOdd(n)
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
|
||||
#define LoopReset ;
|
||||
|
||||
#endif
|
||||
PackedLoop
|
||||
|
||||
#undef BodyOdd
|
||||
#undef BodyEven
|
||||
#undef LoopReset
|
||||
|
||||
#else
|
||||
#ifdef NOTDEF
|
||||
/* you'd think this would be faster --
|
||||
* a single instruction instead of 6
|
||||
* but measurements show it to be ~15% slower
|
||||
*/
|
||||
while ((nl -= 6) >= 0)
|
||||
{
|
||||
asm ("moveml %1+,#0x0c0f;moveml#0x0c0f,%0"
|
||||
: "=m" (*(char *)pdst)
|
||||
: "m" (*(char *)psrc)
|
||||
: "d0", "d1", "d2", "d3",
|
||||
"a2", "a3");
|
||||
pdst += 6;
|
||||
}
|
||||
nl += 6;
|
||||
while (nl--)
|
||||
*pdst++ = *psrc++;
|
||||
#endif
|
||||
#if 0 /*PSZ == 24 && MROP == 0*/
|
||||
DuffL(nl, label1,
|
||||
*pdst = DoMergeRop24u(*psrc, *pdst, im3);
|
||||
pdst++; psrc++; index++;im3 = index % 3;)
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
DuffL(nl, label1,
|
||||
*pdst = MROP_SOLID (*psrc, *pdst);
|
||||
pdst++; psrc++;)
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
#endif
|
||||
|
||||
if (endmask)
|
||||
#if PSZ == 24 && MROP == 0
|
||||
*pdst = DoMaskMergeRop24u(*psrc, *pdst, endmask, (int)(pdst - pdstBase) % 3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
*pdst = MROP_MASK(*psrc, *pdst, endmask);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
}
|
||||
}
|
||||
#ifndef DO_UNALIGNED_BITBLT
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* can not happen */
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
else /* xoffSrc != xoffDst */
|
||||
{
|
||||
if (xoffSrc > xoffDst)
|
||||
{
|
||||
#if PSZ == 24
|
||||
leftShift = (xoffSrc - xoffDst) << 3;
|
||||
#else
|
||||
#if PGSZ == 32
|
||||
leftShift = (xoffSrc - xoffDst) << (5 - PWSH);
|
||||
#else /* PGSZ == 64 */
|
||||
leftShift = (xoffSrc - xoffDst) << (6 - PWSH);
|
||||
#endif /* PGSZ */
|
||||
#endif
|
||||
rightShift = PGSZ - leftShift;
|
||||
}
|
||||
else
|
||||
{
|
||||
#if PSZ == 24
|
||||
rightShift = (xoffDst - xoffSrc) << 3;
|
||||
#else
|
||||
#if PGSZ == 32
|
||||
rightShift = (xoffDst - xoffSrc) << (5 - PWSH);
|
||||
#else /* PGSZ == 64 */
|
||||
rightShift = (xoffDst - xoffSrc) << (6 - PWSH);
|
||||
#endif /* PGSZ */
|
||||
#endif
|
||||
leftShift = PGSZ - rightShift;
|
||||
}
|
||||
while (h--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
bits = 0;
|
||||
if (xoffSrc > xoffDst)
|
||||
bits = *psrc++;
|
||||
if (startmask)
|
||||
{
|
||||
bits1 = BitLeft(bits,leftShift);
|
||||
bits = *psrc++;
|
||||
bits1 |= BitRight(bits,rightShift);
|
||||
*pdst = MROP_MASK(bits1, *pdst, startmask);
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
#ifdef LARGE_INSTRUCTION_CACHE
|
||||
bits1 = bits;
|
||||
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
|
||||
psrc += nl & (UNROLL-1);
|
||||
pdst += nl & (UNROLL-1);
|
||||
|
||||
#define BodyOdd(n) \
|
||||
bits = psrc[-n]; \
|
||||
pdst[-n] = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), pdst[-n]);
|
||||
|
||||
#define BodyEven(n) \
|
||||
bits1 = psrc[-n]; \
|
||||
pdst[-n] = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), pdst[-n]);
|
||||
|
||||
#define LoopReset \
|
||||
pdst += UNROLL; \
|
||||
psrc += UNROLL;
|
||||
|
||||
#else
|
||||
|
||||
#define BodyOdd(n) \
|
||||
bits = *psrc++; \
|
||||
*pdst = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), *pdst); \
|
||||
pdst++;
|
||||
|
||||
#define BodyEven(n) \
|
||||
bits1 = *psrc++; \
|
||||
*pdst = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), *pdst); \
|
||||
pdst++;
|
||||
|
||||
#define LoopReset ;
|
||||
|
||||
#endif /* !FAST_CONSTANT_OFFSET_MODE */
|
||||
|
||||
PackedLoop
|
||||
|
||||
#undef BodyOdd
|
||||
#undef BodyEven
|
||||
#undef LoopReset
|
||||
|
||||
#else
|
||||
DuffL (nl,label2,
|
||||
bits1 = BitLeft(bits, leftShift);
|
||||
bits = *psrc++;
|
||||
*pdst = MROP_SOLID (bits1 | BitRight(bits, rightShift), *pdst);
|
||||
pdst++;
|
||||
)
|
||||
#endif
|
||||
|
||||
if (endmask)
|
||||
{
|
||||
bits1 = BitLeft(bits, leftShift);
|
||||
if (BitLeft(endmask, rightShift))
|
||||
{
|
||||
bits = *psrc;
|
||||
bits1 |= BitRight(bits, rightShift);
|
||||
}
|
||||
*pdst = MROP_MASK (bits1, *pdst, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* (PSZ == 24 && MROP == 0) */
|
||||
#endif /* DO_UNALIGNED_BITBLT */
|
||||
|
||||
}
|
||||
}
|
||||
#endif /* ! DO_MEMCPY */
|
||||
else /* xdir == -1 */
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
xoffSrc = (-(pptSrc->x + w)) & PAM;
|
||||
xoffDst = (-pbox->x2) & PAM;
|
||||
#if 1
|
||||
if(xoffSrc != xoffDst /* Alignments must be same. */
|
||||
|| ((widthDstBytes & PAM) != (widthSrcBytes & PAM) && h > 1))
|
||||
#else
|
||||
if(1)
|
||||
#endif
|
||||
/* Width also must be same, if hight > 1 */
|
||||
{
|
||||
/* ...otherwise, pixel by pixel operation */
|
||||
while (h--)
|
||||
{
|
||||
register int i, si, sii, di;
|
||||
|
||||
for (i = 0, si = pptSrc->x + w - 1, di = pbox->x2 - 1;
|
||||
i < w;
|
||||
i++, si--, di--) {
|
||||
psrc = psrcLine + ((si * BYPP) >> P2WSH);
|
||||
pdst = pdstLine + ((di * BYPP) >> P2WSH);
|
||||
sii = (si & PAM);
|
||||
MROP_SOLID24P(psrc, pdst, sii, di);
|
||||
}
|
||||
psrcLine += widthSrc;
|
||||
pdstLine += widthDst;
|
||||
}
|
||||
}else
|
||||
#endif /* MROP == 0 && PSZ == 24 */
|
||||
{
|
||||
|
||||
#if PSZ == 24
|
||||
#if MROP == 0
|
||||
/* already calculated */
|
||||
#else
|
||||
xoffSrc = (pptSrc->x + w) & PAM;
|
||||
xoffDst = pbox->x2 & PAM;
|
||||
#endif
|
||||
pdstLine += ((pbox->x2 * BYPP - 1) >> P2WSH) + 1;
|
||||
psrcLine += (((pptSrc->x+w) * BYPP - 1) >> P2WSH) + 1;
|
||||
#else
|
||||
xoffSrc = (pptSrc->x + w - 1) & PIM;
|
||||
xoffDst = (pbox->x2 - 1) & PIM;
|
||||
pdstLine += ((pbox->x2-1) >> PWSH) + 1;
|
||||
psrcLine += ((pptSrc->x+w - 1) >> PWSH) + 1;
|
||||
#endif
|
||||
#ifdef DO_UNALIGNED_BITBLT
|
||||
#if PSZ == 24
|
||||
nl = xoffDst - xoffSrc;
|
||||
#else
|
||||
nl = xoffSrc - xoffDst;
|
||||
#endif
|
||||
psrcLine = (CfbBits *)
|
||||
(((unsigned char *) psrcLine) + nl);
|
||||
#else
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* already satisfied */
|
||||
#else
|
||||
if (xoffSrc == xoffDst)
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
register int index;
|
||||
register int im3;
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
#if PSZ == 24 && MROP == 0
|
||||
index = (int)(pdst - pdstBase);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
|
||||
if (endmask)
|
||||
{
|
||||
pdst--;
|
||||
psrc--;
|
||||
#if PSZ == 24 && MROP == 0
|
||||
index--;
|
||||
im3 = index % 3;
|
||||
*pdst = DoMaskMergeRop24u(*psrc, *pdst, endmask, im3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
*pdst = MROP_MASK (*psrc, *pdst, endmask);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
}
|
||||
nl = nlMiddle;
|
||||
#ifdef LARGE_INSTRUCTION_CACHE
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
psrc -= nl & (UNROLL - 1);
|
||||
pdst -= nl & (UNROLL - 1);
|
||||
|
||||
#if PSZ == 24 && MROP == 0
|
||||
#define BodyOdd(n) pdst[n-1] = DoMergeRop24u(psrc[n-1], pdst[n-1], ((int)(pdst - (n - 1) -pdstBase)) % 3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
#define BodyOdd(n) pdst[n-1] = MROP_SOLID (psrc[n-1], pdst[n-1]);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
|
||||
#define BodyEven(n) BodyOdd(n)
|
||||
|
||||
#define LoopReset \
|
||||
pdst -= UNROLL;\
|
||||
psrc -= UNROLL;
|
||||
|
||||
#else
|
||||
|
||||
#if PSZ == 24 && MROP == 0
|
||||
#define BodyOdd(n) --pdst; --psrc; --index; im3 = index % 3;*pdst = DoMergeRop24u(*psrc, *pdst, im3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
#define BodyOdd(n) --pdst; --psrc; *pdst = MROP_SOLID(*psrc, *pdst);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
#define BodyEven(n) BodyOdd(n)
|
||||
#define LoopReset ;
|
||||
|
||||
#endif
|
||||
PackedLoop
|
||||
|
||||
#undef BodyOdd
|
||||
#undef BodyEven
|
||||
#undef LoopReset
|
||||
|
||||
#else
|
||||
#if PSZ == 24 && MROP == 0
|
||||
DuffL(nl,label3,
|
||||
--pdst; --psrc; --index; im3= index%3;*pdst = DoMergeRop24u(*psrc, *pdst, im3);)
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
DuffL(nl,label3,
|
||||
--pdst; --psrc; *pdst = MROP_SOLID (*psrc, *pdst);)
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
#endif
|
||||
|
||||
if (startmask)
|
||||
{
|
||||
--pdst;
|
||||
--psrc;
|
||||
#if PSZ == 24 && MROP == 0
|
||||
*pdst = DoMaskMergeRop24u(*psrc, *pdst, startmask, (int)(pdst - pdstBase) % 3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
*pdst = MROP_MASK(*psrc, *pdst, startmask);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifndef DO_UNALIGNED_BITBLT
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* can not happen */
|
||||
#else /* !( PSZ == 24 && MROP == 0) */
|
||||
else
|
||||
{
|
||||
if (xoffDst > xoffSrc)
|
||||
{
|
||||
#if PSZ == 24
|
||||
leftShift = (xoffDst - xoffSrc) << 3;
|
||||
rightShift = PGSZ - leftShift;
|
||||
#else
|
||||
#if PGSZ == 32
|
||||
rightShift = (xoffDst - xoffSrc) << (5 - PWSH);
|
||||
#else /* PGSZ == 64 */
|
||||
rightShift = (xoffDst - xoffSrc) << (6 - PWSH);
|
||||
#endif /* PGSZ */
|
||||
leftShift = PGSZ - rightShift;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#if PSZ == 24
|
||||
rightShift = (xoffSrc - xoffDst) << 3;
|
||||
leftShift = PGSZ - rightShift;
|
||||
#else
|
||||
#if PGSZ == 32
|
||||
leftShift = (xoffSrc - xoffDst) << (5 - PWSH);
|
||||
#else /* PGSZ == 64 */
|
||||
leftShift = (xoffSrc - xoffDst) << (6 - PWSH);
|
||||
#endif /* PGSZ */
|
||||
rightShift = PGSZ - leftShift;
|
||||
#endif
|
||||
}
|
||||
while (h--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
bits = 0;
|
||||
#if PSZ == 24
|
||||
if (xoffSrc > xoffDst)
|
||||
#else
|
||||
if (xoffDst > xoffSrc)
|
||||
#endif
|
||||
bits = *--psrc;
|
||||
if (endmask)
|
||||
{
|
||||
bits1 = BitRight(bits, rightShift);
|
||||
bits = *--psrc;
|
||||
bits1 |= BitLeft(bits, leftShift);
|
||||
pdst--;
|
||||
*pdst = MROP_MASK(bits1, *pdst, endmask);
|
||||
}
|
||||
nl = nlMiddle;
|
||||
#ifdef LARGE_INSTRUCTION_CACHE
|
||||
bits1 = bits;
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
psrc -= nl & (UNROLL - 1);
|
||||
pdst -= nl & (UNROLL - 1);
|
||||
|
||||
#define BodyOdd(n) \
|
||||
bits = psrc[n-1]; \
|
||||
pdst[n-1] = MROP_SOLID(BitRight(bits1, rightShift) | BitLeft(bits, leftShift),pdst[n-1]);
|
||||
|
||||
#define BodyEven(n) \
|
||||
bits1 = psrc[n-1]; \
|
||||
pdst[n-1] = MROP_SOLID(BitRight(bits, rightShift) | BitLeft(bits1, leftShift),pdst[n-1]);
|
||||
|
||||
#define LoopReset \
|
||||
pdst -= UNROLL; \
|
||||
psrc -= UNROLL;
|
||||
|
||||
#else
|
||||
|
||||
#define BodyOdd(n) \
|
||||
bits = *--psrc; --pdst; \
|
||||
*pdst = MROP_SOLID(BitRight(bits1, rightShift) | BitLeft(bits, leftShift),*pdst);
|
||||
|
||||
#define BodyEven(n) \
|
||||
bits1 = *--psrc; --pdst; \
|
||||
*pdst = MROP_SOLID(BitRight(bits, rightShift) | BitLeft(bits1, leftShift),*pdst);
|
||||
|
||||
#define LoopReset ;
|
||||
|
||||
#endif
|
||||
|
||||
PackedLoop
|
||||
|
||||
#undef BodyOdd
|
||||
#undef BodyEven
|
||||
#undef LoopReset
|
||||
|
||||
#else
|
||||
DuffL (nl, label4,
|
||||
bits1 = BitRight(bits, rightShift);
|
||||
bits = *--psrc;
|
||||
--pdst;
|
||||
*pdst = MROP_SOLID(bits1 | BitLeft(bits, leftShift),*pdst);
|
||||
)
|
||||
#endif
|
||||
|
||||
if (startmask)
|
||||
{
|
||||
bits1 = BitRight(bits, rightShift);
|
||||
if (BitRight (startmask, leftShift))
|
||||
{
|
||||
bits = *--psrc;
|
||||
bits1 |= BitLeft(bits, leftShift);
|
||||
}
|
||||
--pdst;
|
||||
*pdst = MROP_MASK(bits1, *pdst, startmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
#endif
|
||||
}
|
||||
}
|
||||
pbox++;
|
||||
pptSrc++;
|
||||
}
|
||||
if (pboxNew2)
|
||||
{
|
||||
xfree(pptNew2);
|
||||
xfree(pboxNew2);
|
||||
}
|
||||
if (pboxNew1)
|
||||
{
|
||||
xfree(pptNew1);
|
||||
xfree(pboxNew1);
|
||||
}
|
||||
}
|
340
cfb/cfbbres.c
340
cfb/cfbbres.c
|
@ -1,340 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "misc.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "servermd.h"
|
||||
#include "miline.h"
|
||||
|
||||
/* Solid bresenham line */
|
||||
/* NOTES
|
||||
e2 is used less often than e1, so it's not in a register
|
||||
*/
|
||||
|
||||
void
|
||||
cfbBresS(rop, and, xor, addrl, nlwidth, signdx, signdy, axis, x1, y1, e, e1,
|
||||
e2, len)
|
||||
int rop;
|
||||
CfbBits and, xor;
|
||||
CfbBits *addrl; /* pointer to base of bitmap */
|
||||
int nlwidth; /* width in longwords of bitmap */
|
||||
register int signdx;
|
||||
int signdy; /* signs of directions */
|
||||
int axis; /* major axis (Y_AXIS or X_AXIS) */
|
||||
int x1, y1; /* initial point */
|
||||
register int e; /* error accumulator */
|
||||
register int e1; /* bresenham increments */
|
||||
int e2;
|
||||
int len; /* length of line */
|
||||
{
|
||||
register int e3 = e2-e1;
|
||||
#if PSZ == 24
|
||||
CfbBits piQxelXor[3],piQxelAnd[3];
|
||||
char *addrb;
|
||||
int nlwidth3, signdx3;
|
||||
#endif
|
||||
#ifdef PIXEL_ADDR
|
||||
register PixelType *addrp; /* Pixel pointer */
|
||||
|
||||
if (len == 0)
|
||||
return;
|
||||
/* point to first point */
|
||||
nlwidth <<= PWSH;
|
||||
#if PSZ == 24
|
||||
addrp = (PixelType *)(addrl) + (y1 * nlwidth);
|
||||
addrb = (char *)addrp + x1 * 3;
|
||||
|
||||
piQxelXor[0] = (xor << 24) | xor;
|
||||
piQxelXor[1] = (xor << 16)| (xor >> 8);
|
||||
piQxelXor[2] = (xor << 8) | (xor >> 16);
|
||||
piQxelAnd[0] = (and << 24) | and;
|
||||
piQxelAnd[1] = (and << 16)| (and >> 8);
|
||||
piQxelAnd[2] = (and << 8) | (and >> 16);
|
||||
#else
|
||||
addrp = (PixelType *)(addrl) + (y1 * nlwidth) + x1;
|
||||
#endif
|
||||
if (signdy < 0)
|
||||
nlwidth = -nlwidth;
|
||||
e = e-e1; /* to make looping easier */
|
||||
#if PSZ == 24
|
||||
nlwidth3 = nlwidth * sizeof (CfbBits);
|
||||
signdx3 = signdx * 3;
|
||||
#endif
|
||||
|
||||
if (axis == Y_AXIS)
|
||||
{
|
||||
int t;
|
||||
|
||||
t = nlwidth;
|
||||
nlwidth = signdx;
|
||||
signdx = t;
|
||||
#if PSZ == 24
|
||||
t = nlwidth3;
|
||||
nlwidth3 = signdx3;
|
||||
signdx3 = t;
|
||||
#endif
|
||||
}
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
--len;
|
||||
#if PSZ == 24
|
||||
#define body_copy \
|
||||
addrp = (PixelType *)((unsigned long)addrb & ~0x03); \
|
||||
switch((unsigned long)addrb & 3){ \
|
||||
case 0: \
|
||||
*addrp = ((*addrp)&0xFF000000)|(piQxelXor[0] & 0xFFFFFF); \
|
||||
break; \
|
||||
case 1: \
|
||||
*addrp = ((*addrp)&0xFF)|(piQxelXor[2] & 0xFFFFFF00); \
|
||||
break; \
|
||||
case 3: \
|
||||
*addrp = ((*addrp)&0xFFFFFF)|(piQxelXor[0] & 0xFF000000); \
|
||||
*(addrp+1) = ((*(addrp+1))&0xFFFF0000)|(piQxelXor[1] & 0xFFFF); \
|
||||
break; \
|
||||
case 2: \
|
||||
*addrp = ((*addrp)&0xFFFF)|(piQxelXor[1] & 0xFFFF0000); \
|
||||
*(addrp+1) = ((*(addrp+1))&0xFFFFFF00)|(piQxelXor[2] & 0xFF); \
|
||||
break; \
|
||||
}
|
||||
#define body {\
|
||||
body_copy \
|
||||
addrb += signdx3; \
|
||||
e += e1; \
|
||||
if (e >= 0) \
|
||||
{ \
|
||||
addrb += nlwidth3; \
|
||||
e += e3; \
|
||||
} \
|
||||
}
|
||||
#else /* PSZ == 24 */
|
||||
#define body {\
|
||||
*addrp = xor; \
|
||||
addrp += signdx; \
|
||||
e += e1; \
|
||||
if (e >= 0) \
|
||||
{ \
|
||||
addrp += nlwidth; \
|
||||
e += e3; \
|
||||
} \
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
while (len >= 4)
|
||||
{
|
||||
body body body body
|
||||
len -= 4;
|
||||
}
|
||||
switch (len)
|
||||
{
|
||||
case 3: body case 2: body case 1: body
|
||||
}
|
||||
#undef body
|
||||
#if PSZ == 24
|
||||
body_copy
|
||||
# undef body_copy
|
||||
#else
|
||||
*addrp = xor;
|
||||
#endif
|
||||
}
|
||||
else /* not GXcopy */
|
||||
{
|
||||
while(len--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
addrp = (PixelType *)((unsigned long)addrb & ~0x03);
|
||||
switch((unsigned long)addrb & 3){
|
||||
case 0:
|
||||
*addrp = (*addrp & (piQxelAnd[0]|0xFF000000))
|
||||
^ (piQxelXor[0] & 0xFFFFFF);
|
||||
break;
|
||||
case 1:
|
||||
*addrp = (*addrp & (piQxelAnd[2]|0xFF))
|
||||
^ (piQxelXor[2] & 0xFFFFFF00);
|
||||
break;
|
||||
case 3:
|
||||
*addrp = (*addrp & (piQxelAnd[0]|0xFFFFFF))
|
||||
^ (piQxelXor[0] & 0xFF000000);
|
||||
*(addrp+1) = (*(addrp+1) & (piQxelAnd[1]|0xFFFF0000))
|
||||
^ (piQxelXor[1] & 0xFFFF);
|
||||
break;
|
||||
case 2:
|
||||
*addrp = (*addrp & (piQxelAnd[1]|0xFFFF))
|
||||
^ (piQxelXor[1] & 0xFFFF0000);
|
||||
*(addrp+1) = (*(addrp+1) & (piQxelAnd[2]|0xFFFFFF00))
|
||||
^ (piQxelXor[2] & 0xFF);
|
||||
break;
|
||||
}
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
addrb += nlwidth3;
|
||||
e += e3;
|
||||
}
|
||||
addrb += signdx3;
|
||||
#else /* PSZ == 24 */
|
||||
*addrp = DoRRop (*addrp, and, xor);
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
addrp += nlwidth;
|
||||
e += e3;
|
||||
}
|
||||
addrp += signdx;
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
}
|
||||
#else /* !PIXEL_ADDR */
|
||||
register CfbBits tmp, bit;
|
||||
CfbBits leftbit, rightbit;
|
||||
|
||||
/* point to longword containing first point */
|
||||
#if PSZ == 24
|
||||
addrl = (addrl + (y1 * nlwidth) + ((x1 * 3) >>2);
|
||||
#else
|
||||
addrl = (addrl + (y1 * nlwidth) + (x1 >> PWSH));
|
||||
#endif
|
||||
if (signdy < 0)
|
||||
nlwidth = -nlwidth;
|
||||
e = e-e1; /* to make looping easier */
|
||||
|
||||
leftbit = cfbmask[0];
|
||||
#if PSZ == 24
|
||||
rightbit = cfbmask[(PPW-1)<<1];
|
||||
bit = cfbmask[(x1 & 3)<<1];
|
||||
#else
|
||||
rightbit = cfbmask[PPW-1];
|
||||
bit = cfbmask[x1 & PIM];
|
||||
#endif
|
||||
|
||||
if (axis == X_AXIS)
|
||||
{
|
||||
if (signdx > 0)
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, bit);
|
||||
bit = SCRRIGHT(bit,1);
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
addrl += nlwidth;
|
||||
e += e3;
|
||||
}
|
||||
if (!bit)
|
||||
{
|
||||
bit = leftbit;
|
||||
addrl++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, bit);
|
||||
e += e1;
|
||||
bit = SCRLEFT(bit,1);
|
||||
if (e >= 0)
|
||||
{
|
||||
addrl += nlwidth;
|
||||
e += e3;
|
||||
}
|
||||
if (!bit)
|
||||
{
|
||||
bit = rightbit;
|
||||
addrl--;
|
||||
}
|
||||
}
|
||||
}
|
||||
} /* if X_AXIS */
|
||||
else
|
||||
{
|
||||
if (signdx > 0)
|
||||
{
|
||||
while(len--)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, bit);
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
bit = SCRRIGHT(bit,1);
|
||||
if (!bit)
|
||||
{
|
||||
bit = leftbit;
|
||||
addrl++;
|
||||
}
|
||||
e += e3;
|
||||
}
|
||||
addrl += nlwidth;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while(len--)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, bit);
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
bit = SCRLEFT(bit,1);
|
||||
if (!bit)
|
||||
{
|
||||
bit = rightbit;
|
||||
addrl--;
|
||||
}
|
||||
e += e3;
|
||||
}
|
||||
addrl += nlwidth;
|
||||
}
|
||||
}
|
||||
} /* else Y_AXIS */
|
||||
#endif
|
||||
}
|
404
cfb/cfbbresd.c
404
cfb/cfbbresd.c
|
@ -1,404 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "misc.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "miline.h"
|
||||
|
||||
/* Dashed bresenham line */
|
||||
|
||||
void
|
||||
cfbBresD(rrops,
|
||||
pdashIndex, pDash, numInDashList, pdashOffset, isDoubleDash,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, x1, y1, e, e1, e2, len)
|
||||
cfbRRopPtr rrops;
|
||||
int *pdashIndex; /* current dash */
|
||||
unsigned char *pDash; /* dash list */
|
||||
int numInDashList; /* total length of dash list */
|
||||
int *pdashOffset; /* offset into current dash */
|
||||
int isDoubleDash;
|
||||
CfbBits *addrl; /* pointer to base of bitmap */
|
||||
int nlwidth; /* width in longwords of bitmap */
|
||||
int signdx, signdy; /* signs of directions */
|
||||
int axis; /* major axis (Y_AXIS or X_AXIS) */
|
||||
int x1, y1; /* initial point */
|
||||
register int e; /* error accumulator */
|
||||
register int e1; /* bresenham increments */
|
||||
int e2;
|
||||
int len; /* length of line */
|
||||
{
|
||||
#ifdef PIXEL_ADDR
|
||||
register PixelType *addrp;
|
||||
#endif
|
||||
register int e3 = e2-e1;
|
||||
int dashIndex;
|
||||
int dashOffset;
|
||||
int dashRemaining;
|
||||
CfbBits xorFg, andFg, xorBg, andBg;
|
||||
Bool isCopy;
|
||||
int thisDash;
|
||||
#if PSZ == 24
|
||||
CfbBits xorPiQxlFg[3], andPiQxlFg[3], xorPiQxlBg[3], andPiQxlBg[3];
|
||||
char *addrb;
|
||||
int signdx3, signdy3;
|
||||
#endif
|
||||
|
||||
dashOffset = *pdashOffset;
|
||||
dashIndex = *pdashIndex;
|
||||
isCopy = (rrops[0].rop == GXcopy && rrops[1].rop == GXcopy);
|
||||
#if PSZ == 24
|
||||
xorFg = rrops[0].xor & 0xffffff;
|
||||
andFg = rrops[0].and & 0xffffff;
|
||||
xorBg = rrops[1].xor & 0xffffff;
|
||||
andBg = rrops[1].and & 0xffffff;
|
||||
xorPiQxlFg[0] = xorFg | (xorFg << 24);
|
||||
xorPiQxlFg[1] = (xorFg >> 8) | (xorFg << 16);
|
||||
xorPiQxlFg[2] = (xorFg >> 16) | (xorFg << 8);
|
||||
andPiQxlFg[0] = andFg | (andFg << 24);
|
||||
andPiQxlFg[1] = (andFg >> 8) | (andFg << 16);
|
||||
andPiQxlFg[2] = (andFg >> 16) | (andFg << 8);
|
||||
xorPiQxlBg[0] = xorBg | (xorBg << 24);
|
||||
xorPiQxlBg[1] = (xorBg >> 8) | (xorBg << 16);
|
||||
xorPiQxlBg[2] = (xorBg >> 16) | (xorBg << 8);
|
||||
andPiQxlBg[0] = andBg | (andBg << 24);
|
||||
andPiQxlBg[1] = (andBg >> 8) | (andBg << 16);
|
||||
andPiQxlBg[2] = (andFg >> 16) | (andBg << 8);
|
||||
#else
|
||||
xorFg = rrops[0].xor;
|
||||
andFg = rrops[0].and;
|
||||
xorBg = rrops[1].xor;
|
||||
andBg = rrops[1].and;
|
||||
#endif
|
||||
dashRemaining = pDash[dashIndex] - dashOffset;
|
||||
if ((thisDash = dashRemaining) >= len)
|
||||
{
|
||||
thisDash = len;
|
||||
dashRemaining -= len;
|
||||
}
|
||||
e = e-e1; /* to make looping easier */
|
||||
|
||||
#define BresStep(minor,major) {if ((e += e1) >= 0) { e += e3; minor; } major;}
|
||||
|
||||
#define NextDash {\
|
||||
dashIndex++; \
|
||||
if (dashIndex == numInDashList) \
|
||||
dashIndex = 0; \
|
||||
dashRemaining = pDash[dashIndex]; \
|
||||
if ((thisDash = dashRemaining) >= len) \
|
||||
{ \
|
||||
dashRemaining -= len; \
|
||||
thisDash = len; \
|
||||
} \
|
||||
}
|
||||
|
||||
#ifdef PIXEL_ADDR
|
||||
|
||||
#if PSZ == 24
|
||||
#define Loop(store) while (thisDash--) {\
|
||||
store; \
|
||||
BresStep(addrb+=signdy3,addrb+=signdx3) \
|
||||
}
|
||||
/* point to first point */
|
||||
nlwidth <<= PWSH;
|
||||
addrp = (PixelType *)(addrl) + (y1 * nlwidth);
|
||||
addrb = (char *)addrp + x1 * 3;
|
||||
|
||||
#else
|
||||
#define Loop(store) while (thisDash--) {\
|
||||
store; \
|
||||
BresStep(addrp+=signdy,addrp+=signdx) \
|
||||
}
|
||||
/* point to first point */
|
||||
nlwidth <<= PWSH;
|
||||
addrp = (PixelType *)(addrl) + (y1 * nlwidth) + x1;
|
||||
#endif
|
||||
signdy *= nlwidth;
|
||||
#if PSZ == 24
|
||||
signdx3 = signdx * 3;
|
||||
signdy3 = signdy * sizeof (CfbBits);
|
||||
#endif
|
||||
if (axis == Y_AXIS)
|
||||
{
|
||||
int t;
|
||||
|
||||
t = signdx;
|
||||
signdx = signdy;
|
||||
signdy = t;
|
||||
#if PSZ == 24
|
||||
t = signdx3;
|
||||
signdx3 = signdy3;
|
||||
signdy3 = t;
|
||||
#endif
|
||||
}
|
||||
|
||||
if (isCopy)
|
||||
{
|
||||
#if PSZ == 24
|
||||
#define body_copy(pix) { \
|
||||
addrp = (PixelType *)((unsigned long)addrb & ~0x03); \
|
||||
switch((unsigned long)addrb & 3){ \
|
||||
case 0: \
|
||||
*addrp = (*addrp & 0xFF000000)|((pix)[0] & 0xFFFFFF); \
|
||||
break; \
|
||||
case 1: \
|
||||
*addrp = (*addrp & 0xFF)|((pix)[2] & 0xFFFFFF00); \
|
||||
break; \
|
||||
case 3: \
|
||||
*addrp = (*addrp & 0xFFFFFF)|((pix)[0] & 0xFF000000); \
|
||||
*(addrp+1) = (*(addrp+1) & 0xFFFF0000)|((pix)[1] & 0xFFFF); \
|
||||
break; \
|
||||
case 2: \
|
||||
*addrp = (*addrp & 0xFFFF)|((pix)[1] & 0xFFFF0000); \
|
||||
*(addrp+1) = (*(addrp+1) & 0xFFFFFF00)|((pix)[2] & 0xFF); \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
|
||||
for (;;)
|
||||
{
|
||||
len -= thisDash;
|
||||
if (dashIndex & 1) {
|
||||
if (isDoubleDash) {
|
||||
#if PSZ == 24
|
||||
Loop(body_copy(xorPiQxlBg))
|
||||
#else
|
||||
Loop(*addrp = xorBg)
|
||||
#endif
|
||||
} else {
|
||||
Loop(;)
|
||||
}
|
||||
} else {
|
||||
#if PSZ == 24
|
||||
Loop(body_copy(xorPiQxlFg))
|
||||
#else
|
||||
Loop(*addrp = xorFg)
|
||||
#endif
|
||||
}
|
||||
if (!len)
|
||||
break;
|
||||
NextDash
|
||||
}
|
||||
#undef body_copy
|
||||
}
|
||||
else
|
||||
{
|
||||
#define body_set(and, xor) { \
|
||||
addrp = (PixelType *)((unsigned long)addrb & ~0x03); \
|
||||
switch((unsigned long)addrb & 3){ \
|
||||
case 0: \
|
||||
*addrp = (*addrp & ((and)[0]|0xFF000000)) ^ ((xor)[0] & 0xFFFFFF); \
|
||||
break; \
|
||||
case 1: \
|
||||
*addrp = (*addrp & ((and)[2]|0xFF)) ^ ((xor)[2] & 0xFFFFFF00); \
|
||||
break; \
|
||||
case 3: \
|
||||
*addrp = (*addrp & ((and)[0]|0xFFFFFF)) ^ ((xor)[0] & 0xFF000000); \
|
||||
*(addrp+1)=(*(addrp+1)&((and)[1]|0xFFFF0000)) ^ ((xor)[1]&0xFFFF); \
|
||||
break; \
|
||||
case 2: \
|
||||
*addrp = (*addrp & ((and)[1]|0xFFFF)) ^ ((xor)[1] & 0xFFFF0000); \
|
||||
*(addrp+1)=(*(addrp+1)&((and)[2]|0xFFFFFF00)) ^ ((xor)[2] & 0xFF); \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
|
||||
for (;;)
|
||||
{
|
||||
len -= thisDash;
|
||||
if (dashIndex & 1) {
|
||||
if (isDoubleDash) {
|
||||
#if PSZ == 24
|
||||
Loop(body_set(andPiQxlBg, xorPiQxlBg))
|
||||
#else
|
||||
Loop(*addrp = DoRRop(*addrp,andBg, xorBg))
|
||||
#endif
|
||||
} else {
|
||||
Loop(;)
|
||||
}
|
||||
} else {
|
||||
#if PSZ == 24
|
||||
Loop(body_set(andPiQxlFg, xorPiQxlFg))
|
||||
#else
|
||||
Loop(*addrp = DoRRop(*addrp,andFg, xorFg))
|
||||
#endif
|
||||
}
|
||||
if (!len)
|
||||
break;
|
||||
NextDash
|
||||
}
|
||||
#undef body_set
|
||||
}
|
||||
#else /* !PIXEL_ADDR */
|
||||
{
|
||||
register CfbBits tmp;
|
||||
CfbBits startbit, bit;
|
||||
|
||||
/* point to longword containing first point */
|
||||
#if PSZ == 24
|
||||
addrl = (addrl + (y1 * nlwidth) + ((x1*3) >> 2);
|
||||
#else
|
||||
addrl = (addrl + (y1 * nlwidth) + (x1 >> PWSH));
|
||||
#endif
|
||||
signdy = signdy * nlwidth;
|
||||
|
||||
if (signdx > 0)
|
||||
startbit = cfbmask[0];
|
||||
else
|
||||
#if PSZ == 24
|
||||
startbit = cfbmask[(PPW-1)<<1];
|
||||
bit = cfbmask[(x1 & 3)<<1];
|
||||
#else
|
||||
startbit = cfbmask[PPW-1];
|
||||
bit = cfbmask[x1 & PIM];
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#define X_Loop(store) while(thisDash--) {\
|
||||
store; \
|
||||
BresStep(addrl += signdy, \
|
||||
if (signdx > 0) \
|
||||
bit = SCRRIGHT(bit,1); \
|
||||
else \
|
||||
bit = SCRLEFT(bit,1); \
|
||||
if (!bit) \
|
||||
{ \
|
||||
bit = startbit; \
|
||||
addrl += signdx; \
|
||||
}) \
|
||||
}
|
||||
#define Y_Loop(store) while(thisDash--) {\
|
||||
store; \
|
||||
BresStep(if (signdx > 0) \
|
||||
bit = SCRRIGHT(bit,1); \
|
||||
else \
|
||||
bit = SCRLEFT(bit,1); \
|
||||
if (!bit) \
|
||||
{ \
|
||||
bit = startbit; \
|
||||
addrl += signdx; \
|
||||
}, \
|
||||
addrl += signdy) \
|
||||
}
|
||||
#else
|
||||
#define X_Loop(store) while(thisDash--) {\
|
||||
store; \
|
||||
BresStep(addrl += signdy, \
|
||||
if (signdx > 0) \
|
||||
bit = SCRRIGHT(bit,1); \
|
||||
else \
|
||||
bit = SCRLEFT(bit,1); \
|
||||
if (!bit) \
|
||||
{ \
|
||||
bit = startbit; \
|
||||
addrl += signdx; \
|
||||
}) \
|
||||
}
|
||||
#define Y_Loop(store) while(thisDash--) {\
|
||||
store; \
|
||||
BresStep(if (signdx > 0) \
|
||||
bit = SCRRIGHT(bit,1); \
|
||||
else \
|
||||
bit = SCRLEFT(bit,1); \
|
||||
if (!bit) \
|
||||
{ \
|
||||
bit = startbit; \
|
||||
addrl += signdx; \
|
||||
}, \
|
||||
addrl += signdy) \
|
||||
}
|
||||
#endif
|
||||
|
||||
if (axis == X_AXIS)
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
len -= thisDash;
|
||||
if (dashIndex & 1) {
|
||||
if (isDoubleDash) {
|
||||
X_Loop(*addrl = DoMaskRRop(*addrl, andBg, xorBg, bit));
|
||||
} else {
|
||||
X_Loop(;)
|
||||
}
|
||||
} else {
|
||||
X_Loop(*addrl = DoMaskRRop(*addrl, andFg, xorFg, bit));
|
||||
}
|
||||
if (!len)
|
||||
break;
|
||||
NextDash
|
||||
}
|
||||
} /* if X_AXIS */
|
||||
else
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
len -= thisDash;
|
||||
if (dashIndex & 1) {
|
||||
if (isDoubleDash) {
|
||||
Y_Loop(*addrl = DoMaskRRop(*addrl, andBg, xorBg, bit));
|
||||
} else {
|
||||
Y_Loop(;)
|
||||
}
|
||||
} else {
|
||||
Y_Loop(*addrl = DoMaskRRop(*addrl, andFg, xorFg, bit));
|
||||
}
|
||||
if (!len)
|
||||
break;
|
||||
NextDash
|
||||
}
|
||||
} /* else Y_AXIS */
|
||||
}
|
||||
#endif
|
||||
*pdashIndex = dashIndex;
|
||||
*pdashOffset = pDash[dashIndex] - dashRemaining;
|
||||
}
|
119
cfb/cfbcmap.c
119
cfb/cfbcmap.c
|
@ -1,119 +0,0 @@
|
|||
/************************************************************
|
||||
Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose and without
|
||||
fee is hereby granted, provided that the above copyright no-
|
||||
tice appear in all copies and that both that copyright no-
|
||||
tice and this permission notice appear in supporting docu-
|
||||
mentation, and that the names of Sun or The Open Group
|
||||
not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific prior
|
||||
written permission. Sun and The Open Group make no
|
||||
representations about the suitability of this software for
|
||||
any purpose. It is provided "as is" without any express or
|
||||
implied warranty.
|
||||
|
||||
SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
|
||||
NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
|
||||
ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
||||
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
||||
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
********************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "scrnintstr.h"
|
||||
#include "colormapst.h"
|
||||
#include "resource.h"
|
||||
#include "micmap.h"
|
||||
#include "cfb.h"
|
||||
|
||||
int
|
||||
cfbListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps)
|
||||
{
|
||||
return miListInstalledColormaps(pScreen, pmaps);
|
||||
}
|
||||
|
||||
void
|
||||
cfbInstallColormap(ColormapPtr pmap)
|
||||
{
|
||||
miInstallColormap(pmap);
|
||||
}
|
||||
|
||||
void
|
||||
cfbUninstallColormap(ColormapPtr pmap)
|
||||
{
|
||||
miUninstallColormap(pmap);
|
||||
}
|
||||
|
||||
void
|
||||
cfbResolveColor(unsigned short *pred,
|
||||
unsigned short *pgreen,
|
||||
unsigned short *pblue,
|
||||
VisualPtr pVisual)
|
||||
{
|
||||
miResolveColor(pred, pgreen, pblue, pVisual);
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbInitializeColormap(ColormapPtr pmap)
|
||||
{
|
||||
return miInitializeColormap(pmap);
|
||||
}
|
||||
|
||||
int
|
||||
cfbExpandDirectColors (ColormapPtr pmap, int ndef,
|
||||
xColorItem *indefs, xColorItem *outdefs)
|
||||
{
|
||||
return miExpandDirectColors(pmap, ndef, indefs, outdefs);
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbCreateDefColormap(ScreenPtr pScreen)
|
||||
{
|
||||
return miCreateDefColormap(pScreen);
|
||||
}
|
||||
|
||||
void
|
||||
cfbClearVisualTypes(void)
|
||||
{
|
||||
miClearVisualTypes();
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbSetVisualTypes (int depth, int visuals, int bitsPerRGB)
|
||||
{
|
||||
return miSetVisualTypes(depth, visuals, bitsPerRGB, -1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Given a list of formats for a screen, create a list
|
||||
* of visuals and depths for the screen which coorespond to
|
||||
* the set which can be used with this version of cfb.
|
||||
*/
|
||||
|
||||
Bool
|
||||
cfbInitVisuals (VisualPtr *visualp,
|
||||
DepthPtr *depthp,
|
||||
int *nvisualp,
|
||||
int *ndepthp,
|
||||
int *rootDepthp,
|
||||
VisualID *defaultVisp,
|
||||
unsigned long sizes,
|
||||
int bitsPerRGB)
|
||||
{
|
||||
return miInitVisuals(visualp, depthp, nvisualp, ndepthp, rootDepthp,
|
||||
defaultVisp, sizes, bitsPerRGB, -1);
|
||||
}
|
486
cfb/cfbcppl.c
486
cfb/cfbcppl.c
|
@ -1,486 +0,0 @@
|
|||
/*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "gcstruct.h"
|
||||
#include "window.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
#include "cfb.h"
|
||||
#if PSZ == 8
|
||||
#undef PSZ /* for maskbits.h */
|
||||
#include "maskbits.h"
|
||||
#define PSZ 8
|
||||
#include "mergerop.h"
|
||||
#endif
|
||||
|
||||
|
||||
void
|
||||
cfbCopyImagePlane(
|
||||
DrawablePtr pSrcDrawable,
|
||||
DrawablePtr pDstDrawable,
|
||||
int rop,
|
||||
RegionPtr prgnDst,
|
||||
DDXPointPtr pptSrc,
|
||||
unsigned long planemask)
|
||||
{
|
||||
/* note: there must be some sort of trick behind,
|
||||
passing a planemask value with all bits set
|
||||
whilst using the current planemask for the bitPlane value. */
|
||||
#if PSZ == 8
|
||||
cfbCopyPlane8to1 (pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
|
||||
(unsigned long) ~0L, planemask);
|
||||
#endif
|
||||
#if PSZ == 16
|
||||
cfbCopyPlane16to1 (pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
|
||||
(unsigned long) ~0L, planemask);
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
cfbCopyPlane24to1 (pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
|
||||
(unsigned long) ~0L, planemask);
|
||||
#endif
|
||||
#if PSZ == 32
|
||||
cfbCopyPlane32to1 (pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
|
||||
(unsigned long) ~0L, planemask);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#if BITMAP_BIT_ORDER == MSBFirst
|
||||
#define LeftMost (MFB_PPW-1)
|
||||
#define StepBit(bit, inc) ((bit) -= (inc))
|
||||
#else
|
||||
#define LeftMost 0
|
||||
#define StepBit(bit, inc) ((bit) += (inc))
|
||||
#endif
|
||||
|
||||
#define GetBits(psrc, nBits, curBit, bitPos, bits) {\
|
||||
bits = 0; \
|
||||
while (nBits--) \
|
||||
{ \
|
||||
bits |= (PixelType)(((*psrc++ >> bitPos) & 1)) << curBit; \
|
||||
StepBit (curBit, 1); \
|
||||
} \
|
||||
}
|
||||
|
||||
void
|
||||
cfbCopyPlane8to1(
|
||||
DrawablePtr pSrcDrawable,
|
||||
DrawablePtr pDstDrawable,
|
||||
int rop,
|
||||
RegionPtr prgnDst,
|
||||
DDXPointPtr pptSrc,
|
||||
unsigned long planemask,
|
||||
unsigned long bitPlane)
|
||||
{
|
||||
int srcx, srcy, dstx, dsty, width, height;
|
||||
unsigned char *psrcBase;
|
||||
PixelType *pdstBase;
|
||||
int widthSrc, widthDst;
|
||||
unsigned char *psrcLine;
|
||||
PixelType *pdstLine;
|
||||
register unsigned char *psrc;
|
||||
register int i;
|
||||
register int curBit;
|
||||
register int bitPos;
|
||||
register CfbBits bits;
|
||||
register PixelType *pdst;
|
||||
PixelType startmask, endmask;
|
||||
int niStart = 0, niEnd = 0;
|
||||
int bitStart = 0, bitEnd = 0;
|
||||
int nl, nlMiddle;
|
||||
int nbox;
|
||||
BoxPtr pbox;
|
||||
MROP_DECLARE()
|
||||
|
||||
if (!(planemask & 1))
|
||||
return;
|
||||
|
||||
if (rop != GXcopy)
|
||||
MROP_INITIALIZE (rop, planemask);
|
||||
|
||||
cfbGetByteWidthAndPointer (pSrcDrawable, widthSrc, psrcBase)
|
||||
|
||||
mfbGetPixelWidthAndPointer (pDstDrawable, widthDst, pdstBase)
|
||||
|
||||
bitPos = ffs (bitPlane) - 1;
|
||||
|
||||
nbox = REGION_NUM_RECTS(prgnDst);
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
while (nbox--)
|
||||
{
|
||||
dstx = pbox->x1;
|
||||
dsty = pbox->y1;
|
||||
srcx = pptSrc->x;
|
||||
srcy = pptSrc->y;
|
||||
width = pbox->x2 - pbox->x1;
|
||||
height = pbox->y2 - pbox->y1;
|
||||
pbox++;
|
||||
pptSrc++;
|
||||
psrcLine = psrcBase + srcy * widthSrc + srcx;
|
||||
pdstLine = mfbScanline(pdstBase, dstx, dsty, widthDst);
|
||||
dstx &= MFB_PIM;
|
||||
if (dstx + width <= MFB_PPW)
|
||||
{
|
||||
maskpartialbits(dstx, width, startmask);
|
||||
nlMiddle = 0;
|
||||
endmask = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (dstx, width, startmask, endmask, nlMiddle);
|
||||
}
|
||||
if (startmask)
|
||||
{
|
||||
niStart = min(MFB_PPW - dstx, width);
|
||||
bitStart = LeftMost;
|
||||
StepBit (bitStart, dstx);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
niEnd = (dstx + width) & MFB_PIM;
|
||||
bitEnd = LeftMost;
|
||||
}
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
while (height--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
psrcLine += widthSrc;
|
||||
mfbScanlineInc(pdstLine, widthDst);
|
||||
if (startmask)
|
||||
{
|
||||
i = niStart;
|
||||
curBit = bitStart;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = (*pdst & ~startmask) | bits;
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
i = MFB_PPW;
|
||||
curBit = LeftMost;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst++ = bits;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
i = niEnd;
|
||||
curBit = bitEnd;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = (*pdst & ~endmask) | bits;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (height--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
psrcLine += widthSrc;
|
||||
mfbScanlineInc(pdstLine, widthDst);
|
||||
if (startmask)
|
||||
{
|
||||
i = niStart;
|
||||
curBit = bitStart;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = MROP_MASK(bits, *pdst, startmask);
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
i = MFB_PPW;
|
||||
curBit = LeftMost;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = MROP_SOLID(bits, *pdst);
|
||||
pdst++;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
i = niEnd;
|
||||
curBit = bitEnd;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = MROP_MASK (bits, *pdst, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#else /* PSZ == 8 */
|
||||
|
||||
#define mfbmaskbits(x, w, startmask, endmask, nlw) \
|
||||
startmask = mfbGetstarttab((x)&0x1f); \
|
||||
endmask = mfbGetendtab(((x)+(w)) & 0x1f); \
|
||||
if (startmask) \
|
||||
nlw = (((w) - (32 - ((x)&0x1f))) >> 5); \
|
||||
else \
|
||||
nlw = (w) >> 5;
|
||||
|
||||
#define mfbmaskpartialbits(x, w, mask) \
|
||||
mask = mfbGetpartmasks((x)&0x1f,(w)&0x1f);
|
||||
|
||||
#define LeftMost 0
|
||||
#define StepBit(bit, inc) ((bit) += (inc))
|
||||
|
||||
|
||||
#if PSZ == 24
|
||||
#define GetBits(psrc, nBits, curBit, bitPos, bits) {\
|
||||
bits = 0; \
|
||||
while (nBits--) \
|
||||
{ \
|
||||
if (bitPos < 8) \
|
||||
{ \
|
||||
bits |= ((*psrc++ >> bitPos) & 1) << curBit; \
|
||||
psrc += 2; \
|
||||
} \
|
||||
else if (bitPos < 16) \
|
||||
{ \
|
||||
psrc++; \
|
||||
bits |= ((*psrc++ >> (bitPos - 8)) & 1) << curBit; \
|
||||
psrc++; \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
psrc += 2; \
|
||||
bits |= ((*psrc++ >> (bitPos - 16)) & 1) << curBit; \
|
||||
} \
|
||||
StepBit (curBit, 1); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define GetBits(psrc, nBits, curBit, bitPos, bits) {\
|
||||
bits = 0; \
|
||||
while (nBits--) \
|
||||
{ \
|
||||
bits |= ((*psrc++ >> bitPos) & 1) << curBit; \
|
||||
StepBit (curBit, 1); \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
#if PSZ == 16
|
||||
cfbCopyPlane16to1
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
cfbCopyPlane24to1
|
||||
#endif
|
||||
#if PSZ == 32
|
||||
cfbCopyPlane32to1
|
||||
#endif
|
||||
(
|
||||
DrawablePtr pSrcDrawable,
|
||||
DrawablePtr pDstDrawable,
|
||||
int rop,
|
||||
RegionPtr prgnDst,
|
||||
DDXPointPtr pptSrc,
|
||||
unsigned long planemask,
|
||||
unsigned long bitPlane)
|
||||
{
|
||||
int srcx, srcy, dstx, dsty, width, height;
|
||||
CfbBits *psrcBase;
|
||||
CfbBits *pdstBase;
|
||||
int widthSrc, widthDst;
|
||||
#if PSZ == 16
|
||||
unsigned short *psrcLine;
|
||||
register unsigned short *psrc;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
unsigned char *psrcLine;
|
||||
register unsigned char *psrc;
|
||||
#endif
|
||||
#if PSZ == 32
|
||||
unsigned int *psrcLine;
|
||||
register unsigned int *psrc;
|
||||
#endif
|
||||
unsigned int *pdstLine;
|
||||
register unsigned int *pdst;
|
||||
register int i;
|
||||
register int curBit;
|
||||
register int bitPos;
|
||||
register unsigned int bits;
|
||||
unsigned int startmask = 0, endmask = 0;
|
||||
int niStart = 0, niEnd = 0;
|
||||
int bitStart = 0, bitEnd = 0;
|
||||
int nl, nlMiddle;
|
||||
int nbox;
|
||||
BoxPtr pbox;
|
||||
int result;
|
||||
|
||||
|
||||
if (!(planemask & 1))
|
||||
return;
|
||||
|
||||
/* must explicitly ask for "int" widths, as code below expects it */
|
||||
/* on some machines (Alpha), "long" and "int" are not the same size */
|
||||
cfbGetTypedWidthAndPointer (pSrcDrawable, widthSrc, psrcBase, int, CfbBits)
|
||||
cfbGetTypedWidthAndPointer (pDstDrawable, widthDst, pdstBase, int, CfbBits)
|
||||
|
||||
#if PSZ == 16
|
||||
widthSrc <<= 1;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
widthSrc <<= 2;
|
||||
#endif
|
||||
|
||||
bitPos = ffs (bitPlane) - 1;
|
||||
|
||||
nbox = REGION_NUM_RECTS(prgnDst);
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
while (nbox--)
|
||||
{
|
||||
dstx = pbox->x1;
|
||||
dsty = pbox->y1;
|
||||
srcx = pptSrc->x;
|
||||
srcy = pptSrc->y;
|
||||
width = pbox->x2 - pbox->x1;
|
||||
height = pbox->y2 - pbox->y1;
|
||||
pbox++;
|
||||
pptSrc++;
|
||||
#if PSZ == 16
|
||||
psrcLine = (unsigned short *)psrcBase + srcy * widthSrc + srcx;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
psrcLine = (unsigned char *)psrcBase + srcy * widthSrc + srcx * 3;
|
||||
#endif
|
||||
#if PSZ == 32
|
||||
psrcLine = (unsigned int *)psrcBase + srcy * widthSrc + srcx;
|
||||
#endif
|
||||
pdstLine = (unsigned int *)pdstBase + dsty * widthDst + (dstx >> 5);
|
||||
if (dstx + width <= 32)
|
||||
{
|
||||
mfbmaskpartialbits(dstx, width, startmask);
|
||||
nlMiddle = 0;
|
||||
endmask = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
mfbmaskbits (dstx, width, startmask, endmask, nlMiddle);
|
||||
}
|
||||
if (startmask)
|
||||
{
|
||||
niStart = 32 - (dstx & 0x1f);
|
||||
bitStart = LeftMost;
|
||||
StepBit (bitStart, (dstx & 0x1f));
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
niEnd = (dstx + width) & 0x1f;
|
||||
bitEnd = LeftMost;
|
||||
}
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
while (height--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
psrcLine += widthSrc;
|
||||
pdstLine += widthDst;
|
||||
if (startmask)
|
||||
{
|
||||
i = niStart;
|
||||
curBit = bitStart;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
|
||||
*pdst = (*pdst & ~startmask) | bits;
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
i = 32;
|
||||
curBit = LeftMost;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst++ = bits;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
i = niEnd;
|
||||
curBit = bitEnd;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
|
||||
*pdst = (*pdst & ~endmask) | bits;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (height--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
psrcLine += widthSrc;
|
||||
pdstLine += widthDst;
|
||||
if (startmask)
|
||||
{
|
||||
i = niStart;
|
||||
curBit = bitStart;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
DoRop (result, rop, bits, *pdst);
|
||||
|
||||
*pdst = (*pdst & ~startmask) |
|
||||
(result & startmask);
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
i = 32;
|
||||
curBit = LeftMost;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
DoRop (result, rop, bits, *pdst);
|
||||
*pdst = result;
|
||||
++pdst;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
i = niEnd;
|
||||
curBit = bitEnd;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
DoRop (result, rop, bits, *pdst);
|
||||
|
||||
*pdst = (*pdst & ~endmask) |
|
||||
(result & endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* PSZ == 8 */
|
374
cfb/cfbfillarc.c
374
cfb/cfbfillarc.c
|
@ -1,374 +0,0 @@
|
|||
/************************************************************
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
********************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xprotostr.h>
|
||||
#include "regionstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mifillarc.h"
|
||||
#include "cfbrrop.h"
|
||||
#include "mi.h"
|
||||
|
||||
/* gcc 1.35 is stupid */
|
||||
#if defined(__GNUC__) && __GNUC__ < 2 && defined(mc68020)
|
||||
#define STUPID volatile
|
||||
#else
|
||||
#define STUPID
|
||||
#endif
|
||||
|
||||
static void
|
||||
RROP_NAME(cfbFillEllipseSolid)(
|
||||
DrawablePtr pDraw,
|
||||
GCPtr pGC,
|
||||
xArc *arc)
|
||||
{
|
||||
STUPID int x, y, e;
|
||||
STUPID int yk, xk, ym, xm, dx, dy, xorg, yorg;
|
||||
miFillArcRec info;
|
||||
#if PSZ == 24
|
||||
unsigned char *addrlt, *addrlb;
|
||||
#else
|
||||
CfbBits *addrlt, *addrlb;
|
||||
#endif
|
||||
register CfbBits *addrl;
|
||||
register int n;
|
||||
int nlwidth;
|
||||
RROP_DECLARE
|
||||
register int xpos;
|
||||
register int slw;
|
||||
CfbBits startmask, endmask;
|
||||
int nlmiddle;
|
||||
#if PSZ == 24
|
||||
register int pidx;
|
||||
int xpos3;
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
cfbGetByteWidthAndPointer (pDraw, nlwidth, addrlt)
|
||||
#else
|
||||
cfbGetLongWidthAndPointer (pDraw, nlwidth, addrlt)
|
||||
#endif
|
||||
|
||||
RROP_FETCH_GC(pGC);
|
||||
miFillArcSetup(arc, &info);
|
||||
MIFILLARCSETUP();
|
||||
xorg += pDraw->x;
|
||||
yorg += pDraw->y;
|
||||
addrlb = addrlt;
|
||||
addrlt += nlwidth * (yorg - y);
|
||||
addrlb += nlwidth * (yorg + y + dy);
|
||||
while (y)
|
||||
{
|
||||
addrlt += nlwidth;
|
||||
addrlb -= nlwidth;
|
||||
MIFILLARCSTEP(slw);
|
||||
if (!slw)
|
||||
continue;
|
||||
xpos = xorg - x;
|
||||
#if PSZ == 24
|
||||
xpos3 = (xpos * 3) & ~0x03;
|
||||
addrl = (CfbBits *)((char *)addrlt + xpos3);
|
||||
if (slw == 1){
|
||||
RROP_SOLID24(addrl, xpos);
|
||||
if (miFillArcLower(slw)){
|
||||
addrl = (CfbBits *)((char *)addrlb + xpos3);
|
||||
RROP_SOLID24(addrl, xpos);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
maskbits(xpos, slw, startmask, endmask, nlmiddle);
|
||||
xpos &= 3;
|
||||
pidx = xpos;
|
||||
if (startmask){
|
||||
RROP_SOLID_MASK(addrl, startmask, pidx-1);
|
||||
addrl++;
|
||||
if (pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
n = nlmiddle;
|
||||
while (--n >= 0){
|
||||
RROP_SOLID(addrl, pidx);
|
||||
addrl++;
|
||||
if (++pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addrl, endmask, pidx);
|
||||
if (!miFillArcLower(slw))
|
||||
continue;
|
||||
addrl = (CfbBits *)((char *)addrlb + xpos3);
|
||||
pidx = xpos;
|
||||
if (startmask){
|
||||
RROP_SOLID_MASK(addrl, startmask, pidx-1);
|
||||
addrl++;
|
||||
if (pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
n = nlmiddle;
|
||||
while (--n >= 0){
|
||||
RROP_SOLID(addrl, pidx);
|
||||
addrl++;
|
||||
if (++pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addrl, endmask, pidx);
|
||||
#else /* PSZ == 24 */
|
||||
addrl = addrlt + (xpos >> PWSH);
|
||||
if (((xpos & PIM) + slw) <= PPW)
|
||||
{
|
||||
maskpartialbits(xpos, slw, startmask);
|
||||
RROP_SOLID_MASK(addrl,startmask);
|
||||
if (miFillArcLower(slw))
|
||||
{
|
||||
addrl = addrlb + (xpos >> PWSH);
|
||||
RROP_SOLID_MASK(addrl, startmask);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
maskbits(xpos, slw, startmask, endmask, nlmiddle);
|
||||
if (startmask)
|
||||
{
|
||||
RROP_SOLID_MASK(addrl, startmask);
|
||||
addrl++;
|
||||
}
|
||||
n = nlmiddle;
|
||||
RROP_SPAN(addrl,n)
|
||||
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addrl, endmask);
|
||||
if (!miFillArcLower(slw))
|
||||
continue;
|
||||
addrl = addrlb + (xpos >> PWSH);
|
||||
if (startmask)
|
||||
{
|
||||
RROP_SOLID_MASK(addrl, startmask);
|
||||
addrl++;
|
||||
}
|
||||
n = nlmiddle;
|
||||
RROP_SPAN(addrl, n);
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addrl, endmask);
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
RROP_UNDECLARE
|
||||
}
|
||||
|
||||
#if PSZ == 24
|
||||
#define FILLSPAN(xl,xr,addr) \
|
||||
if (xr >= xl){ \
|
||||
n = xr - xl + 1; \
|
||||
addrl = (CfbBits *)((char *)addr + ((xl * 3) & ~0x03)); \
|
||||
if (n <= 1){ \
|
||||
if (n) \
|
||||
RROP_SOLID24(addrl, xl); \
|
||||
} else { \
|
||||
maskbits(xl, n, startmask, endmask, n); \
|
||||
pidx = xl & 3; \
|
||||
if (startmask){ \
|
||||
RROP_SOLID_MASK(addrl, startmask, pidx-1); \
|
||||
addrl++; \
|
||||
if (pidx == 3) \
|
||||
pidx = 0; \
|
||||
} \
|
||||
while (--n >= 0){ \
|
||||
RROP_SOLID(addrl, pidx); \
|
||||
addrl++; \
|
||||
if (++pidx == 3) \
|
||||
pidx = 0; \
|
||||
} \
|
||||
if (endmask) \
|
||||
RROP_SOLID_MASK(addrl, endmask, pidx); \
|
||||
} \
|
||||
}
|
||||
#else /* PSZ == 24 */
|
||||
#define FILLSPAN(xl,xr,addr) \
|
||||
if (xr >= xl) \
|
||||
{ \
|
||||
n = xr - xl + 1; \
|
||||
addrl = addr + (xl >> PWSH); \
|
||||
if (((xl & PIM) + n) <= PPW) \
|
||||
{ \
|
||||
maskpartialbits(xl, n, startmask); \
|
||||
RROP_SOLID_MASK(addrl, startmask); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
maskbits(xl, n, startmask, endmask, n); \
|
||||
if (startmask) \
|
||||
{ \
|
||||
RROP_SOLID_MASK(addrl, startmask); \
|
||||
addrl++; \
|
||||
} \
|
||||
while (n--) \
|
||||
{ \
|
||||
RROP_SOLID(addrl); \
|
||||
++addrl; \
|
||||
} \
|
||||
if (endmask) \
|
||||
RROP_SOLID_MASK(addrl, endmask); \
|
||||
} \
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
|
||||
#define FILLSLICESPANS(flip,addr) \
|
||||
if (!flip) \
|
||||
{ \
|
||||
FILLSPAN(xl, xr, addr); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
xc = xorg - x; \
|
||||
FILLSPAN(xc, xr, addr); \
|
||||
xc += slw - 1; \
|
||||
FILLSPAN(xl, xc, addr); \
|
||||
}
|
||||
|
||||
static void
|
||||
RROP_NAME(cfbFillArcSliceSolid)(
|
||||
DrawablePtr pDraw,
|
||||
GCPtr pGC,
|
||||
xArc *arc)
|
||||
{
|
||||
int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
|
||||
register int x, y, e;
|
||||
miFillArcRec info;
|
||||
miArcSliceRec slice;
|
||||
int xl, xr, xc;
|
||||
#if PSZ == 24
|
||||
unsigned char *addrlt, *addrlb;
|
||||
#else
|
||||
CfbBits *addrlt, *addrlb;
|
||||
#endif
|
||||
register CfbBits *addrl;
|
||||
register int n;
|
||||
int nlwidth;
|
||||
RROP_DECLARE
|
||||
CfbBits startmask, endmask;
|
||||
#if PSZ == 24
|
||||
register int pidx;
|
||||
#endif /* PSZ == 24 */
|
||||
|
||||
#if PSZ == 24
|
||||
cfbGetByteWidthAndPointer (pDraw, nlwidth, addrlt)
|
||||
#else
|
||||
cfbGetLongWidthAndPointer (pDraw, nlwidth, addrlt)
|
||||
#endif
|
||||
|
||||
RROP_FETCH_GC(pGC);
|
||||
miFillArcSetup(arc, &info);
|
||||
miFillArcSliceSetup(arc, &slice, pGC);
|
||||
MIFILLARCSETUP();
|
||||
xorg += pDraw->x;
|
||||
yorg += pDraw->y;
|
||||
addrlb = addrlt;
|
||||
addrlt += nlwidth * (yorg - y);
|
||||
addrlb += nlwidth * (yorg + y + dy);
|
||||
slice.edge1.x += pDraw->x;
|
||||
slice.edge2.x += pDraw->x;
|
||||
while (y > 0)
|
||||
{
|
||||
addrlt += nlwidth;
|
||||
addrlb -= nlwidth;
|
||||
MIFILLARCSTEP(slw);
|
||||
MIARCSLICESTEP(slice.edge1);
|
||||
MIARCSLICESTEP(slice.edge2);
|
||||
if (miFillSliceUpper(slice))
|
||||
{
|
||||
MIARCSLICEUPPER(xl, xr, slice, slw);
|
||||
FILLSLICESPANS(slice.flip_top, addrlt);
|
||||
}
|
||||
if (miFillSliceLower(slice))
|
||||
{
|
||||
MIARCSLICELOWER(xl, xr, slice, slw);
|
||||
FILLSLICESPANS(slice.flip_bot, addrlb);
|
||||
}
|
||||
}
|
||||
RROP_UNDECLARE
|
||||
}
|
||||
|
||||
void
|
||||
RROP_NAME(cfbPolyFillArcSolid) (pDraw, pGC, narcs, parcs)
|
||||
DrawablePtr pDraw;
|
||||
GCPtr pGC;
|
||||
int narcs;
|
||||
xArc *parcs;
|
||||
{
|
||||
register xArc *arc;
|
||||
register int i;
|
||||
int x2, y2;
|
||||
BoxRec box;
|
||||
RegionPtr cclip;
|
||||
|
||||
cclip = cfbGetCompositeClip(pGC);
|
||||
for (arc = parcs, i = narcs; --i >= 0; arc++)
|
||||
{
|
||||
if (miFillArcEmpty(arc))
|
||||
continue;
|
||||
if (miCanFillArc(arc))
|
||||
{
|
||||
box.x1 = arc->x + pDraw->x;
|
||||
box.y1 = arc->y + pDraw->y;
|
||||
/*
|
||||
* Because box.x2 and box.y2 get truncated to 16 bits, and the
|
||||
* RECT_IN_REGION test treats the resulting number as a signed
|
||||
* integer, the RECT_IN_REGION test alone can go the wrong way.
|
||||
* This can result in a server crash because the rendering
|
||||
* routines in this file deal directly with cpu addresses
|
||||
* of pixels to be stored, and do not clip or otherwise check
|
||||
* that all such addresses are within their respective pixmaps.
|
||||
* So we only allow the RECT_IN_REGION test to be used for
|
||||
* values that can be expressed correctly in a signed short.
|
||||
*/
|
||||
x2 = box.x1 + (int)arc->width + 1;
|
||||
box.x2 = x2;
|
||||
y2 = box.y1 + (int)arc->height + 1;
|
||||
box.y2 = y2;
|
||||
if ( (x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&
|
||||
(RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
|
||||
{
|
||||
if ((arc->angle2 >= FULLCIRCLE) ||
|
||||
(arc->angle2 <= -FULLCIRCLE))
|
||||
RROP_NAME(cfbFillEllipseSolid)(pDraw, pGC, arc);
|
||||
else
|
||||
RROP_NAME(cfbFillArcSliceSolid)(pDraw, pGC, arc);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
miPolyFillArc(pDraw, pGC, 1, arc);
|
||||
}
|
||||
}
|
305
cfb/cfbfillrct.c
305
cfb/cfbfillrct.c
|
@ -1,305 +0,0 @@
|
|||
/*
|
||||
* Fill rectangles.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "gcstruct.h"
|
||||
#include "window.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
#include "mi.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mergerop.h"
|
||||
|
||||
|
||||
void
|
||||
cfbFillBoxTileOdd (pDrawable, n, rects, tile, xrot, yrot)
|
||||
DrawablePtr pDrawable;
|
||||
int n;
|
||||
BoxPtr rects;
|
||||
PixmapPtr tile;
|
||||
int xrot, yrot;
|
||||
{
|
||||
#if PSZ == 24
|
||||
if (tile->drawable.width & 3)
|
||||
#else
|
||||
if (tile->drawable.width & PIM)
|
||||
#endif
|
||||
cfbFillBoxTileOddCopy (pDrawable, n, rects, tile, xrot, yrot, GXcopy, ~0L);
|
||||
else
|
||||
cfbFillBoxTile32sCopy (pDrawable, n, rects, tile, xrot, yrot, GXcopy, ~0L);
|
||||
}
|
||||
|
||||
void
|
||||
cfbFillRectTileOdd (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox;
|
||||
BoxPtr pBox;
|
||||
{
|
||||
int xrot, yrot;
|
||||
void (*fill)(DrawablePtr, int, BoxPtr, PixmapPtr, int, int, int, unsigned long);
|
||||
|
||||
xrot = pDrawable->x + pGC->patOrg.x;
|
||||
yrot = pDrawable->y + pGC->patOrg.y;
|
||||
#if PSZ == 24
|
||||
if (pGC->tile.pixmap->drawable.width & 3)
|
||||
#else
|
||||
if (pGC->tile.pixmap->drawable.width & PIM)
|
||||
#endif
|
||||
{
|
||||
fill = cfbFillBoxTileOddGeneral;
|
||||
if ((pGC->planemask & PMSK) == PMSK)
|
||||
{
|
||||
if (pGC->alu == GXcopy)
|
||||
fill = cfbFillBoxTileOddCopy;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fill = cfbFillBoxTile32sGeneral;
|
||||
if ((pGC->planemask & PMSK) == PMSK)
|
||||
{
|
||||
if (pGC->alu == GXcopy)
|
||||
fill = cfbFillBoxTile32sCopy;
|
||||
}
|
||||
}
|
||||
(*fill) (pDrawable, nBox, pBox, pGC->tile.pixmap, xrot, yrot, pGC->alu, pGC->planemask);
|
||||
}
|
||||
|
||||
#define NUM_STACK_RECTS 1024
|
||||
|
||||
void
|
||||
cfbPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
|
||||
DrawablePtr pDrawable;
|
||||
register GCPtr pGC;
|
||||
int nrectFill; /* number of rectangles to fill */
|
||||
xRectangle *prectInit; /* Pointer to first rectangle to fill */
|
||||
{
|
||||
xRectangle *prect;
|
||||
RegionPtr prgnClip;
|
||||
register BoxPtr pbox;
|
||||
register BoxPtr pboxClipped;
|
||||
BoxPtr pboxClippedBase;
|
||||
BoxPtr pextent;
|
||||
BoxRec stackRects[NUM_STACK_RECTS];
|
||||
cfbPrivGC *priv;
|
||||
int numRects;
|
||||
void (*BoxFill)(DrawablePtr, GCPtr, int, BoxPtr);
|
||||
int n;
|
||||
int xorg, yorg;
|
||||
|
||||
#if PSZ != 8
|
||||
if ((pGC->fillStyle == FillStippled) ||
|
||||
(pGC->fillStyle == FillOpaqueStippled)) {
|
||||
miPolyFillRect(pDrawable, pGC, nrectFill, prectInit);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
priv = cfbGetGCPrivate(pGC);
|
||||
prgnClip = pGC->pCompositeClip;
|
||||
|
||||
BoxFill = 0;
|
||||
switch (pGC->fillStyle)
|
||||
{
|
||||
case FillSolid:
|
||||
switch (priv->rop) {
|
||||
case GXcopy:
|
||||
BoxFill = cfbFillRectSolidCopy;
|
||||
break;
|
||||
case GXxor:
|
||||
BoxFill = cfbFillRectSolidXor;
|
||||
break;
|
||||
default:
|
||||
BoxFill = cfbFillRectSolidGeneral;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case FillTiled:
|
||||
if (!pGC->pRotatedPixmap)
|
||||
BoxFill = cfbFillRectTileOdd;
|
||||
else
|
||||
{
|
||||
if (pGC->alu == GXcopy && (pGC->planemask & PMSK) == PMSK)
|
||||
BoxFill = cfbFillRectTile32Copy;
|
||||
else
|
||||
BoxFill = cfbFillRectTile32General;
|
||||
}
|
||||
break;
|
||||
#if PSZ == 8
|
||||
case FillStippled:
|
||||
if (!pGC->pRotatedPixmap)
|
||||
BoxFill = cfb8FillRectStippledUnnatural;
|
||||
else
|
||||
BoxFill = cfb8FillRectTransparentStippled32;
|
||||
break;
|
||||
case FillOpaqueStippled:
|
||||
if (!pGC->pRotatedPixmap)
|
||||
BoxFill = cfb8FillRectStippledUnnatural;
|
||||
else
|
||||
BoxFill = cfb8FillRectOpaqueStippled32;
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
prect = prectInit;
|
||||
xorg = pDrawable->x;
|
||||
yorg = pDrawable->y;
|
||||
if (xorg || yorg)
|
||||
{
|
||||
prect = prectInit;
|
||||
n = nrectFill;
|
||||
while(n--)
|
||||
{
|
||||
prect->x += xorg;
|
||||
prect->y += yorg;
|
||||
prect++;
|
||||
}
|
||||
}
|
||||
|
||||
prect = prectInit;
|
||||
|
||||
numRects = REGION_NUM_RECTS(prgnClip) * nrectFill;
|
||||
if (numRects > NUM_STACK_RECTS)
|
||||
{
|
||||
pboxClippedBase = (BoxPtr)xalloc(numRects * sizeof(BoxRec));
|
||||
if (!pboxClippedBase)
|
||||
return;
|
||||
}
|
||||
else
|
||||
pboxClippedBase = stackRects;
|
||||
|
||||
pboxClipped = pboxClippedBase;
|
||||
|
||||
if (REGION_NUM_RECTS(prgnClip) == 1)
|
||||
{
|
||||
int x1, y1, x2, y2, bx2, by2;
|
||||
|
||||
pextent = REGION_RECTS(prgnClip);
|
||||
x1 = pextent->x1;
|
||||
y1 = pextent->y1;
|
||||
x2 = pextent->x2;
|
||||
y2 = pextent->y2;
|
||||
while (nrectFill--)
|
||||
{
|
||||
if ((pboxClipped->x1 = prect->x) < x1)
|
||||
pboxClipped->x1 = x1;
|
||||
|
||||
if ((pboxClipped->y1 = prect->y) < y1)
|
||||
pboxClipped->y1 = y1;
|
||||
|
||||
bx2 = (int) prect->x + (int) prect->width;
|
||||
if (bx2 > x2)
|
||||
bx2 = x2;
|
||||
pboxClipped->x2 = bx2;
|
||||
|
||||
by2 = (int) prect->y + (int) prect->height;
|
||||
if (by2 > y2)
|
||||
by2 = y2;
|
||||
pboxClipped->y2 = by2;
|
||||
|
||||
prect++;
|
||||
if ((pboxClipped->x1 < pboxClipped->x2) &&
|
||||
(pboxClipped->y1 < pboxClipped->y2))
|
||||
{
|
||||
pboxClipped++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int x1, y1, x2, y2, bx2, by2;
|
||||
|
||||
pextent = REGION_EXTENTS(pGC->pScreen, prgnClip);
|
||||
x1 = pextent->x1;
|
||||
y1 = pextent->y1;
|
||||
x2 = pextent->x2;
|
||||
y2 = pextent->y2;
|
||||
while (nrectFill--)
|
||||
{
|
||||
BoxRec box;
|
||||
|
||||
if ((box.x1 = prect->x) < x1)
|
||||
box.x1 = x1;
|
||||
|
||||
if ((box.y1 = prect->y) < y1)
|
||||
box.y1 = y1;
|
||||
|
||||
bx2 = (int) prect->x + (int) prect->width;
|
||||
if (bx2 > x2)
|
||||
bx2 = x2;
|
||||
box.x2 = bx2;
|
||||
|
||||
by2 = (int) prect->y + (int) prect->height;
|
||||
if (by2 > y2)
|
||||
by2 = y2;
|
||||
box.y2 = by2;
|
||||
|
||||
prect++;
|
||||
|
||||
if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
|
||||
continue;
|
||||
|
||||
n = REGION_NUM_RECTS (prgnClip);
|
||||
pbox = REGION_RECTS(prgnClip);
|
||||
|
||||
/* clip the rectangle to each box in the clip region
|
||||
this is logically equivalent to calling Intersect()
|
||||
*/
|
||||
while(n--)
|
||||
{
|
||||
pboxClipped->x1 = max(box.x1, pbox->x1);
|
||||
pboxClipped->y1 = max(box.y1, pbox->y1);
|
||||
pboxClipped->x2 = min(box.x2, pbox->x2);
|
||||
pboxClipped->y2 = min(box.y2, pbox->y2);
|
||||
pbox++;
|
||||
|
||||
/* see if clipping left anything */
|
||||
if(pboxClipped->x1 < pboxClipped->x2 &&
|
||||
pboxClipped->y1 < pboxClipped->y2)
|
||||
{
|
||||
pboxClipped++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (pboxClipped != pboxClippedBase)
|
||||
(*BoxFill) (pDrawable, pGC,
|
||||
pboxClipped-pboxClippedBase, pboxClippedBase);
|
||||
if (pboxClippedBase != stackRects)
|
||||
xfree(pboxClippedBase);
|
||||
}
|
1004
cfb/cfbfillsp.c
1004
cfb/cfbfillsp.c
File diff suppressed because it is too large
Load Diff
799
cfb/cfbgc.c
799
cfb/cfbgc.c
|
@ -1,799 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "region.h"
|
||||
|
||||
#include "mistruct.h"
|
||||
#include "mibstore.h"
|
||||
#include "migc.h"
|
||||
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
#if PSZ == 8
|
||||
# define useTEGlyphBlt cfbTEGlyphBlt8
|
||||
#else
|
||||
# ifdef WriteBitGroup
|
||||
# define useTEGlyphBlt cfbImageGlyphBlt8
|
||||
# else
|
||||
# define useTEGlyphBlt cfbTEGlyphBlt
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef WriteBitGroup
|
||||
# define useImageGlyphBlt cfbImageGlyphBlt8
|
||||
# define usePolyGlyphBlt cfbPolyGlyphBlt8
|
||||
#else
|
||||
# define useImageGlyphBlt miImageGlyphBlt
|
||||
# define usePolyGlyphBlt miPolyGlyphBlt
|
||||
#endif
|
||||
|
||||
static void cfbUnPushPixels (GCPtr, PixmapPtr, DrawablePtr, int, int, int, int);
|
||||
|
||||
#ifdef FOUR_BIT_CODE
|
||||
# define usePushPixels cfbPushPixels8
|
||||
#else
|
||||
# define usePushPixels cfbUnPushPixels
|
||||
#endif
|
||||
|
||||
#ifdef PIXEL_ADDR
|
||||
# define ZeroPolyArc cfbZeroPolyArcSS8Copy
|
||||
#else
|
||||
# define ZeroPolyArc miZeroPolyArc
|
||||
#endif
|
||||
|
||||
GCFuncs cfbGCFuncs = {
|
||||
cfbValidateGC,
|
||||
miChangeGC,
|
||||
miCopyGC,
|
||||
miDestroyGC,
|
||||
miChangeClip,
|
||||
miDestroyClip,
|
||||
miCopyClip,
|
||||
};
|
||||
|
||||
GCOps cfbTEOps1Rect = {
|
||||
cfbSolidSpansCopy,
|
||||
cfbSetSpans,
|
||||
cfbPutImage,
|
||||
cfbCopyArea,
|
||||
cfbCopyPlane,
|
||||
cfbPolyPoint,
|
||||
#ifdef PIXEL_ADDR
|
||||
cfb8LineSS1Rect,
|
||||
cfb8SegmentSS1Rect,
|
||||
#else
|
||||
cfbLineSS,
|
||||
cfbSegmentSS,
|
||||
#endif
|
||||
miPolyRectangle,
|
||||
ZeroPolyArc,
|
||||
cfbFillPoly1RectCopy,
|
||||
cfbPolyFillRect,
|
||||
cfbPolyFillArcSolidCopy,
|
||||
miPolyText8,
|
||||
miPolyText16,
|
||||
miImageText8,
|
||||
miImageText16,
|
||||
useTEGlyphBlt,
|
||||
usePolyGlyphBlt,
|
||||
usePushPixels
|
||||
};
|
||||
|
||||
GCOps cfbNonTEOps1Rect = {
|
||||
cfbSolidSpansCopy,
|
||||
cfbSetSpans,
|
||||
cfbPutImage,
|
||||
cfbCopyArea,
|
||||
cfbCopyPlane,
|
||||
cfbPolyPoint,
|
||||
#ifdef PIXEL_ADDR
|
||||
cfb8LineSS1Rect,
|
||||
cfb8SegmentSS1Rect,
|
||||
#else
|
||||
cfbLineSS,
|
||||
cfbSegmentSS,
|
||||
#endif
|
||||
miPolyRectangle,
|
||||
ZeroPolyArc,
|
||||
cfbFillPoly1RectCopy,
|
||||
cfbPolyFillRect,
|
||||
cfbPolyFillArcSolidCopy,
|
||||
miPolyText8,
|
||||
miPolyText16,
|
||||
miImageText8,
|
||||
miImageText16,
|
||||
useImageGlyphBlt,
|
||||
usePolyGlyphBlt,
|
||||
usePushPixels
|
||||
};
|
||||
|
||||
GCOps cfbTEOps = {
|
||||
cfbSolidSpansCopy,
|
||||
cfbSetSpans,
|
||||
cfbPutImage,
|
||||
cfbCopyArea,
|
||||
cfbCopyPlane,
|
||||
cfbPolyPoint,
|
||||
cfbLineSS,
|
||||
cfbSegmentSS,
|
||||
miPolyRectangle,
|
||||
ZeroPolyArc,
|
||||
miFillPolygon,
|
||||
cfbPolyFillRect,
|
||||
cfbPolyFillArcSolidCopy,
|
||||
miPolyText8,
|
||||
miPolyText16,
|
||||
miImageText8,
|
||||
miImageText16,
|
||||
useTEGlyphBlt,
|
||||
usePolyGlyphBlt,
|
||||
usePushPixels
|
||||
};
|
||||
|
||||
GCOps cfbNonTEOps = {
|
||||
cfbSolidSpansCopy,
|
||||
cfbSetSpans,
|
||||
cfbPutImage,
|
||||
cfbCopyArea,
|
||||
cfbCopyPlane,
|
||||
cfbPolyPoint,
|
||||
cfbLineSS,
|
||||
cfbSegmentSS,
|
||||
miPolyRectangle,
|
||||
#ifdef PIXEL_ADDR
|
||||
cfbZeroPolyArcSS8Copy,
|
||||
#else
|
||||
miZeroPolyArc,
|
||||
#endif
|
||||
miFillPolygon,
|
||||
cfbPolyFillRect,
|
||||
cfbPolyFillArcSolidCopy,
|
||||
miPolyText8,
|
||||
miPolyText16,
|
||||
miImageText8,
|
||||
miImageText16,
|
||||
useImageGlyphBlt,
|
||||
usePolyGlyphBlt,
|
||||
usePushPixels
|
||||
};
|
||||
|
||||
GCOps *
|
||||
cfbMatchCommon (pGC, devPriv)
|
||||
GCPtr pGC;
|
||||
cfbPrivGCPtr devPriv;
|
||||
{
|
||||
if (pGC->lineWidth != 0)
|
||||
return 0;
|
||||
if (pGC->lineStyle != LineSolid)
|
||||
return 0;
|
||||
if (pGC->fillStyle != FillSolid)
|
||||
return 0;
|
||||
if (devPriv->rop != GXcopy)
|
||||
return 0;
|
||||
if (pGC->font &&
|
||||
FONTMAXBOUNDS(pGC->font,rightSideBearing) -
|
||||
FONTMINBOUNDS(pGC->font,leftSideBearing) <= 32 &&
|
||||
FONTMINBOUNDS(pGC->font,characterWidth) >= 0)
|
||||
{
|
||||
if (TERMINALFONT(pGC->font)
|
||||
#ifdef FOUR_BIT_CODE
|
||||
&& FONTMAXBOUNDS(pGC->font,characterWidth) >= PGSZB
|
||||
#endif
|
||||
)
|
||||
#ifdef NO_ONE_RECT
|
||||
return &cfbTEOps1Rect;
|
||||
#else
|
||||
if (devPriv->oneRect)
|
||||
return &cfbTEOps1Rect;
|
||||
else
|
||||
return &cfbTEOps;
|
||||
#endif
|
||||
else
|
||||
#ifdef NO_ONE_RECT
|
||||
return &cfbNonTEOps1Rect;
|
||||
#else
|
||||
if (devPriv->oneRect)
|
||||
return &cfbNonTEOps1Rect;
|
||||
else
|
||||
return &cfbNonTEOps;
|
||||
#endif
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbCreateGC(pGC)
|
||||
register GCPtr pGC;
|
||||
{
|
||||
cfbPrivGC *pPriv;
|
||||
|
||||
if (PixmapWidthPaddingInfo[pGC->depth].padPixelsLog2 == LOG2_BITMAP_PAD)
|
||||
return (mfbCreateGC(pGC));
|
||||
pGC->clientClip = NULL;
|
||||
pGC->clientClipType = CT_NONE;
|
||||
|
||||
if (cfbNonTEOps.PushPixels == cfbUnPushPixels)
|
||||
{
|
||||
cfbTEOps1Rect.PushPixels = mfbPushPixelsWeak();
|
||||
cfbNonTEOps1Rect.PushPixels = mfbPushPixelsWeak();
|
||||
cfbTEOps.PushPixels = mfbPushPixelsWeak();
|
||||
cfbNonTEOps.PushPixels = mfbPushPixelsWeak();
|
||||
}
|
||||
|
||||
/*
|
||||
* some of the output primitives aren't really necessary, since they
|
||||
* will be filled in ValidateGC because of dix/CreateGC() setting all
|
||||
* the change bits. Others are necessary because although they depend
|
||||
* on being a color frame buffer, they don't change
|
||||
*/
|
||||
|
||||
pGC->ops = &cfbNonTEOps;
|
||||
pGC->funcs = &cfbGCFuncs;
|
||||
|
||||
/* cfb wants to translate before scan conversion */
|
||||
pGC->miTranslate = 1;
|
||||
|
||||
pPriv = cfbGetGCPrivate(pGC);
|
||||
pPriv->rop = pGC->alu;
|
||||
pPriv->oneRect = FALSE;
|
||||
pGC->fExpose = TRUE;
|
||||
pGC->freeCompClip = FALSE;
|
||||
pGC->pRotatedPixmap = (PixmapPtr) NULL;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* Clipping conventions
|
||||
if the drawable is a window
|
||||
CT_REGION ==> pCompositeClip really is the composite
|
||||
CT_other ==> pCompositeClip is the window clip region
|
||||
if the drawable is a pixmap
|
||||
CT_REGION ==> pCompositeClip is the translated client region
|
||||
clipped to the pixmap boundary
|
||||
CT_other ==> pCompositeClip is the pixmap bounding box
|
||||
*/
|
||||
|
||||
void
|
||||
cfbValidateGC(pGC, changes, pDrawable)
|
||||
register GCPtr pGC;
|
||||
unsigned long changes;
|
||||
DrawablePtr pDrawable;
|
||||
{
|
||||
int mask; /* stateChanges */
|
||||
int index; /* used for stepping through bitfields */
|
||||
int new_rrop;
|
||||
int new_line, new_text, new_fillspans, new_fillarea;
|
||||
int new_rotate;
|
||||
int xrot, yrot;
|
||||
/* flags for changing the proc vector */
|
||||
cfbPrivGCPtr devPriv;
|
||||
int oneRect;
|
||||
|
||||
new_rotate = pGC->lastWinOrg.x != pDrawable->x ||
|
||||
pGC->lastWinOrg.y != pDrawable->y;
|
||||
|
||||
pGC->lastWinOrg.x = pDrawable->x;
|
||||
pGC->lastWinOrg.y = pDrawable->y;
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
|
||||
new_rrop = FALSE;
|
||||
new_line = FALSE;
|
||||
new_text = FALSE;
|
||||
new_fillspans = FALSE;
|
||||
new_fillarea = FALSE;
|
||||
|
||||
/*
|
||||
* if the client clip is different or moved OR the subwindowMode has
|
||||
* changed OR the window's clip has changed since the last validation
|
||||
* we need to recompute the composite clip
|
||||
*/
|
||||
|
||||
if ((changes & (GCClipXOrigin|GCClipYOrigin|GCClipMask|GCSubwindowMode)) ||
|
||||
(pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS))
|
||||
)
|
||||
{
|
||||
miComputeCompositeClip (pGC, pDrawable);
|
||||
#ifdef NO_ONE_RECT
|
||||
devPriv->oneRect = FALSE;
|
||||
#else
|
||||
oneRect = REGION_NUM_RECTS(pGC->pCompositeClip) == 1;
|
||||
if (oneRect != devPriv->oneRect)
|
||||
new_line = TRUE;
|
||||
devPriv->oneRect = oneRect;
|
||||
#endif
|
||||
}
|
||||
|
||||
mask = changes;
|
||||
while (mask) {
|
||||
index = lowbit (mask);
|
||||
mask &= ~index;
|
||||
|
||||
/*
|
||||
* this switch acculmulates a list of which procedures might have
|
||||
* to change due to changes in the GC. in some cases (e.g.
|
||||
* changing one 16 bit tile for another) we might not really need
|
||||
* a change, but the code is being paranoid. this sort of batching
|
||||
* wins if, for example, the alu and the font have been changed,
|
||||
* or any other pair of items that both change the same thing.
|
||||
*/
|
||||
switch (index) {
|
||||
case GCFunction:
|
||||
case GCForeground:
|
||||
new_rrop = TRUE;
|
||||
break;
|
||||
case GCPlaneMask:
|
||||
new_rrop = TRUE;
|
||||
new_text = TRUE;
|
||||
break;
|
||||
case GCBackground:
|
||||
break;
|
||||
case GCLineStyle:
|
||||
case GCLineWidth:
|
||||
new_line = TRUE;
|
||||
break;
|
||||
case GCJoinStyle:
|
||||
case GCCapStyle:
|
||||
break;
|
||||
case GCFillStyle:
|
||||
new_text = TRUE;
|
||||
new_fillspans = TRUE;
|
||||
new_line = TRUE;
|
||||
new_fillarea = TRUE;
|
||||
break;
|
||||
case GCFillRule:
|
||||
break;
|
||||
case GCTile:
|
||||
new_fillspans = TRUE;
|
||||
new_fillarea = TRUE;
|
||||
break;
|
||||
|
||||
case GCStipple:
|
||||
if (pGC->stipple)
|
||||
{
|
||||
int width = pGC->stipple->drawable.width;
|
||||
PixmapPtr nstipple;
|
||||
|
||||
if ((width <= PGSZ) && !(width & (width - 1)) &&
|
||||
(nstipple = cfbCopyPixmap(pGC->stipple)))
|
||||
{
|
||||
cfbPadPixmap(nstipple);
|
||||
(*pGC->pScreen->DestroyPixmap)(pGC->stipple);
|
||||
pGC->stipple = nstipple;
|
||||
}
|
||||
}
|
||||
new_fillspans = TRUE;
|
||||
new_fillarea = TRUE;
|
||||
break;
|
||||
|
||||
case GCTileStipXOrigin:
|
||||
new_rotate = TRUE;
|
||||
break;
|
||||
|
||||
case GCTileStipYOrigin:
|
||||
new_rotate = TRUE;
|
||||
break;
|
||||
|
||||
case GCFont:
|
||||
new_text = TRUE;
|
||||
break;
|
||||
case GCSubwindowMode:
|
||||
break;
|
||||
case GCGraphicsExposures:
|
||||
break;
|
||||
case GCClipXOrigin:
|
||||
break;
|
||||
case GCClipYOrigin:
|
||||
break;
|
||||
case GCClipMask:
|
||||
break;
|
||||
case GCDashOffset:
|
||||
break;
|
||||
case GCDashList:
|
||||
break;
|
||||
case GCArcMode:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If the drawable has changed, ensure suitable
|
||||
* entries are in the proc vector.
|
||||
*/
|
||||
if (pDrawable->serialNumber != (pGC->serialNumber & (DRAWABLE_SERIAL_BITS))) {
|
||||
new_fillspans = TRUE; /* deal with FillSpans later */
|
||||
}
|
||||
|
||||
if (new_rotate || new_fillspans)
|
||||
{
|
||||
Bool new_pix = FALSE;
|
||||
|
||||
xrot = pGC->patOrg.x + pDrawable->x;
|
||||
yrot = pGC->patOrg.y + pDrawable->y;
|
||||
|
||||
switch (pGC->fillStyle)
|
||||
{
|
||||
case FillTiled:
|
||||
if (!pGC->tileIsPixel)
|
||||
{
|
||||
int width = pGC->tile.pixmap->drawable.width * PSZ;
|
||||
|
||||
if ((width <= PGSZ) && !(width & (width - 1)))
|
||||
{
|
||||
cfbCopyRotatePixmap(pGC->tile.pixmap, &pGC->pRotatedPixmap,
|
||||
xrot, yrot);
|
||||
new_pix = TRUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
#ifdef FOUR_BIT_CODE
|
||||
case FillStippled:
|
||||
case FillOpaqueStippled:
|
||||
{
|
||||
int width = pGC->stipple->drawable.width;
|
||||
|
||||
if ((width <= PGSZ) && !(width & (width - 1)))
|
||||
{
|
||||
mfbCopyRotatePixmap(pGC->stipple, &pGC->pRotatedPixmap,
|
||||
xrot, yrot);
|
||||
new_pix = TRUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
if (!new_pix && pGC->pRotatedPixmap)
|
||||
{
|
||||
(*pGC->pScreen->DestroyPixmap)(pGC->pRotatedPixmap);
|
||||
pGC->pRotatedPixmap = (PixmapPtr) NULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_rrop)
|
||||
{
|
||||
int old_rrop;
|
||||
|
||||
old_rrop = devPriv->rop;
|
||||
devPriv->rop = cfbReduceRasterOp (pGC->alu, pGC->fgPixel,
|
||||
pGC->planemask,
|
||||
&devPriv->and, &devPriv->xor);
|
||||
if (old_rrop == devPriv->rop)
|
||||
new_rrop = FALSE;
|
||||
else
|
||||
{
|
||||
#ifdef PIXEL_ADDR
|
||||
new_line = TRUE;
|
||||
#endif
|
||||
#ifdef WriteBitGroup
|
||||
new_text = TRUE;
|
||||
#endif
|
||||
new_fillspans = TRUE;
|
||||
new_fillarea = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_rrop || new_fillspans || new_text || new_fillarea || new_line)
|
||||
{
|
||||
GCOps *newops;
|
||||
|
||||
if ((newops = cfbMatchCommon (pGC, devPriv)))
|
||||
{
|
||||
if (pGC->ops->devPrivate.val)
|
||||
miDestroyGCOps (pGC->ops);
|
||||
pGC->ops = newops;
|
||||
new_rrop = new_line = new_fillspans = new_text = new_fillarea = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!pGC->ops->devPrivate.val)
|
||||
{
|
||||
pGC->ops = miCreateGCOps (pGC->ops);
|
||||
pGC->ops->devPrivate.val = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* deal with the changes we've collected */
|
||||
if (new_line)
|
||||
{
|
||||
pGC->ops->FillPolygon = miFillPolygon;
|
||||
#ifdef NO_ONE_RECT
|
||||
if (pGC->fillStyle == FillSolid)
|
||||
{
|
||||
switch (devPriv->rop) {
|
||||
case GXcopy:
|
||||
pGC->ops->FillPolygon = cfbFillPoly1RectCopy;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->FillPolygon = cfbFillPoly1RectGeneral;
|
||||
break;
|
||||
}
|
||||
}
|
||||
#else
|
||||
if (devPriv->oneRect && pGC->fillStyle == FillSolid)
|
||||
{
|
||||
switch (devPriv->rop) {
|
||||
case GXcopy:
|
||||
pGC->ops->FillPolygon = cfbFillPoly1RectCopy;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->FillPolygon = cfbFillPoly1RectGeneral;
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (pGC->lineWidth == 0)
|
||||
{
|
||||
#ifdef PIXEL_ADDR
|
||||
if ((pGC->lineStyle == LineSolid) && (pGC->fillStyle == FillSolid))
|
||||
{
|
||||
switch (devPriv->rop)
|
||||
{
|
||||
case GXxor:
|
||||
pGC->ops->PolyArc = cfbZeroPolyArcSS8Xor;
|
||||
break;
|
||||
case GXcopy:
|
||||
pGC->ops->PolyArc = cfbZeroPolyArcSS8Copy;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->PolyArc = cfbZeroPolyArcSS8General;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
pGC->ops->PolyArc = miZeroPolyArc;
|
||||
}
|
||||
else
|
||||
pGC->ops->PolyArc = miPolyArc;
|
||||
pGC->ops->PolySegment = miPolySegment;
|
||||
switch (pGC->lineStyle)
|
||||
{
|
||||
case LineSolid:
|
||||
if(pGC->lineWidth == 0)
|
||||
{
|
||||
if (pGC->fillStyle == FillSolid)
|
||||
{
|
||||
#if defined(PIXEL_ADDR) && !defined(NO_ONE_RECT)
|
||||
if (devPriv->oneRect &&
|
||||
((pDrawable->x >= pGC->pScreen->width - 32768) &&
|
||||
(pDrawable->y >= pGC->pScreen->height - 32768)))
|
||||
{
|
||||
pGC->ops->Polylines = cfb8LineSS1Rect;
|
||||
pGC->ops->PolySegment = cfb8SegmentSS1Rect;
|
||||
} else
|
||||
#endif
|
||||
#ifdef NO_ONE_RECT
|
||||
{
|
||||
pGC->ops->Polylines = cfb8LineSS1Rect;
|
||||
pGC->ops->PolySegment = cfb8SegmentSS1Rect;
|
||||
}
|
||||
#else
|
||||
{
|
||||
pGC->ops->Polylines = cfbLineSS;
|
||||
pGC->ops->PolySegment = cfbSegmentSS;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
pGC->ops->Polylines = miZeroLine;
|
||||
}
|
||||
else
|
||||
pGC->ops->Polylines = miWideLine;
|
||||
break;
|
||||
case LineOnOffDash:
|
||||
case LineDoubleDash:
|
||||
if (pGC->lineWidth == 0 && pGC->fillStyle == FillSolid)
|
||||
{
|
||||
pGC->ops->Polylines = cfbLineSD;
|
||||
pGC->ops->PolySegment = cfbSegmentSD;
|
||||
} else
|
||||
pGC->ops->Polylines = miWideDash;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_text && (pGC->font))
|
||||
{
|
||||
if (FONTMAXBOUNDS(pGC->font,rightSideBearing) -
|
||||
FONTMINBOUNDS(pGC->font,leftSideBearing) > 32 ||
|
||||
FONTMINBOUNDS(pGC->font,characterWidth) < 0)
|
||||
{
|
||||
pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
|
||||
pGC->ops->ImageGlyphBlt = miImageGlyphBlt;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef WriteBitGroup
|
||||
if (pGC->fillStyle == FillSolid)
|
||||
{
|
||||
if (devPriv->rop == GXcopy)
|
||||
pGC->ops->PolyGlyphBlt = cfbPolyGlyphBlt8;
|
||||
else
|
||||
#ifdef FOUR_BIT_CODE
|
||||
pGC->ops->PolyGlyphBlt = cfbPolyGlyphRop8;
|
||||
#else
|
||||
pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
#endif
|
||||
pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
|
||||
/* special case ImageGlyphBlt for terminal emulator fonts */
|
||||
#if !defined(WriteBitGroup) || PSZ == 8
|
||||
if (TERMINALFONT(pGC->font) &&
|
||||
(pGC->planemask & PMSK) == PMSK
|
||||
#ifdef FOUR_BIT_CODE
|
||||
&& FONTMAXBOUNDS(pGC->font,characterWidth) >= PGSZB
|
||||
#endif
|
||||
)
|
||||
{
|
||||
pGC->ops->ImageGlyphBlt = useTEGlyphBlt;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
#ifdef WriteBitGroup
|
||||
if (devPriv->rop == GXcopy &&
|
||||
pGC->fillStyle == FillSolid &&
|
||||
(pGC->planemask & PMSK) == PMSK)
|
||||
pGC->ops->ImageGlyphBlt = cfbImageGlyphBlt8;
|
||||
else
|
||||
#endif
|
||||
pGC->ops->ImageGlyphBlt = miImageGlyphBlt;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (new_fillspans) {
|
||||
switch (pGC->fillStyle) {
|
||||
case FillSolid:
|
||||
switch (devPriv->rop) {
|
||||
case GXcopy:
|
||||
pGC->ops->FillSpans = cfbSolidSpansCopy;
|
||||
break;
|
||||
case GXxor:
|
||||
pGC->ops->FillSpans = cfbSolidSpansXor;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->FillSpans = cfbSolidSpansGeneral;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case FillTiled:
|
||||
if (pGC->pRotatedPixmap)
|
||||
{
|
||||
if (pGC->alu == GXcopy && (pGC->planemask & PMSK) == PMSK)
|
||||
pGC->ops->FillSpans = cfbTile32FSCopy;
|
||||
else
|
||||
pGC->ops->FillSpans = cfbTile32FSGeneral;
|
||||
}
|
||||
else
|
||||
pGC->ops->FillSpans = cfbUnnaturalTileFS;
|
||||
break;
|
||||
case FillStippled:
|
||||
#ifdef FOUR_BIT_CODE
|
||||
if (pGC->pRotatedPixmap)
|
||||
pGC->ops->FillSpans = cfb8Stipple32FS;
|
||||
else
|
||||
#endif
|
||||
pGC->ops->FillSpans = cfbUnnaturalStippleFS;
|
||||
break;
|
||||
case FillOpaqueStippled:
|
||||
#ifdef FOUR_BIT_CODE
|
||||
if (pGC->pRotatedPixmap)
|
||||
pGC->ops->FillSpans = cfb8OpaqueStipple32FS;
|
||||
else
|
||||
#endif
|
||||
pGC->ops->FillSpans = cfbUnnaturalStippleFS;
|
||||
break;
|
||||
default:
|
||||
FatalError("cfbValidateGC: illegal fillStyle\n");
|
||||
}
|
||||
} /* end of new_fillspans */
|
||||
|
||||
if (new_fillarea) {
|
||||
#ifndef FOUR_BIT_CODE
|
||||
pGC->ops->PolyFillRect = miPolyFillRect;
|
||||
if (pGC->fillStyle == FillSolid || pGC->fillStyle == FillTiled)
|
||||
{
|
||||
pGC->ops->PolyFillRect = cfbPolyFillRect;
|
||||
}
|
||||
#endif
|
||||
#ifdef FOUR_BIT_CODE
|
||||
pGC->ops->PushPixels = mfbPushPixelsWeak();
|
||||
if (pGC->fillStyle == FillSolid && devPriv->rop == GXcopy)
|
||||
pGC->ops->PushPixels = cfbPushPixels8;
|
||||
#endif
|
||||
pGC->ops->PolyFillArc = miPolyFillArc;
|
||||
if (pGC->fillStyle == FillSolid)
|
||||
{
|
||||
switch (devPriv->rop)
|
||||
{
|
||||
case GXcopy:
|
||||
pGC->ops->PolyFillArc = cfbPolyFillArcSolidCopy;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->PolyFillArc = cfbPolyFillArcSolidGeneral;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* this is never called, it just exists to have its address
|
||||
* taken in mfbCreateGC.
|
||||
*/
|
||||
static void
|
||||
cfbUnPushPixels (pGC, pBitmap, pDrawable, dx, dy, xOrg, yOrg)
|
||||
GCPtr pGC;
|
||||
PixmapPtr pBitmap;
|
||||
DrawablePtr pDrawable;
|
||||
int dx, dy, xOrg, yOrg;
|
||||
{
|
||||
return;
|
||||
}
|
213
cfb/cfbgetsp.c
213
cfb/cfbgetsp.c
|
@ -1,213 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
|
||||
#include "misc.h"
|
||||
#include "region.h"
|
||||
#include "gc.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
/* GetSpans -- for each span, gets bits from drawable starting at ppt[i]
|
||||
* and continuing for pwidth[i] bits
|
||||
* Each scanline returned will be server scanline padded, i.e., it will come
|
||||
* out to an integral number of words.
|
||||
*/
|
||||
void
|
||||
cfbGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pchardstStart)
|
||||
DrawablePtr pDrawable; /* drawable from which to get bits */
|
||||
int wMax; /* largest value of all *pwidths */
|
||||
register DDXPointPtr ppt; /* points to start copying from */
|
||||
int *pwidth; /* list of number of bits to copy */
|
||||
int nspans; /* number of scanlines to copy */
|
||||
char *pchardstStart; /* where to put the bits */
|
||||
{
|
||||
PixelGroup *pdstStart = (PixelGroup *)pchardstStart;
|
||||
register PixelGroup *pdst; /* where to put the bits */
|
||||
register PixelGroup *psrc; /* where to get the bits */
|
||||
register PixelGroup tmpSrc; /* scratch buffer for bits */
|
||||
PixelGroup *psrcBase; /* start of src bitmap */
|
||||
int widthSrc; /* width of pixmap in bytes */
|
||||
register DDXPointPtr pptLast; /* one past last point to get */
|
||||
int xEnd; /* last pixel to copy from */
|
||||
int nl, srcBit;
|
||||
int w;
|
||||
PixelGroup *pdstNext;
|
||||
#if PSZ == 24
|
||||
register char *psrcb, *pdstb;
|
||||
register int xIndex = 0;
|
||||
#else
|
||||
register int nstart;
|
||||
#if PSZ != 32 || PPW != 1
|
||||
int nend;
|
||||
#endif
|
||||
PixelGroup startmask, endmask;
|
||||
int nlMiddle;
|
||||
#endif
|
||||
|
||||
switch (pDrawable->bitsPerPixel) {
|
||||
case 1:
|
||||
mfbGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pchardstStart);
|
||||
return;
|
||||
case PSZ:
|
||||
break;
|
||||
default:
|
||||
FatalError("cfbGetSpans: invalid depth\n");
|
||||
}
|
||||
|
||||
/*
|
||||
* XFree86 DDX empties the root borderClip when the VT is
|
||||
* switched away; this checks for that case
|
||||
*/
|
||||
if (!cfbDrawableEnabled(pDrawable))
|
||||
return;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, widthSrc, psrcBase)
|
||||
|
||||
#ifdef PIXEL_ADDR
|
||||
# if PSZ != 24
|
||||
if ((nspans == 1) && (*pwidth == 1))
|
||||
{
|
||||
tmpSrc = *((PixelType *)(psrcBase + (ppt->y * widthSrc))
|
||||
+ ppt->x);
|
||||
#if BITMAP_BIT_ORDER == MSBFirst
|
||||
tmpSrc <<= (sizeof (CfbBits) - sizeof (PixelType)) * 8;
|
||||
#endif
|
||||
*pdstStart = tmpSrc;
|
||||
return;
|
||||
}
|
||||
# endif /* PSZ != 24 */
|
||||
#endif
|
||||
pdst = pdstStart;
|
||||
pptLast = ppt + nspans;
|
||||
while(ppt < pptLast)
|
||||
{
|
||||
#if PSZ == 24
|
||||
xEnd = min(ppt->x + *pwidth, widthSrc * sizeof(CfbBits) / 3);
|
||||
w = xEnd - ppt->x;
|
||||
psrc = psrcBase + ppt->y * widthSrc;
|
||||
srcBit = ppt->x;
|
||||
psrcb = (char *)psrc + (ppt->x * 3);
|
||||
xIndex = 0;
|
||||
pdstb = (char *)pdst;
|
||||
pdstNext = pdst + ((w * 3 + 3) >> 2);
|
||||
#else
|
||||
xEnd = min(ppt->x + *pwidth, widthSrc << PWSH);
|
||||
w = xEnd - ppt->x;
|
||||
psrc = psrcBase + ppt->y * widthSrc + (ppt->x >> PWSH);
|
||||
srcBit = ppt->x & PIM;
|
||||
pdstNext = pdst + ((w + PPW - 1) >> PWSH);
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
if (w < 0)
|
||||
FatalError("cfb24GetSpans: Internal error (w < 0)\n");
|
||||
nl = w;
|
||||
while (nl--){
|
||||
psrc = (PixelGroup *)((unsigned long)psrcb & ~0x03);
|
||||
getbits24(psrc, tmpSrc, srcBit);
|
||||
pdst = (PixelGroup *)((unsigned long)pdstb & ~0x03);
|
||||
putbits24(tmpSrc, PPW, pdst, ~((CfbBits)0), xIndex);
|
||||
srcBit++;
|
||||
psrcb += 3;
|
||||
xIndex++;
|
||||
pdstb += 3;
|
||||
}
|
||||
pdst = pdstNext;
|
||||
#else /* PSZ == 24 */
|
||||
if (srcBit + w <= PPW)
|
||||
{
|
||||
getbits(psrc, srcBit, w, tmpSrc);
|
||||
putbits(tmpSrc, 0, w, pdst, ~((CfbBits)0));
|
||||
pdst++;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(ppt->x, w, startmask, endmask, nlMiddle);
|
||||
nstart = 0;
|
||||
if (startmask)
|
||||
{
|
||||
nstart = PPW - srcBit;
|
||||
getbits(psrc, srcBit, nstart, tmpSrc);
|
||||
putbits(tmpSrc, 0, nstart, pdst, ~((CfbBits)0));
|
||||
if(srcBit + nstart >= PPW)
|
||||
psrc++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
tmpSrc = *psrc;
|
||||
putbits(tmpSrc, nstart, PPW, pdst, ~((CfbBits)0));
|
||||
psrc++;
|
||||
pdst++;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
#if PSZ != 32 || PPW != 1
|
||||
nend = xEnd & PIM;
|
||||
#endif
|
||||
getbits(psrc, 0, nend, tmpSrc);
|
||||
putbits(tmpSrc, nstart, nend, pdst, ~((CfbBits)0));
|
||||
}
|
||||
pdst = pdstNext;
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
ppt++;
|
||||
pwidth++;
|
||||
}
|
||||
}
|
477
cfb/cfbglblt8.c
477
cfb/cfbglblt8.c
|
@ -1,477 +0,0 @@
|
|||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Poly glyph blt. Accepts an arbitrary font <= 32 bits wide, in Copy mode
|
||||
* only.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
#define BOX_OVERLAP(box1, box2, xoffset, yoffset) \
|
||||
((box1)->x1 <= ((int) (box2)->x2 + (xoffset)) && \
|
||||
((int) (box2)->x1 + (xoffset)) <= (box1)->x2 && \
|
||||
(box1)->y1 <= ((int) (box2)->y2 + (yoffset)) && \
|
||||
((int) (box2)->y1 + (yoffset)) <= (box1)->y2)
|
||||
|
||||
#define BOX_CONTAINS(box1, box2, xoffset, yoffset) \
|
||||
((box1)->x1 <= ((int) (box2)->x1 + (xoffset)) && \
|
||||
((int) (box2)->x2 + (xoffset)) <= (box1)->x2 && \
|
||||
(box1)->y1 <= ((int) (box2)->y1 + (yoffset)) && \
|
||||
((int) (box2)->y2 + (yoffset)) <= (box1)->y2)
|
||||
|
||||
#if defined(FOUR_BIT_CODE) || defined(WriteBitGroup) && !defined(GLYPHROP)
|
||||
|
||||
#if GLYPHPADBYTES != 4
|
||||
#define USE_LEFTBITS
|
||||
#endif
|
||||
|
||||
#ifdef USE_LEFTBITS
|
||||
typedef unsigned char *glyphPointer;
|
||||
|
||||
#define GlyphBits(bits,width,dst) getleftbits(bits,width,dst); \
|
||||
(dst) &= widthMask; \
|
||||
(bits) += widthGlyph;
|
||||
#define GlyphBitsS(bits,width,dst,off) GlyphBits(bits,width,dst); \
|
||||
dst = BitRight (dst, off);
|
||||
#else
|
||||
typedef CARD32 *glyphPointer;
|
||||
|
||||
#define GlyphBits(bits,width,dst) dst = *bits++;
|
||||
#define GlyphBitsS(bits,width,dst,off) dst = BitRight(*bits++, off);
|
||||
#endif
|
||||
|
||||
#ifdef GLYPHROP
|
||||
#define cfbPolyGlyphBlt8 cfbPolyGlyphRop8
|
||||
#define cfbPolyGlyphBlt8Clipped cfbPolyGlyphRop8Clipped
|
||||
|
||||
#undef WriteBitGroup
|
||||
#define WriteBitGroup(dst,pixel,bits) RRopBitGroup(dst,bits)
|
||||
|
||||
#endif
|
||||
|
||||
static void cfbPolyGlyphBlt8Clipped(
|
||||
DrawablePtr pDrawable,
|
||||
GCPtr pGC,
|
||||
int x,
|
||||
int y,
|
||||
unsigned int nglyph,
|
||||
CharInfoPtr *ppci, /* array of character info */
|
||||
unsigned char *pglyphBase); /* start of array of glyphs */
|
||||
|
||||
#if defined(HAS_STIPPLE_CODE) && !defined(GLYPHROP) && !defined(USE_LEFTBITS)
|
||||
#define USE_STIPPLE_CODE
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) && !defined(GLYPHROP) && (defined(mc68020) || defined(mc68000) || defined(__mc68000__)) && PSZ == 8 && !defined(USE_LEFTBITS)
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
#undef USE_STIPPLE_CODE
|
||||
#endif
|
||||
#include "stip68kgnu.h"
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#define DST_INC 3
|
||||
#else
|
||||
#define DST_INC (PGSZB >> PWSH)
|
||||
#endif
|
||||
|
||||
/* cfbStippleStack/cfbStippleStackTE are coded in assembly language.
|
||||
* They are only provided on some architecures.
|
||||
*/
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
extern void cfbStippleStack (), cfbStippleStackTE ();
|
||||
#endif
|
||||
|
||||
void
|
||||
cfbPolyGlyphBlt8 (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int x, y;
|
||||
unsigned int nglyph;
|
||||
CharInfoPtr *ppci; /* array of character info */
|
||||
pointer pglyphBase; /* start of array of glyphs */
|
||||
{
|
||||
#ifndef GLYPHROP
|
||||
register CfbBits pixel;
|
||||
#endif
|
||||
#if !defined(STIPPLE) && !defined(USE_STIPPLE_CODE)
|
||||
register CfbBits c;
|
||||
register CfbBits *dst;
|
||||
#endif
|
||||
register glyphPointer glyphBits;
|
||||
register int xoff;
|
||||
|
||||
FontPtr pfont = pGC->font;
|
||||
CharInfoPtr pci;
|
||||
CfbBits *dstLine;
|
||||
CfbBits *pdstBase;
|
||||
int hTmp;
|
||||
int bwidthDst;
|
||||
int widthDst;
|
||||
int h;
|
||||
BoxRec bbox; /* for clipping */
|
||||
int w;
|
||||
RegionPtr clip;
|
||||
BoxPtr extents;
|
||||
#ifdef USE_LEFTBITS
|
||||
int widthGlyph;
|
||||
CfbBits widthMask;
|
||||
#endif
|
||||
#ifndef STIPPLE
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
void (*stipple)();
|
||||
|
||||
stipple = cfbStippleStack;
|
||||
if (FONTCONSTMETRICS(pfont))
|
||||
stipple = cfbStippleStackTE;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
x += pDrawable->x;
|
||||
y += pDrawable->y;
|
||||
|
||||
/* compute an approximate (but covering) bounding box */
|
||||
bbox.x1 = 0;
|
||||
if ((ppci[0]->metrics.leftSideBearing < 0))
|
||||
bbox.x1 = ppci[0]->metrics.leftSideBearing;
|
||||
h = nglyph - 1;
|
||||
w = ppci[h]->metrics.rightSideBearing;
|
||||
while (--h >= 0)
|
||||
w += ppci[h]->metrics.characterWidth;
|
||||
bbox.x2 = w;
|
||||
bbox.y1 = -FONTMAXBOUNDS(pfont,ascent);
|
||||
bbox.y2 = FONTMAXBOUNDS(pfont,descent);
|
||||
|
||||
clip = cfbGetCompositeClip(pGC);
|
||||
extents = &clip->extents;
|
||||
|
||||
if (!clip->data)
|
||||
{
|
||||
if (!BOX_CONTAINS(extents, &bbox, x, y))
|
||||
{
|
||||
if (BOX_OVERLAP (extents, &bbox, x, y))
|
||||
cfbPolyGlyphBlt8Clipped(pDrawable, pGC, x, y,
|
||||
nglyph, ppci, pglyphBase);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* check to make sure some of the text appears on the screen */
|
||||
if (!BOX_OVERLAP (extents, &bbox, x, y))
|
||||
return;
|
||||
|
||||
bbox.x1 += x;
|
||||
bbox.x2 += x;
|
||||
bbox.y1 += y;
|
||||
bbox.y2 += y;
|
||||
|
||||
switch (RECT_IN_REGION(pGC->pScreen, clip, &bbox))
|
||||
{
|
||||
case rgnPART:
|
||||
cfbPolyGlyphBlt8Clipped(pDrawable, pGC, x, y,
|
||||
nglyph, ppci, pglyphBase);
|
||||
case rgnOUT:
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef GLYPHROP
|
||||
cfb8CheckStipple (pGC->alu, pGC->fgPixel, pGC->planemask);
|
||||
#else
|
||||
pixel = cfbGetGCPrivate(pGC)->xor;
|
||||
#endif
|
||||
|
||||
cfbGetTypedWidthAndPointer (pDrawable, bwidthDst, pdstBase, char, CfbBits)
|
||||
|
||||
widthDst = bwidthDst / PGSZB;
|
||||
while (nglyph--)
|
||||
{
|
||||
pci = *ppci++;
|
||||
glyphBits = (glyphPointer) FONTGLYPHBITS(pglyphBase,pci);
|
||||
xoff = x + pci->metrics.leftSideBearing;
|
||||
#if PSZ == 24
|
||||
dstLine = pdstBase + (y - pci->metrics.ascent) * widthDst +((xoff>> 2)*3);
|
||||
#else
|
||||
dstLine = pdstBase +
|
||||
(y - pci->metrics.ascent) * widthDst + (xoff >> PWSH);
|
||||
#endif
|
||||
x += pci->metrics.characterWidth;
|
||||
if ((hTmp = pci->metrics.descent + pci->metrics.ascent))
|
||||
{
|
||||
#if PSZ == 24
|
||||
xoff &= 0x03;
|
||||
#else
|
||||
xoff &= PIM;
|
||||
#endif /* PSZ == 24 */
|
||||
#ifdef STIPPLE
|
||||
STIPPLE(dstLine,glyphBits,pixel,bwidthDst,hTmp,xoff);
|
||||
#else
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
(*stipple)(dstLine,glyphBits,pixel,bwidthDst,hTmp,xoff);
|
||||
#else
|
||||
#ifdef USE_LEFTBITS
|
||||
w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
|
||||
widthGlyph = PADGLYPHWIDTHBYTES(w);
|
||||
widthMask = mfbGetendtab(w);
|
||||
#endif
|
||||
do {
|
||||
dst = dstLine;
|
||||
dstLine = (CfbBits *) (((char *) dstLine) + bwidthDst);
|
||||
GlyphBits(glyphBits, w, c)
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(BitRight(c,xoff)));
|
||||
dst += DST_INC;
|
||||
c = BitLeft(c,PGSZB - xoff);
|
||||
while (c)
|
||||
{
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst += DST_INC;
|
||||
}
|
||||
} while (--hTmp);
|
||||
#endif /* USE_STIPPLE_CODE else */
|
||||
#endif /* STIPPLE else */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
cfbPolyGlyphBlt8Clipped(
|
||||
DrawablePtr pDrawable,
|
||||
GCPtr pGC,
|
||||
int x,
|
||||
int y,
|
||||
unsigned int nglyph,
|
||||
CharInfoPtr *ppci, /* array of character info */
|
||||
unsigned char *pglyphBase) /* start of array of glyphs */
|
||||
{
|
||||
#ifndef GLYPHROP
|
||||
register CfbBits pixel;
|
||||
#endif
|
||||
#if !defined(STIPPLE) && !defined(USE_STIPPLE_CODE)
|
||||
register CfbBits c;
|
||||
#endif
|
||||
register glyphPointer glyphBits;
|
||||
register int xoff;
|
||||
#if defined(USE_LEFTBITS) || (!defined(STIPPLE) && !defined(USE_STIPPLE_CODE))
|
||||
register CfbBits *dst;
|
||||
#endif
|
||||
|
||||
CharInfoPtr pci;
|
||||
FontPtr pfont = pGC->font;
|
||||
CfbBits *dstLine;
|
||||
CfbBits *pdstBase;
|
||||
#ifdef USE_LEFTBITS
|
||||
CARD32 *cTmp;
|
||||
#endif
|
||||
CARD32 *clips;
|
||||
int maxAscent, maxDescent;
|
||||
int minLeftBearing;
|
||||
int hTmp;
|
||||
int widthDst;
|
||||
int bwidthDst;
|
||||
int xG, yG;
|
||||
BoxPtr pBox;
|
||||
int numRects;
|
||||
int w;
|
||||
RegionPtr pRegion;
|
||||
int yBand;
|
||||
#ifdef GLYPHROP
|
||||
CfbBits bits;
|
||||
#endif
|
||||
#ifdef USE_LEFTBITS
|
||||
int widthGlyph;
|
||||
CfbBits widthMask;
|
||||
#endif
|
||||
|
||||
#ifdef GLYPHROP
|
||||
cfb8CheckStipple (pGC->alu, pGC->fgPixel, pGC->planemask);
|
||||
#else
|
||||
pixel = cfbGetGCPrivate(pGC)->xor;
|
||||
#endif
|
||||
|
||||
cfbGetTypedWidthAndPointer (pDrawable, bwidthDst, pdstBase, char, CfbBits)
|
||||
|
||||
widthDst = bwidthDst / PGSZB;
|
||||
maxAscent = FONTMAXBOUNDS(pfont,ascent);
|
||||
maxDescent = FONTMAXBOUNDS(pfont,descent);
|
||||
minLeftBearing = FONTMINBOUNDS(pfont,leftSideBearing);
|
||||
|
||||
pRegion = cfbGetCompositeClip(pGC);
|
||||
|
||||
pBox = REGION_RECTS(pRegion);
|
||||
numRects = REGION_NUM_RECTS (pRegion);
|
||||
while (numRects && pBox->y2 <= y - maxAscent)
|
||||
{
|
||||
++pBox;
|
||||
--numRects;
|
||||
}
|
||||
if (!numRects || pBox->y1 >= y + maxDescent)
|
||||
return;
|
||||
yBand = pBox->y1;
|
||||
while (numRects && pBox->y1 == yBand && pBox->x2 <= x + minLeftBearing)
|
||||
{
|
||||
++pBox;
|
||||
--numRects;
|
||||
}
|
||||
if (!numRects)
|
||||
return;
|
||||
clips = (CARD32 *)xalloc ((maxAscent + maxDescent) *
|
||||
sizeof (CARD32));
|
||||
while (nglyph--)
|
||||
{
|
||||
pci = *ppci++;
|
||||
glyphBits = (glyphPointer) FONTGLYPHBITS(pglyphBase,pci);
|
||||
w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
|
||||
xG = x + pci->metrics.leftSideBearing;
|
||||
yG = y - pci->metrics.ascent;
|
||||
x += pci->metrics.characterWidth;
|
||||
if ((hTmp = pci->metrics.descent + pci->metrics.ascent))
|
||||
{
|
||||
#if PSZ == 24
|
||||
dstLine = pdstBase + yG * widthDst + ((xG>> 2)*3);
|
||||
/* never use (xG*3)>>2 */
|
||||
#else
|
||||
dstLine = pdstBase + yG * widthDst + (xG >> PWSH);
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
xoff = xG & 3;
|
||||
#else
|
||||
xoff = xG & PIM;
|
||||
#endif
|
||||
#ifdef USE_LEFTBITS
|
||||
w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
|
||||
widthGlyph = PADGLYPHWIDTHBYTES(w);
|
||||
widthMask = mfbGetendtab(w);
|
||||
#endif
|
||||
switch (cfb8ComputeClipMasks32 (pBox, numRects, xG, yG, w, hTmp, clips))
|
||||
{
|
||||
case rgnPART:
|
||||
#ifdef USE_LEFTBITS
|
||||
cTmp = clips;
|
||||
do {
|
||||
dst = dstLine;
|
||||
dstLine = (CfbBits *) (((char *) dstLine) + bwidthDst);
|
||||
GlyphBits(glyphBits, w, c)
|
||||
c &= *cTmp++;
|
||||
if (c)
|
||||
{
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(BitRight(c,xoff)));
|
||||
c = BitLeft(c,PGSZB - xoff);
|
||||
dst += DST_INC;
|
||||
while (c)
|
||||
{
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst += DST_INC;
|
||||
}
|
||||
}
|
||||
} while (--hTmp);
|
||||
break;
|
||||
#else /* !USE_LEFTBITS */
|
||||
{
|
||||
int h;
|
||||
|
||||
h = hTmp;
|
||||
do
|
||||
{
|
||||
--h;
|
||||
clips[h] = clips[h] & glyphBits[h];
|
||||
} while (h);
|
||||
}
|
||||
glyphBits = clips;
|
||||
/* fall through */
|
||||
#endif /* USE_LEFTBITS */
|
||||
case rgnIN:
|
||||
#ifdef STIPPLE
|
||||
STIPPLE(dstLine,glyphBits,pixel,bwidthDst,hTmp,xoff);
|
||||
#else
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
cfbStippleStackTE(dstLine,glyphBits,pixel,bwidthDst,hTmp,xoff);
|
||||
#else
|
||||
do {
|
||||
dst = dstLine;
|
||||
dstLine = (CfbBits *) (((char *) dstLine) + bwidthDst);
|
||||
GlyphBits(glyphBits, w, c)
|
||||
if (c)
|
||||
{
|
||||
/* This code originally could read memory locations
|
||||
* that were not mapped. Hence we have to check the
|
||||
* trailing bits to see whether they are zero and if
|
||||
* then skip them correctly. This is no problem for
|
||||
* the GXcopy case, since there only the pixels that
|
||||
* are non-zero are written ...
|
||||
*/
|
||||
#ifndef GLYPHROP
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(BitRight(c,xoff)));
|
||||
c = BitLeft(c,PGSZB - xoff);
|
||||
dst += DST_INC;
|
||||
#else /* GLYPHROP */
|
||||
if ((bits = GetBitGroup(BitRight(c,xoff))))
|
||||
WriteBitGroup(dst, pixel, bits);
|
||||
c = BitLeft(c,PGSZB - xoff);
|
||||
dst += DST_INC;
|
||||
|
||||
while (c && ((bits = GetBitGroup(c)) == 0))
|
||||
{
|
||||
NextBitGroup(c);
|
||||
dst += DST_INC;
|
||||
}
|
||||
#endif /* GLYPHROP */
|
||||
while (c)
|
||||
{
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst += DST_INC;
|
||||
}
|
||||
}
|
||||
} while (--hTmp);
|
||||
#endif /* USE_STIPPLE_CODE else */
|
||||
#endif /* STIPPLE else */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
xfree (clips);
|
||||
}
|
||||
|
||||
#endif /* FOUR_BIT_CODE */
|
554
cfb/cfbhrzvert.c
554
cfb/cfbhrzvert.c
|
@ -1,554 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987,1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "gc.h"
|
||||
#include "window.h"
|
||||
#include "pixmap.h"
|
||||
#include "region.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
/* horizontal solid line
|
||||
abs(len) > 1
|
||||
*/
|
||||
void
|
||||
cfbHorzS(rop, and, xor, addrl, nlwidth, x1, y1, len)
|
||||
register int rop;
|
||||
register CfbBits and;
|
||||
register CfbBits xor;
|
||||
register CfbBits *addrl; /* pointer to base of bitmap */
|
||||
int nlwidth; /* width in longwords of bitmap */
|
||||
int x1; /* initial point */
|
||||
int y1;
|
||||
int len; /* length of line */
|
||||
{
|
||||
register int nlmiddle;
|
||||
|
||||
#if PSZ == 24
|
||||
|
||||
int leftIndex, rightIndex;
|
||||
CfbBits piQxelAnd[3], piQxelXor[3];
|
||||
piQxelAnd[0] = (and & 0xFFFFFF) | ((and<<24) & 0xFF000000);
|
||||
piQxelAnd[1] = ((and>>8) & 0xFFFF)| ((and<<16) & 0xFFFF0000);
|
||||
piQxelAnd[2] = ((and<<8) & 0xFFFFFF00) | ((and>>16) & 0xFF);
|
||||
|
||||
piQxelXor[0] = (xor & 0xFFFFFF) | ((xor<<24) & 0xFF000000);
|
||||
piQxelXor[1] = ((xor>>8) & 0xFFFF)| ((xor<<16) & 0xFFFF0000);
|
||||
piQxelXor[2] = ((xor<<8) & 0xFFFFFF00) | ((xor>>16) & 0xFF);
|
||||
|
||||
leftIndex = x1 & 3;
|
||||
rightIndex = ((x1 + len) < 5)?0:(x1 + len)&3;
|
||||
nlmiddle = len;
|
||||
if(leftIndex){
|
||||
nlmiddle -= (4 - leftIndex);
|
||||
}
|
||||
if(rightIndex){
|
||||
nlmiddle -= rightIndex;
|
||||
}
|
||||
if (nlmiddle < 0)
|
||||
nlmiddle = 0;
|
||||
|
||||
nlmiddle >>= 2;
|
||||
|
||||
addrl += (y1 * nlwidth) + (x1 >> 2)*3 + (leftIndex?leftIndex-1:0);
|
||||
|
||||
switch(leftIndex+len){
|
||||
case 4:
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
break;
|
||||
case 1:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
break;
|
||||
case 2:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
break;
|
||||
case 3:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
|
||||
break;
|
||||
case 1:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
|
||||
break;
|
||||
case 2:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if(leftIndex){
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
|
||||
addrl++;
|
||||
}
|
||||
else{
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
}
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF);
|
||||
break;
|
||||
case 1: /*only if leftIndex = 0 and w = 1*/
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
|
||||
break;
|
||||
case 0: /*never*/
|
||||
break;
|
||||
default:
|
||||
{
|
||||
if (rop == GXcopy){
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl = ((*addrl) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
|
||||
addrl++;
|
||||
*addrl++ = piQxelXor[1];
|
||||
*addrl++ = piQxelXor[2];
|
||||
break;
|
||||
case 2:
|
||||
*addrl = ((*addrl) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
|
||||
addrl++;
|
||||
*addrl++ = piQxelXor[2];
|
||||
break;
|
||||
case 3:
|
||||
*addrl = ((*addrl) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
|
||||
addrl++;
|
||||
break;
|
||||
}
|
||||
while(nlmiddle--){
|
||||
*addrl++ = piQxelXor[0];
|
||||
*addrl++ = piQxelXor[1];
|
||||
*addrl++ = piQxelXor[2];
|
||||
}
|
||||
switch(rightIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl = ((*addrl) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
|
||||
break;
|
||||
case 2:
|
||||
*addrl++ = piQxelXor[0];
|
||||
*addrl = ((*addrl) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
*addrl++ = piQxelXor[0];
|
||||
*addrl++ = piQxelXor[1];
|
||||
*addrl = ((*addrl) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if(rop == GXxor){
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl++ ^= (piQxelXor[0]&0xFF000000);
|
||||
*addrl++ ^= piQxelXor[1];
|
||||
*addrl++ ^= piQxelXor[2];
|
||||
break;
|
||||
case 2:
|
||||
*addrl++ ^= (piQxelXor[1]& 0xFFFF0000);
|
||||
*addrl++ ^= piQxelXor[2];
|
||||
break;
|
||||
case 3:
|
||||
*addrl++ ^= (piQxelXor[2]& 0xFFFFFF00);
|
||||
break;
|
||||
}
|
||||
while(nlmiddle--){
|
||||
*addrl++ ^= piQxelXor[0];
|
||||
*addrl++ ^= piQxelXor[1];
|
||||
*addrl++ ^= piQxelXor[2];
|
||||
}
|
||||
switch(rightIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl ^= (piQxelXor[0]& 0xFFFFFF);
|
||||
break;
|
||||
case 2:
|
||||
*addrl++ ^= piQxelXor[0];
|
||||
*addrl ^= (piQxelXor[1]&0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
*addrl++ ^= piQxelXor[0];
|
||||
*addrl++ ^= piQxelXor[1];
|
||||
*addrl ^= (piQxelXor[2]&0xFF);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else{
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
addrl++;
|
||||
break;
|
||||
case 2:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
addrl++;
|
||||
break;
|
||||
case 3:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
|
||||
addrl++;
|
||||
break;
|
||||
}
|
||||
while(nlmiddle--){
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
addrl++;
|
||||
}
|
||||
switch(rightIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
|
||||
addrl++;
|
||||
break;
|
||||
case 2:
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
register CfbBits startmask;
|
||||
register CfbBits endmask;
|
||||
|
||||
addrl = addrl + (y1 * nlwidth) + (x1 >> PWSH);
|
||||
|
||||
/* all bits inside same longword */
|
||||
if ( ((x1 & PIM) + len) < PPW)
|
||||
{
|
||||
maskpartialbits(x1, len, startmask);
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, startmask);
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(x1, len, startmask, endmask, nlmiddle);
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
if (startmask)
|
||||
{
|
||||
*addrl = (*addrl & ~startmask) | (xor & startmask);
|
||||
addrl++;
|
||||
}
|
||||
while (nlmiddle--)
|
||||
*addrl++ = xor;
|
||||
if (endmask)
|
||||
*addrl = (*addrl & ~endmask) | (xor & endmask);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (startmask)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, startmask);
|
||||
addrl++;
|
||||
}
|
||||
if (rop == GXxor)
|
||||
{
|
||||
while (nlmiddle--)
|
||||
*addrl++ ^= xor;
|
||||
}
|
||||
else
|
||||
{
|
||||
while (nlmiddle--)
|
||||
{
|
||||
*addrl = DoRRop (*addrl, and, xor);
|
||||
addrl++;
|
||||
}
|
||||
}
|
||||
if (endmask)
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, endmask);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/* vertical solid line */
|
||||
|
||||
void
|
||||
cfbVertS(rop, and, xor, addrl, nlwidth, x1, y1, len)
|
||||
int rop;
|
||||
register CfbBits and, xor;
|
||||
register CfbBits *addrl; /* pointer to base of bitmap */
|
||||
register int nlwidth; /* width in longwords of bitmap */
|
||||
int x1, y1; /* initial point */
|
||||
register int len; /* length of line */
|
||||
{
|
||||
#if PSZ == 24
|
||||
int xIdx;
|
||||
CfbBits and2 = 0, xor2 = 0, mask = 0, mask2;
|
||||
#endif
|
||||
#ifdef PIXEL_ADDR
|
||||
register PixelType *bits = (PixelType *) addrl;
|
||||
|
||||
#if PSZ == 24
|
||||
nlwidth <<= PWSH;
|
||||
xIdx = x1 & 3;
|
||||
bits = (PixelType *)(addrl + (y1 * nlwidth) + ((x1*3) >> 2));
|
||||
#else
|
||||
nlwidth <<= PWSH;
|
||||
bits = bits + (y1 * nlwidth) + x1;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
mask2 = 0;
|
||||
switch(xIdx){
|
||||
case 0:
|
||||
mask = 0xFF000000;
|
||||
xor &= 0xFFFFFF;
|
||||
and |= 0xFF000000;
|
||||
break;
|
||||
case 3:
|
||||
mask = 0xFF;
|
||||
xor &= 0xFFFFFF;
|
||||
xor <<= 8;
|
||||
and <<= 8;
|
||||
and |= 0xFF;
|
||||
break;
|
||||
case 1:
|
||||
mask = 0xFFFFFF;
|
||||
mask2 = 0xFFFF0000;
|
||||
xor2 = (xor>>8) & 0xFFFF;
|
||||
xor &= 0xFF;
|
||||
xor <<= 24;
|
||||
and2 = (and >> 8 ) | 0xFFFF0000;
|
||||
and <<= 24;
|
||||
and |= 0xFFFFFF;
|
||||
break;
|
||||
case 2:
|
||||
mask = 0x0000FFFF;
|
||||
mask2 = 0xFFFFFF00;
|
||||
xor2 = (xor >> 16) & 0xFF;
|
||||
xor <<= 16;
|
||||
xor &= 0xFFFF0000;
|
||||
and2 = (and >> 16) | 0xFFFFFF00;
|
||||
and <<= 16;
|
||||
and |= 0xFFFF;
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* special case copy and xor to avoid a test per pixel
|
||||
*/
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
#if PSZ == 24
|
||||
switch(xIdx){
|
||||
case 0:
|
||||
case 3:
|
||||
while (len--){
|
||||
*bits = (*bits & mask)| xor;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
while (len--){
|
||||
*bits = (*bits & mask)| xor;
|
||||
bits++;
|
||||
*bits = (*bits & mask2)| xor2;
|
||||
bits--;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
}
|
||||
#else
|
||||
while (len--)
|
||||
{
|
||||
*bits = xor;
|
||||
bits += nlwidth;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else if (rop == GXxor)
|
||||
{
|
||||
#if PSZ == 24
|
||||
switch(xIdx){
|
||||
case 0:
|
||||
case 3:
|
||||
while (len--){
|
||||
*bits ^= xor;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
while (len--){
|
||||
*bits ^= xor;
|
||||
bits++;
|
||||
*bits ^= xor2;
|
||||
bits--;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
}
|
||||
#else
|
||||
while (len--)
|
||||
{
|
||||
*bits ^= xor;
|
||||
bits += nlwidth;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#if PSZ == 24
|
||||
switch(xIdx){
|
||||
case 0:
|
||||
while (len--){
|
||||
*bits = DoMaskRRop(*bits, and, xor, 0x00FFFFFF);
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
while (len--){
|
||||
*bits = DoMaskRRop(*bits, and, xor, 0xFFFFFF00);
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
while (len--){
|
||||
*bits = DoMaskRRop(*bits, and, xor, 0xFF000000);
|
||||
bits++;
|
||||
*bits = DoMaskRRop(*bits, and2, xor2, 0x0000FFFF);
|
||||
bits--;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
while (len--){
|
||||
*bits = DoMaskRRop(*bits, and, xor, 0xFFFF0000);
|
||||
bits++;
|
||||
*bits = DoMaskRRop(*bits, and2, xor2, 0x000000FF);
|
||||
bits--;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
}
|
||||
#else
|
||||
while (len--)
|
||||
{
|
||||
*bits = DoRRop(*bits, and, xor);
|
||||
bits += nlwidth;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#else /* !PIXEL_ADDR */
|
||||
#if PSZ == 24
|
||||
addrl = addrl + (y1 * nlwidth) + ((x1*3) >>2);
|
||||
|
||||
and |= ~cfbmask[(x1 & 3)<<1];
|
||||
xor &= cfbmask[(x1 & 3)<<1];
|
||||
#else
|
||||
addrl = addrl + (y1 * nlwidth) + (x1 >> PWSH);
|
||||
|
||||
and |= ~cfbmask[x1 & PIM];
|
||||
xor &= cfbmask[x1 & PIM];
|
||||
#endif
|
||||
|
||||
while (len--)
|
||||
{
|
||||
*addrl = DoRRop (*addrl, and, xor);
|
||||
addrl += nlwidth;
|
||||
}
|
||||
#endif
|
||||
}
|
106
cfb/cfbigblt8.c
106
cfb/cfbigblt8.c
|
@ -1,106 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "mi.h"
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
void
|
||||
cfbImageGlyphBlt8 (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int x, y;
|
||||
unsigned int nglyph;
|
||||
CharInfoPtr *ppci;
|
||||
pointer pglyphBase;
|
||||
{
|
||||
ExtentInfoRec info; /* used by QueryGlyphExtents() */
|
||||
xRectangle backrect;
|
||||
int fgPixel;
|
||||
cfbPrivGC *priv;
|
||||
|
||||
/*
|
||||
* We can't avoid GC validations if calling mi functions.
|
||||
*/
|
||||
if ((pGC->ops->PolyFillRect == miPolyFillRect) ||
|
||||
(pGC->ops->PolyGlyphBlt == miPolyGlyphBlt))
|
||||
{
|
||||
miImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
|
||||
return;
|
||||
}
|
||||
|
||||
QueryGlyphExtents(pGC->font, ppci, (unsigned long)nglyph, &info);
|
||||
|
||||
if (info.overallWidth >= 0)
|
||||
{
|
||||
backrect.x = x;
|
||||
backrect.width = info.overallWidth;
|
||||
}
|
||||
else
|
||||
{
|
||||
backrect.x = x + info.overallWidth;
|
||||
backrect.width = -info.overallWidth;
|
||||
}
|
||||
backrect.y = y - FONTASCENT(pGC->font);
|
||||
backrect.height = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font);
|
||||
|
||||
priv = cfbGetGCPrivate(pGC);
|
||||
|
||||
/* this code cheats by knowing that ValidateGC isn't
|
||||
* necessary for PolyFillRect
|
||||
*/
|
||||
|
||||
fgPixel = pGC->fgPixel;
|
||||
|
||||
pGC->fgPixel = pGC->bgPixel;
|
||||
priv->xor = PFILL(pGC->bgPixel);
|
||||
|
||||
(*pGC->ops->PolyFillRect) (pDrawable, pGC, 1, &backrect);
|
||||
|
||||
pGC->fgPixel = fgPixel;
|
||||
|
||||
priv->xor = PFILL(pGC->fgPixel);
|
||||
|
||||
(*pGC->ops->PolyGlyphBlt) (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
|
||||
|
||||
}
|
206
cfb/cfbimage.c
206
cfb/cfbimage.c
|
@ -1,206 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "servermd.h"
|
||||
#include "mi.h"
|
||||
|
||||
void
|
||||
cfbPutImage(pDraw, pGC, depth, x, y, w, h, leftPad, format, pImage)
|
||||
DrawablePtr pDraw;
|
||||
GCPtr pGC;
|
||||
int depth, x, y, w, h;
|
||||
int leftPad;
|
||||
int format;
|
||||
char *pImage;
|
||||
{
|
||||
PixmapPtr pPixmap;
|
||||
|
||||
if ((w == 0) || (h == 0))
|
||||
return;
|
||||
|
||||
if (format != XYPixmap)
|
||||
{
|
||||
pPixmap = GetScratchPixmapHeader(pDraw->pScreen, w+leftPad, h, depth,
|
||||
BitsPerPixel(depth), PixmapBytePad(w+leftPad, depth),
|
||||
(pointer)pImage);
|
||||
if (!pPixmap)
|
||||
return;
|
||||
|
||||
pGC->fExpose = FALSE;
|
||||
if (format == ZPixmap)
|
||||
(void)(*pGC->ops->CopyArea)((DrawablePtr)pPixmap, pDraw, pGC,
|
||||
leftPad, 0, w, h, x, y);
|
||||
else
|
||||
(void)(*pGC->ops->CopyPlane)((DrawablePtr)pPixmap, pDraw, pGC,
|
||||
leftPad, 0, w, h, x, y, 1);
|
||||
pGC->fExpose = TRUE;
|
||||
FreeScratchPixmapHeader(pPixmap);
|
||||
}
|
||||
else
|
||||
{
|
||||
CfbBits oldFg, oldBg;
|
||||
XID gcv[3];
|
||||
CfbBits oldPlanemask;
|
||||
unsigned long i;
|
||||
long bytesPer;
|
||||
|
||||
depth = pGC->depth;
|
||||
oldPlanemask = pGC->planemask;
|
||||
oldFg = pGC->fgPixel;
|
||||
oldBg = pGC->bgPixel;
|
||||
gcv[0] = ~0L;
|
||||
gcv[1] = 0;
|
||||
DoChangeGC(pGC, GCForeground | GCBackground, gcv, 0);
|
||||
bytesPer = (long)h * BitmapBytePad(w + leftPad);
|
||||
|
||||
for (i = 1 << (depth-1); i != 0; i >>= 1, pImage += bytesPer)
|
||||
{
|
||||
if (i & oldPlanemask)
|
||||
{
|
||||
gcv[0] = i;
|
||||
DoChangeGC(pGC, GCPlaneMask, gcv, 0);
|
||||
ValidateGC(pDraw, pGC);
|
||||
(*pGC->ops->PutImage)(pDraw, pGC, 1, x, y, w, h, leftPad,
|
||||
XYBitmap, pImage);
|
||||
}
|
||||
}
|
||||
gcv[0] = oldPlanemask;
|
||||
gcv[1] = oldFg;
|
||||
gcv[2] = oldBg;
|
||||
DoChangeGC(pGC, GCPlaneMask | GCForeground | GCBackground, gcv, 0);
|
||||
ValidateGC(pDraw, pGC);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
cfbGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine)
|
||||
DrawablePtr pDrawable;
|
||||
int sx, sy, w, h;
|
||||
unsigned int format;
|
||||
unsigned long planeMask;
|
||||
char *pdstLine;
|
||||
{
|
||||
BoxRec box;
|
||||
DDXPointRec ptSrc;
|
||||
RegionRec rgnDst;
|
||||
ScreenPtr pScreen;
|
||||
PixmapPtr pPixmap;
|
||||
|
||||
if ((w == 0) || (h == 0))
|
||||
return;
|
||||
if (pDrawable->bitsPerPixel == 1)
|
||||
{
|
||||
mfbGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
|
||||
return;
|
||||
}
|
||||
pScreen = pDrawable->pScreen;
|
||||
/*
|
||||
* XFree86 DDX empties the root borderClip when the VT is
|
||||
* switched away; this checks for that case
|
||||
*/
|
||||
if (!cfbDrawableEnabled (pDrawable))
|
||||
return;
|
||||
if (format == ZPixmap)
|
||||
{
|
||||
pPixmap = GetScratchPixmapHeader(pScreen, w, h,
|
||||
pDrawable->depth, pDrawable->bitsPerPixel,
|
||||
PixmapBytePad(w,pDrawable->depth), (pointer)pdstLine);
|
||||
if (!pPixmap)
|
||||
return;
|
||||
if ((planeMask & PMSK) != PMSK)
|
||||
bzero((char *)pdstLine, pPixmap->devKind * h);
|
||||
ptSrc.x = sx + pDrawable->x;
|
||||
ptSrc.y = sy + pDrawable->y;
|
||||
box.x1 = 0;
|
||||
box.y1 = 0;
|
||||
box.x2 = w;
|
||||
box.y2 = h;
|
||||
REGION_INIT(pScreen, &rgnDst, &box, 1);
|
||||
cfbDoBitblt(pDrawable, (DrawablePtr)pPixmap, GXcopy, &rgnDst,
|
||||
&ptSrc, planeMask);
|
||||
REGION_UNINIT(pScreen, &rgnDst);
|
||||
FreeScratchPixmapHeader(pPixmap);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
#if IMAGE_BYTE_ORDER == LSBFirst
|
||||
|
||||
pPixmap = GetScratchPixmapHeader(pScreen, w, h, /*depth*/ 1,
|
||||
/*bpp*/ 1, BitmapBytePad(w), (pointer)pdstLine);
|
||||
if (!pPixmap)
|
||||
return;
|
||||
|
||||
ptSrc.x = sx + pDrawable->x;
|
||||
ptSrc.y = sy + pDrawable->y;
|
||||
box.x1 = 0;
|
||||
box.y1 = 0;
|
||||
box.x2 = w;
|
||||
box.y2 = h;
|
||||
REGION_INIT(pScreen, &rgnDst, &box, 1);
|
||||
cfbCopyImagePlane (pDrawable, (DrawablePtr)pPixmap, GXcopy, &rgnDst,
|
||||
&ptSrc, planeMask);
|
||||
REGION_UNINIT(pScreen, &rgnDst);
|
||||
FreeScratchPixmapHeader(pPixmap);
|
||||
#else
|
||||
miGetImage (pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
|
||||
#endif
|
||||
}
|
||||
}
|
756
cfb/cfbline.c
756
cfb/cfbline.c
|
@ -1,756 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "mistruct.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "miline.h"
|
||||
|
||||
/* single-pixel lines on a color frame buffer
|
||||
|
||||
NON-SLOPED LINES
|
||||
horizontal lines are always drawn left to right; we have to
|
||||
move the endpoints right by one after they're swapped.
|
||||
horizontal lines will be confined to a single band of a
|
||||
region. the code finds that band (giving up if the lower
|
||||
bound of the band is above the line we're drawing); then it
|
||||
finds the first box in that band that contains part of the
|
||||
line. we clip the line to subsequent boxes in that band.
|
||||
vertical lines are always drawn top to bottom (y-increasing.)
|
||||
this requires adding one to the y-coordinate of each endpoint
|
||||
after swapping.
|
||||
|
||||
SLOPED LINES
|
||||
when clipping a sloped line, we bring the second point inside
|
||||
the clipping box, rather than one beyond it, and then add 1 to
|
||||
the length of the line before drawing it. this lets us use
|
||||
the same box for finding the outcodes for both endpoints. since
|
||||
the equation for clipping the second endpoint to an edge gives us
|
||||
1 beyond the edge, we then have to move the point towards the
|
||||
first point by one step on the major axis.
|
||||
eventually, there will be a diagram here to explain what's going
|
||||
on. the method uses Cohen-Sutherland outcodes to determine
|
||||
outsideness, and a method similar to Pike's layers for doing the
|
||||
actual clipping.
|
||||
|
||||
*/
|
||||
|
||||
void
|
||||
#ifdef POLYSEGMENT
|
||||
cfbSegmentSS (pDrawable, pGC, nseg, pSeg)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nseg;
|
||||
register xSegment *pSeg;
|
||||
#else
|
||||
cfbLineSS (pDrawable, pGC, mode, npt, pptInit)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int mode; /* Origin or Previous */
|
||||
int npt; /* number of points */
|
||||
DDXPointPtr pptInit;
|
||||
#endif
|
||||
{
|
||||
int nboxInit;
|
||||
register int nbox;
|
||||
BoxPtr pboxInit;
|
||||
register BoxPtr pbox;
|
||||
#ifndef POLYSEGMENT
|
||||
register DDXPointPtr ppt; /* pointer to list of translated points */
|
||||
#endif
|
||||
|
||||
unsigned int oc1; /* outcode of point 1 */
|
||||
unsigned int oc2; /* outcode of point 2 */
|
||||
|
||||
CfbBits *addrl; /* address of destination pixmap */
|
||||
int nlwidth; /* width in longwords of destination pixmap */
|
||||
int xorg, yorg; /* origin of window */
|
||||
|
||||
int adx; /* abs values of dx and dy */
|
||||
int ady;
|
||||
int signdx; /* sign of dx and dy */
|
||||
int signdy;
|
||||
int e, e1, e2; /* bresenham error and increments */
|
||||
int len; /* length of segment */
|
||||
int axis; /* major axis */
|
||||
int octant;
|
||||
unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
|
||||
|
||||
/* a bunch of temporaries */
|
||||
int tmp;
|
||||
register int y1, y2;
|
||||
register int x1, x2;
|
||||
RegionPtr cclip;
|
||||
cfbPrivGCPtr devPriv;
|
||||
CfbBits xor, and;
|
||||
int alu;
|
||||
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
cclip = pGC->pCompositeClip;
|
||||
pboxInit = REGION_RECTS(cclip);
|
||||
nboxInit = REGION_NUM_RECTS(cclip);
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwidth, addrl)
|
||||
|
||||
alu = devPriv->rop;
|
||||
xor = devPriv->xor;
|
||||
and = devPriv->and;
|
||||
xorg = pDrawable->x;
|
||||
yorg = pDrawable->y;
|
||||
#ifdef POLYSEGMENT
|
||||
while (nseg--)
|
||||
#else
|
||||
ppt = pptInit;
|
||||
x2 = ppt->x + xorg;
|
||||
y2 = ppt->y + yorg;
|
||||
while(--npt)
|
||||
#endif
|
||||
{
|
||||
nbox = nboxInit;
|
||||
pbox = pboxInit;
|
||||
|
||||
#ifdef POLYSEGMENT
|
||||
x1 = pSeg->x1 + xorg;
|
||||
y1 = pSeg->y1 + yorg;
|
||||
x2 = pSeg->x2 + xorg;
|
||||
y2 = pSeg->y2 + yorg;
|
||||
pSeg++;
|
||||
#else
|
||||
x1 = x2;
|
||||
y1 = y2;
|
||||
++ppt;
|
||||
if (mode == CoordModePrevious)
|
||||
{
|
||||
xorg = x1;
|
||||
yorg = y1;
|
||||
}
|
||||
x2 = ppt->x + xorg;
|
||||
y2 = ppt->y + yorg;
|
||||
#endif
|
||||
|
||||
if (x1 == x2) /* vertical line */
|
||||
{
|
||||
/* make the line go top to bottom of screen, keeping
|
||||
endpoint semantics
|
||||
*/
|
||||
if (y1 > y2)
|
||||
{
|
||||
register int tmp;
|
||||
|
||||
tmp = y2;
|
||||
y2 = y1 + 1;
|
||||
y1 = tmp + 1;
|
||||
#ifdef POLYSEGMENT
|
||||
if (pGC->capStyle != CapNotLast)
|
||||
y1--;
|
||||
#endif
|
||||
}
|
||||
#ifdef POLYSEGMENT
|
||||
else if (pGC->capStyle != CapNotLast)
|
||||
y2++;
|
||||
#endif
|
||||
/* get to first band that might contain part of line */
|
||||
while ((nbox) && (pbox->y2 <= y1))
|
||||
{
|
||||
pbox++;
|
||||
nbox--;
|
||||
}
|
||||
|
||||
if (nbox)
|
||||
{
|
||||
/* stop when lower edge of box is beyond end of line */
|
||||
while((nbox) && (y2 >= pbox->y1))
|
||||
{
|
||||
if ((x1 >= pbox->x1) && (x1 < pbox->x2))
|
||||
{
|
||||
int y1t, y2t;
|
||||
/* this box has part of the line in it */
|
||||
y1t = max(y1, pbox->y1);
|
||||
y2t = min(y2, pbox->y2);
|
||||
if (y1t != y2t)
|
||||
{
|
||||
cfbVertS (alu, and, xor,
|
||||
addrl, nlwidth,
|
||||
x1, y1t, y2t-y1t);
|
||||
}
|
||||
}
|
||||
nbox--;
|
||||
pbox++;
|
||||
}
|
||||
}
|
||||
#ifndef POLYSEGMENT
|
||||
y2 = ppt->y + yorg;
|
||||
#endif
|
||||
}
|
||||
else if (y1 == y2) /* horizontal line */
|
||||
{
|
||||
/* force line from left to right, keeping
|
||||
endpoint semantics
|
||||
*/
|
||||
if (x1 > x2)
|
||||
{
|
||||
register int tmp;
|
||||
|
||||
tmp = x2;
|
||||
x2 = x1 + 1;
|
||||
x1 = tmp + 1;
|
||||
#ifdef POLYSEGMENT
|
||||
if (pGC->capStyle != CapNotLast)
|
||||
x1--;
|
||||
#endif
|
||||
}
|
||||
#ifdef POLYSEGMENT
|
||||
else if (pGC->capStyle != CapNotLast)
|
||||
x2++;
|
||||
#endif
|
||||
|
||||
/* find the correct band */
|
||||
while( (nbox) && (pbox->y2 <= y1))
|
||||
{
|
||||
pbox++;
|
||||
nbox--;
|
||||
}
|
||||
|
||||
/* try to draw the line, if we haven't gone beyond it */
|
||||
if ((nbox) && (pbox->y1 <= y1))
|
||||
{
|
||||
/* when we leave this band, we're done */
|
||||
tmp = pbox->y1;
|
||||
while((nbox) && (pbox->y1 == tmp))
|
||||
{
|
||||
int x1t, x2t;
|
||||
|
||||
if (pbox->x2 <= x1)
|
||||
{
|
||||
/* skip boxes until one might contain start point */
|
||||
nbox--;
|
||||
pbox++;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* stop if left of box is beyond right of line */
|
||||
if (pbox->x1 >= x2)
|
||||
{
|
||||
nbox = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
x1t = max(x1, pbox->x1);
|
||||
x2t = min(x2, pbox->x2);
|
||||
if (x1t != x2t)
|
||||
{
|
||||
cfbHorzS (alu, and, xor,
|
||||
addrl, nlwidth,
|
||||
x1t, y1, x2t-x1t);
|
||||
}
|
||||
nbox--;
|
||||
pbox++;
|
||||
}
|
||||
}
|
||||
#ifndef POLYSEGMENT
|
||||
x2 = ppt->x + xorg;
|
||||
#endif
|
||||
}
|
||||
else /* sloped line */
|
||||
{
|
||||
CalcLineDeltas(x1, y1, x2, y2, adx, ady, signdx, signdy,
|
||||
1, 1, octant);
|
||||
|
||||
if (adx > ady)
|
||||
{
|
||||
axis = X_AXIS;
|
||||
e1 = ady << 1;
|
||||
e2 = e1 - (adx << 1);
|
||||
e = e1 - adx;
|
||||
}
|
||||
else
|
||||
{
|
||||
axis = Y_AXIS;
|
||||
e1 = adx << 1;
|
||||
e2 = e1 - (ady << 1);
|
||||
e = e1 - ady;
|
||||
SetYMajorOctant(octant);
|
||||
}
|
||||
|
||||
FIXUP_ERROR(e, octant, bias);
|
||||
|
||||
/* we have bresenham parameters and two points.
|
||||
all we have to do now is clip and draw.
|
||||
*/
|
||||
|
||||
while(nbox--)
|
||||
{
|
||||
oc1 = 0;
|
||||
oc2 = 0;
|
||||
OUTCODES(oc1, x1, y1, pbox);
|
||||
OUTCODES(oc2, x2, y2, pbox);
|
||||
if ((oc1 | oc2) == 0)
|
||||
{
|
||||
if (axis == X_AXIS)
|
||||
len = adx;
|
||||
else
|
||||
len = ady;
|
||||
#ifdef POLYSEGMENT
|
||||
if (pGC->capStyle != CapNotLast)
|
||||
len++;
|
||||
#endif
|
||||
cfbBresS (alu, and, xor,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, x1, y1,
|
||||
e, e1, e2, len);
|
||||
break;
|
||||
}
|
||||
else if (oc1 & oc2)
|
||||
{
|
||||
pbox++;
|
||||
}
|
||||
else
|
||||
{
|
||||
int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
|
||||
int clip1 = 0, clip2 = 0;
|
||||
int clipdx, clipdy;
|
||||
int err;
|
||||
|
||||
if (miZeroClipLine(pbox->x1, pbox->y1, pbox->x2-1,
|
||||
pbox->y2-1,
|
||||
&new_x1, &new_y1, &new_x2, &new_y2,
|
||||
adx, ady, &clip1, &clip2,
|
||||
octant, bias, oc1, oc2) == -1)
|
||||
{
|
||||
pbox++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (axis == X_AXIS)
|
||||
len = abs(new_x2 - new_x1);
|
||||
else
|
||||
len = abs(new_y2 - new_y1);
|
||||
#ifdef POLYSEGMENT
|
||||
if (clip2 != 0 || pGC->capStyle != CapNotLast)
|
||||
len++;
|
||||
#else
|
||||
len += (clip2 != 0);
|
||||
#endif
|
||||
if (len)
|
||||
{
|
||||
/* unwind bresenham error term to first point */
|
||||
if (clip1)
|
||||
{
|
||||
clipdx = abs(new_x1 - x1);
|
||||
clipdy = abs(new_y1 - y1);
|
||||
if (axis == X_AXIS)
|
||||
err = e+((clipdy*e2) + ((clipdx-clipdy)*e1));
|
||||
else
|
||||
err = e+((clipdx*e2) + ((clipdy-clipdx)*e1));
|
||||
}
|
||||
else
|
||||
err = e;
|
||||
cfbBresS(alu, and, xor,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, new_x1, new_y1,
|
||||
err, e1, e2, len);
|
||||
}
|
||||
pbox++;
|
||||
}
|
||||
} /* while (nbox--) */
|
||||
} /* sloped line */
|
||||
} /* while (nline--) */
|
||||
|
||||
#ifndef POLYSEGMENT
|
||||
/* paint the last point if the end style isn't CapNotLast.
|
||||
(Assume that a projecting, butt, or round cap that is one
|
||||
pixel wide is the same as the single pixel of the endpoint.)
|
||||
*/
|
||||
|
||||
if ((pGC->capStyle != CapNotLast) &&
|
||||
((ppt->x + xorg != pptInit->x + pDrawable->x) ||
|
||||
(ppt->y + yorg != pptInit->y + pDrawable->y) ||
|
||||
(ppt == pptInit + 1)))
|
||||
{
|
||||
nbox = nboxInit;
|
||||
pbox = pboxInit;
|
||||
while (nbox--)
|
||||
{
|
||||
if ((x2 >= pbox->x1) &&
|
||||
(y2 >= pbox->y1) &&
|
||||
(x2 < pbox->x2) &&
|
||||
(y2 < pbox->y2))
|
||||
{
|
||||
CfbBits mask;
|
||||
CfbBits scrbits;
|
||||
|
||||
#if PSZ == 24
|
||||
mask = cfbmask[(x2 & 3)<<1];
|
||||
addrl += (y2 * nlwidth) + ((x2*3) >> 2);
|
||||
#else
|
||||
mask = cfbmask[x2 & PIM];
|
||||
addrl += (y2 * nlwidth) + (x2 >> PWSH);
|
||||
#endif
|
||||
scrbits = *addrl;
|
||||
*addrl = (scrbits & ~mask) |
|
||||
(DoRRop (scrbits, and, xor) & mask);
|
||||
break;
|
||||
}
|
||||
else
|
||||
pbox++;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* Draw dashed 1-pixel lines.
|
||||
*/
|
||||
|
||||
void
|
||||
#ifdef POLYSEGMENT
|
||||
cfbSegmentSD (pDrawable, pGC, nseg, pSeg)
|
||||
DrawablePtr pDrawable;
|
||||
register GCPtr pGC;
|
||||
int nseg;
|
||||
register xSegment *pSeg;
|
||||
#else
|
||||
cfbLineSD( pDrawable, pGC, mode, npt, pptInit)
|
||||
DrawablePtr pDrawable;
|
||||
register GCPtr pGC;
|
||||
int mode; /* Origin or Previous */
|
||||
int npt; /* number of points */
|
||||
DDXPointPtr pptInit;
|
||||
#endif
|
||||
{
|
||||
int nboxInit;
|
||||
register int nbox;
|
||||
BoxPtr pboxInit;
|
||||
register BoxPtr pbox;
|
||||
#ifndef POLYSEGMENT
|
||||
register DDXPointPtr ppt; /* pointer to list of translated points */
|
||||
#endif
|
||||
|
||||
register unsigned int oc1; /* outcode of point 1 */
|
||||
register unsigned int oc2; /* outcode of point 2 */
|
||||
|
||||
CfbBits *addrl; /* address of destination pixmap */
|
||||
int nlwidth; /* width in longwords of destination pixmap */
|
||||
int xorg, yorg; /* origin of window */
|
||||
|
||||
int adx; /* abs values of dx and dy */
|
||||
int ady;
|
||||
int signdx; /* sign of dx and dy */
|
||||
int signdy;
|
||||
int e, e1, e2; /* bresenham error and increments */
|
||||
int len; /* length of segment */
|
||||
int axis; /* major axis */
|
||||
int octant;
|
||||
unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
|
||||
int x1, x2, y1, y2;
|
||||
RegionPtr cclip;
|
||||
cfbRRopRec rrops[2];
|
||||
unsigned char *pDash;
|
||||
int dashOffset;
|
||||
int numInDashList;
|
||||
int dashIndex;
|
||||
int isDoubleDash;
|
||||
int dashIndexTmp, dashOffsetTmp;
|
||||
int unclippedlen;
|
||||
cfbPrivGCPtr devPriv;
|
||||
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
cclip = pGC->pCompositeClip;
|
||||
rrops[0].rop = devPriv->rop;
|
||||
rrops[0].and = devPriv->and;
|
||||
rrops[0].xor = devPriv->xor;
|
||||
if (pGC->alu == GXcopy)
|
||||
{
|
||||
rrops[1].rop = GXcopy;
|
||||
rrops[1].and = 0;
|
||||
rrops[1].xor = PFILL (pGC->bgPixel);
|
||||
}
|
||||
else
|
||||
{
|
||||
rrops[1].rop = cfbReduceRasterOp (pGC->alu,
|
||||
pGC->bgPixel, pGC->planemask,
|
||||
&rrops[1].and, &rrops[1].xor);
|
||||
}
|
||||
pboxInit = REGION_RECTS(cclip);
|
||||
nboxInit = REGION_NUM_RECTS(cclip);
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwidth, addrl)
|
||||
|
||||
/* compute initial dash values */
|
||||
|
||||
pDash = (unsigned char *) pGC->dash;
|
||||
numInDashList = pGC->numInDashList;
|
||||
isDoubleDash = (pGC->lineStyle == LineDoubleDash);
|
||||
dashIndex = 0;
|
||||
dashOffset = 0;
|
||||
miStepDash ((int)pGC->dashOffset, &dashIndex, pDash,
|
||||
numInDashList, &dashOffset);
|
||||
|
||||
xorg = pDrawable->x;
|
||||
yorg = pDrawable->y;
|
||||
#ifdef POLYSEGMENT
|
||||
while (nseg--)
|
||||
#else
|
||||
ppt = pptInit;
|
||||
x2 = ppt->x + xorg;
|
||||
y2 = ppt->y + yorg;
|
||||
while(--npt)
|
||||
#endif
|
||||
{
|
||||
nbox = nboxInit;
|
||||
pbox = pboxInit;
|
||||
|
||||
#ifdef POLYSEGMENT
|
||||
x1 = pSeg->x1 + xorg;
|
||||
y1 = pSeg->y1 + yorg;
|
||||
x2 = pSeg->x2 + xorg;
|
||||
y2 = pSeg->y2 + yorg;
|
||||
pSeg++;
|
||||
#else
|
||||
x1 = x2;
|
||||
y1 = y2;
|
||||
++ppt;
|
||||
if (mode == CoordModePrevious)
|
||||
{
|
||||
xorg = x1;
|
||||
yorg = y1;
|
||||
}
|
||||
x2 = ppt->x + xorg;
|
||||
y2 = ppt->y + yorg;
|
||||
#endif
|
||||
|
||||
CalcLineDeltas(x1, y1, x2, y2, adx, ady, signdx, signdy, 1, 1, octant);
|
||||
|
||||
if (adx > ady)
|
||||
{
|
||||
axis = X_AXIS;
|
||||
e1 = ady << 1;
|
||||
e2 = e1 - (adx << 1);
|
||||
e = e1 - adx;
|
||||
unclippedlen = adx;
|
||||
}
|
||||
else
|
||||
{
|
||||
axis = Y_AXIS;
|
||||
e1 = adx << 1;
|
||||
e2 = e1 - (ady << 1);
|
||||
e = e1 - ady;
|
||||
unclippedlen = ady;
|
||||
SetYMajorOctant(octant);
|
||||
}
|
||||
|
||||
FIXUP_ERROR(e, octant, bias);
|
||||
|
||||
/* we have bresenham parameters and two points.
|
||||
all we have to do now is clip and draw.
|
||||
*/
|
||||
|
||||
while(nbox--)
|
||||
{
|
||||
oc1 = 0;
|
||||
oc2 = 0;
|
||||
OUTCODES(oc1, x1, y1, pbox);
|
||||
OUTCODES(oc2, x2, y2, pbox);
|
||||
if ((oc1 | oc2) == 0)
|
||||
{
|
||||
#ifdef POLYSEGMENT
|
||||
if (pGC->capStyle != CapNotLast)
|
||||
unclippedlen++;
|
||||
dashIndexTmp = dashIndex;
|
||||
dashOffsetTmp = dashOffset;
|
||||
cfbBresD (rrops,
|
||||
&dashIndexTmp, pDash, numInDashList,
|
||||
&dashOffsetTmp, isDoubleDash,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, x1, y1,
|
||||
e, e1, e2, unclippedlen);
|
||||
break;
|
||||
#else
|
||||
cfbBresD (rrops,
|
||||
&dashIndex, pDash, numInDashList,
|
||||
&dashOffset, isDoubleDash,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, x1, y1,
|
||||
e, e1, e2, unclippedlen);
|
||||
goto dontStep;
|
||||
#endif
|
||||
}
|
||||
else if (oc1 & oc2)
|
||||
{
|
||||
pbox++;
|
||||
}
|
||||
else /* have to clip */
|
||||
{
|
||||
int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
|
||||
int clip1 = 0, clip2 = 0;
|
||||
int clipdx, clipdy;
|
||||
int err;
|
||||
|
||||
if (miZeroClipLine(pbox->x1, pbox->y1, pbox->x2-1,
|
||||
pbox->y2-1,
|
||||
&new_x1, &new_y1, &new_x2, &new_y2,
|
||||
adx, ady, &clip1, &clip2,
|
||||
octant, bias, oc1, oc2) == -1)
|
||||
{
|
||||
pbox++;
|
||||
continue;
|
||||
}
|
||||
|
||||
dashIndexTmp = dashIndex;
|
||||
dashOffsetTmp = dashOffset;
|
||||
|
||||
if (clip1)
|
||||
{
|
||||
int dlen;
|
||||
|
||||
if (axis == X_AXIS)
|
||||
dlen = abs(new_x1 - x1);
|
||||
else
|
||||
dlen = abs(new_y1 - y1);
|
||||
miStepDash (dlen, &dashIndexTmp, pDash,
|
||||
numInDashList, &dashOffsetTmp);
|
||||
}
|
||||
|
||||
if (axis == X_AXIS)
|
||||
len = abs(new_x2 - new_x1);
|
||||
else
|
||||
len = abs(new_y2 - new_y1);
|
||||
#ifdef POLYSEGMENT
|
||||
if (clip2 != 0 || pGC->capStyle != CapNotLast)
|
||||
len++;
|
||||
#else
|
||||
len += (clip2 != 0);
|
||||
#endif
|
||||
if (len)
|
||||
{
|
||||
/* unwind bresenham error term to first point */
|
||||
if (clip1)
|
||||
{
|
||||
clipdx = abs(new_x1 - x1);
|
||||
clipdy = abs(new_y1 - y1);
|
||||
if (axis == X_AXIS)
|
||||
err = e+((clipdy*e2) + ((clipdx-clipdy)*e1));
|
||||
else
|
||||
err = e+((clipdx*e2) + ((clipdy-clipdx)*e1));
|
||||
}
|
||||
else
|
||||
err = e;
|
||||
cfbBresD (rrops,
|
||||
&dashIndexTmp, pDash, numInDashList,
|
||||
&dashOffsetTmp, isDoubleDash,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, new_x1, new_y1,
|
||||
err, e1, e2, len);
|
||||
}
|
||||
pbox++;
|
||||
}
|
||||
} /* while (nbox--) */
|
||||
#ifndef POLYSEGMENT
|
||||
/*
|
||||
* walk the dash list around to the next line
|
||||
*/
|
||||
miStepDash (unclippedlen, &dashIndex, pDash,
|
||||
numInDashList, &dashOffset);
|
||||
dontStep: ;
|
||||
#endif
|
||||
} /* while (nline--) */
|
||||
|
||||
#ifndef POLYSEGMENT
|
||||
/* paint the last point if the end style isn't CapNotLast.
|
||||
(Assume that a projecting, butt, or round cap that is one
|
||||
pixel wide is the same as the single pixel of the endpoint.)
|
||||
*/
|
||||
|
||||
if ((pGC->capStyle != CapNotLast) &&
|
||||
((dashIndex & 1) == 0 || isDoubleDash) &&
|
||||
((ppt->x + xorg != pptInit->x + pDrawable->x) ||
|
||||
(ppt->y + yorg != pptInit->y + pDrawable->y) ||
|
||||
(ppt == pptInit + 1)))
|
||||
{
|
||||
nbox = nboxInit;
|
||||
pbox = pboxInit;
|
||||
while (nbox--)
|
||||
{
|
||||
if ((x2 >= pbox->x1) &&
|
||||
(y2 >= pbox->y1) &&
|
||||
(x2 < pbox->x2) &&
|
||||
(y2 < pbox->y2))
|
||||
{
|
||||
CfbBits mask;
|
||||
int pix;
|
||||
|
||||
pix = 0;
|
||||
if (dashIndex & 1)
|
||||
pix = 1;
|
||||
#if PSZ == 24
|
||||
mask = cfbmask[(x2 & 3)<<1];
|
||||
addrl += (y2 * nlwidth) + ((x2 *3)>> 2);
|
||||
#else
|
||||
mask = cfbmask[x2 & PIM];
|
||||
addrl += (y2 * nlwidth) + (x2 >> PWSH);
|
||||
#endif
|
||||
*addrl = DoMaskRRop (*addrl, rrops[pix].and, rrops[pix].xor, mask);
|
||||
break;
|
||||
}
|
||||
else
|
||||
pbox++;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
210
cfb/cfbmap.h
210
cfb/cfbmap.h
|
@ -1,210 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1991, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Map names around so that multiple depths can be supported simultaneously
|
||||
*/
|
||||
|
||||
/* a losing vendor cpp dumps core if we define CFBNAME in terms of CATNAME */
|
||||
|
||||
#if PSZ != 8
|
||||
|
||||
#if PSZ == 32
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CFBNAME(subname) cfb32##subname
|
||||
#else
|
||||
#define CFBNAME(subname) cfb32/**/subname
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CFBNAME(subname) cfb24##subname
|
||||
#else
|
||||
#define CFBNAME(subname) cfb24/**/subname
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if PSZ == 16
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CFBNAME(subname) cfb16##subname
|
||||
#else
|
||||
#define CFBNAME(subname) cfb16/**/subname
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if PSZ == 4
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CFBNAME(subname) cfb4##subname
|
||||
#else
|
||||
#define CFBNAME(subname) cfb4/**/subname
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef CFBNAME
|
||||
cfb can not hack PSZ yet
|
||||
#endif
|
||||
|
||||
#undef CATNAME
|
||||
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CATNAME(prefix,subname) prefix##subname
|
||||
#else
|
||||
#define CATNAME(prefix,subname) prefix/**/subname
|
||||
#endif
|
||||
|
||||
#define QuartetBitsTable CFBNAME(QuartetBitsTable)
|
||||
#define QuartetPixelMaskTable CFBNAME(QuartetPixelMaskTable)
|
||||
#define cfb8ClippedLineCopy CFBNAME(ClippedLineCopy)
|
||||
#define cfb8ClippedLineGeneral CFBNAME(ClippedLineGeneral )
|
||||
#define cfb8ClippedLineXor CFBNAME(ClippedLineXor)
|
||||
#define cfb8LineSS1Rect CFBNAME(LineSS1Rect)
|
||||
#define cfb8LineSS1RectCopy CFBNAME(LineSS1RectCopy)
|
||||
#define cfb8LineSS1RectGeneral CFBNAME(LineSS1RectGeneral )
|
||||
#define cfb8LineSS1RectPreviousCopy CFBNAME(LineSS1RectPreviousCopy)
|
||||
#define cfb8LineSS1RectXor CFBNAME(LineSS1RectXor)
|
||||
#define cfb8SegmentSS1Rect CFBNAME(SegmentSS1Rect)
|
||||
#define cfb8SegmentSS1RectCopy CFBNAME(SegmentSS1RectCopy)
|
||||
#define cfb8SegmentSS1RectGeneral CFBNAME(SegmentSS1RectGeneral )
|
||||
#define cfb8SegmentSS1RectShiftCopy CFBNAME(SegmentSS1RectShiftCopy)
|
||||
#define cfb8SegmentSS1RectXor CFBNAME(SegmentSS1RectXor)
|
||||
#define cfbAllocatePrivates CFBNAME(AllocatePrivates)
|
||||
#define cfbBSFuncRec CFBNAME(BSFuncRec)
|
||||
#define cfbBitBlt CFBNAME(BitBlt)
|
||||
#define cfbBresD CFBNAME(BresD)
|
||||
#define cfbBresS CFBNAME(BresS)
|
||||
#define cfbChangeWindowAttributes CFBNAME(ChangeWindowAttributes)
|
||||
#define cfbClearVisualTypes CFBNAME(cfbClearVisualTypes)
|
||||
#define cfbCloseScreen CFBNAME(CloseScreen)
|
||||
#define cfbCreateDefColormap CFBNAME (cfbCreateDefColormap)
|
||||
#define cfbCopyArea CFBNAME(CopyArea)
|
||||
#define cfbCopyImagePlane CFBNAME(CopyImagePlane)
|
||||
#define cfbCopyPixmap CFBNAME(CopyPixmap)
|
||||
#define cfbCopyPlane CFBNAME(CopyPlane)
|
||||
#define cfbCopyPlaneReduce CFBNAME(CopyPlaneReduce)
|
||||
#define cfbCopyRotatePixmap CFBNAME(CopyRotatePixmap)
|
||||
#define cfbCopyWindow CFBNAME(CopyWindow)
|
||||
#define cfbCreateGC CFBNAME(CreateGC)
|
||||
#define cfbCreatePixmap CFBNAME(CreatePixmap)
|
||||
#define cfbCreateScreenResources CFBNAME(CreateScreenResources)
|
||||
#define cfbCreateWindow CFBNAME(CreateWindow)
|
||||
#define cfbDestroyPixmap CFBNAME(DestroyPixmap)
|
||||
#define cfbDestroyWindow CFBNAME(DestroyWindow)
|
||||
#define cfbDoBitblt CFBNAME(DoBitblt)
|
||||
#define cfbDoBitbltCopy CFBNAME(DoBitbltCopy)
|
||||
#define cfbDoBitbltGeneral CFBNAME(DoBitbltGeneral)
|
||||
#define cfbDoBitbltOr CFBNAME(DoBitbltOr)
|
||||
#define cfbDoBitbltXor CFBNAME(DoBitbltXor)
|
||||
#define cfbExpandDirectColors CFBNAME(cfbExpandDirectColors)
|
||||
#define cfbFillBoxTile32sCopy CFBNAME(FillBoxTile32sCopy)
|
||||
#define cfbFillBoxTile32sGeneral CFBNAME(FillBoxTile32sGeneral)
|
||||
#define cfbFillBoxTileOdd CFBNAME(FillBoxTileOdd)
|
||||
#define cfbFillBoxTileOddCopy CFBNAME(FillBoxTileOddCopy)
|
||||
#define cfbFillBoxTileOddGeneral CFBNAME(FillBoxTileOddGeneral)
|
||||
#define cfbFillPoly1RectCopy CFBNAME(FillPoly1RectCopy)
|
||||
#define cfbFillPoly1RectGeneral CFBNAME(FillPoly1RectGeneral)
|
||||
#define cfbFillRectSolidCopy CFBNAME(FillRectSolidCopy)
|
||||
#define cfbFillRectSolidGeneral CFBNAME(FillRectSolidGeneral)
|
||||
#define cfbFillRectSolidXor CFBNAME(FillRectSolidXor)
|
||||
#define cfbFillRectTile32Copy CFBNAME(FillRectTile32Copy)
|
||||
#define cfbFillRectTile32General CFBNAME(FillRectTile32General)
|
||||
#define cfbFillRectTileOdd CFBNAME(FillRectTileOdd)
|
||||
#define cfbFillSpanTile32sCopy CFBNAME(FillSpanTile32sCopy)
|
||||
#define cfbFillSpanTile32sGeneral CFBNAME(FillSpanTile32sGeneral)
|
||||
#define cfbFillSpanTileOddCopy CFBNAME(FillSpanTileOddCopy)
|
||||
#define cfbFillSpanTileOddGeneral CFBNAME(FillSpanTileOddGeneral)
|
||||
#define cfbFinishScreenInit CFBNAME(FinishScreenInit)
|
||||
#define cfbGCFuncs CFBNAME(GCFuncs)
|
||||
#define cfbGCPrivateKey CFBNAME(GCPrivateKey)
|
||||
#define cfbGetImage CFBNAME(GetImage)
|
||||
#define cfbGetScreenPixmap CFBNAME(GetScreenPixmap)
|
||||
#define cfbGetSpans CFBNAME(GetSpans)
|
||||
#define cfbHorzS CFBNAME(HorzS)
|
||||
#define cfbImageGlyphBlt8 CFBNAME(ImageGlyphBlt8)
|
||||
#define cfbInitializeColormap CFBNAME(InitializeColormap)
|
||||
#define cfbInitVisuals CFBNAME(cfbInitVisuals)
|
||||
#define cfbInstallColormap CFBNAME(InstallColormap)
|
||||
#define cfbLineSD CFBNAME(LineSD)
|
||||
#define cfbLineSS CFBNAME(LineSS)
|
||||
#define cfbListInstalledColormaps CFBNAME(ListInstalledColormaps)
|
||||
#define cfbMapWindow CFBNAME(MapWindow)
|
||||
#define cfbMatchCommon CFBNAME(MatchCommon)
|
||||
#define cfbNonTEOps CFBNAME(NonTEOps)
|
||||
#define cfbNonTEOps1Rect CFBNAME(NonTEOps1Rect)
|
||||
#define cfbPadPixmap CFBNAME(PadPixmap)
|
||||
#define cfbPolyFillArcSolidCopy CFBNAME(PolyFillArcSolidCopy)
|
||||
#define cfbPolyFillArcSolidGeneral CFBNAME(PolyFillArcSolidGeneral)
|
||||
#define cfbPolyFillRect CFBNAME(PolyFillRect)
|
||||
#define cfbPolyGlyphBlt8 CFBNAME(PolyGlyphBlt8)
|
||||
#define cfbPolyGlyphRop8 CFBNAME(PolyGlyphRop8)
|
||||
#define cfbPolyPoint CFBNAME(PolyPoint)
|
||||
#define cfbPositionWindow CFBNAME(PositionWindow)
|
||||
#define cfbPutImage CFBNAME(PutImage)
|
||||
#define cfbReduceRasterOp CFBNAME(ReduceRasterOp)
|
||||
#define cfbResolveColor CFBNAME(ResolveColor)
|
||||
#define cfbRestoreAreas CFBNAME(RestoreAreas)
|
||||
#define cfbSaveAreas CFBNAME(SaveAreas)
|
||||
#define cfbScreenInit CFBNAME(ScreenInit)
|
||||
#define cfbScreenPrivateKey CFBNAME(ScreenPrivateKey)
|
||||
#define cfbSegmentSD CFBNAME(SegmentSD)
|
||||
#define cfbSegmentSS CFBNAME(SegmentSS)
|
||||
#define cfbSetScanline CFBNAME(SetScanline)
|
||||
#define cfbSetScreenPixmap CFBNAME(SetScreenPixmap)
|
||||
#define cfbSetSpans CFBNAME(SetSpans)
|
||||
#define cfbSetVisualTypes CFBNAME(cfbSetVisualTypes)
|
||||
#define cfbSetupScreen CFBNAME(SetupScreen)
|
||||
#define cfbSolidSpansCopy CFBNAME(SolidSpansCopy)
|
||||
#define cfbSolidSpansGeneral CFBNAME(SolidSpansGeneral)
|
||||
#define cfbSolidSpansXor CFBNAME(SolidSpansXor)
|
||||
#define cfbStippleStack CFBNAME(StippleStack)
|
||||
#define cfbStippleStackTE CFBNAME(StippleStackTE)
|
||||
#define cfbTEGlyphBlt CFBNAME(TEGlyphBlt)
|
||||
#define cfbTEOps CFBNAME(TEOps)
|
||||
#define cfbTEOps1Rect CFBNAME(TEOps1Rect)
|
||||
#define cfbTile32FSCopy CFBNAME(Tile32FSCopy)
|
||||
#define cfbTile32FSGeneral CFBNAME(Tile32FSGeneral)
|
||||
#define cfbUninstallColormap CFBNAME(UninstallColormap)
|
||||
#define cfbUnmapWindow CFBNAME(UnmapWindow)
|
||||
#define cfbUnnaturalStippleFS CFBNAME(UnnaturalStippleFS)
|
||||
#define cfbUnnaturalTileFS CFBNAME(UnnaturalTileFS)
|
||||
#define cfbValidateGC CFBNAME(ValidateGC)
|
||||
#define cfbVertS CFBNAME(VertS)
|
||||
#define cfbWindowPrivateKey CFBNAME(WindowPrivateKey)
|
||||
#define cfbXRotatePixmap CFBNAME(XRotatePixmap)
|
||||
#define cfbYRotatePixmap CFBNAME(YRotatePixmap)
|
||||
#define cfbZeroPolyArcSS8Copy CFBNAME(ZeroPolyArcSSCopy)
|
||||
#define cfbZeroPolyArcSS8General CFBNAME(ZeroPolyArcSSGeneral)
|
||||
#define cfbZeroPolyArcSS8Xor CFBNAME(ZeroPolyArcSSXor)
|
||||
#define cfbendpartial CFBNAME(endpartial)
|
||||
#define cfbendtab CFBNAME(endtab)
|
||||
#define cfbmask CFBNAME(mask)
|
||||
#define cfbrmask CFBNAME(rmask)
|
||||
#define cfbstartpartial CFBNAME(startpartial)
|
||||
#define cfbstarttab CFBNAME(starttab)
|
||||
|
||||
#endif /* PSZ != 8 */
|
1400
cfb/cfbmskbits.c
1400
cfb/cfbmskbits.c
File diff suppressed because it is too large
Load Diff
854
cfb/cfbmskbits.h
854
cfb/cfbmskbits.h
|
@ -1,854 +0,0 @@
|
|||
/************************************************************
|
||||
Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose and without
|
||||
fee is hereby granted, provided that the above copyright no-
|
||||
tice appear in all copies and that both that copyright no-
|
||||
tice and this permission notice appear in supporting docu-
|
||||
mentation, and that the names of Sun or The Open Group
|
||||
not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific prior
|
||||
written permission. Sun and The Open Group make no
|
||||
representations about the suitability of this software for
|
||||
any purpose. It is provided "as is" without any express or
|
||||
implied warranty.
|
||||
|
||||
SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
|
||||
NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
|
||||
ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
||||
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
||||
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
********************************************************/
|
||||
|
||||
/* Optimizations for PSZ == 32 added by Kyle Marvin (marvin@vitec.com) */
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "compiler.h"
|
||||
|
||||
/*
|
||||
* ==========================================================================
|
||||
* Converted from mfb to support memory-mapped color framebuffer by smarks@sun,
|
||||
* April-May 1987.
|
||||
*
|
||||
* The way I did the conversion was to consider each longword as an
|
||||
* array of four bytes instead of an array of 32 one-bit pixels. So
|
||||
* getbits() and putbits() retain much the same calling sequence, but
|
||||
* they move bytes around instead of bits. Of course, this entails the
|
||||
* removal of all of the one-bit-pixel dependencies from the other
|
||||
* files, but the major bit-hacking stuff should be covered here.
|
||||
*
|
||||
* I've created some new macros that make it easier to understand what's
|
||||
* going on in the pixel calculations, and that make it easier to change the
|
||||
* pixel size.
|
||||
*
|
||||
* name explanation
|
||||
* ---- -----------
|
||||
* PSZ pixel size (in bits)
|
||||
* PGSZ pixel group size (in bits)
|
||||
* PGSZB pixel group size (in bytes)
|
||||
* PGSZBMSK mask with lowest PGSZB bits set to 1
|
||||
* PPW pixels per word (pixels per pixel group)
|
||||
* PPWMSK mask with lowest PPW bits set to 1
|
||||
* PLST index of last pixel in a word (should be PPW-1)
|
||||
* PIM pixel index mask (index within a pixel group)
|
||||
* PWSH pixel-to-word shift (should be log2(PPW))
|
||||
* PMSK mask with lowest PSZ bits set to 1
|
||||
*
|
||||
*
|
||||
* Here are some sample values. In the notation cfbA,B: A is PSZ, and
|
||||
* B is PGSZB. All the other values are derived from these
|
||||
* two. This table does not show all combinations!
|
||||
*
|
||||
* name cfb8,4 cfb24,4 cfb32,4 cfb8,8 cfb24,8 cfb32,8
|
||||
* ---- ------ ------- ------ ------ ------ -------
|
||||
* PSZ 8 24 32 8 24 32
|
||||
* PGSZ 32 32 32 64 64 64
|
||||
* PGSZB 4 4 4 8 8 8
|
||||
* PGSZBMSK 0xF 0xF? 0xF 0xFF 0xFF 0xFF
|
||||
* PPW 4 1 1 8 2 2
|
||||
* PPWMSK 0xF 0x1 0x1 0xFF 0x3? 0x3
|
||||
* PLST 3 0 0 7 1 1
|
||||
* PIM 0x3 0x0 0x0 0x7 0x1? 0x1
|
||||
* PWSH 2 0 0 3 1 1
|
||||
* PMSK 0xFF 0xFFFFFF 0xFFFFFFFF 0xFF 0xFFFFFF 0xFFFFFFFF
|
||||
*
|
||||
*
|
||||
* I have also added a new macro, PFILL, that takes one pixel and
|
||||
* replicates it throughout a word. This macro definition is dependent
|
||||
* upon pixel and word size; it doesn't use macros like PPW and so
|
||||
* forth. Examples: for monochrome, PFILL(1) => 0xffffffff, PFILL(0) =>
|
||||
* 0x00000000. For 8-bit color, PFILL(0x5d) => 0x5d5d5d5d. This macro
|
||||
* is used primarily for replicating a plane mask into a word.
|
||||
*
|
||||
* Color framebuffers operations also support the notion of a plane
|
||||
* mask. This mask determines which planes of the framebuffer can be
|
||||
* altered; the others are left unchanged. I have added another
|
||||
* parameter to the putbits and putbitsrop macros that is the plane
|
||||
* mask.
|
||||
* ==========================================================================
|
||||
*
|
||||
* Keith Packard (keithp@suse.com)
|
||||
* 64bit code is no longer supported; it requires DIX support
|
||||
* for repadding images which significantly impacts performance
|
||||
*/
|
||||
|
||||
/*
|
||||
* PSZ needs to be defined before we get here. Usually it comes from a
|
||||
* -DPSZ=foo on the compilation command line.
|
||||
*/
|
||||
|
||||
#ifndef PSZ
|
||||
#define PSZ 8
|
||||
#endif
|
||||
|
||||
/*
|
||||
* PixelGroup is the data type used to operate on groups of pixels.
|
||||
* We typedef it here to CARD32 with the assumption that you
|
||||
* want to manipulate 32 bits worth of pixels at a time as you can. If CARD32
|
||||
* is not appropriate for your server, define it to something else
|
||||
* before including this file. In this case you will also have to define
|
||||
* PGSZB to the size in bytes of PixelGroup.
|
||||
*/
|
||||
#ifndef PixelGroup
|
||||
#define PixelGroup CARD32
|
||||
#define PGSZB 4
|
||||
#endif /* PixelGroup */
|
||||
|
||||
#ifndef CfbBits
|
||||
#define CfbBits CARD32
|
||||
#endif
|
||||
|
||||
#define PGSZ (PGSZB << 3)
|
||||
#define PPW (PGSZ/PSZ)
|
||||
#define PLST (PPW-1)
|
||||
#define PIM PLST
|
||||
#define PMSK (((PixelGroup)1 << PSZ) - 1)
|
||||
#define PPWMSK (((PixelGroup)1 << PPW) - 1) /* instead of BITMSK */
|
||||
#define PGSZBMSK (((PixelGroup)1 << PGSZB) - 1)
|
||||
|
||||
/* set PWSH = log2(PPW) using brute force */
|
||||
|
||||
#if PPW == 1
|
||||
#define PWSH 0
|
||||
#else
|
||||
#if PPW == 2
|
||||
#define PWSH 1
|
||||
#else
|
||||
#if PPW == 4
|
||||
#define PWSH 2
|
||||
#else
|
||||
#if PPW == 8
|
||||
#define PWSH 3
|
||||
#else
|
||||
#if PPW == 16
|
||||
#define PWSH 4
|
||||
#endif /* PPW == 16 */
|
||||
#endif /* PPW == 8 */
|
||||
#endif /* PPW == 4 */
|
||||
#endif /* PPW == 2 */
|
||||
#endif /* PPW == 1 */
|
||||
|
||||
/* Defining PIXEL_ADDR means that individual pixels are addressable by this
|
||||
* machine (as type PixelType). A possible CFB architecture which supported
|
||||
* 8-bits-per-pixel on a non byte-addressable machine would not have this
|
||||
* defined.
|
||||
*
|
||||
* Defining FOUR_BIT_CODE means that cfb knows how to stipple on this machine;
|
||||
* eventually, stippling code for 16 and 32 bit devices should be written
|
||||
* which would allow them to also use FOUR_BIT_CODE. There isn't that
|
||||
* much to do in those cases, but it would make them quite a bit faster.
|
||||
*/
|
||||
|
||||
#if PSZ == 8
|
||||
#define PIXEL_ADDR
|
||||
typedef CARD8 PixelType;
|
||||
#define FOUR_BIT_CODE
|
||||
#endif
|
||||
|
||||
#if PSZ == 16
|
||||
#define PIXEL_ADDR
|
||||
typedef CARD16 PixelType;
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#undef PMSK
|
||||
#define PMSK 0xFFFFFF
|
||||
/*#undef PIM
|
||||
#define PIM 3*/
|
||||
#define PIXEL_ADDR
|
||||
typedef CARD32 PixelType;
|
||||
#endif
|
||||
|
||||
#if PSZ == 32
|
||||
#undef PMSK
|
||||
#define PMSK 0xFFFFFFFF
|
||||
#define PIXEL_ADDR
|
||||
typedef CARD32 PixelType;
|
||||
#endif
|
||||
|
||||
|
||||
/* the following notes use the following conventions:
|
||||
SCREEN LEFT SCREEN RIGHT
|
||||
in this file and maskbits.c, left and right refer to screen coordinates,
|
||||
NOT bit numbering in registers.
|
||||
|
||||
cfbstarttab[n]
|
||||
pixels[0,n-1] = 0's pixels[n,PPW-1] = 1's
|
||||
cfbendtab[n] =
|
||||
pixels[0,n-1] = 1's pixels[n,PPW-1] = 0's
|
||||
|
||||
cfbstartpartial[], cfbendpartial[]
|
||||
these are used as accelerators for doing putbits and masking out
|
||||
bits that are all contained between longword boudaries. the extra
|
||||
256 bytes of data seems a small price to pay -- code is smaller,
|
||||
and narrow things (e.g. window borders) go faster.
|
||||
|
||||
the names may seem misleading; they are derived not from which end
|
||||
of the word the bits are turned on, but at which end of a scanline
|
||||
the table tends to be used.
|
||||
|
||||
look at the tables and macros to understand boundary conditions.
|
||||
(careful readers will note that starttab[n] = ~endtab[n] for n != 0)
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
these two macros depend on the screen's bit ordering.
|
||||
in both of them x is a screen position. they are used to
|
||||
combine bits collected from multiple longwords into a
|
||||
single destination longword, and to unpack a single
|
||||
source longword into multiple destinations.
|
||||
|
||||
SCRLEFT(dst, x)
|
||||
takes dst[x, PPW] and moves them to dst[0, PPW-x]
|
||||
the contents of the rest of dst are 0 ONLY IF
|
||||
dst is UNSIGNED.
|
||||
is cast as an unsigned.
|
||||
this is a right shift on the VAX, left shift on
|
||||
Sun and pc-rt.
|
||||
|
||||
SCRRIGHT(dst, x)
|
||||
takes dst[0,x] and moves them to dst[PPW-x, PPW]
|
||||
the contents of the rest of dst are 0 ONLY IF
|
||||
dst is UNSIGNED.
|
||||
this is a left shift on the VAX, right shift on
|
||||
Sun and pc-rt.
|
||||
|
||||
|
||||
the remaining macros are cpu-independent; all bit order dependencies
|
||||
are built into the tables and the two macros above.
|
||||
|
||||
maskbits(x, w, startmask, endmask, nlw)
|
||||
for a span of width w starting at position x, returns
|
||||
a mask for ragged pixels at start, mask for ragged pixels at end,
|
||||
and the number of whole longwords between the ends.
|
||||
|
||||
maskpartialbits(x, w, mask)
|
||||
works like maskbits(), except all the pixels are in the
|
||||
same longword (i.e. (x&0xPIM + w) <= PPW)
|
||||
|
||||
mask32bits(x, w, startmask, endmask, nlw)
|
||||
as maskbits, but does not calculate nlw. it is used by
|
||||
cfbGlyphBlt to put down glyphs <= PPW bits wide.
|
||||
|
||||
getbits(psrc, x, w, dst)
|
||||
starting at position x in psrc (x < PPW), collect w
|
||||
pixels and put them in the screen left portion of dst.
|
||||
psrc is a longword pointer. this may span longword boundaries.
|
||||
it special-cases fetching all w bits from one longword.
|
||||
|
||||
+--------+--------+ +--------+
|
||||
| | m |n| | ==> | m |n| |
|
||||
+--------+--------+ +--------+
|
||||
x x+w 0 w
|
||||
psrc psrc+1 dst
|
||||
m = PPW - x
|
||||
n = w - m
|
||||
|
||||
implementation:
|
||||
get m pixels, move to screen-left of dst, zeroing rest of dst;
|
||||
get n pixels from next word, move screen-right by m, zeroing
|
||||
lower m pixels of word.
|
||||
OR the two things together.
|
||||
|
||||
putbits(src, x, w, pdst, planemask)
|
||||
starting at position x in pdst, put down the screen-leftmost
|
||||
w bits of src. pdst is a longword pointer. this may
|
||||
span longword boundaries.
|
||||
it special-cases putting all w bits into the same longword.
|
||||
|
||||
+--------+ +--------+--------+
|
||||
| m |n| | ==> | | m |n| |
|
||||
+--------+ +--------+--------+
|
||||
0 w x x+w
|
||||
dst pdst pdst+1
|
||||
m = PPW - x
|
||||
n = w - m
|
||||
|
||||
implementation:
|
||||
get m pixels, shift screen-right by x, zero screen-leftmost x
|
||||
pixels; zero rightmost m bits of *pdst and OR in stuff
|
||||
from before the semicolon.
|
||||
shift src screen-left by m, zero bits n-32;
|
||||
zero leftmost n pixels of *(pdst+1) and OR in the
|
||||
stuff from before the semicolon.
|
||||
|
||||
putbitsrop(src, x, w, pdst, planemask, ROP)
|
||||
like putbits but calls DoRop with the rasterop ROP (see cfb.h for
|
||||
DoRop)
|
||||
|
||||
getleftbits(psrc, w, dst)
|
||||
get the leftmost w (w<=PPW) bits from *psrc and put them
|
||||
in dst. this is used by the cfbGlyphBlt code for glyphs
|
||||
<=PPW bits wide.
|
||||
*/
|
||||
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
#define BitRight(lw,n) ((lw) >> (n))
|
||||
#define BitLeft(lw,n) ((lw) << (n))
|
||||
#else /* (BITMAP_BIT_ORDER == LSBFirst) */
|
||||
#define BitRight(lw,n) ((lw) << (n))
|
||||
#define BitLeft(lw,n) ((lw) >> (n))
|
||||
#endif /* (BITMAP_BIT_ORDER == MSBFirst) */
|
||||
|
||||
#define SCRLEFT(lw, n) BitLeft (lw, (n) * PSZ)
|
||||
#define SCRRIGHT(lw, n) BitRight(lw, (n) * PSZ)
|
||||
|
||||
/*
|
||||
* Note that the shift direction is independent of the byte ordering of the
|
||||
* machine. The following is portable code.
|
||||
*/
|
||||
#if PPW == 16
|
||||
#define PFILL(p) ( ((p)&PMSK) | \
|
||||
((p)&PMSK) << PSZ | \
|
||||
((p)&PMSK) << 2*PSZ | \
|
||||
((p)&PMSK) << 3*PSZ | \
|
||||
((p)&PMSK) << 4*PSZ | \
|
||||
((p)&PMSK) << 5*PSZ | \
|
||||
((p)&PMSK) << 6*PSZ | \
|
||||
((p)&PMSK) << 7*PSZ | \
|
||||
((p)&PMSK) << 8*PSZ | \
|
||||
((p)&PMSK) << 9*PSZ | \
|
||||
((p)&PMSK) << 10*PSZ | \
|
||||
((p)&PMSK) << 11*PSZ | \
|
||||
((p)&PMSK) << 12*PSZ | \
|
||||
((p)&PMSK) << 13*PSZ | \
|
||||
((p)&PMSK) << 14*PSZ | \
|
||||
((p)&PMSK) << 15*PSZ )
|
||||
#define PFILL2(p, pf) { \
|
||||
pf = (p) & PMSK; \
|
||||
pf |= (pf << PSZ); \
|
||||
pf |= (pf << 2*PSZ); \
|
||||
pf |= (pf << 4*PSZ); \
|
||||
pf |= (pf << 8*PSZ); \
|
||||
}
|
||||
#endif /* PPW == 16 */
|
||||
#if PPW == 8
|
||||
#define PFILL(p) ( ((p)&PMSK) | \
|
||||
((p)&PMSK) << PSZ | \
|
||||
((p)&PMSK) << 2*PSZ | \
|
||||
((p)&PMSK) << 3*PSZ | \
|
||||
((p)&PMSK) << 4*PSZ | \
|
||||
((p)&PMSK) << 5*PSZ | \
|
||||
((p)&PMSK) << 6*PSZ | \
|
||||
((p)&PMSK) << 7*PSZ )
|
||||
#define PFILL2(p, pf) { \
|
||||
pf = (p) & PMSK; \
|
||||
pf |= (pf << PSZ); \
|
||||
pf |= (pf << 2*PSZ); \
|
||||
pf |= (pf << 4*PSZ); \
|
||||
}
|
||||
#endif
|
||||
#if PPW == 4
|
||||
#define PFILL(p) ( ((p)&PMSK) | \
|
||||
((p)&PMSK) << PSZ | \
|
||||
((p)&PMSK) << 2*PSZ | \
|
||||
((p)&PMSK) << 3*PSZ )
|
||||
#define PFILL2(p, pf) { \
|
||||
pf = (p) & PMSK; \
|
||||
pf |= (pf << PSZ); \
|
||||
pf |= (pf << 2*PSZ); \
|
||||
}
|
||||
#endif
|
||||
#if PPW == 2
|
||||
#define PFILL(p) ( ((p)&PMSK) | \
|
||||
((p)&PMSK) << PSZ )
|
||||
#define PFILL2(p, pf) { \
|
||||
pf = (p) & PMSK; \
|
||||
pf |= (pf << PSZ); \
|
||||
}
|
||||
#endif
|
||||
#if PPW == 1
|
||||
#define PFILL(p) (p)
|
||||
#define PFILL2(p,pf) (pf = (p))
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Reduced raster op - using precomputed values, perform the above
|
||||
* in three instructions
|
||||
*/
|
||||
|
||||
#define DoRRop(dst, and, xor) (((dst) & (and)) ^ (xor))
|
||||
|
||||
#define DoMaskRRop(dst, and, xor, mask) \
|
||||
(((dst) & ((and) | ~(mask))) ^ (xor & mask))
|
||||
|
||||
#if PSZ != 32 || PPW != 1
|
||||
|
||||
# if (PSZ == 24 && PPW == 1)
|
||||
#define maskbits(x, w, startmask, endmask, nlw) {\
|
||||
startmask = cfbstarttab[(x)&3]; \
|
||||
endmask = cfbendtab[((x)+(w)) & 3]; \
|
||||
nlw = ((((x)+(w))*3)>>2) - (((x)*3 +3)>>2); \
|
||||
}
|
||||
|
||||
#define mask32bits(x, w, startmask, endmask) \
|
||||
startmask = cfbstarttab[(x)&3]; \
|
||||
endmask = cfbendtab[((x)+(w)) & 3];
|
||||
|
||||
#define maskpartialbits(x, w, mask) \
|
||||
mask = cfbstartpartial[(x) & 3] & cfbendpartial[((x)+(w)) & 3];
|
||||
|
||||
#define maskbits24(x, w, startmask, endmask, nlw) \
|
||||
startmask = cfbstarttab24[(x) & 3]; \
|
||||
endmask = cfbendtab24[((x)+(w)) & 3]; \
|
||||
if (startmask){ \
|
||||
nlw = (((w) - (4 - ((x) & 3))) >> 2); \
|
||||
} else { \
|
||||
nlw = (w) >> 2; \
|
||||
}
|
||||
|
||||
#define getbits24(psrc, dst, index) {\
|
||||
register int idx; \
|
||||
switch(idx = ((index)&3)<<1){ \
|
||||
case 0: \
|
||||
dst = (*(psrc) &cfbmask[idx]); \
|
||||
break; \
|
||||
case 6: \
|
||||
dst = BitLeft((*(psrc) &cfbmask[idx]), cfb24Shift[idx]); \
|
||||
break; \
|
||||
default: \
|
||||
dst = BitLeft((*(psrc) &cfbmask[idx]), cfb24Shift[idx]) | \
|
||||
BitRight(((*((psrc)+1)) &cfbmask[idx+1]), cfb24Shift[idx+1]); \
|
||||
}; \
|
||||
}
|
||||
|
||||
#define putbits24(src, w, pdst, planemask, index) {\
|
||||
register PixelGroup dstpixel; \
|
||||
register unsigned int idx; \
|
||||
switch(idx = ((index)&3)<<1){ \
|
||||
case 0: \
|
||||
dstpixel = (*(pdst) &cfbmask[idx]); \
|
||||
break; \
|
||||
case 6: \
|
||||
dstpixel = BitLeft((*(pdst) &cfbmask[idx]), cfb24Shift[idx]); \
|
||||
break; \
|
||||
default: \
|
||||
dstpixel = BitLeft((*(pdst) &cfbmask[idx]), cfb24Shift[idx])| \
|
||||
BitRight(((*((pdst)+1)) &cfbmask[idx+1]), cfb24Shift[idx+1]); \
|
||||
}; \
|
||||
dstpixel &= ~(planemask); \
|
||||
dstpixel |= (src & planemask); \
|
||||
*(pdst) &= cfbrmask[idx]; \
|
||||
switch(idx){ \
|
||||
case 0: \
|
||||
*(pdst) |= (dstpixel & cfbmask[idx]); \
|
||||
break; \
|
||||
case 2: \
|
||||
case 4: \
|
||||
pdst++;idx++; \
|
||||
*(pdst) = ((*(pdst)) & cfbrmask[idx]) | \
|
||||
(BitLeft(dstpixel, cfb24Shift[idx]) & cfbmask[idx]); \
|
||||
pdst--;idx--; \
|
||||
case 6: \
|
||||
*(pdst) |= (BitRight(dstpixel, cfb24Shift[idx]) & cfbmask[idx]); \
|
||||
break; \
|
||||
}; \
|
||||
}
|
||||
|
||||
#define putbitsrop24(src, x, pdst, planemask, rop) \
|
||||
{ \
|
||||
register PixelGroup t1, dstpixel; \
|
||||
register unsigned int idx; \
|
||||
switch(idx = (x)<<1){ \
|
||||
case 0: \
|
||||
dstpixel = (*(pdst) &cfbmask[idx]); \
|
||||
break; \
|
||||
case 6: \
|
||||
dstpixel = BitLeft((*(pdst) &cfbmask[idx]), cfb24Shift[idx]); \
|
||||
break; \
|
||||
default: \
|
||||
dstpixel = BitLeft((*(pdst) &cfbmask[idx]), cfb24Shift[idx])| \
|
||||
BitRight(((*((pdst)+1)) &cfbmask[idx+1]), cfb24Shift[idx+1]); \
|
||||
}; \
|
||||
DoRop(t1, rop, (src), dstpixel); \
|
||||
dstpixel &= ~planemask; \
|
||||
dstpixel |= (t1 & planemask); \
|
||||
*(pdst) &= cfbrmask[idx]; \
|
||||
switch(idx){ \
|
||||
case 0: \
|
||||
*(pdst) |= (dstpixel & cfbmask[idx]); \
|
||||
break; \
|
||||
case 2: \
|
||||
case 4: \
|
||||
*((pdst)+1) = ((*((pdst)+1)) & cfbrmask[idx+1]) | \
|
||||
(BitLeft(dstpixel, cfb24Shift[idx+1]) & (cfbmask[idx+1])); \
|
||||
case 6: \
|
||||
*(pdst) |= (BitRight(dstpixel, cfb24Shift[idx]) & cfbmask[idx]); \
|
||||
}; \
|
||||
}
|
||||
# else /* PSZ == 24 && PPW == 1 */
|
||||
#define maskbits(x, w, startmask, endmask, nlw) \
|
||||
startmask = cfbstarttab[(x)&PIM]; \
|
||||
endmask = cfbendtab[((x)+(w)) & PIM]; \
|
||||
if (startmask) \
|
||||
nlw = (((w) - (PPW - ((x)&PIM))) >> PWSH); \
|
||||
else \
|
||||
nlw = (w) >> PWSH;
|
||||
|
||||
#define maskpartialbits(x, w, mask) \
|
||||
mask = cfbstartpartial[(x) & PIM] & cfbendpartial[((x) + (w)) & PIM];
|
||||
|
||||
#define mask32bits(x, w, startmask, endmask) \
|
||||
startmask = cfbstarttab[(x)&PIM]; \
|
||||
endmask = cfbendtab[((x)+(w)) & PIM];
|
||||
|
||||
/* FIXME */
|
||||
#define maskbits24(x, w, startmask, endmask, nlw) \
|
||||
abort()
|
||||
#define getbits24(psrc, dst, index) \
|
||||
abort()
|
||||
#define putbits24(src, w, pdst, planemask, index) \
|
||||
abort()
|
||||
#define putbitsrop24(src, x, pdst, planemask, rop) \
|
||||
abort()
|
||||
|
||||
#endif /* PSZ == 24 && PPW == 1 */
|
||||
|
||||
#define getbits(psrc, x, w, dst) \
|
||||
if ( ((x) + (w)) <= PPW) \
|
||||
{ \
|
||||
dst = SCRLEFT(*(psrc), (x)); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
int m; \
|
||||
m = PPW-(x); \
|
||||
dst = (SCRLEFT(*(psrc), (x)) & cfbendtab[m]) | \
|
||||
(SCRRIGHT(*((psrc)+1), m) & cfbstarttab[m]); \
|
||||
}
|
||||
|
||||
|
||||
#define putbits(src, x, w, pdst, planemask) \
|
||||
if ( ((x)+(w)) <= PPW) \
|
||||
{ \
|
||||
PixelGroup tmpmask; \
|
||||
maskpartialbits((x), (w), tmpmask); \
|
||||
tmpmask &= PFILL(planemask); \
|
||||
*(pdst) = (*(pdst) & ~tmpmask) | (SCRRIGHT(src, x) & tmpmask); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
unsigned int m; \
|
||||
unsigned int n; \
|
||||
PixelGroup pm = PFILL(planemask); \
|
||||
m = PPW-(x); \
|
||||
n = (w) - m; \
|
||||
*(pdst) = (*(pdst) & (cfbendtab[x] | ~pm)) | \
|
||||
(SCRRIGHT(src, x) & (cfbstarttab[x] & pm)); \
|
||||
*((pdst)+1) = (*((pdst)+1) & (cfbstarttab[n] | ~pm)) | \
|
||||
(SCRLEFT(src, m) & (cfbendtab[n] & pm)); \
|
||||
}
|
||||
#if defined(__GNUC__) && defined(mc68020)
|
||||
#undef getbits
|
||||
#define FASTGETBITS(psrc, x, w, dst) \
|
||||
asm ("bfextu %3{%1:%2},%0" \
|
||||
: "=d" (dst) : "di" (x), "di" (w), "o" (*(char *)(psrc)))
|
||||
|
||||
#define getbits(psrc,x,w,dst) \
|
||||
{ \
|
||||
FASTGETBITS(psrc, (x) * PSZ, (w) * PSZ, dst); \
|
||||
dst = SCRLEFT(dst,PPW-(w)); \
|
||||
}
|
||||
|
||||
#define FASTPUTBITS(src, x, w, pdst) \
|
||||
asm ("bfins %3,%0{%1:%2}" \
|
||||
: "=o" (*(char *)(pdst)) \
|
||||
: "di" (x), "di" (w), "d" (src), "0" (*(char *) (pdst)))
|
||||
|
||||
#undef putbits
|
||||
#define putbits(src, x, w, pdst, planemask) \
|
||||
{ \
|
||||
if (planemask != PMSK) { \
|
||||
PixelGroup _m, _pm; \
|
||||
FASTGETBITS(pdst, (x) * PSZ , (w) * PSZ, _m); \
|
||||
PFILL2(planemask, _pm); \
|
||||
_m &= (~_pm); \
|
||||
_m |= (SCRRIGHT(src, PPW-(w)) & _pm); \
|
||||
FASTPUTBITS(_m, (x) * PSZ, (w) * PSZ, pdst); \
|
||||
} else { \
|
||||
FASTPUTBITS(SCRRIGHT(src, PPW-(w)), (x) * PSZ, (w) * PSZ, pdst); \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
#endif /* mc68020 */
|
||||
|
||||
#define putbitsrop(src, x, w, pdst, planemask, rop) \
|
||||
if ( ((x)+(w)) <= PPW) \
|
||||
{ \
|
||||
PixelGroup tmpmask; \
|
||||
PixelGroup t1, t2; \
|
||||
maskpartialbits((x), (w), tmpmask); \
|
||||
PFILL2(planemask, t1); \
|
||||
tmpmask &= t1; \
|
||||
t1 = SCRRIGHT((src), (x)); \
|
||||
DoRop(t2, rop, t1, *(pdst)); \
|
||||
*(pdst) = (*(pdst) & ~tmpmask) | (t2 & tmpmask); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
CfbBits m; \
|
||||
CfbBits n; \
|
||||
PixelGroup t1, t2; \
|
||||
PixelGroup pm; \
|
||||
PFILL2(planemask, pm); \
|
||||
m = PPW-(x); \
|
||||
n = (w) - m; \
|
||||
t1 = SCRRIGHT((src), (x)); \
|
||||
DoRop(t2, rop, t1, *(pdst)); \
|
||||
*(pdst) = (*(pdst) & (cfbendtab[x] | ~pm)) | (t2 & (cfbstarttab[x] & pm));\
|
||||
t1 = SCRLEFT((src), m); \
|
||||
DoRop(t2, rop, t1, *((pdst) + 1)); \
|
||||
*((pdst)+1) = (*((pdst)+1) & (cfbstarttab[n] | ~pm)) | \
|
||||
(t2 & (cfbendtab[n] & pm)); \
|
||||
}
|
||||
|
||||
#else /* PSZ == 32 && PPW == 1*/
|
||||
|
||||
/*
|
||||
* These macros can be optimized for 32-bit pixels since there is no
|
||||
* need to worry about left/right edge masking. These macros were
|
||||
* derived from the above using the following reductions:
|
||||
*
|
||||
* - x & PIW = 0 [since PIW = 0]
|
||||
* - all masking tables are only indexed by 0 [ due to above ]
|
||||
* - cfbstartab[0] and cfbendtab[0] = 0 [ no left/right edge masks]
|
||||
* - cfbstartpartial[0] and cfbendpartial[0] = ~0 [no partial pixel mask]
|
||||
*
|
||||
* Macro reduction based upon constants cannot be performed automatically
|
||||
* by the compiler since it does not know the contents of the masking
|
||||
* arrays in cfbmskbits.c.
|
||||
*/
|
||||
#define maskbits(x, w, startmask, endmask, nlw) \
|
||||
startmask = endmask = 0; \
|
||||
nlw = (w);
|
||||
|
||||
#define maskpartialbits(x, w, mask) \
|
||||
mask = 0xFFFFFFFF;
|
||||
|
||||
#define mask32bits(x, w, startmask, endmask) \
|
||||
startmask = endmask = 0;
|
||||
|
||||
/*
|
||||
* For 32-bit operations, getbits(), putbits(), and putbitsrop()
|
||||
* will only be invoked with x = 0 and w = PPW (1). The getbits()
|
||||
* macro is only called within left/right edge logic, which doesn't
|
||||
* happen for 32-bit pixels.
|
||||
*/
|
||||
#define getbits(psrc, x, w, dst) (dst) = *(psrc)
|
||||
|
||||
#define putbits(src, x, w, pdst, planemask) \
|
||||
*(pdst) = (*(pdst) & ~planemask) | (src & planemask);
|
||||
|
||||
#define putbitsrop(src, x, w, pdst, planemask, rop) \
|
||||
{ \
|
||||
PixelGroup t1; \
|
||||
DoRop(t1, rop, (src), *(pdst)); \
|
||||
*(pdst) = (*(pdst) & ~planemask) | (t1 & planemask); \
|
||||
}
|
||||
|
||||
#endif /* PSZ != 32 */
|
||||
|
||||
/*
|
||||
* Use these macros only when you're using the MergeRop stuff
|
||||
* in ../mfb/mergerop.h
|
||||
*/
|
||||
|
||||
/* useful only when not spanning destination longwords */
|
||||
#if PSZ == 24
|
||||
#define putbitsmropshort24(src,x,w,pdst,index) {\
|
||||
PixelGroup _tmpmask; \
|
||||
PixelGroup _t1; \
|
||||
maskpartialbits ((x), (w), _tmpmask); \
|
||||
_t1 = SCRRIGHT((src), (x)); \
|
||||
DoMaskMergeRop24(_t1, pdst, _tmpmask, index); \
|
||||
}
|
||||
#endif
|
||||
#define putbitsmropshort(src,x,w,pdst) {\
|
||||
PixelGroup _tmpmask; \
|
||||
PixelGroup _t1; \
|
||||
maskpartialbits ((x), (w), _tmpmask); \
|
||||
_t1 = SCRRIGHT((src), (x)); \
|
||||
*pdst = DoMaskMergeRop(_t1, *pdst, _tmpmask); \
|
||||
}
|
||||
|
||||
/* useful only when spanning destination longwords */
|
||||
#define putbitsmroplong(src,x,w,pdst) { \
|
||||
PixelGroup _startmask, _endmask; \
|
||||
int _m; \
|
||||
PixelGroup _t1; \
|
||||
_m = PPW - (x); \
|
||||
_startmask = cfbstarttab[x]; \
|
||||
_endmask = cfbendtab[(w) - _m]; \
|
||||
_t1 = SCRRIGHT((src), (x)); \
|
||||
pdst[0] = DoMaskMergeRop(_t1,pdst[0],_startmask); \
|
||||
_t1 = SCRLEFT ((src),_m); \
|
||||
pdst[1] = DoMaskMergeRop(_t1,pdst[1],_endmask); \
|
||||
}
|
||||
|
||||
#define putbitsmrop(src,x,w,pdst) \
|
||||
if ((x) + (w) <= PPW) {\
|
||||
putbitsmropshort(src,x,w,pdst); \
|
||||
} else { \
|
||||
putbitsmroplong(src,x,w,pdst); \
|
||||
}
|
||||
|
||||
#if GETLEFTBITS_ALIGNMENT == 1
|
||||
#define getleftbits(psrc, w, dst) dst = *((unsigned int *) psrc)
|
||||
#define getleftbits24(psrc, w, dst, idx){ \
|
||||
regiseter int index; \
|
||||
switch(index = ((idx)&3)<<1){ \
|
||||
case 0: \
|
||||
dst = (*((unsigned int *) psrc))&cfbmask[index]; \
|
||||
break; \
|
||||
case 2: \
|
||||
case 4: \
|
||||
dst = BitLeft(((*((unsigned int *) psrc))&cfbmask[index]), cfb24Shift[index]); \
|
||||
dst |= BitRight(((*((unsigned int *) psrc)+1)&cfbmask[index]), cfb4Shift[index]); \
|
||||
break; \
|
||||
case 6: \
|
||||
dst = BitLeft((*((unsigned int *) psrc)),cfb24Shift[index]); \
|
||||
break; \
|
||||
}; \
|
||||
}
|
||||
#endif /* GETLEFTBITS_ALIGNMENT == 1 */
|
||||
|
||||
#define getglyphbits(psrc, x, w, dst) \
|
||||
{ \
|
||||
dst = BitLeft((unsigned) *(psrc), (x)); \
|
||||
if ( ((x) + (w)) > 32) \
|
||||
dst |= (BitRight((unsigned) *((psrc)+1), 32-(x))); \
|
||||
}
|
||||
#if GETLEFTBITS_ALIGNMENT == 2
|
||||
#define getleftbits(psrc, w, dst) \
|
||||
{ \
|
||||
if ( ((int)(psrc)) & 0x01 ) \
|
||||
getglyphbits( ((unsigned int *)(((char *)(psrc))-1)), 8, (w), (dst) ); \
|
||||
else \
|
||||
dst = *((unsigned int *) psrc); \
|
||||
}
|
||||
#endif /* GETLEFTBITS_ALIGNMENT == 2 */
|
||||
|
||||
#if GETLEFTBITS_ALIGNMENT == 4
|
||||
#define getleftbits(psrc, w, dst) \
|
||||
{ \
|
||||
int off, off_b; \
|
||||
off_b = (off = ( ((int)(psrc)) & 0x03)) << 3; \
|
||||
getglyphbits( \
|
||||
(unsigned int *)( ((char *)(psrc)) - off), \
|
||||
(off_b), (w), (dst) \
|
||||
); \
|
||||
}
|
||||
#endif /* GETLEFTBITS_ALIGNMENT == 4 */
|
||||
|
||||
/*
|
||||
* getstipplepixels( psrcstip, x, w, ones, psrcpix, destpix )
|
||||
*
|
||||
* Converts bits to pixels in a reasonable way. Takes w (1 <= w <= PPW)
|
||||
* bits from *psrcstip, starting at bit x; call this a quartet of bits.
|
||||
* Then, takes the pixels from *psrcpix corresponding to the one-bits (if
|
||||
* ones is TRUE) or the zero-bits (if ones is FALSE) of the quartet
|
||||
* and puts these pixels into destpix.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* getstipplepixels( &(0x08192A3B), 17, 4, 1, &(0x4C5D6E7F), dest )
|
||||
*
|
||||
* 0x08192A3B = 0000 1000 0001 1001 0010 1010 0011 1011
|
||||
*
|
||||
* This will take 4 bits starting at bit 17, so the quartet is 0x5 = 0101.
|
||||
* It will take pixels from 0x4C5D6E7F corresponding to the one-bits in this
|
||||
* quartet, so dest = 0x005D007F.
|
||||
*
|
||||
* XXX Works with both byte order.
|
||||
* XXX This works for all values of x and w within a doubleword.
|
||||
*/
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
#define getstipplepixels( psrcstip, x, w, ones, psrcpix, destpix ) \
|
||||
{ \
|
||||
PixelGroup q; \
|
||||
int m; \
|
||||
if ((m = ((x) - ((PPW*PSZ)-PPW))) > 0) { \
|
||||
q = (*(psrcstip)) << m; \
|
||||
if ( (x)+(w) > (PPW*PSZ) ) \
|
||||
q |= *((psrcstip)+1) >> ((PPW*PSZ)-m); \
|
||||
} \
|
||||
else \
|
||||
q = (*(psrcstip)) >> -m; \
|
||||
q = QuartetBitsTable[(w)] & ((ones) ? q : ~q); \
|
||||
*(destpix) = (*(psrcpix)) & QuartetPixelMaskTable[q]; \
|
||||
}
|
||||
/* I just copied this to get the linker satisfied on PowerPC,
|
||||
* so this may not be correct at all.
|
||||
*/
|
||||
#define getstipplepixels24(psrcstip,xt,ones,psrcpix,destpix,stipindex) \
|
||||
{ \
|
||||
PixelGroup q; \
|
||||
q = *(psrcstip) >> (xt); \
|
||||
q = ((ones) ? q : ~q) & 1; \
|
||||
*(destpix) = (*(psrcpix)) & QuartetPixelMaskTable[q]; \
|
||||
}
|
||||
#else /* BITMAP_BIT_ORDER == LSB */
|
||||
|
||||
/* this must load 32 bits worth; for most machines, thats an int */
|
||||
#define CfbFetchUnaligned(x) ldl_u(x)
|
||||
|
||||
#define getstipplepixels( psrcstip, xt, w, ones, psrcpix, destpix ) \
|
||||
{ \
|
||||
PixelGroup q; \
|
||||
q = CfbFetchUnaligned(psrcstip) >> (xt); \
|
||||
if ( ((xt)+(w)) > (PPW*PSZ) ) \
|
||||
q |= (CfbFetchUnaligned((psrcstip)+1)) << ((PPW*PSZ)-(xt)); \
|
||||
q = QuartetBitsTable[(w)] & ((ones) ? q : ~q); \
|
||||
*(destpix) = (*(psrcpix)) & QuartetPixelMaskTable[q]; \
|
||||
}
|
||||
#if PSZ == 24
|
||||
#define getstipplepixels24(psrcstip,xt,ones,psrcpix,destpix,stipindex) \
|
||||
{ \
|
||||
PixelGroup q; \
|
||||
q = *(psrcstip) >> (xt); \
|
||||
q = ((ones) ? q : ~q) & 1; \
|
||||
*(destpix) = (*(psrcpix)) & QuartetPixelMaskTable[q]; \
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
#endif
|
||||
|
||||
extern PixelGroup cfbstarttab[];
|
||||
extern PixelGroup cfbendtab[];
|
||||
extern PixelGroup cfbstartpartial[];
|
||||
extern PixelGroup cfbendpartial[];
|
||||
extern PixelGroup cfbrmask[];
|
||||
extern PixelGroup cfbmask[];
|
||||
extern PixelGroup QuartetBitsTable[];
|
||||
extern PixelGroup QuartetPixelMaskTable[];
|
||||
#if PSZ == 24
|
||||
extern int cfb24Shift[];
|
||||
#endif
|
375
cfb/cfbpixmap.c
375
cfb/cfbpixmap.c
|
@ -1,375 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
/* pixmap management
|
||||
written by drewry, september 1986
|
||||
|
||||
on a monchrome device, a pixmap is a bitmap.
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "mi.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
PixmapPtr
|
||||
cfbCreatePixmap (pScreen, width, height, depth, usage_hint)
|
||||
ScreenPtr pScreen;
|
||||
int width;
|
||||
int height;
|
||||
int depth;
|
||||
unsigned usage_hint;
|
||||
{
|
||||
PixmapPtr pPixmap;
|
||||
size_t datasize;
|
||||
size_t paddedWidth;
|
||||
|
||||
paddedWidth = PixmapBytePad(width, depth);
|
||||
|
||||
if (paddedWidth / 4 > 32767 || height > 32767)
|
||||
return NullPixmap;
|
||||
datasize = height * paddedWidth;
|
||||
pPixmap = AllocatePixmap(pScreen, datasize);
|
||||
if (!pPixmap)
|
||||
return NullPixmap;
|
||||
pPixmap->drawable.type = DRAWABLE_PIXMAP;
|
||||
pPixmap->drawable.class = 0;
|
||||
pPixmap->drawable.pScreen = pScreen;
|
||||
pPixmap->drawable.depth = depth;
|
||||
pPixmap->drawable.bitsPerPixel = BitsPerPixel(depth);
|
||||
pPixmap->drawable.id = 0;
|
||||
pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
|
||||
pPixmap->drawable.x = 0;
|
||||
pPixmap->drawable.y = 0;
|
||||
pPixmap->drawable.width = width;
|
||||
pPixmap->drawable.height = height;
|
||||
pPixmap->devKind = paddedWidth;
|
||||
pPixmap->refcnt = 1;
|
||||
pPixmap->devPrivate.ptr = datasize ?
|
||||
(pointer)((char *)pPixmap + pScreen->totalPixmapSize) : NULL;
|
||||
pPixmap->usage_hint = usage_hint;
|
||||
return pPixmap;
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbDestroyPixmap(pPixmap)
|
||||
PixmapPtr pPixmap;
|
||||
{
|
||||
if(--pPixmap->refcnt)
|
||||
return TRUE;
|
||||
dixFreePrivates(pPixmap->devPrivates);
|
||||
xfree(pPixmap);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PixmapPtr
|
||||
cfbCopyPixmap(pSrc)
|
||||
register PixmapPtr pSrc;
|
||||
{
|
||||
register PixmapPtr pDst;
|
||||
int size;
|
||||
ScreenPtr pScreen;
|
||||
|
||||
size = pSrc->drawable.height * pSrc->devKind;
|
||||
pScreen = pSrc->drawable.pScreen;
|
||||
pDst = (*pScreen->CreatePixmap) (pScreen, pSrc->drawable.width,
|
||||
pSrc->drawable.height, pSrc->drawable.depth, 0);
|
||||
if (!pDst)
|
||||
return NullPixmap;
|
||||
memmove((char *)pDst->devPrivate.ptr, (char *)pSrc->devPrivate.ptr, size);
|
||||
return pDst;
|
||||
}
|
||||
|
||||
|
||||
/* replicates a pattern to be a full 32 bits wide.
|
||||
relies on the fact that each scnaline is longword padded.
|
||||
doesn't do anything if pixmap is not a factor of 32 wide.
|
||||
changes width field of pixmap if successful, so that the fast
|
||||
cfbXRotatePixmap code gets used if we rotate the pixmap later.
|
||||
cfbYRotatePixmap code gets used if we rotate the pixmap later.
|
||||
|
||||
calculate number of times to repeat
|
||||
for each scanline of pattern
|
||||
zero out area to be filled with replicate
|
||||
left shift and or in original as many times as needed
|
||||
*/
|
||||
void
|
||||
cfbPadPixmap(pPixmap)
|
||||
PixmapPtr pPixmap;
|
||||
{
|
||||
register int width = (pPixmap->drawable.width) * (pPixmap->drawable.bitsPerPixel);
|
||||
register int h;
|
||||
register CfbBits mask;
|
||||
register CfbBits *p;
|
||||
register CfbBits bits; /* real pattern bits */
|
||||
register int i;
|
||||
int rep; /* repeat count for pattern */
|
||||
|
||||
if (width >= PGSZ)
|
||||
return;
|
||||
|
||||
rep = PGSZ/width;
|
||||
if (rep*width != PGSZ)
|
||||
return;
|
||||
|
||||
mask = mfbGetendtab(width);
|
||||
|
||||
p = (CfbBits *)(pPixmap->devPrivate.ptr);
|
||||
for (h=0; h < pPixmap->drawable.height; h++)
|
||||
{
|
||||
*p &= mask;
|
||||
bits = *p;
|
||||
for(i=1; i<rep; i++)
|
||||
{
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
bits >>= width;
|
||||
#else
|
||||
bits <<= width;
|
||||
#endif
|
||||
*p |= bits;
|
||||
}
|
||||
p++;
|
||||
}
|
||||
pPixmap->drawable.width = PGSZ/(pPixmap->drawable.bitsPerPixel);
|
||||
}
|
||||
|
||||
|
||||
#ifdef notdef
|
||||
/*
|
||||
* cfb debugging routine -- assumes pixmap is 1 byte deep
|
||||
*/
|
||||
static cfbdumppixmap(pPix)
|
||||
PixmapPtr pPix;
|
||||
{
|
||||
unsigned int *pw;
|
||||
char *psrc, *pdst;
|
||||
int i, j;
|
||||
char line[66];
|
||||
|
||||
ErrorF( "pPixmap: 0x%x\n", pPix);
|
||||
ErrorF( "%d wide %d high\n", pPix->drawable.width, pPix->drawable.height);
|
||||
if (pPix->drawable.width > 64)
|
||||
{
|
||||
ErrorF( "too wide to see\n");
|
||||
return;
|
||||
}
|
||||
|
||||
pw = (unsigned int *) pPix->devPrivate.ptr;
|
||||
psrc = (char *) pw;
|
||||
|
||||
/*
|
||||
for ( i=0; i<pPix->drawable.height; ++i )
|
||||
ErrorF( "0x%x\n", pw[i] );
|
||||
*/
|
||||
|
||||
for ( i = 0; i < pPix->drawable.height; ++i ) {
|
||||
pdst = line;
|
||||
for(j = 0; j < pPix->drawable.width; j++) {
|
||||
*pdst++ = *psrc++ ? 'X' : ' ' ;
|
||||
}
|
||||
*pdst++ = '\n';
|
||||
*pdst++ = '\0';
|
||||
ErrorF( "%s", line);
|
||||
}
|
||||
}
|
||||
#endif /* notdef */
|
||||
|
||||
/* Rotates pixmap pPix by w pixels to the right on the screen. Assumes that
|
||||
* words are PGSZ bits wide, and that the least significant bit appears on the
|
||||
* left.
|
||||
*/
|
||||
void
|
||||
cfbXRotatePixmap(pPix, rw)
|
||||
PixmapPtr pPix;
|
||||
register int rw;
|
||||
{
|
||||
register CfbBits *pw, *pwFinal;
|
||||
register CfbBits t;
|
||||
int rot;
|
||||
|
||||
if (pPix == NullPixmap)
|
||||
return;
|
||||
|
||||
switch (((DrawablePtr) pPix)->bitsPerPixel) {
|
||||
case PSZ:
|
||||
break;
|
||||
case 1:
|
||||
mfbXRotatePixmap(pPix, rw);
|
||||
return;
|
||||
default:
|
||||
ErrorF("cfbXRotatePixmap: unsupported bitsPerPixel %d\n", ((DrawablePtr) pPix)->bitsPerPixel);
|
||||
return;
|
||||
}
|
||||
pw = (CfbBits *)pPix->devPrivate.ptr;
|
||||
modulus (rw, (int) pPix->drawable.width, rot);
|
||||
if(pPix->drawable.width == PPW)
|
||||
{
|
||||
pwFinal = pw + pPix->drawable.height;
|
||||
while(pw < pwFinal)
|
||||
{
|
||||
t = *pw;
|
||||
*pw++ = SCRRIGHT(t, rot) |
|
||||
(SCRLEFT(t, (PPW-rot)) & cfbendtab[rot]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ErrorF("cfb internal error: trying to rotate odd-sized pixmap.\n");
|
||||
#ifdef notdef
|
||||
register CfbBits *pwTmp;
|
||||
int size, tsize;
|
||||
|
||||
tsize = PixmapBytePad(pPix->drawable.width - rot, pPix->drawable.depth);
|
||||
pwTmp = (CfbBits *) xalloc(pPix->drawable.height * tsize);
|
||||
if (!pwTmp)
|
||||
return;
|
||||
/* divide pw (the pixmap) in two vertically at (w - rot) and swap */
|
||||
tsize >>= 2;
|
||||
size = pPix->devKind >> SIZE0F(PixelGroup);
|
||||
cfbQuickBlt((CfbBits *)pw, (CfbBits *)pwTmp,
|
||||
0, 0, 0, 0,
|
||||
(int)pPix->drawable.width - rot, (int)pPix->drawable.height,
|
||||
size, tsize);
|
||||
cfbQuickBlt((CfbBits *)pw, (CfbBits *)pw,
|
||||
(int)pPix->drawable.width - rot, 0, 0, 0,
|
||||
rot, (int)pPix->drawable.height,
|
||||
size, size);
|
||||
cfbQuickBlt((CfbBits *)pwTmp, (CfbBits *)pw,
|
||||
0, 0, rot, 0,
|
||||
(int)pPix->drawable.width - rot, (int)pPix->drawable.height,
|
||||
tsize, size);
|
||||
xfree(pwTmp);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/* Rotates pixmap pPix by h lines. Assumes that h is always less than
|
||||
pPix->drawable.height
|
||||
works on any width.
|
||||
*/
|
||||
void
|
||||
cfbYRotatePixmap(pPix, rh)
|
||||
register PixmapPtr pPix;
|
||||
int rh;
|
||||
{
|
||||
int nbyDown; /* bytes to move down to row 0; also offset of
|
||||
row rh */
|
||||
int nbyUp; /* bytes to move up to line rh; also
|
||||
offset of first line moved down to 0 */
|
||||
char *pbase;
|
||||
char *ptmp;
|
||||
int rot;
|
||||
|
||||
if (pPix == NullPixmap)
|
||||
return;
|
||||
switch (((DrawablePtr) pPix)->bitsPerPixel) {
|
||||
case PSZ:
|
||||
break;
|
||||
case 1:
|
||||
mfbYRotatePixmap(pPix, rh);
|
||||
return;
|
||||
default:
|
||||
ErrorF("cfbYRotatePixmap: unsupported bitsPerPixel %d\n", ((DrawablePtr) pPix)->bitsPerPixel);
|
||||
return;
|
||||
}
|
||||
|
||||
modulus (rh, (int) pPix->drawable.height, rot);
|
||||
pbase = (char *)pPix->devPrivate.ptr;
|
||||
|
||||
nbyDown = rot * pPix->devKind;
|
||||
nbyUp = (pPix->devKind * pPix->drawable.height) - nbyDown;
|
||||
if(!(ptmp = (char *)xalloc(nbyUp)))
|
||||
return;
|
||||
|
||||
memmove(ptmp, pbase, nbyUp); /* save the low rows */
|
||||
memmove(pbase, pbase+nbyUp, nbyDown); /* slide the top rows down */
|
||||
memmove(pbase+nbyDown, ptmp, nbyUp); /* move lower rows up to row rot */
|
||||
xfree(ptmp);
|
||||
}
|
||||
|
||||
void
|
||||
cfbCopyRotatePixmap(psrcPix, ppdstPix, xrot, yrot)
|
||||
register PixmapPtr psrcPix, *ppdstPix;
|
||||
int xrot, yrot;
|
||||
{
|
||||
register PixmapPtr pdstPix;
|
||||
|
||||
if ((pdstPix = *ppdstPix) &&
|
||||
(pdstPix->devKind == psrcPix->devKind) &&
|
||||
(pdstPix->drawable.height == psrcPix->drawable.height))
|
||||
{
|
||||
memmove((char *)pdstPix->devPrivate.ptr,
|
||||
(char *)psrcPix->devPrivate.ptr,
|
||||
psrcPix->drawable.height * psrcPix->devKind);
|
||||
pdstPix->drawable.width = psrcPix->drawable.width;
|
||||
pdstPix->drawable.depth = psrcPix->drawable.depth;
|
||||
pdstPix->drawable.bitsPerPixel = psrcPix->drawable.bitsPerPixel;
|
||||
pdstPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (pdstPix)
|
||||
/* FIX XBUG 6168 */
|
||||
(*pdstPix->drawable.pScreen->DestroyPixmap)(pdstPix);
|
||||
*ppdstPix = pdstPix = cfbCopyPixmap(psrcPix);
|
||||
if (!pdstPix)
|
||||
return;
|
||||
}
|
||||
cfbPadPixmap(pdstPix);
|
||||
if (xrot)
|
||||
cfbXRotatePixmap(pdstPix, xrot);
|
||||
if (yrot)
|
||||
cfbYRotatePixmap(pdstPix, yrot);
|
||||
}
|
363
cfb/cfbply1rct.c
363
cfb/cfbply1rct.c
|
@ -1,363 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "mistruct.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfbrrop.h"
|
||||
|
||||
void
|
||||
RROP_NAME(cfbFillPoly1Rect) (pDrawable, pGC, shape, mode, count, ptsIn)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int shape;
|
||||
int mode;
|
||||
int count;
|
||||
DDXPointPtr ptsIn;
|
||||
{
|
||||
cfbPrivGCPtr devPriv;
|
||||
int nwidth;
|
||||
CfbBits *addrl, *addr;
|
||||
#if PSZ == 24
|
||||
CfbBits startmask, endmask;
|
||||
register int pidx;
|
||||
#else
|
||||
#if PPW > 1
|
||||
CfbBits mask, bits = ~((CfbBits)0);
|
||||
#endif
|
||||
#endif
|
||||
int maxy;
|
||||
int origin;
|
||||
register int vertex1, vertex2;
|
||||
int c = 0;
|
||||
BoxPtr extents;
|
||||
int clip;
|
||||
int y;
|
||||
int *vertex1p = NULL, *vertex2p;
|
||||
int *endp;
|
||||
int x1 = 0, x2 = 0;
|
||||
int dx1 = 0, dx2 = 0;
|
||||
int dy1 = 0, dy2 = 0;
|
||||
int e1 = 0, e2 = 0;
|
||||
int step1 = 0, step2 = 0;
|
||||
int sign1 = 0, sign2 = 0;
|
||||
int h;
|
||||
int l;
|
||||
#if PSZ != 24 && PPW > 1
|
||||
int r;
|
||||
#endif
|
||||
int nmiddle;
|
||||
RROP_DECLARE
|
||||
|
||||
if (mode == CoordModePrevious)
|
||||
{
|
||||
miFillPolygon (pDrawable, pGC, shape, mode, count, ptsIn);
|
||||
return;
|
||||
}
|
||||
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
#ifdef NO_ONE_RECT
|
||||
if (REGION_NUM_RECTS(pGC->pCompositeClip) != 1)
|
||||
{
|
||||
miFillPolygon (pDrawable, pGC, shape, mode, count, ptsIn);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
origin = *((int *) &pDrawable->x);
|
||||
vertex2 = origin - ((origin & 0x8000) << 1);
|
||||
extents = &pGC->pCompositeClip->extents;
|
||||
RROP_FETCH_GCPRIV(devPriv);
|
||||
vertex1 = *((int *) &extents->x1) - vertex2;
|
||||
vertex2 = *((int *) &extents->x2) - vertex2 - 0x00010001;
|
||||
clip = 0;
|
||||
y = 32767;
|
||||
maxy = 0;
|
||||
vertex2p = (int *) ptsIn;
|
||||
endp = vertex2p + count;
|
||||
if (shape == Convex)
|
||||
{
|
||||
while (count--)
|
||||
{
|
||||
c = *vertex2p;
|
||||
clip |= (c - vertex1) | (vertex2 - c);
|
||||
c = intToY(c);
|
||||
if (c < y)
|
||||
{
|
||||
y = c;
|
||||
vertex1p = vertex2p;
|
||||
}
|
||||
vertex2p++;
|
||||
if (c > maxy)
|
||||
maxy = c;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int yFlip = 0;
|
||||
dx1 = 1;
|
||||
x2 = -1;
|
||||
x1 = -1;
|
||||
while (count--)
|
||||
{
|
||||
c = *vertex2p;
|
||||
clip |= (c - vertex1) | (vertex2 - c);
|
||||
c = intToY(c);
|
||||
if (c < y)
|
||||
{
|
||||
y = c;
|
||||
vertex1p = vertex2p;
|
||||
}
|
||||
vertex2p++;
|
||||
if (c > maxy)
|
||||
maxy = c;
|
||||
if (c == x1)
|
||||
continue;
|
||||
if (dx1 > 0)
|
||||
{
|
||||
if (x2 < 0)
|
||||
x2 = c;
|
||||
else
|
||||
dx2 = dx1 = (c - x1) >> 31;
|
||||
}
|
||||
else
|
||||
if ((c - x1) >> 31 != dx1)
|
||||
{
|
||||
dx1 = ~dx1;
|
||||
yFlip++;
|
||||
}
|
||||
x1 = c;
|
||||
}
|
||||
x1 = (x2 - c) >> 31;
|
||||
if (x1 != dx1)
|
||||
yFlip++;
|
||||
if (x1 != dx2)
|
||||
yFlip++;
|
||||
if (yFlip != 2)
|
||||
clip = 0x8000;
|
||||
}
|
||||
if (y == maxy)
|
||||
return;
|
||||
|
||||
if (clip & 0x80008000)
|
||||
{
|
||||
miFillPolygon (pDrawable, pGC, shape, mode, vertex2p - (int *) ptsIn, ptsIn);
|
||||
return;
|
||||
}
|
||||
|
||||
#define AddrYPlus(a,y) (CfbBits *) (((unsigned char *) (a)) + (y) * nwidth)
|
||||
|
||||
cfbGetTypedWidthAndPointer(pDrawable, nwidth, addrl, unsigned char, CfbBits);
|
||||
addrl = AddrYPlus(addrl,y + pDrawable->y);
|
||||
origin = intToX(origin);
|
||||
vertex2p = vertex1p;
|
||||
vertex2 = vertex1 = *vertex2p++;
|
||||
if (vertex2p == endp)
|
||||
vertex2p = (int *) ptsIn;
|
||||
#define Setup(c,x,vertex,dx,dy,e,sign,step) {\
|
||||
x = intToX(vertex); \
|
||||
if ((dy = intToY(c) - y)) { \
|
||||
dx = intToX(c) - x; \
|
||||
step = 0; \
|
||||
if (dx >= 0) \
|
||||
{ \
|
||||
e = 0; \
|
||||
sign = 1; \
|
||||
if (dx >= dy) {\
|
||||
step = dx / dy; \
|
||||
dx = dx % dy; \
|
||||
} \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
e = 1 - dy; \
|
||||
sign = -1; \
|
||||
dx = -dx; \
|
||||
if (dx >= dy) { \
|
||||
step = - (dx / dy); \
|
||||
dx = dx % dy; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
x += origin; \
|
||||
vertex = c; \
|
||||
}
|
||||
|
||||
#define Step(x,dx,dy,e,sign,step) {\
|
||||
x += step; \
|
||||
if ((e += dx) > 0) \
|
||||
{ \
|
||||
x += sign; \
|
||||
e -= dy; \
|
||||
} \
|
||||
}
|
||||
for (;;)
|
||||
{
|
||||
if (y == intToY(vertex1))
|
||||
{
|
||||
do
|
||||
{
|
||||
if (vertex1p == (int *) ptsIn)
|
||||
vertex1p = endp;
|
||||
c = *--vertex1p;
|
||||
Setup (c,x1,vertex1,dx1,dy1,e1,sign1,step1)
|
||||
} while (y >= intToY(vertex1));
|
||||
h = dy1;
|
||||
}
|
||||
else
|
||||
{
|
||||
Step(x1,dx1,dy1,e1,sign1,step1)
|
||||
h = intToY(vertex1) - y;
|
||||
}
|
||||
if (y == intToY(vertex2))
|
||||
{
|
||||
do
|
||||
{
|
||||
c = *vertex2p++;
|
||||
if (vertex2p == endp)
|
||||
vertex2p = (int *) ptsIn;
|
||||
Setup (c,x2,vertex2,dx2,dy2,e2,sign2,step2)
|
||||
} while (y >= intToY(vertex2));
|
||||
if (dy2 < h)
|
||||
h = dy2;
|
||||
}
|
||||
else
|
||||
{
|
||||
Step(x2,dx2,dy2,e2,sign2,step2)
|
||||
if ((c = (intToY(vertex2) - y)) < h)
|
||||
h = c;
|
||||
}
|
||||
/* fill spans for this segment */
|
||||
y += h;
|
||||
for (;;)
|
||||
{
|
||||
l = x1;
|
||||
#if PSZ != 24 && PPW > 1
|
||||
r = x2;
|
||||
#endif
|
||||
nmiddle = x2 - x1;
|
||||
if (nmiddle < 0)
|
||||
{
|
||||
nmiddle = -nmiddle;
|
||||
l = x2;
|
||||
#if PSZ != 24 && PPW > 1
|
||||
r = x1;
|
||||
#endif
|
||||
}
|
||||
#if PPW > 1
|
||||
c = l & PIM;
|
||||
l -= c;
|
||||
#endif
|
||||
|
||||
#if PGSZ == 32
|
||||
#define LWRD_SHIFT 2
|
||||
#else /* PGSZ == 64 */
|
||||
#define LWRD_SHIFT 3
|
||||
#endif /* PGSZ */
|
||||
|
||||
#if PSZ == 24
|
||||
addr = (CfbBits *)((char *)addrl + ((l * 3) & ~0x03));
|
||||
if (nmiddle <= 1){
|
||||
if (nmiddle)
|
||||
RROP_SOLID24(addr, l);
|
||||
} else {
|
||||
maskbits(l, nmiddle, startmask, endmask, nmiddle);
|
||||
pidx = l & 3;
|
||||
if (startmask){
|
||||
RROP_SOLID_MASK(addr, startmask, pidx-1);
|
||||
addr++;
|
||||
if (pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
while (--nmiddle >= 0){
|
||||
RROP_SOLID(addr, pidx);
|
||||
addr++;
|
||||
if (++pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addr, endmask, pidx);
|
||||
}
|
||||
#else /* PSZ == 24 */
|
||||
#if PWSH > LWRD_SHIFT
|
||||
l = l >> (PWSH - LWRD_SHIFT);
|
||||
#endif
|
||||
#if PWSH < LWRD_SHIFT
|
||||
l = l << (LWRD_SHIFT - PWSH);
|
||||
#endif
|
||||
addr = (CfbBits *) (((char *) addrl) + l);
|
||||
#if PPW > 1
|
||||
if (c + nmiddle < PPW)
|
||||
{
|
||||
mask = SCRRIGHT (bits,c) ^ SCRRIGHT (bits,c+nmiddle);
|
||||
RROP_SOLID_MASK(addr,mask);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (c)
|
||||
{
|
||||
mask = SCRRIGHT(bits, c);
|
||||
RROP_SOLID_MASK(addr,mask);
|
||||
nmiddle += c - PPW;
|
||||
addr++;
|
||||
}
|
||||
#endif
|
||||
nmiddle >>= PWSH;
|
||||
while (--nmiddle >= 0) {
|
||||
RROP_SOLID(addr); addr++;
|
||||
}
|
||||
#if PPW > 1
|
||||
if ((mask = ~SCRRIGHT(bits, r & PIM)))
|
||||
RROP_SOLID_MASK(addr,mask);
|
||||
}
|
||||
#endif
|
||||
#endif /* PSZ == 24 */
|
||||
if (!--h)
|
||||
break;
|
||||
addrl = AddrYPlus (addrl, 1);
|
||||
Step(x1,dx1,dy1,e1,sign1,step1)
|
||||
Step(x2,dx2,dy2,e2,sign2,step2)
|
||||
}
|
||||
if (y == maxy)
|
||||
break;
|
||||
addrl = AddrYPlus (addrl, 1);
|
||||
}
|
||||
RROP_UNDECLARE
|
||||
}
|
202
cfb/cfbpolypnt.c
202
cfb/cfbpolypnt.c
|
@ -1,202 +0,0 @@
|
|||
/************************************************************
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
********************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
#define isClipped(c,ul,lr) ((((c) - (ul)) | ((lr) - (c))) & ClipMask)
|
||||
|
||||
/* WARNING: pbox contains two shorts. This code assumes they are packed
|
||||
* and can be referenced together as an INT32.
|
||||
*/
|
||||
|
||||
#define PointLoop(fill) { \
|
||||
for (nbox = REGION_NUM_RECTS(cclip), pbox = REGION_RECTS(cclip); \
|
||||
--nbox >= 0; \
|
||||
pbox++) \
|
||||
{ \
|
||||
c1 = *((INT32 *) &pbox->x1) - off; \
|
||||
c2 = *((INT32 *) &pbox->x2) - off - 0x00010001; \
|
||||
for (ppt = (INT32 *) pptInit, i = npt; --i >= 0;) \
|
||||
{ \
|
||||
pt = *ppt++; \
|
||||
if (!isClipped(pt,c1,c2)) { \
|
||||
fill \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#if PSZ == 24
|
||||
# include "cfbrrop24.h"
|
||||
#endif
|
||||
|
||||
void
|
||||
cfbPolyPoint(pDrawable, pGC, mode, npt, pptInit)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int mode;
|
||||
int npt;
|
||||
xPoint *pptInit;
|
||||
{
|
||||
register INT32 pt;
|
||||
register INT32 c1, c2;
|
||||
register CARD32 ClipMask = 0x80008000;
|
||||
register CfbBits xor;
|
||||
#ifdef PIXEL_ADDR
|
||||
register PixelType *addrp;
|
||||
register int npwidth;
|
||||
#if PSZ != 24
|
||||
PixelType *addrpt;
|
||||
#endif
|
||||
#else
|
||||
register CfbBits *addrl;
|
||||
register int nlwidth;
|
||||
register int xoffset;
|
||||
CfbBits *addrlt;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
RROP_DECLARE
|
||||
register int xtmp;
|
||||
register PixelType *p;
|
||||
#endif
|
||||
register INT32 *ppt;
|
||||
RegionPtr cclip;
|
||||
int nbox;
|
||||
register int i;
|
||||
register BoxPtr pbox;
|
||||
CfbBits and;
|
||||
int rop = pGC->alu;
|
||||
int off;
|
||||
cfbPrivGCPtr devPriv;
|
||||
xPoint *pptPrev;
|
||||
|
||||
devPriv =cfbGetGCPrivate(pGC);
|
||||
rop = devPriv->rop;
|
||||
if (rop == GXnoop)
|
||||
return;
|
||||
cclip = pGC->pCompositeClip;
|
||||
xor = devPriv->xor;
|
||||
if ((mode == CoordModePrevious) && (npt > 1))
|
||||
{
|
||||
for (pptPrev = pptInit + 1, i = npt - 1; --i >= 0; pptPrev++)
|
||||
{
|
||||
pptPrev->x += (pptPrev-1)->x;
|
||||
pptPrev->y += (pptPrev-1)->y;
|
||||
}
|
||||
}
|
||||
off = *((int *) &pDrawable->x);
|
||||
off -= (off & 0x8000) << 1;
|
||||
#ifdef PIXEL_ADDR
|
||||
cfbGetPixelWidthAndPointer(pDrawable, npwidth, addrp);
|
||||
#if PSZ == 24
|
||||
addrp = addrp + pDrawable->y * npwidth;
|
||||
#else
|
||||
addrp = addrp + pDrawable->y * npwidth + pDrawable->x;
|
||||
#endif
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
#if PSZ == 24
|
||||
RROP_COPY_SETUP(xor)
|
||||
#endif
|
||||
if (!(npwidth & (npwidth - 1)))
|
||||
{
|
||||
npwidth = ffs(npwidth) - 1;
|
||||
#if PSZ == 24
|
||||
PointLoop(
|
||||
xtmp = pDrawable->x + intToX(pt);
|
||||
p = addrp + (intToY(pt) << npwidth) + ((xtmp * 3) >>2);
|
||||
RROP_SOLID24_COPY(p, xtmp))
|
||||
#else
|
||||
PointLoop(*(addrp + (intToY(pt) << npwidth) + intToX(pt)) = xor;)
|
||||
#endif
|
||||
}
|
||||
#ifdef sun
|
||||
else if (npwidth == 1152)
|
||||
{
|
||||
register int y;
|
||||
PointLoop(y = intToY(pt); *(addrp + (y << 10) + (y << 7) + intToX(pt)) = xor;)
|
||||
}
|
||||
#endif
|
||||
else
|
||||
{
|
||||
#if PSZ == 24
|
||||
PointLoop(
|
||||
xtmp = pDrawable->x + intToX(pt);
|
||||
p = addrp + intToY(pt) * npwidth + ((xtmp * 3) >> 2);
|
||||
RROP_SOLID24_COPY(p, xtmp))
|
||||
#else
|
||||
PointLoop(*(addrp + intToY(pt) * npwidth + intToX(pt)) = xor;)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
and = devPriv->and;
|
||||
#if PSZ == 24
|
||||
RROP_SET_SETUP(xor, and)
|
||||
PointLoop(
|
||||
xtmp = pDrawable->x + intToX(pt);
|
||||
p = addrp + intToY(pt) * npwidth + ((xtmp * 3) >> 2);
|
||||
RROP_SOLID24_SET(p, xtmp))
|
||||
#else
|
||||
PointLoop( addrpt = addrp + intToY(pt) * npwidth + intToX(pt);
|
||||
*addrpt = DoRRop (*addrpt, and, xor);)
|
||||
#endif
|
||||
}
|
||||
#else /* !PIXEL_ADDR */
|
||||
cfbGetLongWidthAndPointer(pDrawable, nlwidth, addrl);
|
||||
addrl = addrl + pDrawable->y * nlwidth + (pDrawable->x >> PWSH);
|
||||
xoffset = pDrawable->x & PIM;
|
||||
and = devPriv->and;
|
||||
#if PSZ == 24
|
||||
PointLoop( addrlt = addrl + intToY(pt) * nlwidth
|
||||
+ ((intToX(pt) + xoffset) >> PWSH);
|
||||
*addrlt = DoRRop (*addrlt,
|
||||
and | ~cfbmask[(intToX(pt) + xoffset) & PIM],
|
||||
xor & cfbmask[(intToX(pt) + xoffset) & PIM]);
|
||||
)
|
||||
#else
|
||||
PointLoop( addrlt = addrl + intToY(pt) * nlwidth
|
||||
+ ((intToX(pt) + xoffset) >> PWSH);
|
||||
*addrlt = DoRRop (*addrlt,
|
||||
and | ~cfbmask[((intToX(pt) + xoffset) & 3)<<1],
|
||||
xor & cfbmask[((intToX(pt) + xoffset) & 3)<<1]);
|
||||
)
|
||||
#endif
|
||||
#endif /* PIXEL_ADDR */
|
||||
}
|
184
cfb/cfbpush8.c
184
cfb/cfbpush8.c
|
@ -1,184 +0,0 @@
|
|||
/*
|
||||
* Push Pixels for 8 bit displays.
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
#define MFB_CONSTS_ONLY
|
||||
#include "maskbits.h"
|
||||
|
||||
void
|
||||
cfbPushPixels8 (pGC, pBitmap, pDrawable, dx, dy, xOrg, yOrg)
|
||||
GCPtr pGC;
|
||||
PixmapPtr pBitmap;
|
||||
DrawablePtr pDrawable;
|
||||
int dx, dy, xOrg, yOrg;
|
||||
{
|
||||
register CfbBits *src, *dst;
|
||||
register CfbBits pixel;
|
||||
register CfbBits c, bits;
|
||||
CfbBits *pdstLine, *psrcLine;
|
||||
CfbBits *pdstBase;
|
||||
int srcWidth;
|
||||
int dstWidth;
|
||||
int xoff;
|
||||
int nBitmapLongs, nPixmapLongs;
|
||||
int nBitmapTmp, nPixmapTmp;
|
||||
CfbBits rightMask;
|
||||
BoxRec bbox;
|
||||
cfbPrivGCPtr devPriv;
|
||||
|
||||
bbox.x1 = xOrg;
|
||||
bbox.y1 = yOrg;
|
||||
bbox.x2 = bbox.x1 + dx;
|
||||
bbox.y2 = bbox.y1 + dy;
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
|
||||
switch (RECT_IN_REGION(pGC->pScreen, pGC->pCompositeClip, &bbox))
|
||||
{
|
||||
case rgnPART:
|
||||
mfbPushPixels(pGC, pBitmap, pDrawable, dx, dy, xOrg, yOrg);
|
||||
case rgnOUT:
|
||||
return;
|
||||
}
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, dstWidth, pdstBase)
|
||||
|
||||
psrcLine = (CfbBits *) pBitmap->devPrivate.ptr;
|
||||
srcWidth = (int) pBitmap->devKind >> PWSH;
|
||||
|
||||
pixel = devPriv->xor;
|
||||
xoff = xOrg & PIM;
|
||||
nBitmapLongs = (dx + xoff) >> MFB_PWSH;
|
||||
nPixmapLongs = (dx + PGSZB + xoff) >> PWSH;
|
||||
|
||||
rightMask = ~cfb8BitLenMasks[((dx + xoff) & MFB_PIM)];
|
||||
|
||||
pdstLine = pdstBase + (yOrg * dstWidth) + (xOrg >> PWSH);
|
||||
|
||||
while (dy--)
|
||||
{
|
||||
c = 0;
|
||||
nPixmapTmp = nPixmapLongs;
|
||||
nBitmapTmp = nBitmapLongs;
|
||||
src = psrcLine;
|
||||
dst = pdstLine;
|
||||
while (nBitmapTmp--)
|
||||
{
|
||||
bits = *src++;
|
||||
c |= BitRight (bits, xoff);
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
nPixmapTmp -= 8;
|
||||
c = 0;
|
||||
if (xoff)
|
||||
c = BitLeft (bits, PGSZ - xoff);
|
||||
}
|
||||
if (BitLeft (rightMask, xoff))
|
||||
c |= BitRight (*src, xoff);
|
||||
c &= rightMask;
|
||||
switch (nPixmapTmp) {
|
||||
case 8:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 7:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 6:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 5:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 4:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 3:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 2:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 1:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 0:
|
||||
break;
|
||||
}
|
||||
pdstLine += dstWidth;
|
||||
psrcLine += srcWidth;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
593
cfb/cfbrctstp8.c
593
cfb/cfbrctstp8.c
|
@ -1,593 +0,0 @@
|
|||
/*
|
||||
* Fill 32 bit stippled rectangles for 8 bit frame buffers
|
||||
*/
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
Author: Keith Packard, MIT X Consortium
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "gcstruct.h"
|
||||
#include "window.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
#define MFB_CONSTS_ONLY
|
||||
#include "maskbits.h"
|
||||
|
||||
void
|
||||
cfb8FillRectOpaqueStippled32 (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox; /* number of boxes to fill */
|
||||
register BoxPtr pBox; /* pointer to list of boxes to fill */
|
||||
{
|
||||
CfbBits *src;
|
||||
int stippleHeight;
|
||||
|
||||
int nlwDst; /* width in longwords of the dest pixmap */
|
||||
int w; /* width of current box */
|
||||
register int h; /* height of current box */
|
||||
CfbBits startmask;
|
||||
CfbBits endmask; /* masks for reggedy bits at either end of line */
|
||||
int nlwMiddle; /* number of longwords between sides of boxes */
|
||||
register int nlw; /* loop version of nlwMiddle */
|
||||
CfbBits *dstLine;
|
||||
register CfbBits *dst; /* pointer to bits we're writing */
|
||||
CfbBits *dstTmp;
|
||||
int y; /* current scan line */
|
||||
|
||||
CfbBits *pbits;/* pointer to start of pixmap */
|
||||
register CfbBits bits; /* bits from stipple */
|
||||
int rot;
|
||||
register CfbBits xor;
|
||||
PixmapPtr stipple;
|
||||
int wEnd;
|
||||
|
||||
stipple = pGC->pRotatedPixmap;
|
||||
|
||||
cfb8CheckOpaqueStipple(pGC->alu, pGC->fgPixel, pGC->bgPixel, pGC->planemask);
|
||||
|
||||
stippleHeight = stipple->drawable.height;
|
||||
src = (CfbBits *)stipple->devPrivate.ptr;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pbits)
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
w = pBox->x2 - pBox->x1;
|
||||
h = pBox->y2 - pBox->y1;
|
||||
y = pBox->y1;
|
||||
dstLine = pbits + (pBox->y1 * nlwDst) + ((pBox->x1 & ~PIM) >> PWSH);
|
||||
if (((pBox->x1 & PIM) + w) <= PPW)
|
||||
{
|
||||
maskpartialbits(pBox->x1, w, startmask);
|
||||
nlwMiddle = 0;
|
||||
endmask = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (pBox->x1, w, startmask, endmask, nlwMiddle);
|
||||
}
|
||||
rot = (pBox->x1 & ((PGSZ-1) & ~PIM));
|
||||
pBox++;
|
||||
y = y % stippleHeight;
|
||||
#if PPW == 4
|
||||
if (cfb8StippleRRop == GXcopy)
|
||||
{
|
||||
if (w < PGSZ*2)
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot)
|
||||
RotBitsLeft(bits,rot);
|
||||
dst = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
*dst = (*dst & ~startmask) |
|
||||
(GetPixelGroup (bits) & startmask);
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
nlw = nlwMiddle;
|
||||
while (nlw--)
|
||||
{
|
||||
*dst++ = GetPixelGroup(bits);
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
*dst = (*dst & ~endmask) |
|
||||
(GetPixelGroup (bits) & endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
wEnd = 7 - (nlwMiddle & 7);
|
||||
nlwMiddle = (nlwMiddle >> 3) + 1;
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot != 0)
|
||||
RotBitsLeft (bits, rot);
|
||||
dstTmp = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
*dstTmp = (*dstTmp & ~startmask) |
|
||||
(GetPixelGroup (bits) & startmask);
|
||||
dstTmp++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
w = 7 - wEnd;
|
||||
while (w--)
|
||||
{
|
||||
nlw = nlwMiddle;
|
||||
dst = dstTmp;
|
||||
dstTmp++;
|
||||
xor = GetPixelGroup (bits);
|
||||
while (nlw--)
|
||||
{
|
||||
*dst = xor;
|
||||
dst += 8;
|
||||
}
|
||||
NextBitGroup (bits);
|
||||
}
|
||||
nlwMiddle--;
|
||||
w = wEnd + 1;
|
||||
if (endmask)
|
||||
{
|
||||
dst = dstTmp + (nlwMiddle << 3);
|
||||
*dst = (*dst & ~endmask) |
|
||||
(GetPixelGroup(bits) & endmask);
|
||||
}
|
||||
while (w--)
|
||||
{
|
||||
nlw = nlwMiddle;
|
||||
dst = dstTmp;
|
||||
dstTmp++;
|
||||
xor = GetPixelGroup (bits);
|
||||
while (nlw--)
|
||||
{
|
||||
*dst = xor;
|
||||
dst += 8;
|
||||
}
|
||||
NextBitGroup (bits);
|
||||
}
|
||||
nlwMiddle++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif /* PPW == 4 */
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot)
|
||||
RotBitsLeft(bits,rot);
|
||||
dst = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
xor = GetBitGroup(bits);
|
||||
*dst = MaskRRopPixels(*dst, xor, startmask);
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
nlw = nlwMiddle;
|
||||
while (nlw--)
|
||||
{
|
||||
RRopBitGroup(dst, GetBitGroup(bits));
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
xor = GetBitGroup(bits);
|
||||
*dst = MaskRRopPixels(*dst, xor, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
cfb8FillRectTransparentStippled32 (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox; /* number of boxes to fill */
|
||||
BoxPtr pBox; /* pointer to list of boxes to fill */
|
||||
{
|
||||
int x, y, w, h;
|
||||
int nlwMiddle, nlwDst;
|
||||
CfbBits startmask, endmask;
|
||||
register CfbBits *dst;
|
||||
CfbBits *dstLine, *pbits, *dstTmp;
|
||||
CfbBits *src;
|
||||
register CfbBits xor;
|
||||
register CfbBits bits, mask;
|
||||
int rot;
|
||||
int wEnd;
|
||||
cfbPrivGCPtr devPriv;
|
||||
PixmapPtr stipple;
|
||||
int stippleHeight;
|
||||
register int nlw;
|
||||
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
stipple = pGC->pRotatedPixmap;
|
||||
src = (CfbBits *)stipple->devPrivate.ptr;
|
||||
stippleHeight = stipple->drawable.height;
|
||||
|
||||
cfb8CheckStipple (pGC->alu, pGC->fgPixel, pGC->planemask);
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pbits)
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
x = pBox->x1;
|
||||
w = pBox->x2 - x;
|
||||
if (((x & PIM) + w) <= PPW)
|
||||
{
|
||||
maskpartialbits(x, w, startmask);
|
||||
endmask = 0;
|
||||
nlwMiddle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (x, w, startmask, endmask, nlwMiddle);
|
||||
}
|
||||
rot = (x & ((PGSZ-1) & ~PIM));
|
||||
y = pBox->y1;
|
||||
dstLine = pbits + (y * nlwDst) + (x >> PWSH);
|
||||
h = pBox->y2 - y;
|
||||
pBox++;
|
||||
y %= stippleHeight;
|
||||
#if PPW == 4
|
||||
if (cfb8StippleRRop == GXcopy)
|
||||
{
|
||||
xor = devPriv->xor;
|
||||
if (w < PGSZ*2)
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot != 0)
|
||||
RotBitsLeft (bits, rot);
|
||||
dst = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
*dst = (*dst & ~(mask & startmask)) |
|
||||
(xor & (mask & startmask));
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
nlw = nlwMiddle;
|
||||
while (nlw--)
|
||||
{
|
||||
WriteBitGroup (dst,xor,GetBitGroup(bits))
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
*dst = (*dst & ~(mask & endmask)) |
|
||||
(xor & (mask & endmask));
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
wEnd = 7 - (nlwMiddle & 7);
|
||||
nlwMiddle = (nlwMiddle >> 3) + 1;
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot != 0)
|
||||
RotBitsLeft (bits, rot);
|
||||
dstTmp = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
*dstTmp = (*dstTmp & ~(mask & startmask)) |
|
||||
(xor & (mask & startmask));
|
||||
dstTmp++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
w = 7 - wEnd;
|
||||
while (w--)
|
||||
{
|
||||
nlw = nlwMiddle;
|
||||
dst = dstTmp;
|
||||
dstTmp++;
|
||||
#if defined(__GNUC__) && defined(mc68020)
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
xor = xor & mask;
|
||||
mask = ~mask;
|
||||
while (nlw--)
|
||||
{
|
||||
*dst = (*dst & mask) | xor;
|
||||
dst += 8;
|
||||
}
|
||||
xor = devPriv->xor;
|
||||
#else
|
||||
#define SwitchBitsLoop(body) \
|
||||
while (nlw--) \
|
||||
{ \
|
||||
body \
|
||||
dst += 8; \
|
||||
}
|
||||
SwitchBitGroup(dst, xor, GetBitGroup(bits));
|
||||
#undef SwitchBitsLoop
|
||||
#endif
|
||||
NextBitGroup (bits);
|
||||
}
|
||||
nlwMiddle--;
|
||||
w = wEnd + 1;
|
||||
if (endmask)
|
||||
{
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
dst = dstTmp + (nlwMiddle << 3);
|
||||
*dst = (*dst & ~(mask & endmask)) |
|
||||
(xor & (mask & endmask));
|
||||
}
|
||||
while (w--)
|
||||
{
|
||||
nlw = nlwMiddle;
|
||||
dst = dstTmp;
|
||||
dstTmp++;
|
||||
#if defined(__GNUC__) && defined(mc68020)
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
xor = xor & mask;
|
||||
mask = ~mask;
|
||||
while (nlw--)
|
||||
{
|
||||
*dst = (*dst & mask) | xor;
|
||||
dst += 8;
|
||||
}
|
||||
xor = devPriv->xor;
|
||||
#else
|
||||
#define SwitchBitsLoop(body) \
|
||||
while (nlw--) \
|
||||
{ \
|
||||
body \
|
||||
dst += 8; \
|
||||
}
|
||||
SwitchBitGroup(dst, xor, GetBitGroup(bits));
|
||||
#undef SwitchBitsLoop
|
||||
#endif
|
||||
NextBitGroup (bits);
|
||||
}
|
||||
nlwMiddle++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif /* PPW == 4 */
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot != 0)
|
||||
RotBitsLeft (bits, rot);
|
||||
dst = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
xor = GetBitGroup(bits);
|
||||
*dst = MaskRRopPixels(*dst, xor, startmask);
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
nlw = nlwMiddle;
|
||||
while (nlw--)
|
||||
{
|
||||
RRopBitGroup(dst, GetBitGroup(bits));
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
xor = GetBitGroup(bits);
|
||||
*dst = MaskRRopPixels(*dst, xor, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
cfb8FillRectStippledUnnatural (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox;
|
||||
register BoxPtr pBox;
|
||||
{
|
||||
CfbBits *pdstBase; /* pointer to start of bitmap */
|
||||
CfbBits *pdstLine; /* current destination line */
|
||||
int nlwDst; /* width in longwords of bitmap */
|
||||
PixmapPtr pStipple; /* pointer to stipple we want to fill with */
|
||||
int nlwMiddle;
|
||||
register int nlw;
|
||||
int x, y, w, h, xrem, xSrc, ySrc;
|
||||
int stwidth, stippleWidth;
|
||||
int stippleHeight;
|
||||
register CfbBits bits, inputBits;
|
||||
register int partBitsLeft;
|
||||
int nextPartBits;
|
||||
int bitsLeft, bitsWhole;
|
||||
register CfbBits *pdst; /* pointer to current word in bitmap */
|
||||
CfbBits *srcTemp, *srcStart;
|
||||
CfbBits *psrcBase;
|
||||
CfbBits startmask, endmask;
|
||||
|
||||
if (pGC->fillStyle == FillStippled)
|
||||
cfb8CheckStipple (pGC->alu, pGC->fgPixel, pGC->planemask);
|
||||
else
|
||||
cfb8CheckOpaqueStipple (pGC->alu, pGC->fgPixel, pGC->bgPixel, pGC->planemask);
|
||||
|
||||
if (cfb8StippleRRop == GXnoop)
|
||||
return;
|
||||
|
||||
/*
|
||||
* OK, so what's going on here? We have two Drawables:
|
||||
*
|
||||
* The Stipple:
|
||||
* Depth = 1
|
||||
* Width = stippleWidth
|
||||
* Words per scanline = stwidth
|
||||
* Pointer to pixels = pStipple->devPrivate.ptr
|
||||
*/
|
||||
|
||||
pStipple = pGC->stipple;
|
||||
|
||||
stwidth = pStipple->devKind >> PWSH;
|
||||
stippleWidth = pStipple->drawable.width;
|
||||
stippleHeight = pStipple->drawable.height;
|
||||
psrcBase = (CfbBits *) pStipple->devPrivate.ptr;
|
||||
|
||||
/*
|
||||
* The Target:
|
||||
* Depth = PSZ
|
||||
* Width = determined from *pwidth
|
||||
* Words per scanline = nlwDst
|
||||
* Pointer to pixels = addrlBase
|
||||
*/
|
||||
|
||||
xSrc = pDrawable->x;
|
||||
ySrc = pDrawable->y;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pdstBase)
|
||||
|
||||
/* this replaces rotating the stipple. Instead we just adjust the offset
|
||||
* at which we start grabbing bits from the stipple.
|
||||
* Ensure that ppt->x - xSrc >= 0 and ppt->y - ySrc >= 0,
|
||||
* so that iline and xrem always stay within the stipple bounds.
|
||||
*/
|
||||
|
||||
xSrc += (pGC->patOrg.x % stippleWidth) - stippleWidth;
|
||||
ySrc += (pGC->patOrg.y % stippleHeight) - stippleHeight;
|
||||
|
||||
bitsWhole = stippleWidth;
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
x = pBox->x1;
|
||||
y = pBox->y1;
|
||||
w = pBox->x2 - x;
|
||||
h = pBox->y2 - y;
|
||||
pBox++;
|
||||
pdstLine = pdstBase + y * nlwDst + (x >> PWSH);
|
||||
y = (y - ySrc) % stippleHeight;
|
||||
srcStart = psrcBase + y * stwidth;
|
||||
xrem = ((x & ~PIM) - xSrc) % stippleWidth;
|
||||
if (((x & PIM) + w) < PPW)
|
||||
{
|
||||
maskpartialbits (x, w, startmask);
|
||||
nlwMiddle = 0;
|
||||
endmask = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (x, w, startmask, endmask, nlwMiddle);
|
||||
}
|
||||
while (h--)
|
||||
{
|
||||
srcTemp = srcStart + (xrem >> MFB_PWSH);
|
||||
bitsLeft = stippleWidth - (xrem & ~MFB_PIM);
|
||||
NextUnnaturalStippleWord
|
||||
NextSomeBits (inputBits, (xrem & MFB_PIM));
|
||||
partBitsLeft -= (xrem & MFB_PIM);
|
||||
NextUnnaturalStippleBits
|
||||
nlw = nlwMiddle;
|
||||
pdst = pdstLine;
|
||||
if (startmask)
|
||||
{
|
||||
*pdst = MaskRRopPixels(*pdst,bits,startmask);
|
||||
pdst++;
|
||||
NextUnnaturalStippleBits
|
||||
}
|
||||
while (nlw--)
|
||||
{
|
||||
*pdst = RRopPixels(*pdst,bits);
|
||||
pdst++;
|
||||
NextUnnaturalStippleBits
|
||||
}
|
||||
if (endmask)
|
||||
*pdst = MaskRRopPixels(*pdst,bits,endmask);
|
||||
pdstLine += nlwDst;
|
||||
y++;
|
||||
srcStart += stwidth;
|
||||
if (y == stippleHeight)
|
||||
{
|
||||
y = 0;
|
||||
srcStart = psrcBase;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* PSZ == 8 */
|
227
cfb/cfbrrop.c
227
cfb/cfbrrop.c
|
@ -1,227 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
/* cfb reduced rasterop computations */
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
/* A description:
|
||||
*
|
||||
* There are four possible operations on each bit in the destination word,
|
||||
*
|
||||
* 1 2 3 4
|
||||
*
|
||||
* 0 0 0 1 1
|
||||
* 1 0 1 0 1
|
||||
*
|
||||
* On examination of the reduced rop equation (dst = (dst & and) ^ xor),
|
||||
* these four fall to reduced rops as follows:
|
||||
*
|
||||
* and 0 1 1 0
|
||||
* xor 0 0 1 1
|
||||
*
|
||||
* or, (if 'and' is expensive) (dst = (dst | or) ^ xor)
|
||||
*
|
||||
* or 1 0 0 1
|
||||
* xor 1 0 1 0
|
||||
*
|
||||
* The trouble with using this later equation is that trivial
|
||||
* rasterop reduction is more difficult; some common rasterops
|
||||
* use complicated expressions of xor/and instead of the simple
|
||||
* ones while other common rasterops are not made any simpler:
|
||||
*
|
||||
* GXcopy: *dst = ~xor instead of *dst = xor
|
||||
* GXand: *dst = *dst & ~or instead of *dst = *dst & and
|
||||
* GXor: *dst = *dst | or instead of *dst = *dst | xor
|
||||
* GXxor: *dst = *dst ^ xor instead of *dst = *dst ^ xor
|
||||
*
|
||||
* If you're really set on using this second mechanism, the changes
|
||||
* are pretty simple.
|
||||
*
|
||||
* All that remains is to provide a mechanism for computing and/xor values
|
||||
* based on the raster op and foreground value.
|
||||
*
|
||||
* The 16 rops fall as follows, with the associated reduced
|
||||
* rop and/xor and or/xor values. The values in parenthesis following the
|
||||
* reduced values gives an equation using the source value for
|
||||
* the reduced value, and is one of {0, src, ~src, 1} as appropriate.
|
||||
*
|
||||
* clear and andReverse copy
|
||||
* src 0 1 0 1 0 1 0 1
|
||||
* dst 0 0 0 0 0 0 0 0 1 0 0 1
|
||||
* 1 0 0 1 0 1 1 0 0 1 0 1
|
||||
*
|
||||
* and 0 0 (0) 0 1 (src) 0 1 (src) 0 0 (0)
|
||||
* xor 0 0 (0) 0 0 (0) 0 1 (src) 0 1 (src)
|
||||
*
|
||||
* or 1 1 (1) 1 0 (~src) 1 0 (~src) 1 1 (1)
|
||||
* xor 1 1 (1) 1 0 (~src) 1 1 (1) 1 0 (~src)
|
||||
*
|
||||
* andInverted noop xor or
|
||||
* src 0 1 0 1 0 1 0 1
|
||||
* dst 0 0 0 0 0 0 0 0 1 0 0 1
|
||||
* 1 1 0 1 1 1 1 1 0 1 1 1
|
||||
*
|
||||
* and 1 0 (~src) 1 1 (1) 1 1 (1) 1 0 (~src)
|
||||
* xor 0 0 (0) 0 0 (0) 0 1 (src) 0 1 (src)
|
||||
*
|
||||
* or 0 1 (src) 0 0 (0) 0 0 (0) 0 1 (src)
|
||||
* xor 0 1 (src) 0 0 (0) 0 1 (src) 0 0 (0)
|
||||
*
|
||||
* nor equiv invert orReverse
|
||||
* src 0 1 0 1 0 1 0 1
|
||||
* dst 0 1 0 0 1 0 0 1 1 0 1 1
|
||||
* 1 0 0 1 0 1 1 0 0 1 0 1
|
||||
*
|
||||
* and 1 0 (~src) 1 1 (1) 1 1 (1) 1 0 (~src)
|
||||
* xor 1 0 (~src) 1 0 (~src) 1 1 (1) 1 1 (1)
|
||||
*
|
||||
* or 0 1 (src) 0 0 (0) 0 0 (0) 0 1 (src)
|
||||
* xor 1 1 (1) 1 0 (~src) 1 1 (1) 1 0 (~src)
|
||||
*
|
||||
* copyInverted orInverted nand set
|
||||
* src 0 1 0 1 0 1 0 1
|
||||
* dst 0 1 0 0 1 0 0 1 1 0 1 1
|
||||
* 1 1 0 1 1 1 1 1 0 1 1 1
|
||||
*
|
||||
* and 0 0 (0) 0 1 (src) 0 1 (src) 0 0 (0)
|
||||
* xor 1 0 (~src) 1 0 (~src) 1 1 (1) 1 1 (1)
|
||||
*
|
||||
* or 1 1 (1) 1 0 (~src) 1 0 (~src) 1 1 (1)
|
||||
* xor 0 1 (src) 0 0 (0) 0 1 (src) 0 0 (0)
|
||||
*/
|
||||
|
||||
int
|
||||
cfbReduceRasterOp (rop, fg, pm, andp, xorp)
|
||||
int rop;
|
||||
CfbBits fg, pm;
|
||||
CfbBits *andp, *xorp;
|
||||
{
|
||||
CfbBits and, xor;
|
||||
int rrop;
|
||||
|
||||
fg = PFILL (fg);
|
||||
pm = PFILL (pm);
|
||||
switch (rop)
|
||||
{
|
||||
case GXclear:
|
||||
and = 0;
|
||||
xor = 0;
|
||||
break;
|
||||
case GXand:
|
||||
and = fg;
|
||||
xor = 0;
|
||||
break;
|
||||
case GXandReverse:
|
||||
and = fg;
|
||||
xor = fg;
|
||||
break;
|
||||
case GXcopy:
|
||||
and = 0;
|
||||
xor = fg;
|
||||
break;
|
||||
case GXandInverted:
|
||||
and = ~fg;
|
||||
xor = 0;
|
||||
break;
|
||||
case GXnoop:
|
||||
and = ~0;
|
||||
xor = 0;
|
||||
break;
|
||||
case GXxor:
|
||||
and = ~0;
|
||||
xor = fg;
|
||||
break;
|
||||
case GXor:
|
||||
and = ~fg;
|
||||
xor = fg;
|
||||
break;
|
||||
case GXnor:
|
||||
and = ~fg;
|
||||
xor = ~fg;
|
||||
break;
|
||||
case GXequiv:
|
||||
and = ~0;
|
||||
xor = ~fg;
|
||||
break;
|
||||
case GXinvert:
|
||||
and = ~0;
|
||||
xor = ~0;
|
||||
break;
|
||||
case GXorReverse:
|
||||
and = ~fg;
|
||||
xor = ~0;
|
||||
break;
|
||||
case GXcopyInverted:
|
||||
and = 0;
|
||||
xor = ~fg;
|
||||
break;
|
||||
case GXorInverted:
|
||||
and = fg;
|
||||
xor = ~fg;
|
||||
break;
|
||||
case GXnand:
|
||||
and = fg;
|
||||
xor = ~0;
|
||||
break;
|
||||
case GXset:
|
||||
and = 0;
|
||||
xor = ~0;
|
||||
break;
|
||||
default:
|
||||
and = xor = 0;
|
||||
break;
|
||||
}
|
||||
and |= ~pm;
|
||||
xor &= pm;
|
||||
*andp = and;
|
||||
*xorp = xor;
|
||||
/* check for some special cases to reduce computation */
|
||||
if (and == 0)
|
||||
rrop = GXcopy;
|
||||
/* nothing checks for GXnoop
|
||||
else if (and == ~0 && xor == 0)
|
||||
rrop = GXnoop;
|
||||
*/
|
||||
else if (and == ~0)
|
||||
rrop = GXxor;
|
||||
else if (xor == 0)
|
||||
rrop = GXand;
|
||||
else if ( (and ^ xor) == ~0) /* fix XBUG 6541 */
|
||||
rrop = GXor;
|
||||
else
|
||||
rrop = GXset; /* rop not reduced */
|
||||
return rrop;
|
||||
}
|
343
cfb/cfbrrop.h
343
cfb/cfbrrop.h
|
@ -1,343 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#ifndef GXcopy
|
||||
#include <X11/X.h>
|
||||
#endif
|
||||
|
||||
#define RROP_FETCH_GC(gc) \
|
||||
RROP_FETCH_GCPRIV((cfbPrivGCPtr)dixLookupPrivate(&(gc)->devPrivates, \
|
||||
cfbGCPrivateKey))
|
||||
|
||||
#ifndef RROP
|
||||
#define RROP GXset
|
||||
#endif
|
||||
|
||||
#if RROP == GXcopy
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_xor; \
|
||||
CfbBits piQxelXor[3], spiQxelXor[8];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_xor = (devPriv)->xor; \
|
||||
spiQxelXor[0] = rrop_xor & 0xFFFFFF; \
|
||||
spiQxelXor[2] = rrop_xor << 24; \
|
||||
spiQxelXor[3] = (rrop_xor & 0xFFFF00)>> 8; \
|
||||
spiQxelXor[4] = rrop_xor << 16; \
|
||||
spiQxelXor[5] = (rrop_xor & 0xFF0000)>> 16; \
|
||||
spiQxelXor[6] = rrop_xor << 8; \
|
||||
spiQxelXor[1] = spiQxelXor[7] = 0; \
|
||||
piQxelXor[0] = (rrop_xor & 0xFFFFFF)|(rrop_xor << 24); \
|
||||
piQxelXor[1] = (rrop_xor << 16)|((rrop_xor & 0xFFFF00)>> 8); \
|
||||
piQxelXor[2] = (rrop_xor << 8)|((rrop_xor & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
register int idx = ((index) & 3)<< 1; \
|
||||
*(dst) = (*(dst) & cfbrmask[idx])|spiQxelXor[idx]; \
|
||||
if (idx == 2 || idx == 4){ \
|
||||
idx++; \
|
||||
*((dst)+1) = (*((dst)+1) & cfbrmask[idx])|spiQxelXor[idx]; \
|
||||
} \
|
||||
}
|
||||
#define RROP_SOLID(dst, idx) \
|
||||
(*(dst) = piQxelXor[(idx)])
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) = (*(dst) & ~(mask))|(piQxelXor[(idx)] & (mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelXor; (void)spiQxelXor;
|
||||
#else
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_xor = (devPriv)->xor;
|
||||
#define RROP_DECLARE register CfbBits rrop_xor;
|
||||
#define RROP_SOLID(dst) (*(dst) = (rrop_xor))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) = (*(dst) & ~(mask)) | ((rrop_xor) & (mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,Copy)
|
||||
#endif /* GXcopy */
|
||||
|
||||
#if RROP == GXxor
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_xor; \
|
||||
CfbBits piQxelXor[3], spiQxelXor[8];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_xor = (devPriv)->xor; \
|
||||
spiQxelXor[0] = rrop_xor & 0xFFFFFF; \
|
||||
spiQxelXor[2] = rrop_xor << 24; \
|
||||
spiQxelXor[3] = (rrop_xor & 0xFFFF00)>> 8; \
|
||||
spiQxelXor[4] = rrop_xor << 16; \
|
||||
spiQxelXor[5] = (rrop_xor & 0xFF0000)>> 16; \
|
||||
spiQxelXor[6] = rrop_xor << 8; \
|
||||
spiQxelXor[1] = spiQxelXor[7] = 0; \
|
||||
piQxelXor[0] = (rrop_xor & 0xFFFFFF)|(rrop_xor << 24); \
|
||||
piQxelXor[1] = (rrop_xor << 16)|((rrop_xor & 0xFFFF00)>> 8); \
|
||||
piQxelXor[2] = (rrop_xor << 8)|((rrop_xor & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
register int idx = ((index) & 3)<< 1; \
|
||||
*(dst) ^= spiQxelXor[idx]; \
|
||||
if (idx == 2 || idx == 4) \
|
||||
*((dst)+1) ^= spiQxelXor[idx+1]; \
|
||||
}
|
||||
#define RROP_SOLID(dst,idx) \
|
||||
(*(dst) ^= piQxelXor[(idx)])
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) ^= (piQxelXor[(idx)] & (mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelXor; (void)spiQxelXor;
|
||||
#else
|
||||
#define RROP_DECLARE register CfbBits rrop_xor;
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_xor = (devPriv)->xor;
|
||||
#define RROP_SOLID(dst) (*(dst) ^= (rrop_xor))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) ^= ((rrop_xor) & (mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,Xor)
|
||||
#endif /* GXxor */
|
||||
|
||||
#if RROP == GXand
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_and; \
|
||||
CfbBits piQxelAnd[3], spiQxelAnd[6];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_and = (devPriv)->and; \
|
||||
spiQxelAnd[0] = (rrop_and & 0xFFFFFF) | 0xFF000000; \
|
||||
spiQxelAnd[2] = (rrop_and << 24) | 0xFFFFFF; \
|
||||
spiQxelAnd[3] = ((rrop_and & 0xFFFF00)>> 8) | 0xFFFF0000; \
|
||||
spiQxelAnd[4] = (rrop_and << 16) | 0xFFFF; \
|
||||
spiQxelAnd[5] = ((rrop_and & 0xFF0000)>> 16) | 0xFFFFFF00; \
|
||||
spiQxelAnd[1] = (rrop_and << 8) | 0xFF; \
|
||||
piQxelAnd[0] = (rrop_and & 0xFFFFFF)|(rrop_and << 24); \
|
||||
piQxelAnd[1] = (rrop_and << 16)|((rrop_and & 0xFFFF00)>> 8); \
|
||||
piQxelAnd[2] = (rrop_and << 8)|((rrop_and & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
switch((index) & 3){ \
|
||||
case 0: \
|
||||
*(dst) &= spiQxelAnd[0]; \
|
||||
break; \
|
||||
case 3: \
|
||||
*(dst) &= spiQxelAnd[1]; \
|
||||
break; \
|
||||
case 1: \
|
||||
*(dst) &= spiQxelAnd[2]; \
|
||||
*((dst)+1) &= spiQxelAnd[3]; \
|
||||
break; \
|
||||
case 2: \
|
||||
*(dst) &= spiQxelAnd[4]; \
|
||||
*((dst)+1) &= spiQxelAnd[5]; \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
#define RROP_SOLID(dst,idx) \
|
||||
(*(dst) &= piQxelAnd[(idx)])
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) &= (piQxelAnd[(idx)] | ~(mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelAnd; (void)spiQxelAnd;
|
||||
#else
|
||||
#define RROP_DECLARE register CfbBits rrop_and;
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_and = (devPriv)->and;
|
||||
#define RROP_SOLID(dst) (*(dst) &= (rrop_and))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) &= ((rrop_and) | ~(mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,And)
|
||||
#endif /* GXand */
|
||||
|
||||
#if RROP == GXor
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_or; \
|
||||
CfbBits piQxelOr[3], spiQxelOr[6];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_or = (devPriv)->xor; \
|
||||
spiQxelOr[0] = rrop_or & 0xFFFFFF; \
|
||||
spiQxelOr[1] = rrop_or << 24; \
|
||||
spiQxelOr[2] = rrop_or << 16; \
|
||||
spiQxelOr[3] = rrop_or << 8; \
|
||||
spiQxelOr[4] = (rrop_or & 0xFFFF00)>> 8; \
|
||||
spiQxelOr[5] = (rrop_or & 0xFF0000)>> 16; \
|
||||
piQxelOr[0] = (rrop_or & 0xFFFFFF)|(rrop_or << 24); \
|
||||
piQxelOr[1] = (rrop_or << 16)|((rrop_or & 0xFFFF00)>> 8); \
|
||||
piQxelOr[2] = (rrop_or << 8)|((rrop_or & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
switch((index) & 3){ \
|
||||
case 0: \
|
||||
*(dst) |= spiQxelOr[0]; \
|
||||
break; \
|
||||
case 3: \
|
||||
*(dst) |= spiQxelOr[3]; \
|
||||
break; \
|
||||
case 1: \
|
||||
*(dst) |= spiQxelOr[1]; \
|
||||
*((dst)+1) |= spiQxelOr[4]; \
|
||||
break; \
|
||||
case 2: \
|
||||
*(dst) |= spiQxelOr[2]; \
|
||||
*((dst)+1) |= spiQxelOr[5]; \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
#define RROP_SOLID(dst,idx) \
|
||||
(*(dst) |= piQxelOr[(idx)])
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) |= (piQxelOr[(idx)] & (mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelOr; (void)spiQxelOr;
|
||||
#else
|
||||
#define RROP_DECLARE register CfbBits rrop_or;
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_or = (devPriv)->xor;
|
||||
#define RROP_SOLID(dst) (*(dst) |= (rrop_or))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) |= ((rrop_or) & (mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,Or)
|
||||
#endif /* GXor */
|
||||
|
||||
#if RROP == GXnoop
|
||||
#define RROP_DECLARE
|
||||
#define RROP_FETCH_GCPRIV(devPriv)
|
||||
#define RROP_SOLID(dst)
|
||||
#define RROP_SOLID_MASK(dst,mask)
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,Noop)
|
||||
#define RROP_UNDECLARE
|
||||
#endif /* GXnoop */
|
||||
|
||||
#if RROP == GXset
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_and, rrop_xor; \
|
||||
CfbBits piQxelAnd[3], piQxelXor[3], spiQxelAnd[6], spiQxelXor[6];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_and = (devPriv)->and; \
|
||||
rrop_xor = (devPriv)->xor; \
|
||||
spiQxelXor[0] = rrop_xor & 0xFFFFFF; \
|
||||
spiQxelXor[1] = rrop_xor << 24; \
|
||||
spiQxelXor[2] = rrop_xor << 16; \
|
||||
spiQxelXor[3] = rrop_xor << 8; \
|
||||
spiQxelXor[4] = (rrop_xor & 0xFFFF00)>> 8; \
|
||||
spiQxelXor[5] = (rrop_xor & 0xFF0000)>> 16; \
|
||||
spiQxelAnd[0] = (rrop_and & 0xFFFFFF) | 0xFF000000; \
|
||||
spiQxelAnd[1] = (rrop_and << 24) | 0xFFFFFF; \
|
||||
spiQxelAnd[2] = (rrop_and << 16) | 0xFFFF; \
|
||||
spiQxelAnd[3] = (rrop_and << 8) | 0xFF; \
|
||||
spiQxelAnd[4] = ((rrop_and & 0xFFFF00)>> 8) | 0xFFFF0000; \
|
||||
spiQxelAnd[5] = ((rrop_and & 0xFF0000)>> 16) | 0xFFFFFF00; \
|
||||
piQxelAnd[0] = (rrop_and & 0xFFFFFF)|(rrop_and << 24); \
|
||||
piQxelAnd[1] = (rrop_and << 16)|((rrop_and & 0xFFFF00)>> 8); \
|
||||
piQxelAnd[2] = (rrop_and << 8)|((rrop_and & 0xFF0000)>> 16); \
|
||||
piQxelXor[0] = (rrop_xor & 0xFFFFFF)|(rrop_xor << 24); \
|
||||
piQxelXor[1] = (rrop_xor << 16)|((rrop_xor & 0xFFFF00)>> 8); \
|
||||
piQxelXor[2] = (rrop_xor << 8)|((rrop_xor & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
switch((index) & 3){ \
|
||||
case 0: \
|
||||
*(dst) = ((*(dst) & (piQxelAnd[0] |0xFF000000))^(piQxelXor[0] & 0xFFFFFF)); \
|
||||
break; \
|
||||
case 3: \
|
||||
*(dst) = ((*(dst) & (piQxelAnd[2]|0xFF))^(piQxelXor[2] & 0xFFFFFF00)); \
|
||||
break; \
|
||||
case 1: \
|
||||
*(dst) = ((*(dst) & (piQxelAnd[0]|0xFFFFFF))^(piQxelXor[0] & 0xFF000000)); \
|
||||
*((dst)+1) = ((*((dst)+1) & (piQxelAnd[1]|0xFFFF0000))^(piQxelXor[1] & 0xFFFF)); \
|
||||
break; \
|
||||
case 2: \
|
||||
*(dst) = ((*(dst) & (piQxelAnd[1]|0xFFFF))^(piQxelXor[1] & 0xFFFF0000)); \
|
||||
*((dst)+1) = ((*((dst)+1) & (piQxelAnd[2]|0xFFFFFF00))^(piQxelXor[2] & 0xFF)); \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
#define RROP_SOLID(dst,idx) \
|
||||
(*(dst) = DoRRop (*(dst), piQxelAnd[(idx)], piQxelXor[(idx)]))
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) = DoMaskRRop (*(dst), piQxelAnd[(idx)], piQxelXor[(idx)], (mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelAnd; (void)piQxelXor; \
|
||||
(void)spiQxelAnd; (void)spiQxelXor;
|
||||
#else
|
||||
#define RROP_DECLARE register CfbBits rrop_and, rrop_xor;
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_and = (devPriv)->and; \
|
||||
rrop_xor = (devPriv)->xor;
|
||||
#define RROP_SOLID(dst) (*(dst) = DoRRop (*(dst), rrop_and, rrop_xor))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) = DoMaskRRop (*(dst), rrop_and, rrop_xor, (mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,General)
|
||||
#endif /* GXset */
|
||||
|
||||
#define RROP_UNROLL_CASE1(p,i) case (i): RROP_SOLID((p) - (i));
|
||||
#define RROP_UNROLL_CASE2(p,i) RROP_UNROLL_CASE1(p,(i)+1) RROP_UNROLL_CASE1(p,i)
|
||||
#define RROP_UNROLL_CASE4(p,i) RROP_UNROLL_CASE2(p,(i)+2) RROP_UNROLL_CASE2(p,i)
|
||||
#define RROP_UNROLL_CASE8(p,i) RROP_UNROLL_CASE4(p,(i)+4) RROP_UNROLL_CASE4(p,i)
|
||||
#define RROP_UNROLL_CASE16(p,i) RROP_UNROLL_CASE8(p,(i)+8) RROP_UNROLL_CASE8(p,i)
|
||||
#define RROP_UNROLL_CASE32(p,i) RROP_UNROLL_CASE16(p,(i)+16) RROP_UNROLL_CASE16(p,i)
|
||||
#define RROP_UNROLL_CASE3(p) RROP_UNROLL_CASE2(p,2) RROP_UNROLL_CASE1(p,1)
|
||||
#define RROP_UNROLL_CASE7(p) RROP_UNROLL_CASE4(p,4) RROP_UNROLL_CASE3(p)
|
||||
#define RROP_UNROLL_CASE15(p) RROP_UNROLL_CASE8(p,8) RROP_UNROLL_CASE7(p)
|
||||
#define RROP_UNROLL_CASE31(p) RROP_UNROLL_CASE16(p,16) RROP_UNROLL_CASE15(p)
|
||||
#ifdef LONG64
|
||||
#define RROP_UNROLL_CASE63(p) RROP_UNROLL_CASE32(p,32) RROP_UNROLL_CASE31(p)
|
||||
#endif /* LONG64 */
|
||||
|
||||
#define RROP_UNROLL_LOOP1(p,i) RROP_SOLID((p) + (i));
|
||||
#define RROP_UNROLL_LOOP2(p,i) RROP_UNROLL_LOOP1(p,(i)) RROP_UNROLL_LOOP1(p,(i)+1)
|
||||
#define RROP_UNROLL_LOOP4(p,i) RROP_UNROLL_LOOP2(p,(i)) RROP_UNROLL_LOOP2(p,(i)+2)
|
||||
#define RROP_UNROLL_LOOP8(p,i) RROP_UNROLL_LOOP4(p,(i)) RROP_UNROLL_LOOP4(p,(i)+4)
|
||||
#define RROP_UNROLL_LOOP16(p,i) RROP_UNROLL_LOOP8(p,(i)) RROP_UNROLL_LOOP8(p,(i)+8)
|
||||
#define RROP_UNROLL_LOOP32(p,i) RROP_UNROLL_LOOP16(p,(i)) RROP_UNROLL_LOOP16(p,(i)+16)
|
||||
#ifdef LONG64
|
||||
#define RROP_UNROLL_LOOP64(p,i) RROP_UNROLL_LOOP32(p,(i)) RROP_UNROLL_LOOP32(p,(i)+32)
|
||||
#endif /* LONG64 */
|
||||
|
||||
#if defined (FAST_CONSTANT_OFFSET_MODE) && defined (SHARED_IDCACHE) && (RROP == GXcopy)
|
||||
|
||||
#ifdef LONG64
|
||||
#define RROP_UNROLL_SHIFT 6
|
||||
#define RROP_UNROLL_CASE(p) RROP_UNROLL_CASE63(p)
|
||||
#define RROP_UNROLL_LOOP(p) RROP_UNROLL_LOOP64(p,-64)
|
||||
#else /* not LONG64 */
|
||||
#define RROP_UNROLL_SHIFT 5
|
||||
#define RROP_UNROLL_CASE(p) RROP_UNROLL_CASE31(p)
|
||||
#define RROP_UNROLL_LOOP(p) RROP_UNROLL_LOOP32(p,-32)
|
||||
#endif /* LONG64 */
|
||||
#define RROP_UNROLL (1<<RROP_UNROLL_SHIFT)
|
||||
#define RROP_UNROLL_MASK (RROP_UNROLL-1)
|
||||
|
||||
#define RROP_SPAN(pdst,nmiddle) {\
|
||||
int part = (nmiddle) & RROP_UNROLL_MASK; \
|
||||
(nmiddle) >>= RROP_UNROLL_SHIFT; \
|
||||
(pdst) += part * (sizeof (CfbBits) / sizeof (*pdst)); \
|
||||
switch (part) {\
|
||||
RROP_UNROLL_CASE((CfbBits *) (pdst)) \
|
||||
} \
|
||||
while (--(nmiddle) >= 0) { \
|
||||
(pdst) += RROP_UNROLL * (sizeof (CfbBits) / sizeof (*pdst)); \
|
||||
RROP_UNROLL_LOOP((CfbBits *) (pdst)) \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define RROP_SPAN(pdst,nmiddle) \
|
||||
while (--(nmiddle) >= 0) { \
|
||||
RROP_SOLID((CfbBits *) (pdst)); \
|
||||
(pdst) += sizeof (CfbBits) / sizeof (*pdst); \
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define RROP_NAME_CAT(prefix,suffix) prefix##suffix
|
||||
#else
|
||||
#define RROP_NAME_CAT(prefix,suffix) prefix/**/suffix
|
||||
#endif
|
223
cfb/cfbscrinit.c
223
cfb/cfbscrinit.c
|
@ -1,223 +0,0 @@
|
|||
/************************************************************
|
||||
Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose and without
|
||||
fee is hereby granted, provided that the above copyright no-
|
||||
tice appear in all copies and that both that copyright no-
|
||||
tice and this permission notice appear in supporting docu-
|
||||
mentation, and that the names of Sun or The Open Group
|
||||
not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific prior
|
||||
written permission. Sun and The Open Group make no
|
||||
representations about the suitability of this software for
|
||||
any purpose. It is provided "as is" without any express or
|
||||
implied warranty.
|
||||
|
||||
SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
|
||||
NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
|
||||
ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
||||
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
||||
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
********************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "resource.h"
|
||||
#include "colormap.h"
|
||||
#include "colormapst.h"
|
||||
#include "cfb.h"
|
||||
#include "mi.h"
|
||||
#include "mistruct.h"
|
||||
#include "dix.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mibstore.h"
|
||||
|
||||
Bool
|
||||
cfbCloseScreen (index, pScreen)
|
||||
int index;
|
||||
ScreenPtr pScreen;
|
||||
{
|
||||
int d;
|
||||
DepthPtr depths = pScreen->allowedDepths;
|
||||
|
||||
for (d = 0; d < pScreen->numDepths; d++)
|
||||
xfree (depths[d].vids);
|
||||
xfree (depths);
|
||||
xfree (pScreen->visuals);
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
xfree (dixLookupPrivate(&pScreen->devPrivates, cfbScreenPrivateKey));
|
||||
#else
|
||||
xfree (pScreen->devPrivate);
|
||||
#endif
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void DestroyColormapNoop(
|
||||
ColormapPtr pColormap)
|
||||
{
|
||||
/* NOOP */
|
||||
}
|
||||
|
||||
static void StoreColorsNoop(
|
||||
ColormapPtr pColormap,
|
||||
int ndef,
|
||||
xColorItem * pdef)
|
||||
{
|
||||
/* NOOP */
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
||||
register ScreenPtr pScreen;
|
||||
pointer pbits; /* pointer to screen bitmap */
|
||||
int xsize, ysize; /* in pixels */
|
||||
int dpix, dpiy; /* dots per inch */
|
||||
int width; /* pixel width of frame buffer */
|
||||
{
|
||||
if (!cfbAllocatePrivates(pScreen, NULL))
|
||||
return FALSE;
|
||||
pScreen->defColormap = FakeClientID(0);
|
||||
/* let CreateDefColormap do whatever it wants for pixels */
|
||||
pScreen->blackPixel = pScreen->whitePixel = (Pixel) 0;
|
||||
pScreen->QueryBestSize = mfbQueryBestSizeWeak();
|
||||
/* SaveScreen */
|
||||
pScreen->GetImage = cfbGetImage;
|
||||
pScreen->GetSpans = cfbGetSpans;
|
||||
pScreen->CreateWindow = cfbCreateWindow;
|
||||
pScreen->DestroyWindow = cfbDestroyWindow;
|
||||
pScreen->PositionWindow = cfbPositionWindow;
|
||||
pScreen->ChangeWindowAttributes = cfbChangeWindowAttributes;
|
||||
pScreen->RealizeWindow = cfbMapWindow;
|
||||
pScreen->UnrealizeWindow = cfbUnmapWindow;
|
||||
pScreen->CopyWindow = cfbCopyWindow;
|
||||
pScreen->CreatePixmap = cfbCreatePixmap;
|
||||
pScreen->DestroyPixmap = cfbDestroyPixmap;
|
||||
pScreen->RealizeFont = mfbRealizeFontWeak();
|
||||
pScreen->UnrealizeFont = mfbUnrealizeFontWeak();
|
||||
pScreen->CreateGC = cfbCreateGC;
|
||||
pScreen->CreateColormap = cfbInitializeColormap;
|
||||
pScreen->DestroyColormap = DestroyColormapNoop;
|
||||
pScreen->InstallColormap = cfbInstallColormap;
|
||||
pScreen->UninstallColormap = cfbUninstallColormap;
|
||||
pScreen->ListInstalledColormaps = cfbListInstalledColormaps;
|
||||
pScreen->StoreColors = StoreColorsNoop;
|
||||
pScreen->ResolveColor = cfbResolveColor;
|
||||
pScreen->BitmapToRegion = mfbPixmapToRegionWeak();
|
||||
|
||||
mfbRegisterCopyPlaneProc (pScreen, cfbCopyPlane);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
Bool
|
||||
cfbCreateScreenResources(pScreen)
|
||||
ScreenPtr pScreen;
|
||||
{
|
||||
Bool retval;
|
||||
|
||||
pointer oldDevPrivate = pScreen->devPrivate;
|
||||
pScreen->devPrivate = dixLookupPrivate(&pScreen->devPrivates,
|
||||
cfbScreenPrivateKey);
|
||||
retval = miCreateScreenResources(pScreen);
|
||||
dixSetPrivate(&pScreen->devPrivates, cfbScreenPrivateKey,
|
||||
pScreen->devPrivate);
|
||||
pScreen->devPrivate = oldDevPrivate;
|
||||
return retval;
|
||||
}
|
||||
#endif
|
||||
|
||||
Bool
|
||||
cfbFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
||||
register ScreenPtr pScreen;
|
||||
pointer pbits; /* pointer to screen bitmap */
|
||||
int xsize, ysize; /* in pixels */
|
||||
int dpix, dpiy; /* dots per inch */
|
||||
int width; /* pixel width of frame buffer */
|
||||
{
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
pointer oldDevPrivate;
|
||||
#endif
|
||||
VisualPtr visuals;
|
||||
DepthPtr depths;
|
||||
int nvisuals;
|
||||
int ndepths;
|
||||
int rootdepth;
|
||||
VisualID defaultVisual;
|
||||
|
||||
rootdepth = 0;
|
||||
if (!cfbInitVisuals (&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
|
||||
&defaultVisual,((unsigned long)1<<(PSZ-1)), 8))
|
||||
return FALSE;
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
oldDevPrivate = pScreen->devPrivate;
|
||||
#endif
|
||||
if (! miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
|
||||
rootdepth, ndepths, depths,
|
||||
defaultVisual, nvisuals, visuals))
|
||||
return FALSE;
|
||||
/* overwrite miCloseScreen with our own */
|
||||
pScreen->CloseScreen = cfbCloseScreen;
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
pScreen->CreateScreenResources = cfbCreateScreenResources;
|
||||
dixSetPrivate(&pScreen->devPrivates, cfbScreenPrivateKey,
|
||||
pScreen->devPrivate);
|
||||
pScreen->devPrivate = oldDevPrivate;
|
||||
#endif
|
||||
pScreen->GetScreenPixmap = cfbGetScreenPixmap;
|
||||
pScreen->SetScreenPixmap = cfbSetScreenPixmap;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* dts * (inch/dot) * (25.4 mm / inch) = mm */
|
||||
Bool
|
||||
cfbScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
||||
register ScreenPtr pScreen;
|
||||
pointer pbits; /* pointer to screen bitmap */
|
||||
int xsize, ysize; /* in pixels */
|
||||
int dpix, dpiy; /* dots per inch */
|
||||
int width; /* pixel width of frame buffer */
|
||||
{
|
||||
if (!cfbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width))
|
||||
return FALSE;
|
||||
return cfbFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width);
|
||||
}
|
||||
|
||||
PixmapPtr
|
||||
cfbGetScreenPixmap(pScreen)
|
||||
ScreenPtr pScreen;
|
||||
{
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
return (PixmapPtr)dixLookupPrivate(&pScreen->devPrivates,
|
||||
cfbScreenPrivateKey);
|
||||
#else
|
||||
return (PixmapPtr)pScreen->devPrivate;
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
cfbSetScreenPixmap(pPix)
|
||||
PixmapPtr pPix;
|
||||
{
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
if (pPix)
|
||||
dixSetPrivate(&pPix->drawable.pScreen->devPrivates,
|
||||
cfbScreenPrivateKey, pPix);
|
||||
#else
|
||||
if (pPix)
|
||||
pPix->drawable.pScreen->devPrivate = (pointer)pPix;
|
||||
#endif
|
||||
}
|
316
cfb/cfbsetsp.c
316
cfb/cfbsetsp.c
|
@ -1,316 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
|
||||
#include "misc.h"
|
||||
#include "regionstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include <mergerop.h>
|
||||
|
||||
/* cfbSetScanline -- copies the bits from psrc to the drawable starting at
|
||||
* (xStart, y) and continuing to (xEnd, y). xOrigin tells us where psrc
|
||||
* starts on the scanline. (I.e., if this scanline passes through multiple
|
||||
* boxes, we may not want to start grabbing bits at psrc but at some offset
|
||||
* further on.)
|
||||
*/
|
||||
void
|
||||
cfbSetScanline(y, xOrigin, xStart, xEnd, psrc, alu, pdstBase, widthDst, planemask)
|
||||
int y;
|
||||
int xOrigin; /* where this scanline starts */
|
||||
int xStart; /* first bit to use from scanline */
|
||||
int xEnd; /* last bit to use from scanline + 1 */
|
||||
register unsigned int *psrc;
|
||||
register int alu; /* raster op */
|
||||
int *pdstBase; /* start of the drawable */
|
||||
int widthDst; /* width of drawable in words */
|
||||
unsigned long planemask;
|
||||
{
|
||||
int w; /* width of scanline in bits */
|
||||
register int *pdst; /* where to put the bits */
|
||||
register int tmpSrc; /* scratch buffer to collect bits in */
|
||||
int offSrc;
|
||||
int nl;
|
||||
#if PSZ == 24
|
||||
register char *psrcb, *pdstb;
|
||||
register int xIndex;
|
||||
#else
|
||||
int dstBit; /* offset in bits from beginning of
|
||||
* word */
|
||||
register int nstart; /* number of bits from first partial */
|
||||
#if PSZ != 32 || PPW != 1
|
||||
register int nend; /* " " last partial word */
|
||||
#endif
|
||||
int startmask, endmask, nlMiddle;
|
||||
#endif
|
||||
DeclareMergeRop()
|
||||
|
||||
InitializeMergeRop(alu,planemask);
|
||||
#if PSZ == 24
|
||||
pdst = pdstBase + (y * widthDst);
|
||||
xIndex = xStart;
|
||||
pdstb = (char *)pdst + (xStart * 3);
|
||||
offSrc = xStart - xOrigin;
|
||||
psrcb = (char *)psrc + (offSrc * 3);
|
||||
#else
|
||||
pdst = pdstBase + (y * widthDst) + (xStart >> PWSH);
|
||||
psrc += (xStart - xOrigin) >> PWSH;
|
||||
offSrc = (xStart - xOrigin) & PIM;
|
||||
#endif
|
||||
w = xEnd - xStart;
|
||||
|
||||
#if PSZ == 24
|
||||
nl = w;
|
||||
while (nl--){
|
||||
psrc = (unsigned int *)((unsigned long)psrcb & ~0x03);
|
||||
getbits24(psrc, tmpSrc, offSrc);
|
||||
pdst = (int *)((unsigned long)pdstb & ~0x03);
|
||||
DoMergeRop24(tmpSrc, pdst, xIndex);
|
||||
offSrc++;
|
||||
psrcb += 3;
|
||||
xIndex++;
|
||||
pdstb += 3;
|
||||
}
|
||||
#else /* PSZ == 24 */
|
||||
dstBit = xStart & PIM;
|
||||
if (dstBit + w <= PPW)
|
||||
{
|
||||
maskpartialbits(dstBit, w, startmask);
|
||||
endmask = 0;
|
||||
nlMiddle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(xStart, w, startmask, endmask, nlMiddle);
|
||||
}
|
||||
if (startmask)
|
||||
nstart = PPW - dstBit;
|
||||
else
|
||||
nstart = 0;
|
||||
#if PSZ != 32 || PPW != 1
|
||||
if (endmask)
|
||||
nend = xEnd & PIM;
|
||||
else
|
||||
nend = 0;
|
||||
#endif
|
||||
if (startmask)
|
||||
{
|
||||
getbits(psrc, offSrc, nstart, tmpSrc);
|
||||
putbitsmropshort(tmpSrc, dstBit, nstart, pdst);
|
||||
pdst++;
|
||||
offSrc += nstart;
|
||||
if (offSrc > PLST)
|
||||
{
|
||||
psrc++;
|
||||
offSrc -= PPW;
|
||||
}
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
getbits(psrc, offSrc, PPW, tmpSrc);
|
||||
*pdst = DoMergeRop(tmpSrc, *pdst);
|
||||
pdst++;
|
||||
psrc++;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
getbits(psrc, offSrc, nend, tmpSrc);
|
||||
putbitsmropshort(tmpSrc, 0, nend, pdst);
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* SetSpans -- for each span copy pwidth[i] bits from psrc to pDrawable at
|
||||
* ppt[i] using the raster op from the GC. If fSorted is TRUE, the scanlines
|
||||
* are in increasing Y order.
|
||||
* Source bit lines are server scanline padded so that they always begin
|
||||
* on a word boundary.
|
||||
*/
|
||||
void
|
||||
cfbSetSpans(pDrawable, pGC, pcharsrc, ppt, pwidth, nspans, fSorted)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
char *pcharsrc;
|
||||
register DDXPointPtr ppt;
|
||||
int *pwidth;
|
||||
int nspans;
|
||||
int fSorted;
|
||||
{
|
||||
unsigned int *psrc = (unsigned int *)pcharsrc;
|
||||
CfbBits *pdstBase; /* start of dst bitmap */
|
||||
int widthDst; /* width of bitmap in words */
|
||||
register BoxPtr pbox, pboxLast, pboxTest;
|
||||
register DDXPointPtr pptLast;
|
||||
int alu;
|
||||
RegionPtr prgnDst;
|
||||
int xStart, xEnd;
|
||||
int yMax;
|
||||
|
||||
alu = pGC->alu;
|
||||
prgnDst = cfbGetCompositeClip(pGC);
|
||||
pptLast = ppt + nspans;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
|
||||
|
||||
yMax = (int) pDrawable->y + (int) pDrawable->height;
|
||||
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
pboxLast = pbox + REGION_NUM_RECTS(prgnDst);
|
||||
|
||||
if(fSorted)
|
||||
{
|
||||
/* scan lines sorted in ascending order. Because they are sorted, we
|
||||
* don't have to check each scanline against each clip box. We can be
|
||||
* sure that this scanline only has to be clipped to boxes at or after the
|
||||
* beginning of this y-band
|
||||
*/
|
||||
pboxTest = pbox;
|
||||
while(ppt < pptLast)
|
||||
{
|
||||
pbox = pboxTest;
|
||||
if(ppt->y >= yMax)
|
||||
break;
|
||||
while(pbox < pboxLast)
|
||||
{
|
||||
if(pbox->y1 > ppt->y)
|
||||
{
|
||||
/* scanline is before clip box */
|
||||
break;
|
||||
}
|
||||
else if(pbox->y2 <= ppt->y)
|
||||
{
|
||||
/* clip box is before scanline */
|
||||
pboxTest = ++pbox;
|
||||
continue;
|
||||
}
|
||||
else if(pbox->x1 > ppt->x + *pwidth)
|
||||
{
|
||||
/* clip box is to right of scanline */
|
||||
break;
|
||||
}
|
||||
else if(pbox->x2 <= ppt->x)
|
||||
{
|
||||
/* scanline is to right of clip box */
|
||||
pbox++;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* at least some of the scanline is in the current clip box */
|
||||
xStart = max(pbox->x1, ppt->x);
|
||||
xEnd = min(ppt->x + *pwidth, pbox->x2);
|
||||
cfbSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu,
|
||||
(int *)pdstBase, widthDst, pGC->planemask);
|
||||
if(ppt->x + *pwidth <= pbox->x2)
|
||||
{
|
||||
/* End of the line, as it were */
|
||||
break;
|
||||
}
|
||||
else
|
||||
pbox++;
|
||||
}
|
||||
/* We've tried this line against every box; it must be outside them
|
||||
* all. move on to the next point */
|
||||
ppt++;
|
||||
psrc += PixmapWidthInPadUnits(*pwidth, pDrawable->depth);
|
||||
pwidth++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* scan lines not sorted. We must clip each line against all the boxes */
|
||||
while(ppt < pptLast)
|
||||
{
|
||||
if(ppt->y >= 0 && ppt->y < yMax)
|
||||
{
|
||||
|
||||
for(pbox = REGION_RECTS(prgnDst); pbox< pboxLast; pbox++)
|
||||
{
|
||||
if(pbox->y1 > ppt->y)
|
||||
{
|
||||
/* rest of clip region is above this scanline,
|
||||
* skip it */
|
||||
break;
|
||||
}
|
||||
if(pbox->y2 <= ppt->y)
|
||||
{
|
||||
/* clip box is below scanline */
|
||||
pbox++;
|
||||
break;
|
||||
}
|
||||
if(pbox->x1 <= ppt->x + *pwidth &&
|
||||
pbox->x2 > ppt->x)
|
||||
{
|
||||
xStart = max(pbox->x1, ppt->x);
|
||||
xEnd = min(pbox->x2, ppt->x + *pwidth);
|
||||
cfbSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu,
|
||||
(int *)pdstBase, widthDst, pGC->planemask);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
psrc += PixmapWidthInPadUnits(*pwidth, pDrawable->depth);
|
||||
ppt++;
|
||||
pwidth++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
1365
cfb/cfbsolid.c
1365
cfb/cfbsolid.c
File diff suppressed because it is too large
Load Diff
589
cfb/cfbteblt8.c
589
cfb/cfbteblt8.c
|
@ -1,589 +0,0 @@
|
|||
/*
|
||||
* TEGblt - ImageText expanded glyph fonts only. For
|
||||
* 8 bit displays, in Copy mode with no clipping.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
/*
|
||||
* this code supports up to 5 characters at a time. The performance
|
||||
* differences between 4 and 5 is usually small (~7% on PMAX) and
|
||||
* frequently negative (SPARC and Sun3), so this file is compiled
|
||||
* only once for now. If you want to use the other options, you'll
|
||||
* need to hack cfbgc.c as well.
|
||||
*/
|
||||
|
||||
#ifndef NGLYPHS
|
||||
#define NGLYPHS 4
|
||||
#define DO_COMMON
|
||||
#endif
|
||||
|
||||
#ifdef DO_COMMON
|
||||
#define CFBTEGBLT8 cfbTEGlyphBlt8
|
||||
#endif
|
||||
|
||||
/*
|
||||
* On little-endian machines (or where fonts are padded to 32-bit
|
||||
* boundaries) we can use some magic to avoid the expense of getleftbits
|
||||
*/
|
||||
|
||||
#if ((BITMAP_BIT_ORDER == LSBFirst && NGLYPHS >= 4) || GLYPHPADBYTES == 4)
|
||||
|
||||
#if GLYPHPADBYTES == 1
|
||||
typedef unsigned char *glyphPointer;
|
||||
#define USE_LEFTBITS
|
||||
#endif
|
||||
|
||||
#if GLYPHPADBYTES == 2
|
||||
typedef unsigned short *glyphPointer;
|
||||
#define USE_LEFTBITS
|
||||
#endif
|
||||
|
||||
#if GLYPHPADBYTES == 4
|
||||
typedef unsigned int *glyphPointer;
|
||||
#endif
|
||||
|
||||
#define GetBitsL c = BitLeft (*leftChar++, lshift)
|
||||
#define NGetBits1S(r) c = BitRight(*char1++ r, xoff1)
|
||||
#define NGetBits1L(r) GetBitsL | BitRight(*char1++ r, xoff1)
|
||||
#define NGetBits1U(r) c = *char1++ r
|
||||
#define NGetBits2S(r) NGetBits1S(| BitRight(*char2++ r, widthGlyph))
|
||||
#define NGetBits2L(r) NGetBits1L(| BitRight(*char2++ r, widthGlyph))
|
||||
#define NGetBits2U(r) NGetBits1U(| BitRight(*char2++ r, widthGlyph))
|
||||
#define NGetBits3S(r) NGetBits2S(| BitRight(*char3++ r, widthGlyph))
|
||||
#define NGetBits3L(r) NGetBits2L(| BitRight(*char3++ r, widthGlyph))
|
||||
#define NGetBits3U(r) NGetBits2U(| BitRight(*char3++ r, widthGlyph))
|
||||
#define NGetBits4S(r) NGetBits3S(| BitRight(*char4++ r, widthGlyph))
|
||||
#define NGetBits4L(r) NGetBits3L(| BitRight(*char4++ r, widthGlyph))
|
||||
#define NGetBits4U(r) NGetBits3U(| BitRight(*char4++ r, widthGlyph))
|
||||
#define NGetBits5S(r) NGetBits4S(| BitRight(*char5++ r, widthGlyph))
|
||||
#define NGetBits5L(r) NGetBits4L(| BitRight(*char5++ r, widthGlyph))
|
||||
#define NGetBits5U(r) NGetBits4U(| BitRight(*char5++ r, widthGlyph))
|
||||
#define GetBits1S c = BitRight(*char1++, xoff1)
|
||||
#define GetBits1L GetBitsL | BitRight(*char1++, xoff1)
|
||||
#define GetBits1U c = *char1++
|
||||
#define GetBits2S NGetBits1S(| BitRight(*char2++, widthGlyph))
|
||||
#define GetBits2L NGetBits1L(| BitRight(*char2++, widthGlyph))
|
||||
#define GetBits2U NGetBits1U(| BitRight(*char2++, widthGlyph))
|
||||
#define GetBits3S NGetBits2S(| BitRight(*char3++, widthGlyph))
|
||||
#define GetBits3L NGetBits2L(| BitRight(*char3++, widthGlyph))
|
||||
#define GetBits3U NGetBits2U(| BitRight(*char3++, widthGlyph))
|
||||
#define GetBits4S NGetBits3S(| BitRight(*char4++, widthGlyph))
|
||||
#define GetBits4L NGetBits3L(| BitRight(*char4++, widthGlyph))
|
||||
#define GetBits4U NGetBits3U(| BitRight(*char4++, widthGlyph))
|
||||
#define GetBits5S NGetBits4S(| BitRight(*char5++, widthGlyph))
|
||||
#define GetBits5L NGetBits4L(| BitRight(*char5++, widthGlyph))
|
||||
#define GetBits5U NGetBits4U(| BitRight(*char5++, widthGlyph))
|
||||
|
||||
#else
|
||||
|
||||
typedef unsigned int *glyphPointer;
|
||||
|
||||
#define USE_LEFTBITS
|
||||
#define ALL_LEFTBITS
|
||||
|
||||
#define GetBitsL WGetBitsL
|
||||
#define GetBits1S WGetBits1S
|
||||
#define GetBits1L WGetBits1L
|
||||
#define GetBits1U WGetBits1U
|
||||
|
||||
#define GetBits2S GetBits1S Get1Bits (char2, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff2);
|
||||
#define GetBits2L GetBits1L Get1Bits (char2, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff2);
|
||||
#define GetBits2U GetBits1U Get1Bits (char2, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff2);
|
||||
|
||||
#define GetBits3S GetBits2S Get1Bits (char3, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff3);
|
||||
#define GetBits3L GetBits2L Get1Bits (char3, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff3);
|
||||
#define GetBits3U GetBits2U Get1Bits (char3, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff3);
|
||||
|
||||
#define GetBits4S GetBits3S Get1Bits (char4, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff4);
|
||||
#define GetBits4L GetBits3L Get1Bits (char4, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff4);
|
||||
#define GetBits4U GetBits3U Get1Bits (char4, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff4);
|
||||
|
||||
#define GetBits5S GetBits4S Get1Bits (char5, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff5);
|
||||
#define GetBits5L GetBits4L Get1Bits (char5, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff5);
|
||||
#define GetBits5U GetBits4U Get1Bits (char5, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff5);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef USE_LEFTBITS
|
||||
|
||||
#define IncChar(c) (c = (glyphPointer) (((char *) c) + glyphBytes))
|
||||
|
||||
#define Get1Bits(ch,dst) glyphbits (ch, widthGlyph, glyphMask, dst); \
|
||||
IncChar (ch);
|
||||
|
||||
#define glyphbits(bits,width,mask,dst) getleftbits(bits,width,dst); \
|
||||
dst &= mask;
|
||||
|
||||
#define WGetBitsL Get1Bits(leftChar,c); \
|
||||
c = BitLeft (c, lshift);
|
||||
#define WGetBits1S Get1Bits (char1, c) \
|
||||
c = BitRight (c, xoff1);
|
||||
#define WGetBits1L WGetBitsL Get1Bits (char1, tmpSrc) \
|
||||
c |= BitRight (tmpSrc, xoff1);
|
||||
#define WGetBits1U Get1Bits (char1, c)
|
||||
|
||||
#else
|
||||
#define WGetBitsL GetBitsL
|
||||
#define WGetBits1S GetBits1S
|
||||
#define WGetBits1L GetBits1L
|
||||
#define WGetBits1U GetBits1U
|
||||
#endif
|
||||
|
||||
#if NGLYPHS == 2
|
||||
# define GetBitsNS GetBits2S
|
||||
# define GetBitsNL GetBits2L
|
||||
# define GetBitsNU GetBits2U
|
||||
# define LastChar char2
|
||||
#ifndef CFBTEGBLT8
|
||||
# define CFBTEGBLT8 cfbTEGlyphBlt8x2
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS == 3
|
||||
# define GetBitsNS GetBits3S
|
||||
# define GetBitsNL GetBits3L
|
||||
# define GetBitsNU GetBits3U
|
||||
# define LastChar char3
|
||||
#ifndef CFBTEGBLT8
|
||||
# define CFBTEGBLT8 cfbTEGlyphBlt8x3
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS == 4
|
||||
# define GetBitsNS GetBits4S
|
||||
# define GetBitsNL GetBits4L
|
||||
# define GetBitsNU GetBits4U
|
||||
# define LastChar char4
|
||||
#ifndef CFBTEGBLT8
|
||||
# define CFBTEGBLT8 cfbTEGlyphBlt8x4
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS == 5
|
||||
# define GetBitsNS GetBits5S
|
||||
# define GetBitsNL GetBits5L
|
||||
# define GetBitsNU GetBits5U
|
||||
# define LastChar char5
|
||||
#ifndef CFBTEGBLT8
|
||||
# define CFBTEGBLT8 cfbTEGlyphBlt8x5
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* another ugly giant macro */
|
||||
#define SwitchEm switch (ew) \
|
||||
{ \
|
||||
case 0: \
|
||||
break; \
|
||||
case 1: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 2: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 3: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step StoreBits(2) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 4: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 5: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) Step \
|
||||
StoreBits(4) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 6: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) Step \
|
||||
StoreBits(4) Step StoreBits(5) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 7: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) Step \
|
||||
StoreBits(4) Step StoreBits(5) Step \
|
||||
StoreBits(6) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 8: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) Step \
|
||||
StoreBits(4) Step StoreBits(5) Step \
|
||||
StoreBits(6) Step StoreBits(7) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
}
|
||||
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
#define StorePixels(o,p) dst[o] = p
|
||||
#define Loop dst += widthDst;
|
||||
#else
|
||||
#define StorePixels(o,p) do { *dst = (p); dst++; } while (0)
|
||||
#define Loop dst += widthLeft;
|
||||
#endif
|
||||
|
||||
#define Step NextBitGroup(c);
|
||||
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
#define StoreBits(o) StorePixels(o,GetPixelGroup(c));
|
||||
#define FirstStep Step
|
||||
#else
|
||||
#if PGSZ == 64
|
||||
#define StoreBits(o) StorePixels(o,cfb8Pixels[(c) & PGSZBMSK]);
|
||||
#define FirstStep Step
|
||||
#else /* PGSZ == 32 */
|
||||
#define StoreBits(o) StorePixels(o,*((CfbBits *) (((char *) cfb8Pixels) + (c & 0x3c))));
|
||||
#define FirstStep c = BitLeft (c, 2);
|
||||
#endif /* PGSZ */
|
||||
#endif /* BITMAP_BIT_ORDER */
|
||||
|
||||
|
||||
void
|
||||
CFBTEGBLT8 (pDrawable, pGC, xInit, yInit, nglyph, ppci, pglyphBase)
|
||||
DrawablePtr pDrawable;
|
||||
GC *pGC;
|
||||
int xInit, yInit;
|
||||
unsigned int nglyph;
|
||||
CharInfoPtr *ppci; /* array of character info */
|
||||
pointer pglyphBase; /* start of array of glyphs */
|
||||
{
|
||||
register CfbBits c;
|
||||
register CfbBits *dst;
|
||||
register CfbBits leftMask, rightMask;
|
||||
register int hTmp;
|
||||
register int xoff1;
|
||||
register glyphPointer char1;
|
||||
register glyphPointer char2;
|
||||
#if NGLYPHS >= 3
|
||||
register glyphPointer char3;
|
||||
#endif
|
||||
#if NGLYPHS >= 4
|
||||
register glyphPointer char4;
|
||||
#endif
|
||||
#if NGLYPHS >= 5
|
||||
register glyphPointer char5;
|
||||
#endif
|
||||
#ifdef ALL_LEFTBITS
|
||||
int xoff2, xoff3, xoff4, xoff5;
|
||||
#endif
|
||||
|
||||
FontPtr pfont = pGC->font;
|
||||
CfbBits *dstLine;
|
||||
glyphPointer oldRightChar;
|
||||
CfbBits *pdstBase;
|
||||
glyphPointer leftChar;
|
||||
int widthDst;
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
int widthLeft;
|
||||
#endif
|
||||
int widthGlyph;
|
||||
int h;
|
||||
int ew;
|
||||
int x, y;
|
||||
BoxRec bbox; /* for clipping */
|
||||
int lshift;
|
||||
int widthGlyphs;
|
||||
#ifdef USE_LEFTBITS
|
||||
register CfbBits glyphMask;
|
||||
register CfbBits tmpSrc;
|
||||
register int glyphBytes;
|
||||
#endif
|
||||
|
||||
widthGlyph = FONTMAXBOUNDS(pfont,characterWidth);
|
||||
h = FONTASCENT(pfont) + FONTDESCENT(pfont);
|
||||
if (!h)
|
||||
return;
|
||||
x = xInit + FONTMAXBOUNDS(pfont,leftSideBearing) + pDrawable->x;
|
||||
y = yInit - FONTASCENT(pfont) + pDrawable->y;
|
||||
bbox.x1 = x;
|
||||
bbox.x2 = x + (widthGlyph * nglyph);
|
||||
bbox.y1 = y;
|
||||
bbox.y2 = y + h;
|
||||
|
||||
switch (RECT_IN_REGION(pGC->pScreen, cfbGetCompositeClip(pGC), &bbox))
|
||||
{
|
||||
case rgnPART:
|
||||
cfbImageGlyphBlt8(pDrawable, pGC, xInit, yInit, nglyph, ppci, pglyphBase);
|
||||
case rgnOUT:
|
||||
return;
|
||||
}
|
||||
|
||||
if (!cfb8CheckPixels (pGC->fgPixel, pGC->bgPixel))
|
||||
cfb8SetPixels (pGC->fgPixel, pGC->bgPixel);
|
||||
|
||||
leftChar = 0;
|
||||
|
||||
cfbGetLongWidthAndPointer(pDrawable, widthDst, pdstBase)
|
||||
|
||||
#if NGLYPHS == 2
|
||||
widthGlyphs = widthGlyph << 1;
|
||||
#else
|
||||
#if NGLYPHS == 4
|
||||
widthGlyphs = widthGlyph << 2;
|
||||
#else
|
||||
widthGlyphs = widthGlyph * NGLYPHS;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef USE_LEFTBITS
|
||||
glyphMask = mfbGetendtab(widthGlyph);
|
||||
glyphBytes = GLYPHWIDTHBYTESPADDED(*ppci);
|
||||
#endif
|
||||
|
||||
pdstBase += y * widthDst;
|
||||
#ifdef DO_COMMON
|
||||
if (widthGlyphs <= 32)
|
||||
#endif
|
||||
while (nglyph >= NGLYPHS)
|
||||
{
|
||||
nglyph -= NGLYPHS;
|
||||
hTmp = h;
|
||||
dstLine = pdstBase + (x >> PWSH);
|
||||
xoff1 = x & PIM;
|
||||
char1 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
char2 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
#ifdef ALL_LEFTBITS
|
||||
xoff2 = xoff1 + widthGlyph;
|
||||
#endif
|
||||
#if NGLYPHS >= 3
|
||||
char3 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
#ifdef ALL_LEFTBITS
|
||||
xoff3 = xoff2 + widthGlyph;
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS >= 4
|
||||
char4 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
#ifdef ALL_LEFTBITS
|
||||
xoff4 = xoff3 + widthGlyph;
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS >= 5
|
||||
char5 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
#ifdef ALL_LEFTBITS
|
||||
xoff5 = xoff4 + widthGlyph;
|
||||
#endif
|
||||
#endif
|
||||
oldRightChar = LastChar;
|
||||
dst = dstLine;
|
||||
if (xoff1)
|
||||
{
|
||||
ew = ((widthGlyphs - (PGSZB - xoff1)) >> PWSH) + 1;
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
widthLeft = widthDst - ew;
|
||||
#endif
|
||||
if (!leftChar)
|
||||
{
|
||||
leftMask = cfbendtab[xoff1];
|
||||
rightMask = cfbstarttab[xoff1];
|
||||
|
||||
#define StoreBits0 StorePixels (0, (dst[0] & leftMask) | \
|
||||
(GetPixelGroup(c) & rightMask));
|
||||
#define GetBits GetBitsNS
|
||||
|
||||
SwitchEm
|
||||
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
lshift = widthGlyph - xoff1;
|
||||
|
||||
#define StoreBits0 StorePixels (0,GetPixelGroup(c));
|
||||
#define GetBits GetBitsNL
|
||||
|
||||
SwitchEm
|
||||
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#if NGLYPHS == 4 && PGSZ == 32
|
||||
ew = widthGlyph; /* widthGlyphs >> 2 */
|
||||
#else
|
||||
ew = widthGlyphs >> PWSH;
|
||||
#endif
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
widthLeft = widthDst - ew;
|
||||
#endif
|
||||
|
||||
#define StoreBits0 StorePixels (0,GetPixelGroup(c));
|
||||
#define GetBits GetBitsNU
|
||||
|
||||
SwitchEm
|
||||
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
x += widthGlyphs;
|
||||
leftChar = oldRightChar;
|
||||
}
|
||||
while (nglyph--)
|
||||
{
|
||||
xoff1 = x & PIM;
|
||||
char1 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
hTmp = h;
|
||||
dstLine = pdstBase + (x >> PWSH);
|
||||
oldRightChar = char1;
|
||||
dst = dstLine;
|
||||
if (xoff1)
|
||||
{
|
||||
ew = ((widthGlyph - (PGSZB - xoff1)) >> PWSH) + 1;
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
widthLeft = widthDst - ew;
|
||||
#endif
|
||||
if (!leftChar)
|
||||
{
|
||||
leftMask = cfbendtab[xoff1];
|
||||
rightMask = cfbstarttab[xoff1];
|
||||
|
||||
#define StoreBits0 StorePixels (0, (dst[0] & leftMask) | \
|
||||
(GetPixelGroup(c) & rightMask));
|
||||
#define GetBits WGetBits1S
|
||||
|
||||
SwitchEm
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
lshift = widthGlyph - xoff1;
|
||||
|
||||
#define StoreBits0 StorePixels (0,GetPixelGroup(c));
|
||||
#define GetBits WGetBits1L
|
||||
|
||||
SwitchEm
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ew = widthGlyph >> PWSH;
|
||||
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
widthLeft = widthDst - ew;
|
||||
#endif
|
||||
|
||||
#define StoreBits0 StorePixels (0,GetPixelGroup(c));
|
||||
#define GetBits WGetBits1U
|
||||
|
||||
SwitchEm
|
||||
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
x += widthGlyph;
|
||||
leftChar = oldRightChar;
|
||||
}
|
||||
/*
|
||||
* draw the tail of the last character
|
||||
*/
|
||||
xoff1 = x & PIM;
|
||||
if (xoff1)
|
||||
{
|
||||
rightMask = cfbstarttab[xoff1];
|
||||
leftMask = cfbendtab[xoff1];
|
||||
lshift = widthGlyph - xoff1;
|
||||
dst = pdstBase + (x >> PWSH);
|
||||
hTmp = h;
|
||||
while (hTmp--)
|
||||
{
|
||||
GetBitsL;
|
||||
*dst = (*dst & rightMask) | (GetPixelGroup(c) & leftMask);
|
||||
dst += widthDst;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* PSZ == 8 */
|
218
cfb/cfbtegblt.c
218
cfb/cfbtegblt.c
|
@ -1,218 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mi.h"
|
||||
#define MFB_CONSTS_ONLY
|
||||
#include "maskbits.h"
|
||||
|
||||
/*
|
||||
this works for fonts with glyphs <= 32 bits wide, on an
|
||||
arbitrarily deep display. Use cfbTEGlyphBlt8 for 8 bit displays.
|
||||
|
||||
This should be called only with a terminal-emulator font;
|
||||
this means that the FIXED_METRICS flag is set, and that
|
||||
glyphbounds == charbounds.
|
||||
|
||||
in theory, this goes faster; even if it doesn't, it reduces the
|
||||
flicker caused by writing a string over itself with image text (since
|
||||
the background gets repainted per character instead of per string.)
|
||||
this seems to be important for some converted X10 applications.
|
||||
|
||||
Image text looks at the bits in the glyph and the fg and bg in the
|
||||
GC. it paints a rectangle, as defined in the protocol dcoument,
|
||||
and the paints the characters.
|
||||
|
||||
*/
|
||||
|
||||
void
|
||||
cfbTEGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
||||
DrawablePtr pDrawable;
|
||||
GC *pGC;
|
||||
int x, y;
|
||||
unsigned int nglyph;
|
||||
CharInfoPtr *ppci; /* array of character info */
|
||||
pointer pglyphBase; /* start of array of glyphs */
|
||||
{
|
||||
FontPtr pfont = pGC->font;
|
||||
int widthDst;
|
||||
CfbBits *pdstBase; /* pointer to longword with top row
|
||||
of current glyph */
|
||||
|
||||
int w; /* width of glyph and char */
|
||||
int h; /* height of glyph and char */
|
||||
register int xpos=x; /* current x%32 */
|
||||
int ypos=y; /* current y%32 */
|
||||
register unsigned char *pglyph;
|
||||
int widthGlyph;
|
||||
|
||||
register CfbBits *pdst;/* pointer to current longword in dst */
|
||||
int hTmp; /* counter for height */
|
||||
BoxRec bbox; /* for clipping */
|
||||
|
||||
register int wtmp,xtemp,width;
|
||||
CfbBits bgfill,fgfill,*ptemp,tmpDst1,tmpDst2,*pdtmp;
|
||||
#if PSZ != 24
|
||||
int tmpx;
|
||||
#endif
|
||||
|
||||
xpos += pDrawable->x;
|
||||
ypos += pDrawable->y;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
|
||||
|
||||
wtmp = FONTMAXBOUNDS(pfont,characterWidth);
|
||||
h = FONTASCENT(pfont) + FONTDESCENT(pfont);
|
||||
widthGlyph = GLYPHWIDTHBYTESPADDED(*ppci);
|
||||
|
||||
xpos += FONTMAXBOUNDS(pfont,leftSideBearing);
|
||||
ypos -= FONTASCENT(pfont);
|
||||
|
||||
bbox.x1 = xpos;
|
||||
bbox.x2 = xpos + (wtmp * nglyph);
|
||||
bbox.y1 = ypos;
|
||||
bbox.y2 = ypos + h;
|
||||
|
||||
fgfill = PFILL(pGC->fgPixel);
|
||||
bgfill = PFILL(pGC->bgPixel);
|
||||
|
||||
switch (RECT_IN_REGION(pGC->pScreen, cfbGetCompositeClip(pGC), &bbox))
|
||||
{
|
||||
case rgnOUT:
|
||||
break;
|
||||
case rgnPART:
|
||||
/* this is the WRONG thing to do, but it works.
|
||||
calling the non-terminal text is easy, but slow, given
|
||||
what we know about the font.
|
||||
|
||||
the right thing to do is something like:
|
||||
for each clip rectangle
|
||||
compute at which row the glyph starts to be in it,
|
||||
and at which row the glyph ceases to be in it
|
||||
compute which is the first glyph inside the left
|
||||
edge, and the last one inside the right edge
|
||||
draw a fractional first glyph, using only
|
||||
the rows we know are in
|
||||
draw all the whole glyphs, using the appropriate rows
|
||||
draw any pieces of the last glyph, using the right rows
|
||||
|
||||
this way, the code would take advantage of knowing that
|
||||
all glyphs are the same height and don't overlap.
|
||||
|
||||
one day...
|
||||
*/
|
||||
cfbImageGlyphBlt8(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
|
||||
break;
|
||||
case rgnIN:
|
||||
|
||||
pdtmp = pdstBase + (widthDst * ypos);
|
||||
while(nglyph--)
|
||||
{
|
||||
|
||||
pglyph = FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
pdst = pdtmp;
|
||||
hTmp = h;
|
||||
|
||||
while (hTmp--)
|
||||
{
|
||||
x = xpos;
|
||||
width = wtmp;
|
||||
xtemp = 0;
|
||||
|
||||
while (width > 0)
|
||||
{
|
||||
#if PSZ == 24
|
||||
w = 1;
|
||||
ptemp = (CfbBits *)(pglyph + ((xtemp *3)>> 2));
|
||||
getstipplepixels24(ptemp,xtemp,0,&bgfill,&tmpDst1, xtemp);
|
||||
getstipplepixels24(ptemp,xtemp,1,&fgfill,&tmpDst2, xtemp);
|
||||
#else
|
||||
tmpx = x & PIM;
|
||||
w = min(width, PPW - tmpx);
|
||||
w = min(w, (PGSZ - xtemp));
|
||||
ptemp = (CfbBits *)(pglyph + (xtemp >> MFB_PWSH));
|
||||
getstipplepixels(ptemp,xtemp,w,0,&bgfill,&tmpDst1);
|
||||
getstipplepixels(ptemp,xtemp,w,1,&fgfill,&tmpDst2);
|
||||
#endif
|
||||
|
||||
{
|
||||
CfbBits tmpDst = tmpDst1 | tmpDst2;
|
||||
#if PSZ == 24
|
||||
CfbBits *pdsttmp = pdst + ((x*3) >> 2);
|
||||
putbits24(tmpDst,w,pdsttmp,pGC->planemask,x);
|
||||
#else
|
||||
CfbBits *pdsttmp = pdst + (x >> PWSH);
|
||||
putbits(tmpDst,tmpx,w,pdsttmp,pGC->planemask);
|
||||
#endif
|
||||
}
|
||||
x += w;
|
||||
xtemp += w;
|
||||
width -= w;
|
||||
}
|
||||
pglyph += widthGlyph;
|
||||
pdst += widthDst;
|
||||
}
|
||||
xpos += wtmp;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
517
cfb/cfbtile32.c
517
cfb/cfbtile32.c
|
@ -1,517 +0,0 @@
|
|||
/*
|
||||
* Fill 32 bit tiled rectangles. Used by PolyFillRect.
|
||||
* no depth dependencies.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "gcstruct.h"
|
||||
#include "window.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
#include "mergerop.h"
|
||||
|
||||
#include "mi.h"
|
||||
#include "mispans.h"
|
||||
|
||||
#ifdef sparc
|
||||
#define SHARED_IDCACHE
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#define STORE(p) (*(p) = MROP_PREBUILT_SOLID(srcpix,*(p)))
|
||||
/*#define STORE24(p,index) {\
|
||||
register int idx = ((index) & 3)<< 1; \
|
||||
*(p) = (((MROP_PREBUILT_SOLID(srcpix,*(p))<<cfb24Shift[idx])&cfbmask[idx])| \
|
||||
(*(p)&cfbrmask[idx])); \
|
||||
idx++; \
|
||||
(p)++; \
|
||||
*(p) = (((MROP_PREBUILT_SOLID(srcpix,*(p))>>cfb24Shift[idx])&cfbmask[idx])| \
|
||||
(*(p)&cfbrmask[idx])); \
|
||||
(p)--; \
|
||||
}*/
|
||||
#define STORE24(p,index) MROP_PREBUILT_SOLID24(srcpix, (p), index)
|
||||
|
||||
#define STORE_MASK(p,mask) (*(p) = MROP_PREBUILT_MASK(srcpix,*(p),(mask)))
|
||||
#define QSTORE(p) ((*(p) = MROP_PREBUILT_SOLID(((srcpix<<24)|srcpix),*(p))), \
|
||||
(p)++,(*(p) = MROP_PREBUILT_SOLID(((srcpix<<16)|(srcpix>>8)),*(p))), \
|
||||
(p)++,(*(p) = MROP_PREBUILT_SOLID(((srcpix<<8)|(srcpix>>16)),*(p))))
|
||||
|
||||
#if (MROP == Mcopy) && defined(FAST_CONSTANT_OFFSET_MODE) && defined(SHARED_IDCACHE)
|
||||
# define Expand(left,right) {\
|
||||
int part = nlwMiddle & ((PGSZB*2)-1); \
|
||||
nlwMiddle *= 3; \
|
||||
nlwMiddle >>= PWSH + 3; \
|
||||
while (h--) { \
|
||||
srcpix = psrc[srcy]; \
|
||||
MROP_PREBUILD(srcpix); \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0; \
|
||||
left \
|
||||
p += part; \
|
||||
switch (part) { \
|
||||
case 7: \
|
||||
STORE24(p - 7, xtmp - 7); \
|
||||
case 6: \
|
||||
STORE24(p - 6, xtmp - 6); \
|
||||
case 5: \
|
||||
STORE24(p - 5, xtmp - 5); \
|
||||
case 4: \
|
||||
STORE24(p - 4, xtmp - 4); \
|
||||
case 3: \
|
||||
STORE24(p - 3, xtmp - 3); \
|
||||
case 2: \
|
||||
STORE24(p - 2, xtmp - 2); \
|
||||
case 1: \
|
||||
STORE24(p - 1, xtmp - 1); \
|
||||
} \
|
||||
nlw = nlwMiddle; \
|
||||
while (nlw) { \
|
||||
STORE24 (p + 0, xtmp + 0); \
|
||||
STORE24 (p + 1, xtmp + 1); \
|
||||
STORE24 (p + 2, xtmp + 2); \
|
||||
STORE24 (p + 3, xtmp + 3); \
|
||||
STORE24 (p + 4, xtmp + 4); \
|
||||
STORE24 (p + 5, xtmp + 5); \
|
||||
STORE24 (p + 6, xtmp + 6); \
|
||||
STORE24 (p + 7, xtmp + 7); \
|
||||
p += 8; \
|
||||
xtmp += 8; \
|
||||
nlw--; \
|
||||
} \
|
||||
right \
|
||||
p += nlwExtra; \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define Expand(left,right) {\
|
||||
while (h--) { \
|
||||
srcpix = psrc[srcy]; \
|
||||
MROP_PREBUILD(srcpix); \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0; \
|
||||
left \
|
||||
while (nlw--) \
|
||||
{ \
|
||||
STORE24(p,xtmp); \
|
||||
if(xtmp&3) p++; \
|
||||
xtmp++; \
|
||||
} \
|
||||
right \
|
||||
p += nlwExtra; \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
#else /*PSZ != 24*/
|
||||
#define STORE(p) (*(p) = MROP_PREBUILT_SOLID(srcpix,*(p)))
|
||||
|
||||
#if (MROP == Mcopy) && defined(FAST_CONSTANT_OFFSET_MODE) && defined(SHARED_IDCACHE)
|
||||
# define Expand(left,right) {\
|
||||
int part = nlwMiddle & ((PGSZB*2)-1); \
|
||||
nlwMiddle >>= PWSH + 1; \
|
||||
while (h--) { \
|
||||
srcpix = psrc[srcy]; \
|
||||
MROP_PREBUILD(srcpix); \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0; \
|
||||
left \
|
||||
p += part; \
|
||||
switch (part) { \
|
||||
case 7: \
|
||||
STORE(p - 7); \
|
||||
case 6: \
|
||||
STORE(p - 6); \
|
||||
case 5: \
|
||||
STORE(p - 5); \
|
||||
case 4: \
|
||||
STORE(p - 4); \
|
||||
case 3: \
|
||||
STORE(p - 3); \
|
||||
case 2: \
|
||||
STORE(p - 2); \
|
||||
case 1: \
|
||||
STORE(p - 1); \
|
||||
} \
|
||||
nlw = nlwMiddle; \
|
||||
while (nlw) { \
|
||||
STORE (p + 0); \
|
||||
STORE (p + 1); \
|
||||
STORE (p + 2); \
|
||||
STORE (p + 3); \
|
||||
STORE (p + 4); \
|
||||
STORE (p + 5); \
|
||||
STORE (p + 6); \
|
||||
STORE (p + 7); \
|
||||
p += 8; \
|
||||
nlw--; \
|
||||
} \
|
||||
right \
|
||||
p += nlwExtra; \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define Expand(left,right) {\
|
||||
while (h--) { \
|
||||
srcpix = psrc[srcy]; \
|
||||
MROP_PREBUILD(srcpix); \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0; \
|
||||
left \
|
||||
nlw = nlwMiddle; \
|
||||
while (nlw--) \
|
||||
{ \
|
||||
STORE(p); \
|
||||
p++; \
|
||||
} \
|
||||
right \
|
||||
p += nlwExtra; \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
#endif /*PSZ == 24*/
|
||||
|
||||
void
|
||||
MROP_NAME(cfbFillRectTile32) (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox; /* number of boxes to fill */
|
||||
BoxPtr pBox; /* pointer to list of boxes to fill */
|
||||
{
|
||||
register CfbBits srcpix;
|
||||
CfbBits *psrc; /* pointer to bits in tile, if needed */
|
||||
int tileHeight; /* height of the tile */
|
||||
|
||||
int nlwDst; /* width in longwords of the dest pixmap */
|
||||
int w; /* width of current box */
|
||||
register int h; /* height of current box */
|
||||
register CfbBits startmask;
|
||||
register CfbBits endmask; /* masks for reggedy bits at either end of line */
|
||||
int nlwMiddle; /* number of longwords between sides of boxes */
|
||||
int nlwExtra; /* to get from right of box to left of next span */
|
||||
register int nlw = 0; /* loop version of nlwMiddle */
|
||||
register CfbBits *p; /* pointer to bits we're writing */
|
||||
int y; /* current scan line */
|
||||
int srcy; /* current tile position */
|
||||
|
||||
CfbBits *pbits;/* pointer to start of pixmap */
|
||||
PixmapPtr tile; /* rotated, expanded tile */
|
||||
#if MROP == 0 && PSZ == 24
|
||||
DeclareMergeRop()
|
||||
#else
|
||||
MROP_DECLARE_REG()
|
||||
#endif
|
||||
MROP_PREBUILT_DECLARE()
|
||||
#if PSZ == 24
|
||||
CfbBits xtmp;
|
||||
#endif
|
||||
|
||||
tile = pGC->pRotatedPixmap;
|
||||
tileHeight = tile->drawable.height;
|
||||
psrc = (CfbBits *)tile->devPrivate.ptr;
|
||||
|
||||
#if MROP == 0 && PSZ == 24
|
||||
InitializeMergeRop(pGC->alu, pGC->planemask);
|
||||
#else
|
||||
MROP_INITIALIZE(pGC->alu, pGC->planemask);
|
||||
#endif
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pbits)
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
w = pBox->x2 - pBox->x1;
|
||||
h = pBox->y2 - pBox->y1;
|
||||
y = pBox->y1;
|
||||
#if PSZ == 24
|
||||
xtmp = pBox->x1;
|
||||
p = pbits + (y * nlwDst) + ((pBox->x1*3) >> 2);
|
||||
/* p = pbits + (y * nlwDst) + ((pBox->x1>> 2)*3);*/
|
||||
#else
|
||||
p = pbits + (y * nlwDst) + (pBox->x1 >> PWSH);
|
||||
#endif
|
||||
srcy = y % tileHeight;
|
||||
|
||||
#if PSZ == 24
|
||||
if (w == 1 && ((pBox->x1 & 3) == 0 || (pBox->x1 & 3) == 3))
|
||||
#else
|
||||
if ( ((pBox->x1 & PIM) + w) <= PPW)
|
||||
#endif
|
||||
{
|
||||
maskpartialbits(pBox->x1, w, startmask);
|
||||
nlwExtra = nlwDst;
|
||||
while (h--)
|
||||
{
|
||||
srcpix = psrc[srcy];
|
||||
MROP_PREBUILD(srcpix);
|
||||
++srcy;
|
||||
if (srcy == tileHeight)
|
||||
srcy = 0;
|
||||
*p = MROP_PREBUILT_MASK (srcpix, *p, startmask);
|
||||
p += nlwExtra;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(pBox->x1, w, startmask, endmask, nlwMiddle);
|
||||
nlwExtra = nlwDst - nlwMiddle;
|
||||
|
||||
if (startmask)
|
||||
{
|
||||
nlwExtra -= 1;
|
||||
if (endmask)
|
||||
{
|
||||
Expand(*p = MROP_PREBUILT_MASK(srcpix, *p, startmask); p++;,
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, endmask);)
|
||||
}
|
||||
else
|
||||
{
|
||||
Expand(*p = MROP_PREBUILT_MASK(srcpix, *p, startmask); p++;,
|
||||
;)
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (endmask)
|
||||
{
|
||||
Expand(;,
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, endmask);)
|
||||
}
|
||||
else
|
||||
{
|
||||
Expand(;,
|
||||
;)
|
||||
}
|
||||
}
|
||||
}
|
||||
pBox++;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
MROP_NAME(cfbTile32FS)(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nInit; /* number of spans to fill */
|
||||
DDXPointPtr pptInit; /* pointer to list of start points */
|
||||
int *pwidthInit; /* pointer to list of n widths */
|
||||
int fSorted;
|
||||
{
|
||||
/* next three parameters are post-clip */
|
||||
int n; /* number of spans to fill */
|
||||
DDXPointPtr ppt; /* pointer to list of start points */
|
||||
int *pwidth;/* pointer to list of n widths */
|
||||
CfbBits *pbits; /* pointer to start of bitmap */
|
||||
int nlwDst; /* width in longwords of bitmap */
|
||||
register CfbBits *p; /* pointer to current longword in bitmap */
|
||||
register int w; /* current span width */
|
||||
register int nlw;
|
||||
register int x;
|
||||
register CfbBits startmask;
|
||||
register CfbBits endmask;
|
||||
register CfbBits srcpix;
|
||||
int y;
|
||||
int *pwidthFree;/* copies of the pointers to free */
|
||||
DDXPointPtr pptFree;
|
||||
PixmapPtr tile;
|
||||
CfbBits *psrc; /* pointer to bits in tile */
|
||||
int tileHeight;/* height of the tile */
|
||||
#if MROP == 0 && PSZ == 24
|
||||
DeclareMergeRop()
|
||||
#else
|
||||
MROP_DECLARE_REG()
|
||||
#endif
|
||||
MROP_PREBUILT_DECLARE()
|
||||
#if PSZ == 24
|
||||
CfbBits xtmp;
|
||||
#endif
|
||||
|
||||
n = nInit * miFindMaxBand( cfbGetCompositeClip(pGC) );
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree)
|
||||
{
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
ppt = pptFree;
|
||||
n = miClipSpans( cfbGetCompositeClip(pGC),
|
||||
pptInit, pwidthInit, nInit,
|
||||
ppt, pwidth, fSorted);
|
||||
|
||||
tile = pGC->pRotatedPixmap;
|
||||
tileHeight = tile->drawable.height;
|
||||
psrc = (CfbBits *)tile->devPrivate.ptr;
|
||||
|
||||
#if MROP == 0 && PSZ == 24
|
||||
InitializeMergeRop(pGC->alu, pGC->planemask);
|
||||
#else
|
||||
MROP_INITIALIZE(pGC->alu, pGC->planemask);
|
||||
#endif
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pbits)
|
||||
|
||||
#if MROP == Mcopy
|
||||
if (!(tileHeight & (tileHeight-1)))
|
||||
{
|
||||
tileHeight--;
|
||||
while (n--)
|
||||
{
|
||||
x = ppt->x;
|
||||
y = ppt->y;
|
||||
++ppt;
|
||||
w = *pwidth++;
|
||||
#if PSZ == 24
|
||||
/* p = pbits + (y * nlwDst) + ((x*3) >> 2);*/
|
||||
xtmp = x;
|
||||
p = pbits + (y * nlwDst) + ((x >> 2)*3);
|
||||
#else
|
||||
p = pbits + (y * nlwDst) + (x >> PWSH);
|
||||
#endif
|
||||
srcpix = psrc[y & tileHeight];
|
||||
MROP_PREBUILD(srcpix);
|
||||
|
||||
#if PSZ == 24
|
||||
if ((x & 3) + w < 5)
|
||||
#else
|
||||
if ((x & PIM) + w < PPW)
|
||||
#endif
|
||||
{
|
||||
maskpartialbits(x, w, startmask);
|
||||
*p = MROP_PREBUILT_MASK (srcpix, *p, startmask);
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(x, w, startmask, endmask, nlw);
|
||||
if (startmask)
|
||||
{
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, startmask);
|
||||
#if PSZ == 24
|
||||
if(xtmp&3) p++;
|
||||
xtmp++;
|
||||
#else
|
||||
p++;
|
||||
#endif
|
||||
}
|
||||
while (nlw--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
STORE24(p,xtmp);
|
||||
if(xtmp&3) p++;
|
||||
++xtmp;
|
||||
#else
|
||||
STORE(p);
|
||||
++p;
|
||||
#endif
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
while (n--)
|
||||
{
|
||||
x = ppt->x;
|
||||
y = ppt->y;
|
||||
++ppt;
|
||||
w = *pwidth++;
|
||||
#if PSZ == 24
|
||||
/* p = pbits + (y * nlwDst) + ((x *3)>> 2);*/
|
||||
p = pbits + (y * nlwDst) + ((x >> 2)*3);
|
||||
xtmp = x;
|
||||
#else
|
||||
p = pbits + (y * nlwDst) + (x >> PWSH);
|
||||
#endif
|
||||
srcpix = psrc[y % tileHeight];
|
||||
MROP_PREBUILD(srcpix);
|
||||
|
||||
#if PSZ == 24
|
||||
if ((x & 3) + w < 5)
|
||||
#else
|
||||
if ((x & PIM) + w < PPW)
|
||||
#endif
|
||||
{
|
||||
maskpartialbits(x, w, startmask);
|
||||
*p = MROP_PREBUILT_MASK (srcpix, *p, startmask);
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(x, w, startmask, endmask, nlw);
|
||||
if (startmask)
|
||||
{
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, startmask);
|
||||
#if PSZ == 24
|
||||
if(xtmp&3)p++;
|
||||
xtmp++;
|
||||
#else
|
||||
p++;
|
||||
#endif
|
||||
}
|
||||
while (nlw--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
STORE24(p,xtmp);
|
||||
if(xtmp&3)p++;
|
||||
xtmp++;
|
||||
#else
|
||||
STORE(p);
|
||||
++p;
|
||||
#endif
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
1245
cfb/cfbtileodd.c
1245
cfb/cfbtileodd.c
File diff suppressed because it is too large
Load Diff
161
cfb/cfbunmap.h
161
cfb/cfbunmap.h
|
@ -1,161 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1994-1998 The XFree86 Project, Inc. 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 THE
|
||||
* XFREE86 PROJECT 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.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Unmap names
|
||||
*/
|
||||
|
||||
#undef CFBNAME
|
||||
#undef CATNAME
|
||||
|
||||
#undef QuartetBitsTable
|
||||
#undef QuartetPixelMaskTable
|
||||
#undef cfb8ClippedLineCopy
|
||||
#undef cfb8ClippedLineGeneral
|
||||
#undef cfb8ClippedLineXor
|
||||
#undef cfb8LineSS1Rect
|
||||
#undef cfb8LineSS1RectCopy
|
||||
#undef cfb8LineSS1RectGeneral
|
||||
#undef cfb8LineSS1RectPreviousCopy
|
||||
#undef cfb8LineSS1RectXor
|
||||
#undef cfb8SegmentSS1Rect
|
||||
#undef cfb8SegmentSS1RectCopy
|
||||
#undef cfb8SegmentSS1RectGeneral
|
||||
#undef cfb8SegmentSS1RectShiftCopy
|
||||
#undef cfb8SegmentSS1RectXor
|
||||
#undef cfbAllocatePrivates
|
||||
#undef cfbBSFuncRec
|
||||
#undef cfbBitBlt
|
||||
#undef cfbBresD
|
||||
#undef cfbBresS
|
||||
#undef cfbChangeWindowAttributes
|
||||
#undef cfbClearVisualTypes
|
||||
#undef cfbCloseScreen
|
||||
#undef cfbCreateDefColormap
|
||||
#undef cfbCopyArea
|
||||
#undef cfbCopyImagePlane
|
||||
#undef cfbCopyPixmap
|
||||
#undef cfbCopyPlane
|
||||
#undef cfbCopyPlaneReduce
|
||||
#undef cfbCopyRotatePixmap
|
||||
#undef cfbCopyWindow
|
||||
#undef cfbCreateGC
|
||||
#undef cfbCreatePixmap
|
||||
#undef cfbCreateScreenResources
|
||||
#undef cfbCreateWindow
|
||||
#undef cfbDestroyPixmap
|
||||
#undef cfbDestroyWindow
|
||||
#undef cfbDoBitblt
|
||||
#undef cfbDoBitbltCopy
|
||||
#undef cfbDoBitbltGeneral
|
||||
#undef cfbDoBitbltOr
|
||||
#undef cfbDoBitbltXor
|
||||
#undef cfbExpandDirectColors
|
||||
#undef cfbFillBoxTile32sCopy
|
||||
#undef cfbFillBoxTile32sGeneral
|
||||
#undef cfbFillBoxTileOdd
|
||||
#undef cfbFillBoxTileOddCopy
|
||||
#undef cfbFillBoxTileOddGeneral
|
||||
#undef cfbFillPoly1RectCopy
|
||||
#undef cfbFillPoly1RectGeneral
|
||||
#undef cfbFillRectSolidCopy
|
||||
#undef cfbFillRectSolidGeneral
|
||||
#undef cfbFillRectSolidXor
|
||||
#undef cfbFillRectTile32Copy
|
||||
#undef cfbFillRectTile32General
|
||||
#undef cfbFillRectTileOdd
|
||||
#undef cfbFillSpanTile32sCopy
|
||||
#undef cfbFillSpanTile32sGeneral
|
||||
#undef cfbFillSpanTileOddCopy
|
||||
#undef cfbFillSpanTileOddGeneral
|
||||
#undef cfbFinishScreenInit
|
||||
#undef cfbGCFuncs
|
||||
#undef cfbGCPrivateKey
|
||||
#undef cfbGetImage
|
||||
#undef cfbGetScreenPixmap
|
||||
#undef cfbGetSpans
|
||||
#undef cfbHorzS
|
||||
#undef cfbImageGlyphBlt8
|
||||
#undef cfbInitializeColormap
|
||||
#undef cfbInitVisuals
|
||||
#undef cfbInstallColormap
|
||||
#undef cfbLineSD
|
||||
#undef cfbLineSS
|
||||
#undef cfbListInstalledColormaps
|
||||
#undef cfbMapWindow
|
||||
#undef cfbMatchCommon
|
||||
#undef cfbNonTEOps
|
||||
#undef cfbNonTEOps1Rect
|
||||
#undef cfbPadPixmap
|
||||
#undef cfbPolyFillArcSolidCopy
|
||||
#undef cfbPolyFillArcSolidGeneral
|
||||
#undef cfbPolyFillRect
|
||||
#undef cfbPolyGlyphBlt8
|
||||
#undef cfbPolyGlyphRop8
|
||||
#undef cfbPolyPoint
|
||||
#undef cfbPositionWindow
|
||||
#undef cfbPutImage
|
||||
#undef cfbReduceRasterOp
|
||||
#undef cfbResolveColor
|
||||
#undef cfbRestoreAreas
|
||||
#undef cfbSaveAreas
|
||||
#undef cfbScreenInit
|
||||
#undef cfbScreenPrivateKey
|
||||
#undef cfbSegmentSD
|
||||
#undef cfbSegmentSS
|
||||
#undef cfbSetScanline
|
||||
#undef cfbSetScreenPixmap
|
||||
#undef cfbSetSpans
|
||||
#undef cfbSetVisualTypes
|
||||
#undef cfbSetupScreen
|
||||
#undef cfbSolidSpansCopy
|
||||
#undef cfbSolidSpansGeneral
|
||||
#undef cfbSolidSpansXor
|
||||
#undef cfbStippleStack
|
||||
#undef cfbStippleStackTE
|
||||
#undef cfbTEGlyphBlt
|
||||
#undef cfbTEOps
|
||||
#undef cfbTEOps1Rect
|
||||
#undef cfbTile32FSCopy
|
||||
#undef cfbTile32FSGeneral
|
||||
#undef cfbUninstallColormap
|
||||
#undef cfbUnmapWindow
|
||||
#undef cfbUnnaturalStippleFS
|
||||
#undef cfbUnnaturalTileFS
|
||||
#undef cfbValidateGC
|
||||
#undef cfbVertS
|
||||
#undef cfbWindowPrivateKey
|
||||
#undef cfbXRotatePixmap
|
||||
#undef cfbYRotatePixmap
|
||||
#undef cfbZeroPolyArcSS8Copy
|
||||
#undef cfbZeroPolyArcSS8General
|
||||
#undef cfbZeroPolyArcSS8Xor
|
||||
#undef cfbendpartial
|
||||
#undef cfbendtab
|
||||
#undef cfbmask
|
||||
#undef cfbrmask
|
||||
#undef cfbstartpartial
|
||||
#undef cfbstarttab
|
160
cfb/cfbwindow.c
160
cfb/cfbwindow.c
|
@ -1,160 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
#include "cfb.h"
|
||||
#include "mistruct.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
Bool
|
||||
cfbCreateWindow(WindowPtr pWin)
|
||||
{
|
||||
#ifdef PIXMAP_PER_WINDOW
|
||||
/* Setup pointer to Screen pixmap */
|
||||
dixSetPrivate(&pWin->devPrivates, frameWindowPrivateKey,
|
||||
cfbGetScreenPixmap(pWin->drawable.pScreen));
|
||||
#endif
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbDestroyWindow(WindowPtr pWin)
|
||||
{
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
Bool
|
||||
cfbMapWindow(pWindow)
|
||||
WindowPtr pWindow;
|
||||
{
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
Bool
|
||||
cfbPositionWindow(WindowPtr pWin, int x, int y)
|
||||
{
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
Bool
|
||||
cfbUnmapWindow(pWindow)
|
||||
WindowPtr pWindow;
|
||||
{
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/* UNCLEAN!
|
||||
this code calls the bitblt helper code directly.
|
||||
|
||||
cfbCopyWindow copies only the parts of the destination that are
|
||||
visible in the source.
|
||||
*/
|
||||
|
||||
|
||||
void
|
||||
cfbCopyWindow(pWin, ptOldOrg, prgnSrc)
|
||||
WindowPtr pWin;
|
||||
DDXPointRec ptOldOrg;
|
||||
RegionPtr prgnSrc;
|
||||
{
|
||||
DDXPointPtr pptSrc;
|
||||
register DDXPointPtr ppt;
|
||||
RegionRec rgnDst;
|
||||
register BoxPtr pbox;
|
||||
register int dx, dy;
|
||||
register int i, nbox;
|
||||
WindowPtr pwinRoot;
|
||||
|
||||
pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];
|
||||
|
||||
REGION_NULL(pWin->drawable.pScreen, &rgnDst);
|
||||
|
||||
dx = ptOldOrg.x - pWin->drawable.x;
|
||||
dy = ptOldOrg.y - pWin->drawable.y;
|
||||
REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
|
||||
REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
|
||||
|
||||
pbox = REGION_RECTS(&rgnDst);
|
||||
nbox = REGION_NUM_RECTS(&rgnDst);
|
||||
if(!nbox || !(pptSrc = (DDXPointPtr )xalloc(nbox * sizeof(DDXPointRec))))
|
||||
{
|
||||
REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);
|
||||
return;
|
||||
}
|
||||
ppt = pptSrc;
|
||||
|
||||
for (i = nbox; --i >= 0; ppt++, pbox++)
|
||||
{
|
||||
ppt->x = pbox->x1 + dx;
|
||||
ppt->y = pbox->y1 + dy;
|
||||
}
|
||||
|
||||
cfbDoBitbltCopy((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
|
||||
GXcopy, &rgnDst, pptSrc, ~0L);
|
||||
xfree(pptSrc);
|
||||
REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
|
||||
{
|
||||
return (TRUE);
|
||||
}
|
||||
|
322
cfb/cfbzerarc.c
322
cfb/cfbzerarc.c
|
@ -1,322 +0,0 @@
|
|||
/************************************************************
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
********************************************************/
|
||||
|
||||
|
||||
/* Derived from:
|
||||
* "Algorithm for drawing ellipses or hyperbolae with a digital plotter"
|
||||
* by M. L. V. Pitteway
|
||||
* The Computer Journal, November 1967, Volume 10, Number 3, pp. 282-289
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xprotostr.h>
|
||||
#include "regionstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mizerarc.h"
|
||||
#include "cfbrrop.h"
|
||||
#include "mi.h"
|
||||
|
||||
#ifdef PIXEL_ADDR
|
||||
|
||||
static void
|
||||
RROP_NAME(cfbZeroArcSS8)(
|
||||
DrawablePtr pDraw,
|
||||
GCPtr pGC,
|
||||
xArc *arc)
|
||||
{
|
||||
miZeroArcRec info;
|
||||
Bool do360;
|
||||
register int x;
|
||||
PixelType *addrp;
|
||||
register PixelType *yorgp, *yorgop;
|
||||
#if PSZ == 24
|
||||
int xorg, xorg3, xorgo, xorgo3;
|
||||
register int xtmp;
|
||||
#endif
|
||||
RROP_DECLARE
|
||||
register int yoffset;
|
||||
int npwidth, dyoffset;
|
||||
register int y, a, b, d, mask;
|
||||
register int k1, k3, dx, dy;
|
||||
|
||||
cfbGetPixelWidthAndPointer(pDraw,npwidth, addrp)
|
||||
|
||||
RROP_FETCH_GC (pGC);
|
||||
do360 = miZeroArcSetup(arc, &info, TRUE);
|
||||
yorgp = addrp + ((info.yorg + pDraw->y) * npwidth);
|
||||
yorgop = addrp + ((info.yorgo + pDraw->y) * npwidth);
|
||||
info.xorg += pDraw->x;
|
||||
info.xorgo += pDraw->x;
|
||||
#if PSZ == 24
|
||||
xorg = info.xorg;
|
||||
xorg3 = xorg * 3;
|
||||
info.xorg = (info.xorg * 3) >> 2;
|
||||
xorgo = info.xorgo;
|
||||
xorgo3 = xorgo * 3;
|
||||
info.xorgo = (info.xorgo * 3) >> 2;
|
||||
#endif
|
||||
MIARCSETUP();
|
||||
yoffset = y ? npwidth : 0;
|
||||
dyoffset = 0;
|
||||
mask = info.initialMask;
|
||||
if (!(arc->width & 1))
|
||||
{
|
||||
#if PSZ == 24
|
||||
if (mask & 2)
|
||||
RROP_SOLID24((yorgp + info.xorgo), xorgo);
|
||||
if (mask & 8)
|
||||
RROP_SOLID24((yorgop + info.xorgo), xorgo);
|
||||
#else
|
||||
if (mask & 2)
|
||||
RROP_SOLID((yorgp + info.xorgo));
|
||||
if (mask & 8)
|
||||
RROP_SOLID((yorgop + info.xorgo));
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
if (!info.end.x || !info.end.y)
|
||||
{
|
||||
mask = info.end.mask;
|
||||
info.end = info.altend;
|
||||
}
|
||||
if (do360 && (arc->width == arc->height) && !(arc->width & 1))
|
||||
{
|
||||
register int xoffset = npwidth;
|
||||
#if PSZ == 24
|
||||
PixelType *yorghb = yorgp + (info.h * npwidth);
|
||||
register int tmp1, tmp2, tmp1_3, tmp2_3;
|
||||
|
||||
tmp1 = xorg + info.h;
|
||||
tmp1_3 = tmp1 * 3;
|
||||
tmp2 = xorg - info.h;
|
||||
tmp2_3 = tmp2 * 3;
|
||||
while (1)
|
||||
{
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg + x);
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg + x);
|
||||
xtmp = (xorg3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg - x);
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg - x);
|
||||
if (a < 0)
|
||||
break;
|
||||
xtmp = (tmp1_3 - y * 3) >> 2;
|
||||
RROP_SOLID24(yorghb - xoffset + xtmp, tmp1 - y);
|
||||
RROP_SOLID24(yorghb + xoffset + xtmp, tmp1 - y);
|
||||
xtmp = (tmp2_3 + y * 3) >> 2;
|
||||
RROP_SOLID24(yorghb - xoffset + xtmp, tmp2 + y);
|
||||
RROP_SOLID24(yorghb + xoffset + xtmp, tmp2 + y);
|
||||
xoffset += npwidth;
|
||||
MIARCCIRCLESTEP(yoffset += npwidth;);
|
||||
}
|
||||
#else
|
||||
PixelType *yorghb = yorgp + (info.h * npwidth) + info.xorg;
|
||||
PixelType *yorgohb = yorghb - info.h;
|
||||
|
||||
yorgp += info.xorg;
|
||||
yorgop += info.xorg;
|
||||
yorghb += info.h;
|
||||
while (1)
|
||||
{
|
||||
RROP_SOLID(yorgp + yoffset + x);
|
||||
RROP_SOLID(yorgp + yoffset - x);
|
||||
RROP_SOLID(yorgop - yoffset - x);
|
||||
RROP_SOLID(yorgop - yoffset + x);
|
||||
if (a < 0)
|
||||
break;
|
||||
RROP_SOLID(yorghb - xoffset - y);
|
||||
RROP_SOLID(yorgohb - xoffset + y);
|
||||
RROP_SOLID(yorgohb + xoffset + y);
|
||||
RROP_SOLID(yorghb + xoffset - y);
|
||||
xoffset += npwidth;
|
||||
MIARCCIRCLESTEP(yoffset += npwidth;);
|
||||
}
|
||||
yorgp -= info.xorg;
|
||||
yorgop -= info.xorg;
|
||||
#endif /* PSZ == 24 */
|
||||
x = info.w;
|
||||
yoffset = info.h * npwidth;
|
||||
}
|
||||
else if (do360)
|
||||
{
|
||||
while (y < info.h || x < info.w)
|
||||
{
|
||||
MIARCOCTANTSHIFT(dyoffset = npwidth;);
|
||||
#if PSZ == 24
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg + x);
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg + x);
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorgo - x);
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorgo - x);
|
||||
#else
|
||||
RROP_SOLID(yorgp + yoffset + info.xorg + x);
|
||||
RROP_SOLID(yorgp + yoffset + info.xorgo - x);
|
||||
RROP_SOLID(yorgop - yoffset + info.xorgo - x);
|
||||
RROP_SOLID(yorgop - yoffset + info.xorg + x);
|
||||
#endif
|
||||
MIARCSTEP(yoffset += dyoffset;, yoffset += npwidth;);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (y < info.h || x < info.w)
|
||||
{
|
||||
MIARCOCTANTSHIFT(dyoffset = npwidth;);
|
||||
if ((x == info.start.x) || (y == info.start.y))
|
||||
{
|
||||
mask = info.start.mask;
|
||||
info.start = info.altstart;
|
||||
}
|
||||
#if PSZ == 24
|
||||
if (mask & 1){
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg + x);
|
||||
}
|
||||
if (mask & 2){
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorgo - x);
|
||||
}
|
||||
if (mask & 4){
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorgo - x);
|
||||
}
|
||||
if (mask & 8){
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg + x);
|
||||
}
|
||||
#else
|
||||
if (mask & 1)
|
||||
RROP_SOLID(yorgp + yoffset + info.xorg + x);
|
||||
if (mask & 2)
|
||||
RROP_SOLID(yorgp + yoffset + info.xorgo - x);
|
||||
if (mask & 4)
|
||||
RROP_SOLID(yorgop - yoffset + info.xorgo - x);
|
||||
if (mask & 8)
|
||||
RROP_SOLID(yorgop - yoffset + info.xorg + x);
|
||||
#endif /* PSZ == 24 */
|
||||
if ((x == info.end.x) || (y == info.end.y))
|
||||
{
|
||||
mask = info.end.mask;
|
||||
info.end = info.altend;
|
||||
}
|
||||
MIARCSTEP(yoffset += dyoffset;, yoffset += npwidth;);
|
||||
}
|
||||
}
|
||||
if ((x == info.start.x) || (y == info.start.y))
|
||||
mask = info.start.mask;
|
||||
#if PSZ == 24
|
||||
if (mask & 1){
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg + x);
|
||||
}
|
||||
if (mask & 4){
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorgo - x);
|
||||
}
|
||||
#else
|
||||
if (mask & 1)
|
||||
RROP_SOLID(yorgp + yoffset + info.xorg + x);
|
||||
if (mask & 4)
|
||||
RROP_SOLID(yorgop - yoffset + info.xorgo - x);
|
||||
#endif /* PSZ == 24 */
|
||||
if (arc->height & 1)
|
||||
{
|
||||
#if PSZ == 24
|
||||
if (mask & 2){
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorgo - x);
|
||||
}
|
||||
if (mask & 8){
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg + x);
|
||||
}
|
||||
#else
|
||||
if (mask & 2)
|
||||
RROP_SOLID(yorgp + yoffset + info.xorgo - x);
|
||||
if (mask & 8)
|
||||
RROP_SOLID(yorgop - yoffset + info.xorg + x);
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
RROP_UNDECLARE
|
||||
}
|
||||
|
||||
void
|
||||
RROP_NAME (cfbZeroPolyArcSS8) (pDraw, pGC, narcs, parcs)
|
||||
register DrawablePtr pDraw;
|
||||
GCPtr pGC;
|
||||
int narcs;
|
||||
xArc *parcs;
|
||||
{
|
||||
register xArc *arc;
|
||||
register int i;
|
||||
BoxRec box;
|
||||
int x2, y2;
|
||||
RegionPtr cclip;
|
||||
|
||||
cclip = cfbGetCompositeClip(pGC);
|
||||
for (arc = parcs, i = narcs; --i >= 0; arc++)
|
||||
{
|
||||
if (miCanZeroArc(arc))
|
||||
{
|
||||
box.x1 = arc->x + pDraw->x;
|
||||
box.y1 = arc->y + pDraw->y;
|
||||
/*
|
||||
* Because box.x2 and box.y2 get truncated to 16 bits, and the
|
||||
* RECT_IN_REGION test treats the resulting number as a signed
|
||||
* integer, the RECT_IN_REGION test alone can go the wrong way.
|
||||
* This can result in a server crash because the rendering
|
||||
* routines in this file deal directly with cpu addresses
|
||||
* of pixels to be stored, and do not clip or otherwise check
|
||||
* that all such addresses are within their respective pixmaps.
|
||||
* So we only allow the RECT_IN_REGION test to be used for
|
||||
* values that can be expressed correctly in a signed short.
|
||||
*/
|
||||
x2 = box.x1 + (int)arc->width + 1;
|
||||
box.x2 = x2;
|
||||
y2 = box.y1 + (int)arc->height + 1;
|
||||
box.y2 = y2;
|
||||
if ( (x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&
|
||||
(RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
|
||||
RROP_NAME (cfbZeroArcSS8) (pDraw, pGC, arc);
|
||||
else
|
||||
miZeroPolyArc(pDraw, pGC, 1, arc);
|
||||
}
|
||||
else
|
||||
miPolyArc(pDraw, pGC, 1, arc);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
121
cfb/stip68kgnu.h
121
cfb/stip68kgnu.h
|
@ -1,121 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
/*
|
||||
* Stipple stack macro for 68k GCC
|
||||
*/
|
||||
|
||||
#define STIPPLE(addr,stipple,value,width,count,shift) \
|
||||
__asm volatile ( \
|
||||
"lea 5f,%/a1\n\
|
||||
moveq #28,%/d2\n\
|
||||
addl %2,%/d2\n\
|
||||
moveq #28,%/d3\n\
|
||||
subql #4,%2\n\
|
||||
negl %2\n\
|
||||
1:\n\
|
||||
movel %0,%/a0\n\
|
||||
addl %6,%0\n\
|
||||
movel %3@+,%/d1\n\
|
||||
jeq 3f\n\
|
||||
movel %/d1,%/d0\n\
|
||||
lsrl %/d2,%/d0\n\
|
||||
lsll #5,%/d0\n\
|
||||
lsll %2,%/d1\n\
|
||||
jmp %/a1@(%/d0:l)\n\
|
||||
2:\n\
|
||||
addl #4,%/a0\n\
|
||||
movel %/d1,%/d0\n\
|
||||
lsrl %/d3,%/d0\n\
|
||||
lsll #5,%/d0\n\
|
||||
lsll #4,%/d1\n\
|
||||
jmp %/a1@(%/d0:l)\n\
|
||||
5:\n\
|
||||
jne 2b ; dbra %1,1b ; jra 4f\n\
|
||||
. = 5b + 0x20\n\
|
||||
moveb %5,%/a0@(3)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f\n\
|
||||
. = 5b + 0x40\n\
|
||||
moveb %5,%/a0@(2)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f\n\
|
||||
. = 5b + 0x60\n\
|
||||
movew %5,%/a0@(2)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f\n\
|
||||
. = 5b + 0x80\n\
|
||||
moveb %5,%/a0@(1)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0xa0\n\
|
||||
moveb %5,%/a0@(3) ; moveb %5,%/a0@(1)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0xc0\n\
|
||||
movew %5,%/a0@(1)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0xe0\n\
|
||||
movew %5,%/a0@(2) ; moveb %5,%/a0@(1)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x100\n\
|
||||
moveb %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x120\n\
|
||||
moveb %5,%/a0@(3) ; moveb %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x140\n\
|
||||
moveb %5,%/a0@(2) ; moveb %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x160\n\
|
||||
movew %5,%/a0@(2) ; moveb %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x180\n\
|
||||
movew %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x1a0\n\
|
||||
moveb %5,%/a0@(3) ; movew %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x1c0\n\
|
||||
moveb %5,%/a0@(2) ; movew %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x1e0\n\
|
||||
movel %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; \n\
|
||||
3: dbra %1,1b ; \n\
|
||||
4:\n"\
|
||||
: "=a" (addr), /* %0 */ \
|
||||
"=d" (count), /* %1 */ \
|
||||
"=d" (shift), /* %2 */ \
|
||||
"=a" (stipple) /* %3 */ \
|
||||
: "0" (addr), /* %4 */ \
|
||||
"d" (value), /* %5 */ \
|
||||
"a" (width), /* %6 */ \
|
||||
"1" (count-1), /* %7 */ \
|
||||
"2" (shift), /* %8 */ \
|
||||
"3" (stipple) /* %9 */ \
|
||||
: /* ctemp */ "d0", \
|
||||
/* c */ "d1", \
|
||||
/* lshift */ "d2", \
|
||||
/* rshift */ "d3", \
|
||||
/* atemp */ "a0", \
|
||||
/* case */ "a1")
|
281
cfb/stipmips.s
281
cfb/stipmips.s
|
@ -1,281 +0,0 @@
|
|||
/*
|
||||
* $Xorg: stipmips.s,v 1.4 2001/02/09 02:04:39 xorgcvs Exp $
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
/*
|
||||
* MIPS assembly code for optimized text rendering.
|
||||
*
|
||||
* Other stippling could be done in assembly, but the payoff is
|
||||
* not nearly as large. Mostly because large areas are heavily
|
||||
* optimized already.
|
||||
*/
|
||||
|
||||
#ifdef MIPSEL
|
||||
# define BitsR sll
|
||||
# define BitsL srl
|
||||
# define BO(o) o
|
||||
# define HO(o) o
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) and dest, bits, 0xf
|
||||
#else
|
||||
# define BitsR srl
|
||||
# define BitsL sll
|
||||
# define BO(o) 3-o
|
||||
# define HO(o) 2-o
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) srl dest, bits, 28
|
||||
#endif
|
||||
|
||||
/* reordering instructions would be fatal here */
|
||||
.set noreorder
|
||||
|
||||
|
||||
/*
|
||||
* cfbStippleStack(addr, stipple, value, stride, Count, Shift)
|
||||
* 4 5 6 7 16(sp) 20(sp)
|
||||
*
|
||||
* Apply successive 32-bit stipples starting at addr, addr+stride, ...
|
||||
*
|
||||
* Used for text rendering, but only when no data could be lost
|
||||
* when the stipple is shifted left by Shift bits
|
||||
*/
|
||||
/* arguments */
|
||||
#define addr $4
|
||||
#define stipple $5
|
||||
#define value $6
|
||||
#define stride $7
|
||||
#define Count 16($sp)
|
||||
#define Shift 20($sp)
|
||||
|
||||
/* local variables */
|
||||
#define count $14
|
||||
#define shift $13
|
||||
#define atemp $12
|
||||
#define bits $11
|
||||
#define lshift $9
|
||||
#define sbase $8
|
||||
#define stemp $2
|
||||
|
||||
#define CASE_SIZE 5 /* case blocks are 2^5 bytes each */
|
||||
#define CASE_MASK 0x1e0 /* first case mask */
|
||||
|
||||
#define ForEachLine $200
|
||||
#define NextLine $201
|
||||
#define NextLine1 $202
|
||||
#define CaseBegin $203
|
||||
#define ForEachBits $204
|
||||
#define ForEachBits1 $205
|
||||
#define NextBits $206
|
||||
|
||||
#ifdef TETEXT
|
||||
#define cfbStippleStack cfbStippleStackTE
|
||||
#endif
|
||||
|
||||
.globl cfbStippleStack
|
||||
.ent cfbStippleStack 2
|
||||
cfbStippleStack:
|
||||
.frame $sp, 0, $31
|
||||
lw count, Count /* fetch stack params */
|
||||
la sbase,CaseBegin /* load up switch table */
|
||||
lw shift, Shift
|
||||
li lshift, 4 /* compute offset within */
|
||||
subu lshift, lshift, shift /* stipple of remaining bits */
|
||||
#ifdef MIPSEL
|
||||
addu shift, shift, CASE_SIZE /* first shift for LSB */
|
||||
#else
|
||||
addu shift, shift, 28-CASE_SIZE /* first shift for MSB */
|
||||
#endif
|
||||
/* do ... while (--count > 0); */
|
||||
ForEachLine:
|
||||
lw bits, 0(stipple) /* get stipple bits */
|
||||
move atemp, addr /* set up for this line */
|
||||
#ifdef TETEXT
|
||||
/* Terminal emulator fonts are expanded and have many 0 rows */
|
||||
beqz bits, NextLine /* skip out early on 0 */
|
||||
#endif
|
||||
addu addr, addr, stride /* step for the loop */
|
||||
BitsR stemp, bits, shift /* get first bits */
|
||||
and stemp, stemp, CASE_MASK /* compute first branch */
|
||||
addu stemp, stemp, sbase /* ... */
|
||||
j stemp /* ... */
|
||||
BitsL bits, bits, lshift /* set remaining bits */
|
||||
|
||||
ForEachBits:
|
||||
addu atemp, atemp, 4
|
||||
ForEachBits1:
|
||||
FourBits(stemp, bits) /* compute jump for */
|
||||
sll stemp, stemp, CASE_SIZE /* next four bits */
|
||||
addu stemp, stemp, sbase /* ... */
|
||||
j stemp /* ... */
|
||||
BitsL bits, bits, 4 /* step for remaining bits */
|
||||
CaseBegin:
|
||||
bnez bits, ForEachBits1 /* 0 */
|
||||
addu atemp, atemp, 4
|
||||
NextLine:
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 1 */
|
||||
sb value, BO(0)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 2 */
|
||||
sb value, BO(1)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 3 */
|
||||
sh value, HO(0)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 4 */
|
||||
sb value, BO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
sb value, BO(0)(atemp) /* 5 */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
sb value, BO(1)(atemp) /* 6 */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 7 */
|
||||
swl value, BO(2)(atemp) /* untested on MSB */
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 8 */
|
||||
sb value, BO(3)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
sb value, BO(0)(atemp) /* 9 */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(3)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
sb value, BO(1)(atemp) /* a */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(3)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
sh value, HO(0)(atemp) /* b */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(3)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* c */
|
||||
sh value, HO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
sb value, BO(0)(atemp) /* d */
|
||||
bnez bits, ForEachBits
|
||||
sh value, HO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* e */
|
||||
swr value, BO(1)(atemp) /* untested on MSB */
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* f */
|
||||
sw value, WO(0)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
.end cfbStippleStack
|
290
cfb/stipsparc.s
290
cfb/stipsparc.s
|
@ -1,290 +0,0 @@
|
|||
/*
|
||||
* $Xorg: stipsparc.s,v 1.4 2001/02/09 02:04:39 xorgcvs Exp $
|
||||
* $XdotOrg: $
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
/* $XFree86: xc/programs/Xserver/cfb/stipsparc.s,v 1.4 2001/01/17 22:36:38 dawes Exp $ */
|
||||
|
||||
/*
|
||||
* SPARC assembly code for optimized text rendering.
|
||||
*
|
||||
* Other stippling could be done in assembly, but the payoff is
|
||||
* not nearly as large. Mostly because large areas are heavily
|
||||
* optimized already.
|
||||
*/
|
||||
|
||||
/* not that I expect to ever see an LSB SPARC, but ... */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
# define BitsR sll
|
||||
# define BitsL srl
|
||||
# define BO(o) o
|
||||
# define HO(o) o
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) and bits, 0xf, dest
|
||||
#else
|
||||
# define BitsR srl
|
||||
# define BitsL sll
|
||||
# define BO(o) 3-o
|
||||
# define HO(o) 2-o
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) srl bits, 28, dest
|
||||
#endif
|
||||
|
||||
/*
|
||||
* cfbStippleStack(addr, stipple, value, stride, Count, Shift)
|
||||
* 4 5 6 7 16(sp) 20(sp)
|
||||
*
|
||||
* Apply successive 32-bit stipples starting at addr, addr+stride, ...
|
||||
*
|
||||
* Used for text rendering, but only when no data could be lost
|
||||
* when the stipple is shifted left by Shift bits
|
||||
*/
|
||||
/* arguments */
|
||||
#define addr %i0
|
||||
#define stipple %i1
|
||||
#define value %i2
|
||||
#define stride %i3
|
||||
#define count %i4
|
||||
#define shift %i5
|
||||
|
||||
/* local variables */
|
||||
#define atemp %l0
|
||||
#define bits %l1
|
||||
#define lshift %l2
|
||||
#define sbase %l3
|
||||
#define stemp %l4
|
||||
|
||||
#define CASE_SIZE 5 /* case blocks are 2^5 bytes each */
|
||||
#define CASE_MASK 0x1e0 /* first case mask */
|
||||
|
||||
#define ForEachLine LY1
|
||||
#define NextLine LY2
|
||||
#define CaseBegin LY3
|
||||
#define ForEachBits LY4
|
||||
#define NextBits LY5
|
||||
|
||||
#if defined(SVR4) || defined(__ELF__)
|
||||
#ifdef TETEXT
|
||||
#define _cfbStippleStack cfbStippleStackTE
|
||||
#else
|
||||
#define _cfbStippleStack cfbStippleStack
|
||||
#endif
|
||||
#else
|
||||
#ifdef TETEXT
|
||||
#define _cfbStippleStack _cfbStippleStackTE
|
||||
#endif
|
||||
#endif
|
||||
.seg "text"
|
||||
.proc 16
|
||||
.globl _cfbStippleStack
|
||||
_cfbStippleStack:
|
||||
save %sp,-64,%sp
|
||||
#ifdef SHAREDCODE
|
||||
1:
|
||||
call 2f
|
||||
nop
|
||||
2:
|
||||
mov %o7,sbase /* sbase = 1b(1:) */
|
||||
add sbase, CaseBegin-1b, sbase
|
||||
#else /* !SHAREDCODE */
|
||||
sethi %hi(CaseBegin),sbase /* load up switch table */
|
||||
or sbase,%lo(CaseBegin),sbase
|
||||
#endif /* SHAREDCODE */
|
||||
mov 4,lshift /* compute offset within */
|
||||
sub lshift, shift, lshift /* stipple of remaining bits */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
inc CASE_SIZE, shift /* first shift for LSB */
|
||||
#else
|
||||
inc 28-CASE_SIZE, shift /* first shift for MSB */
|
||||
#endif
|
||||
/* do ... while (--count > 0); */
|
||||
ForEachLine:
|
||||
ld [stipple],bits /* get stipple bits */
|
||||
mov addr,atemp /* set up for this line */
|
||||
#ifdef TETEXT
|
||||
/* Terminal emulator fonts are expanded and have many 0 rows */
|
||||
tst bits
|
||||
bz NextLine /* skip out early on 0 */
|
||||
#endif
|
||||
add addr, stride, addr /* step for the loop */
|
||||
BitsR bits, shift, stemp /* get first bits */
|
||||
and stemp, CASE_MASK, stemp /* compute first jump */
|
||||
BitsL bits, lshift, bits /* set remaining bits */
|
||||
jmp sbase+stemp /* ... */
|
||||
tst bits
|
||||
|
||||
ForEachBits:
|
||||
inc 4, atemp
|
||||
ForEachBits1:
|
||||
FourBits(stemp, bits) /* compute jump for */
|
||||
sll stemp, CASE_SIZE, stemp /* these four bits */
|
||||
BitsL bits, 4, bits /* step for remaining bits */
|
||||
jmp sbase+stemp /* jump */
|
||||
tst bits
|
||||
CaseBegin:
|
||||
bnz,a ForEachBits1 /* 0 */
|
||||
inc 4, atemp
|
||||
NextLine:
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 1 */
|
||||
stb value, [atemp+BO(0)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 2 */
|
||||
stb value, [atemp+BO(1)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 3 */
|
||||
sth value, [atemp+HO(0)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 4 */
|
||||
stb value, [atemp+BO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
stb value, [atemp+BO(0)] /* 5 */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
stb value, [atemp+BO(1)] /* 6 */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
sth value, [atemp+HO(0)] /* 7 */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
bnz ForEachBits /* 8 */
|
||||
stb value, [atemp+BO(3)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
stb value, [atemp+BO(0)] /* 9 */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(3)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
stb value, [atemp+BO(1)] /* a */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(3)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
sth value, [atemp+HO(0)] /* b */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(3)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
bnz ForEachBits /* c */
|
||||
sth value, [atemp+HO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
stb value, [atemp+BO(0)] /* d */
|
||||
bnz ForEachBits
|
||||
sth value, [atemp+HO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
stb value, [atemp+BO(1)] /* e */
|
||||
bnz ForEachBits
|
||||
sth value, [atemp+HO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
bnz ForEachBits /* f */
|
||||
st value, [atemp+WO(0)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
291
cfb/stipsprc32.s
291
cfb/stipsprc32.s
|
@ -1,291 +0,0 @@
|
|||
/*
|
||||
* $Xorg: stipsprc32.s,v 1.4 2001/02/09 02:04:39 xorgcvs Exp $
|
||||
* $XdotOrg: $
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
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 THE
|
||||
OPEN GROUP 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.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
/* $XFree86: xc/programs/Xserver/cfb/stipsprc32.s,v 1.4 2001/01/17 22:36:38 dawes Exp $ */
|
||||
|
||||
/*
|
||||
* SPARC assembly code for optimized text rendering.
|
||||
*
|
||||
* Other stippling could be done in assembly, but the payoff is
|
||||
* not nearly as large. Mostly because large areas are heavily
|
||||
* optimized already.
|
||||
*/
|
||||
|
||||
/* not that I expect to ever see an LSB SPARC, but ... */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
# define BitsR sll
|
||||
# define BitsL srl
|
||||
# define WO(o) 3-o
|
||||
# define FourBits(dest,bits) and bits, 0xf, dest
|
||||
#else
|
||||
# define BitsR srl
|
||||
# define BitsL sll
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) srl bits, 28, dest
|
||||
#endif
|
||||
|
||||
/*
|
||||
* cfb32StippleStack(addr, stipple, value, stride, Count, Shift)
|
||||
* 4 5 6 7 16(sp) 20(sp)
|
||||
*
|
||||
* Apply successive 32-bit stipples starting at addr, addr+stride, ...
|
||||
*
|
||||
* Used for text rendering, but only when no data could be lost
|
||||
* when the stipple is shifted left by Shift bits
|
||||
*/
|
||||
/* arguments */
|
||||
#define addr %i0
|
||||
#define stipple %i1
|
||||
#define value %i2
|
||||
#define stride %i3
|
||||
#define count %i4
|
||||
#define shift %i5
|
||||
|
||||
/* local variables */
|
||||
#define atemp %l0
|
||||
#define bits %l1
|
||||
#define lshift %l2
|
||||
#define sbase %l3
|
||||
#define stemp %l4
|
||||
|
||||
#define CASE_SIZE 5 /* case blocks are 2^5 bytes each */
|
||||
#define CASE_MASK 0x1e0 /* first case mask */
|
||||
|
||||
#define ForEachLine LY1
|
||||
#define NextLine LY2
|
||||
#define CaseBegin LY3
|
||||
#define ForEachBits LY4
|
||||
#define NextBits LY5
|
||||
|
||||
#if defined(SVR4) || defined(__ELF__)
|
||||
#ifdef TETEXT
|
||||
#define _cfb32StippleStack cfb32StippleStackTE
|
||||
#else
|
||||
#define _cfb32StippleStack cfb32StippleStack
|
||||
#endif
|
||||
#else
|
||||
#ifdef TETEXT
|
||||
#define _cfb32StippleStack _cfb32StippleStackTE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
.seg "text"
|
||||
.proc 16
|
||||
.globl _cfb32StippleStack
|
||||
_cfb32StippleStack:
|
||||
save %sp,-64,%sp
|
||||
#ifdef SHAREDCODE
|
||||
1:
|
||||
call 2f
|
||||
nop
|
||||
2:
|
||||
mov %o7,sbase /* sbase = 1b(1:) */
|
||||
add sbase, CaseBegin-1b, sbase
|
||||
#else /* !SHAREDCODE */
|
||||
sethi %hi(CaseBegin),sbase /* load up switch table */
|
||||
or sbase,%lo(CaseBegin),sbase
|
||||
#endif /* !SHAREDCODE */
|
||||
mov 4,lshift /* compute offset within */
|
||||
sub lshift, shift, lshift /* stipple of remaining bits */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
inc CASE_SIZE, shift /* first shift for LSB */
|
||||
#else
|
||||
inc 28-CASE_SIZE, shift /* first shift for MSB */
|
||||
#endif
|
||||
/* do ... while (--count > 0); */
|
||||
ForEachLine:
|
||||
ld [stipple],bits /* get stipple bits */
|
||||
mov addr,atemp /* set up for this line */
|
||||
#ifdef TETEXT
|
||||
/* Terminal emulator fonts are expanded and have many 0 rows */
|
||||
tst bits
|
||||
bz NextLine /* skip out early on 0 */
|
||||
#endif
|
||||
add addr, stride, addr /* step for the loop */
|
||||
BitsR bits, shift, stemp /* get first bits */
|
||||
and stemp, CASE_MASK, stemp /* compute first jump */
|
||||
BitsL bits, lshift, bits /* set remaining bits */
|
||||
jmp sbase+stemp /* ... */
|
||||
tst bits
|
||||
|
||||
ForEachBits:
|
||||
inc 16, atemp
|
||||
ForEachBits1:
|
||||
FourBits(stemp, bits) /* compute jump for */
|
||||
sll stemp, CASE_SIZE, stemp /* these four bits */
|
||||
BitsL bits, 4, bits /* step for remaining bits */
|
||||
jmp sbase+stemp /* jump */
|
||||
tst bits
|
||||
CaseBegin:
|
||||
bnz,a ForEachBits1 /* 0 */
|
||||
inc 16, atemp
|
||||
NextLine:
|
||||
deccc 1, count
|
||||
NextLine1:
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 1 */
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 2 */
|
||||
st value, [atemp+WO(8)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(8)] /* 3 */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
bnz ForEachBits /* 4 */
|
||||
st value, [atemp+WO(4)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(4)] /* 5 */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(4)] /* 6 */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(8)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(4)] /* 7 */
|
||||
st value, [atemp+WO(8)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
b NextLine1
|
||||
deccc 1, count
|
||||
nop
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 8 */
|
||||
st value, [atemp+WO(0)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(0)] /* 9 */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(0)] /* a */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(8)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(0)] /* b */
|
||||
st value, [atemp+WO(8)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
b NextLine1
|
||||
deccc 1, count
|
||||
nop
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(0)] /* c */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(4)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(0)] /* d */
|
||||
st value, [atemp+WO(4)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
b NextLine1
|
||||
deccc 1, count
|
||||
nop
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(0)] /* e */
|
||||
st value, [atemp+WO(4)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(8)]
|
||||
b NextLine1
|
||||
deccc 1, count
|
||||
nop
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(0)] /* f */
|
||||
st value, [atemp+WO(4)]
|
||||
st value, [atemp+WO(8)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
|
@ -1,9 +0,0 @@
|
|||
noinst_LTLIBRARIES = libcfb32.la
|
||||
|
||||
include $(top_srcdir)/cfb/Makefile.am.inc
|
||||
|
||||
libcfb32_la_SOURCES = $(libcfb_common_sources) $(libcfb_gen_sources)
|
||||
|
||||
INCLUDES = $(CFB_INCLUDES) $(DIX_CFLAGS) -I$(top_srcdir)/hw/xfree86/os-support -I$(top_srcdir)/hw/xfree86/common
|
||||
|
||||
AM_CFLAGS = -DPSZ=32 $(PLATFORMDEFS)
|
70
configure.ac
70
configure.ac
|
@ -58,6 +58,7 @@ AC_PROG_LN_S
|
|||
AC_LIBTOOL_WIN32_DLL
|
||||
AC_DISABLE_STATIC
|
||||
AC_PROG_LIBTOOL
|
||||
DOLT
|
||||
AC_PROG_MAKE_SET
|
||||
PKG_PROG_PKG_CONFIG
|
||||
AC_PROG_LEX
|
||||
|
@ -313,6 +314,7 @@ case $host_cpu in
|
|||
case $host_os in
|
||||
*linux*) DEFAULT_INT10=vm86 ;;
|
||||
*freebsd*) AC_DEFINE(USE_DEV_IO) ;;
|
||||
*dragonfly*) AC_DEFINE(USE_DEV_IO) ;;
|
||||
*netbsd*) AC_DEFINE(USE_I386_IOPL)
|
||||
SYS_LIBS=-li386
|
||||
;;
|
||||
|
@ -337,6 +339,7 @@ case $host_cpu in
|
|||
I386_VIDEO=yes
|
||||
case $host_os in
|
||||
*freebsd*) AC_DEFINE(USE_DEV_IO, 1, [BSD /dev/io]) ;;
|
||||
*dragonfly*) AC_DEFINE(USE_DEV_IO, 1, [BSD /dev/io]) ;;
|
||||
*netbsd*) AC_DEFINE(USE_I386_IOPL, 1, [BSD i386 iopl])
|
||||
SYS_LIBS=-lx86_64
|
||||
;;
|
||||
|
@ -367,7 +370,7 @@ DRI2=no
|
|||
KDRIVE_HW=no
|
||||
dnl it would be nice to autodetect these *CONS_SUPPORTs
|
||||
case $host_os in
|
||||
*freebsd*)
|
||||
*freebsd* | *dragonfly*)
|
||||
case $host_os in
|
||||
kfreebsd*-gnu) ;;
|
||||
*) AC_DEFINE(CSRG_BASED, 1, [System is BSD-like]) ;;
|
||||
|
@ -521,7 +524,7 @@ AC_ARG_ENABLE(glx-tls, AS_HELP_STRING([--enable-glx-tls], [Build GLX with
|
|||
|
||||
dnl Extensions.
|
||||
AC_ARG_ENABLE(registry, AS_HELP_STRING([--disable-registry], [Build string registry module (default: enabled)]), [XREGISTRY=$enableval], [XREGISTRY=yes])
|
||||
AC_ARG_ENABLE(composite, AS_HELP_STRING([--disable-composite], [Build Composite extension (default: enabled)]), [COMPOSITE=$enableval], [COMPOSITE=yes])
|
||||
AC_ARG_ENABLE(composite, AS_HELP_STRING([--disable-composite], [Build Composite extension (default: enabled)]), [COMPOSITE=$enableval], [COMPOSITE=auto])
|
||||
AC_ARG_ENABLE(mitshm, AS_HELP_STRING([--disable-shm], [Build SHM extension (default: enabled)]), [MITSHM=$enableval], [MITSHM=yes])
|
||||
AC_ARG_ENABLE(xres, AS_HELP_STRING([--disable-xres], [Build XRes extension (default: enabled)]), [RES=$enableval], [RES=yes])
|
||||
AC_ARG_ENABLE(xtrap, AS_HELP_STRING([--disable-xtrap], [Build XTrap extension (default: enabled)]), [XTRAP=$enableval], [XTRAP=yes])
|
||||
|
@ -541,12 +544,10 @@ AC_ARG_ENABLE(xf86misc, AS_HELP_STRING([--disable-xf86misc], [Build XF86Mi
|
|||
AC_ARG_ENABLE(xace, AS_HELP_STRING([--disable-xace], [Build X-ACE extension (default: enabled)]), [XACE=$enableval], [XACE=yes])
|
||||
AC_ARG_ENABLE(xselinux, AS_HELP_STRING([--disable-xselinux], [Build SELinux extension (default: disabled)]), [XSELINUX=$enableval], [XSELINUX=no])
|
||||
AC_ARG_ENABLE(xcsecurity, AS_HELP_STRING([--disable-xcsecurity], [Build Security extension (default: disabled)]), [XCSECURITY=$enableval], [XCSECURITY=no])
|
||||
AC_ARG_ENABLE(appgroup, AS_HELP_STRING([--disable-appgroup], [Build XC-APPGROUP extension (default: disabled)]), [APPGROUP=$enableval], [APPGROUP=$XCSECURITY])
|
||||
AC_ARG_ENABLE(xcalibrate, AS_HELP_STRING([--enable-xcalibrate], [Build XCalibrate extension (default: disabled)]), [XCALIBRATE=$enableval], [XCALIBRATE=no])
|
||||
AC_ARG_ENABLE(tslib, AS_HELP_STRING([--enable-tslib], [Build kdrive tslib touchscreen support (default: disabled)]), [TSLIB=$enableval], [TSLIB=no])
|
||||
AC_ARG_ENABLE(xevie, AS_HELP_STRING([--disable-xevie], [Build XEvIE extension (default: enabled)]), [XEVIE=$enableval], [XEVIE=yes])
|
||||
AC_ARG_ENABLE(cup, AS_HELP_STRING([--disable-cup], [Build TOG-CUP extension (default: enabled)]), [CUP=$enableval], [CUP=yes])
|
||||
AC_ARG_ENABLE(evi, AS_HELP_STRING([--disable-evi], [Build Extended-Visual-Information extension (default: enabled)]), [EVI=$enableval], [EVI=yes])
|
||||
AC_ARG_ENABLE(multibuffer, AS_HELP_STRING([--enable-multibuffer], [Build Multibuffer extension (default: disabled)]), [MULTIBUFFER=$enableval], [MULTIBUFFER=no])
|
||||
AC_ARG_ENABLE(fontcache, AS_HELP_STRING([--enable-fontcache], [Build FontCache extension (default: disabled)]), [FONTCACHE=$enableval], [FONTCACHE=no])
|
||||
AC_ARG_ENABLE(dbe, AS_HELP_STRING([--disable-dbe], [Build DBE extension (default: enabled)]), [DBE=$enableval], [DBE=yes])
|
||||
|
@ -571,9 +572,8 @@ AC_ARG_ENABLE(xgl, AS_HELP_STRING([--enable-xgl], [Build Xgl server (
|
|||
AC_ARG_ENABLE(xglx, AS_HELP_STRING([--enable-xglx], [Build Xglx xgl module (default: no)]), [XGLX=$enableval], [XGLX=no])
|
||||
AC_ARG_ENABLE(xegl, AS_HELP_STRING([--enable-xegl], [Build Xegl xgl module (default: no)]), [XEGL=$enableval], [XEGL=no])
|
||||
dnl legacy fb support
|
||||
AC_ARG_ENABLE(mfb, AS_HELP_STRING([--enable-mfb], [Build legacy mono framebuffer support (default: enabled)]), [MFB=$enableval], [MFB=$XORG])
|
||||
AC_ARG_ENABLE(cfb, AS_HELP_STRING([--enable-cfb], [Build legacy color framebuffer support (default: enabled)]), [CFB=$enableval], [CFB=$XORG])
|
||||
AC_ARG_ENABLE(afb, AS_HELP_STRING([--enable-afb], [Build legacy advanced framebuffer support (default: enabled)]), [AFB=$enableval], [AFB=$XORG])
|
||||
AC_ARG_ENABLE(mfb, AS_HELP_STRING([--enable-mfb], [Build legacy mono framebuffer support (default: disable)]), [MFB=$enableval], [MFB=no])
|
||||
AC_ARG_ENABLE(afb, AS_HELP_STRING([--enable-afb], [Build legacy advanced framebuffer support (default: disable)]), [AFB=$enableval], [AFB=no])
|
||||
dnl kdrive and its subsystems
|
||||
AC_ARG_ENABLE(kdrive, AS_HELP_STRING([--enable-kdrive], [Build kdrive servers (default: no)]), [KDRIVE=$enableval], [KDRIVE=no])
|
||||
AC_ARG_ENABLE(xephyr, AS_HELP_STRING([--enable-xephyr], [Build the kdrive Xephyr server (default: auto)]), [XEPHYR=$enableval], [XEPHYR=auto])
|
||||
|
@ -732,7 +732,7 @@ if ! test "x$have_clock_gettime" = xno; then
|
|||
CPPFLAGS_SAVE="$CPPFLAGS"
|
||||
|
||||
if test x"$glibc" = xyes; then
|
||||
CPPFLAGS="$CPPFLAGS -D_POSIX_C_SOURCE=199309L"
|
||||
CPPFLAGS="$CPPFLAGS -D_POSIX_C_SOURCE=200112L"
|
||||
fi
|
||||
|
||||
AC_RUN_IFELSE([
|
||||
|
@ -781,6 +781,18 @@ if test "x$XREGISTRY" = xyes; then
|
|||
AC_DEFINE(XREGISTRY, 1, [Build registry module])
|
||||
fi
|
||||
|
||||
dnl XQuartz DDX Detection... Yes, it's ugly to have it here... but we need to disable COMPOSITE for
|
||||
if test "x$COMPOSITE" = xauto; then
|
||||
case $host_os in
|
||||
darwin*)
|
||||
test "x$XQUARTZ" = xyes -o "x$XQUARTZ" = xauto && COMPOSITE=no
|
||||
;;
|
||||
*)
|
||||
COMPOSITE=yes
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(COMPOSITE, [test "x$COMPOSITE" = xyes])
|
||||
if test "x$COMPOSITE" = xyes; then
|
||||
AC_DEFINE(COMPOSITE, 1, [Support Composite Extension])
|
||||
|
@ -917,26 +929,12 @@ if test "x$XEVIE" = xyes; then
|
|||
REQUIRED_MODULES="$REQUIRED_MODULES evieproto"
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(APPGROUP, [test "x$APPGROUP" = xyes])
|
||||
if test "x$APPGROUP" = xyes; then
|
||||
if test "x$XACE" != xyes || test "x$XCSECURITY" != xyes; then
|
||||
AC_MSG_ERROR([cannot build APPGROUP extension without X-ACE and XC-SECURITY])
|
||||
fi
|
||||
AC_DEFINE(XAPPGROUP, 1, [Build APPGROUP extension])
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(CUP, [test "x$CUP" = xyes])
|
||||
if test "x$CUP" = xyes; then
|
||||
AC_DEFINE(TOGCUP, 1, [Build TOG-CUP extension])
|
||||
# Requires xextproto which is always required
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(EVI, [test "x$EVI" = xyes])
|
||||
if test "x$EVI" = xyes; then
|
||||
AC_DEFINE(EVI, 1, [Build Extended-Visual-Information extension])
|
||||
# Requires xextproto which is always required
|
||||
fi
|
||||
|
||||
AM_CONDITIONAL(MULTIBUFFER, [test "x$MULTIBUFFER" = xyes])
|
||||
if test "x$MULTIBUFFER" = xyes; then
|
||||
AC_DEFINE(MULTIBUFFER, 1, [Build Multibuffer extension])
|
||||
|
@ -1096,12 +1094,9 @@ AC_DEFINE(NO_LIBCWRAPPER, 1, [Define to 1 if modules should avoid the libcwrappe
|
|||
|
||||
if test "x$DEBUGGING" = xyes; then
|
||||
AC_DEFINE(DEBUG, 1, [Enable debugging code])
|
||||
else
|
||||
AC_DEFINE(NDEBUG, 1, [Disable some debugging code])
|
||||
fi
|
||||
AM_CONDITIONAL(DEBUG, [test "x$DEBUGGING" = xyes])
|
||||
|
||||
AC_DEFINE(MITMISC, 1, [Support MIT Misc extension])
|
||||
AC_DEFINE(XTEST, 1, [Support XTest extension])
|
||||
AC_DEFINE(XSYNC, 1, [Support XSync extension])
|
||||
AC_DEFINE(XCMISC, 1, [Support XCMisc extension])
|
||||
|
@ -1360,7 +1355,7 @@ if test "x$XORG" = xyes -o "x$XGL" = xyes; then
|
|||
;;
|
||||
esac
|
||||
;;
|
||||
freebsd* | kfreebsd*-gnu)
|
||||
freebsd* | kfreebsd*-gnu | dragonfly*)
|
||||
XORG_OS="freebsd"
|
||||
XORG_OS_SUBDIR="bsd"
|
||||
xorg_bus_bsdpci="yes"
|
||||
|
@ -1555,7 +1550,11 @@ if test "x$XORG" = xyes -o "x$XGL" = xyes; then
|
|||
abi_xinput=`extract_abi XINPUT`
|
||||
abi_extension=`extract_abi EXTENSION`
|
||||
abi_font=`extract_abi FONT`
|
||||
AC_SUBST([abi_ansic abi_videodrv abi_xinput abi_extension abi_font])
|
||||
AC_SUBST([abi_ansic])
|
||||
AC_SUBST([abi_videodrv])
|
||||
AC_SUBST([abi_xinput])
|
||||
AC_SUBST([abi_extension])
|
||||
AC_SUBST([abi_font])
|
||||
fi
|
||||
AM_CONDITIONAL([XORG], [test "x$XORG" = xyes])
|
||||
AM_CONDITIONAL([XORG_BUS_LINUXPCI], [test "x$xorg_bus_linuxpci" = xyes])
|
||||
|
@ -1576,12 +1575,10 @@ AM_CONDITIONAL([XF86VIDMODE], [test "x$XF86VIDMODE" = xyes])
|
|||
|
||||
dnl legacy fb support
|
||||
test "x$MFB" = xauto && MFB="$XORG"
|
||||
test "x$CFB" = xauto && CFB="$XORG"
|
||||
test "x$AFB" = xauto && AFB="$XORG"
|
||||
AM_CONDITIONAL(MFB, [test "x$MFB" = xyes])
|
||||
AM_CONDITIONAL(CFB, [test "x$CFB" = xyes])
|
||||
AM_CONDITIONAL(AFB, [test "x$AFB" = xyes])
|
||||
if test "x$MFB" = xyes -o "x$CFB" = xyes -o "x$AFB" = xyes; then
|
||||
if test "x$MFB" = xyes -o "x$AFB" = xyes; then
|
||||
if test "x$XORG" != xyes; then
|
||||
AC_MSG_ERROR([legacy fb support requires the Xorg server])
|
||||
fi
|
||||
|
@ -1594,7 +1591,7 @@ AC_MSG_RESULT([$XPRINT])
|
|||
|
||||
if test "x$XPRINT" = xyes; then
|
||||
PKG_CHECK_MODULES([XPRINTMODULES], [printproto x11 xfont $XDMCP_MODULES xau])
|
||||
XPRINT_CFLAGS="$XPRINTMODULES_CFLAGS"
|
||||
XPRINT_CFLAGS="$XPRINTMODULES_CFLAGS -DXPRINT"
|
||||
XPRINT_LIBS="$XEXT_LIB $CONFIG_LIB $DBE_LIB $XTRAP_LIB $RECORD_LIB $RENDER_LIB $COMPOSITE_LIB $RANDR_LIB $XI_LIB $FIXES_LIB $DAMAGE_LIB $XI_LIB $GLX_LIBS $MIEXT_DAMAGE_LIB $XKB_LIB $XKB_STUB_LIB"
|
||||
XPRINT_SYS_LIBS="$XPRINTMODULES_LIBS"
|
||||
|
||||
|
@ -1730,7 +1727,8 @@ if test "X$XQUARTZ" = Xauto; then
|
|||
fi
|
||||
|
||||
if test "x$XQUARTZ" = xyes; then
|
||||
AC_DEFINE([XQUARTZ],[1],[Have Quartz])
|
||||
AC_DEFINE(XQUARTZ,1,[Have Quartz])
|
||||
AC_DEFINE(ROOTLESS,1,[Build Rootless code])
|
||||
|
||||
#glxAGL / glxCGL don't work yet
|
||||
# AC_CACHE_CHECK([for AGL framework],xorg_cv_AGL_framework,[
|
||||
|
@ -2094,7 +2092,9 @@ DIX_CFLAGS="-DHAVE_DIX_CONFIG_H $XSERVER_CFLAGS"
|
|||
|
||||
AC_SUBST([DIX_CFLAGS])
|
||||
|
||||
AC_SUBST([libdir exec_prefix prefix])
|
||||
AC_SUBST([libdir])
|
||||
AC_SUBST([exec_prefix])
|
||||
AC_SUBST([prefix])
|
||||
|
||||
# Man page sections - used in config utils & generating man pages
|
||||
XORG_MANPAGE_SECTIONS
|
||||
|
@ -2127,8 +2127,6 @@ fb/Makefile
|
|||
record/Makefile
|
||||
XTrap/Makefile
|
||||
mfb/Makefile
|
||||
cfb/Makefile
|
||||
cfb32/Makefile
|
||||
config/Makefile
|
||||
mi/Makefile
|
||||
miext/Makefile
|
||||
|
@ -2136,7 +2134,6 @@ miext/damage/Makefile
|
|||
miext/shadow/Makefile
|
||||
miext/cw/Makefile
|
||||
miext/rootless/Makefile
|
||||
miext/rootless/accel/Makefile
|
||||
os/Makefile
|
||||
randr/Makefile
|
||||
render/Makefile
|
||||
|
@ -2187,7 +2184,6 @@ hw/xfree86/xaa/Makefile
|
|||
hw/xfree86/xf1bpp/Makefile
|
||||
hw/xfree86/xf4bpp/Makefile
|
||||
hw/xfree86/xf8_16bpp/Makefile
|
||||
hw/xfree86/xf8_32bpp/Makefile
|
||||
hw/xfree86/utils/Makefile
|
||||
hw/xfree86/utils/cvt/Makefile
|
||||
hw/xfree86/utils/gtf/Makefile
|
||||
|
|
|
@ -1,4 +1,10 @@
|
|||
noinst_LTLIBRARIES = libdix.la libxpstubs.la
|
||||
standard_dix_libs = libdix.la libxpstubs.la
|
||||
|
||||
if XPRINT
|
||||
noinst_LTLIBRARIES = $(standard_dix_libs) libXpdix.la
|
||||
else
|
||||
noinst_LTLIBRARIES = $(standard_dix_libs)
|
||||
endif
|
||||
|
||||
AM_CFLAGS = $(DIX_CFLAGS) \
|
||||
-DVENDOR_NAME=\""@VENDOR_NAME@"\" \
|
||||
|
@ -40,7 +46,11 @@ libdix_la_SOURCES = \
|
|||
libxpstubs_la_SOURCES = \
|
||||
xpstubs.c
|
||||
|
||||
INCLUDES = -I$(top_srcdir)/Xprint
|
||||
if XPRINT
|
||||
libXpdix_la_SOURCES = $(libdix_la_SOURCES)
|
||||
libXpdix_la_CPPFLAGS = -I$(top_srcdir)/hw/xprint
|
||||
libXpdix_la_CFLAGS = $(AM_CFLAGS) $(XPRINT_CFLAGS)
|
||||
endif
|
||||
|
||||
EXTRA_DIST = buildatoms BuiltInAtoms CHANGES Xserver.d Xserver-dtrace.h.in
|
||||
|
||||
|
|
|
@ -830,12 +830,12 @@ CloseDownDevices(void)
|
|||
for (dev = inputInfo.devices; dev; dev = next)
|
||||
{
|
||||
next = dev->next;
|
||||
CloseDevice(dev);
|
||||
DeleteInputDeviceRequest(dev);
|
||||
}
|
||||
for (dev = inputInfo.off_devices; dev; dev = next)
|
||||
{
|
||||
next = dev->next;
|
||||
CloseDevice(dev);
|
||||
DeleteInputDeviceRequest(dev);
|
||||
}
|
||||
|
||||
inputInfo.devices = NULL;
|
||||
|
|
|
@ -136,9 +136,6 @@ int ProcInitialConnection();
|
|||
#endif
|
||||
#include "privates.h"
|
||||
#include "xace.h"
|
||||
#ifdef XAPPGROUP
|
||||
#include "appgroup.h"
|
||||
#endif
|
||||
#ifdef XKB
|
||||
#ifndef XKB_IN_SERVER
|
||||
#define XKB_IN_SERVER
|
||||
|
@ -3517,9 +3514,6 @@ void InitClient(ClientPtr client, int i, pointer ospriv)
|
|||
}
|
||||
#endif
|
||||
client->replyBytesRemaining = 0;
|
||||
#ifdef XAPPGROUP
|
||||
client->appgroup = NULL;
|
||||
#endif
|
||||
client->fontResFunc = NULL;
|
||||
#ifdef SMART_SCHEDULE
|
||||
client->smart_priority = 0;
|
||||
|
@ -3646,9 +3640,6 @@ SendConnSetup(ClientPtr client, char *reason)
|
|||
|
||||
client->requestVector = client->swapped ? SwappedProcVector : ProcVector;
|
||||
client->sequence = 0;
|
||||
#ifdef XAPPGROUP
|
||||
XagConnectionInfo (client, &lconnSetupPrefix, &lConnectionInfo, &numScreens);
|
||||
#endif
|
||||
((xConnSetup *)lConnectionInfo)->ridBase = client->clientAsMask;
|
||||
((xConnSetup *)lConnectionInfo)->ridMask = RESOURCE_ID_MASK;
|
||||
#ifdef MATCH_CLIENT_ENDIAN
|
||||
|
|
|
@ -270,7 +270,8 @@ dixLookupClient(ClientPtr *pClient, XID rid, ClientPtr client, Mask access)
|
|||
*pClient = clients[clientIndex];
|
||||
return Success;
|
||||
bad:
|
||||
client->errorValue = rid;
|
||||
if(client)
|
||||
client->errorValue = rid;
|
||||
*pClient = NULL;
|
||||
return rc;
|
||||
}
|
||||
|
|
|
@ -2663,6 +2663,13 @@ XYToWindow(DeviceIntPtr pDev, int x, int y)
|
|||
wInputShape(pWin),
|
||||
x - pWin->drawable.x,
|
||||
y - pWin->drawable.y, &box))
|
||||
#endif
|
||||
#ifdef ROOTLESS
|
||||
/* In rootless mode windows may be offscreen, even when
|
||||
* they're in X's stack. (E.g. if the native window system
|
||||
* implements some form of virtual desktop system).
|
||||
*/
|
||||
&& !pWin->rootlessUnhittable
|
||||
#endif
|
||||
)
|
||||
{
|
||||
|
|
14
dix/main.c
14
dix/main.c
|
@ -113,9 +113,6 @@ Equipment Corporation.
|
|||
#include "dispatch.h" /* InitProcVectors() */
|
||||
#endif
|
||||
|
||||
#include <pthread.h>
|
||||
pthread_key_t threadname_key=0;
|
||||
|
||||
#ifdef DPMSExtension
|
||||
#define DPMS_SERVER
|
||||
#include <X11/extensions/dpms.h>
|
||||
|
@ -251,17 +248,6 @@ main(int argc, char *argv[], char *envp[])
|
|||
char *xauthfile;
|
||||
HWEventQueueType alwaysCheckForInput[2];
|
||||
|
||||
if(threadname_key == 0) ErrorF("pthread_key_create returned %d\n", pthread_key_create(&threadname_key, NULL));
|
||||
ErrorF("threadname_key = %d\n", threadname_key);
|
||||
if(pthread_getspecific(threadname_key) == NULL) {
|
||||
char *nameptr = malloc(32);
|
||||
sprintf(nameptr, "main thread %d", random());
|
||||
// strcpy(nameptr, "main thread");
|
||||
ErrorF("calling: pthread_setspecific(%d, %s)=%d\n", threadname_key, nameptr, pthread_setspecific(threadname_key, nameptr));
|
||||
if (pthread_getspecific(threadname_key) != NULL) ErrorF("current thread: %s\n", (char *)pthread_getspecific(threadname_key));
|
||||
} else {
|
||||
if (pthread_getspecific(threadname_key) != NULL) ErrorF("thread was already: %s\n", (char *)pthread_getspecific(threadname_key));
|
||||
}
|
||||
display = "0";
|
||||
|
||||
InitGlobals();
|
||||
|
|
71
dix/window.c
71
dix/window.c
|
@ -124,9 +124,6 @@ Equipment Corporation.
|
|||
#include "dixevents.h"
|
||||
#include "globals.h"
|
||||
|
||||
#ifdef XAPPGROUP
|
||||
#include "appgroup.h"
|
||||
#endif
|
||||
#include "privates.h"
|
||||
#include "xace.h"
|
||||
|
||||
|
@ -310,6 +307,10 @@ SetWindowToDefaults(WindowPtr pWin)
|
|||
|
||||
sem = xcalloc(1, sizeof(FocusSemaphoresRec));
|
||||
dixSetPrivate(&pWin->devPrivates, FocusPrivatesKey, sem);
|
||||
|
||||
#ifdef ROOTLESS
|
||||
pWin->rootlessUnhittable = FALSE;
|
||||
#endif
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -632,14 +633,6 @@ CreateWindow(Window wid, WindowPtr pParent, int x, int y, unsigned w,
|
|||
if (!ancwopt)
|
||||
ancwopt = FindWindowWithOptional(pParent)->optional;
|
||||
if (visual == CopyFromParent) {
|
||||
#ifdef XAPPGROUP
|
||||
VisualID ag_visual;
|
||||
|
||||
if (client->appgroup && !pParent->parent &&
|
||||
(ag_visual = XagRootVisual (client)))
|
||||
visual = ag_visual;
|
||||
else
|
||||
#endif
|
||||
visual = ancwopt->visual;
|
||||
}
|
||||
|
||||
|
@ -1339,22 +1332,6 @@ ChangeWindowAttributes(WindowPtr pWin, Mask vmask, XID *vlist, ClientPtr client)
|
|||
pVlist++;
|
||||
if (cmap == CopyFromParent)
|
||||
{
|
||||
#ifdef XAPPGROUP
|
||||
Colormap ag_colormap;
|
||||
ClientPtr win_owner;
|
||||
|
||||
/*
|
||||
* win_owner == client for CreateWindow, other clients
|
||||
* can ChangeWindowAttributes
|
||||
*/
|
||||
win_owner = clients[CLIENT_ID(pWin->drawable.id)];
|
||||
|
||||
if ( win_owner && win_owner->appgroup &&
|
||||
!pWin->parent->parent &&
|
||||
(ag_colormap = XagDefaultColormap (win_owner)))
|
||||
cmap = ag_colormap;
|
||||
else
|
||||
#endif
|
||||
if (pWin->parent &&
|
||||
(!pWin->optional ||
|
||||
pWin->optional->visual == wVisual (pWin->parent)))
|
||||
|
@ -2283,10 +2260,6 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
|
|||
h = pWin->drawable.height,
|
||||
bw = pWin->borderWidth;
|
||||
int rc, action, smode = Above;
|
||||
#ifdef XAPPGROUP
|
||||
ClientPtr win_owner;
|
||||
ClientPtr ag_leader = NULL;
|
||||
#endif
|
||||
xEvent event;
|
||||
|
||||
if ((pWin->drawable.class == InputOnly) && (mask & IllegalInputOnlyConfigureMask))
|
||||
|
@ -2382,17 +2355,9 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
|
|||
else
|
||||
pSib = pWin->nextSib;
|
||||
|
||||
#ifdef XAPPGROUP
|
||||
win_owner = clients[CLIENT_ID(pWin->drawable.id)];
|
||||
ag_leader = XagLeader (win_owner);
|
||||
#endif
|
||||
|
||||
if ((!pWin->overrideRedirect) &&
|
||||
(RedirectSend(pParent)
|
||||
#ifdef XAPPGROUP
|
||||
|| (win_owner->appgroup && ag_leader &&
|
||||
XagIsControlledRoot (client, pParent))
|
||||
#endif
|
||||
))
|
||||
{
|
||||
event.u.u.type = ConfigureRequest;
|
||||
|
@ -2417,16 +2382,6 @@ ConfigureWindow(WindowPtr pWin, Mask mask, XID *vlist, ClientPtr client)
|
|||
event.u.configureRequest.height = h;
|
||||
event.u.configureRequest.borderWidth = bw;
|
||||
event.u.configureRequest.valueMask = mask;
|
||||
#ifdef XAPPGROUP
|
||||
/* make sure if the ag_leader maps the window it goes to the wm */
|
||||
if (ag_leader && ag_leader != client &&
|
||||
XagIsControlledRoot (client, pParent)) {
|
||||
event.u.configureRequest.parent = XagId (win_owner);
|
||||
(void) TryClientEvents (ag_leader, &event, 1,
|
||||
NoEventMask, NoEventMask, NullGrab);
|
||||
return Success;
|
||||
}
|
||||
#endif
|
||||
event.u.configureRequest.parent = pParent->drawable.id;
|
||||
if (MaybeDeliverEventsToClient(pParent, &event, 1,
|
||||
SubstructureRedirectMask, client) == 1)
|
||||
|
@ -2803,31 +2758,13 @@ MapWindow(WindowPtr pWin, ClientPtr client)
|
|||
{
|
||||
xEvent event;
|
||||
Bool anyMarked;
|
||||
#ifdef XAPPGROUP
|
||||
ClientPtr win_owner = clients[CLIENT_ID(pWin->drawable.id)];
|
||||
ClientPtr ag_leader = XagLeader (win_owner);
|
||||
#endif
|
||||
|
||||
if ((!pWin->overrideRedirect) &&
|
||||
(RedirectSend(pParent)
|
||||
#ifdef XAPPGROUP
|
||||
|| (win_owner->appgroup && ag_leader &&
|
||||
XagIsControlledRoot (client, pParent))
|
||||
#endif
|
||||
))
|
||||
{
|
||||
event.u.u.type = MapRequest;
|
||||
event.u.mapRequest.window = pWin->drawable.id;
|
||||
#ifdef XAPPGROUP
|
||||
/* make sure if the ag_leader maps the window it goes to the wm */
|
||||
if (ag_leader && ag_leader != client &&
|
||||
XagIsControlledRoot (client, pParent)) {
|
||||
event.u.mapRequest.parent = XagId (win_owner);
|
||||
(void) TryClientEvents (ag_leader, &event, 1,
|
||||
NoEventMask, NoEventMask, NullGrab);
|
||||
return Success;
|
||||
}
|
||||
#endif
|
||||
event.u.mapRequest.parent = pParent->drawable.id;
|
||||
|
||||
if (MaybeDeliverEventsToClient(pParent, &event, 1,
|
||||
|
|
124
exa/exa.c
124
exa/exa.c
|
@ -224,6 +224,43 @@ exaLog2(int val)
|
|||
return bits - 1;
|
||||
}
|
||||
|
||||
static void
|
||||
exaSetAccelBlock(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
|
||||
int w, int h, int bpp)
|
||||
{
|
||||
pExaPixmap->accel_blocked = 0;
|
||||
|
||||
if (pExaScr->info->maxPitchPixels) {
|
||||
int max_pitch = pExaScr->info->maxPitchPixels * (bpp + 7) / 8;
|
||||
|
||||
if (pExaPixmap->fb_pitch > max_pitch)
|
||||
pExaPixmap->accel_blocked |= EXA_RANGE_PITCH;
|
||||
}
|
||||
|
||||
if (pExaScr->info->maxPitchBytes &&
|
||||
pExaPixmap->fb_pitch > pExaScr->info->maxPitchBytes)
|
||||
pExaPixmap->accel_blocked |= EXA_RANGE_PITCH;
|
||||
|
||||
if (w > pExaScr->info->maxX)
|
||||
pExaPixmap->accel_blocked |= EXA_RANGE_WIDTH;
|
||||
|
||||
if (h > pExaScr->info->maxY)
|
||||
pExaPixmap->accel_blocked |= EXA_RANGE_HEIGHT;
|
||||
}
|
||||
|
||||
static void
|
||||
exaSetFbPitch(ExaScreenPrivPtr pExaScr, ExaPixmapPrivPtr pExaPixmap,
|
||||
int w, int h, int bpp)
|
||||
{
|
||||
if (pExaScr->info->flags & EXA_OFFSCREEN_ALIGN_POT && w != 1)
|
||||
pExaPixmap->fb_pitch = (1 << (exaLog2(w - 1) + 1)) * bpp / 8;
|
||||
else
|
||||
pExaPixmap->fb_pitch = w * bpp / 8;
|
||||
|
||||
pExaPixmap->fb_pitch = EXA_ALIGN(pExaPixmap->fb_pitch,
|
||||
pExaScr->info->pixmapPitchAlign);
|
||||
}
|
||||
|
||||
/**
|
||||
* exaCreatePixmap() creates a new pixmap.
|
||||
*
|
||||
|
@ -268,12 +305,8 @@ exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth,
|
|||
if (paddedWidth / 4 > 32767 || h > 32767)
|
||||
return NullPixmap;
|
||||
|
||||
if (pExaScr->info->flags & EXA_OFFSCREEN_ALIGN_POT && w != 1)
|
||||
pExaPixmap->fb_pitch = (1 << (exaLog2(w - 1) + 1)) * bpp / 8;
|
||||
else
|
||||
pExaPixmap->fb_pitch = w * bpp / 8;
|
||||
pExaPixmap->fb_pitch = EXA_ALIGN(pExaPixmap->fb_pitch,
|
||||
pExaScr->info->pixmapPitchAlign);
|
||||
exaSetFbPitch(pExaScr, pExaPixmap, w, h, bpp);
|
||||
|
||||
if (paddedWidth < pExaPixmap->fb_pitch)
|
||||
paddedWidth = pExaPixmap->fb_pitch;
|
||||
|
||||
|
@ -307,12 +340,7 @@ exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth,
|
|||
pExaPixmap->offscreen = FALSE;
|
||||
|
||||
pExaPixmap->fb_ptr = NULL;
|
||||
if (pExaScr->info->flags & EXA_OFFSCREEN_ALIGN_POT && w != 1)
|
||||
pExaPixmap->fb_pitch = (1 << (exaLog2(w - 1) + 1)) * bpp / 8;
|
||||
else
|
||||
pExaPixmap->fb_pitch = w * bpp / 8;
|
||||
pExaPixmap->fb_pitch = EXA_ALIGN(pExaPixmap->fb_pitch,
|
||||
pExaScr->info->pixmapPitchAlign);
|
||||
exaSetFbPitch(pExaScr, pExaPixmap, w, h, bpp);
|
||||
pExaPixmap->fb_size = pExaPixmap->fb_pitch * h;
|
||||
|
||||
if (pExaPixmap->fb_pitch > 131071) {
|
||||
|
@ -339,25 +367,8 @@ exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth,
|
|||
REGION_NULL(pScreen, &pExaPixmap->validSys);
|
||||
REGION_NULL(pScreen, &pExaPixmap->validFB);
|
||||
|
||||
/* Check whether this pixmap can be used for acceleration. */
|
||||
pExaPixmap->accel_blocked = 0;
|
||||
|
||||
if (pExaScr->info->maxPitchPixels) {
|
||||
int max_pitch = pExaScr->info->maxPitchPixels * (bpp + 7) / 8;
|
||||
|
||||
if (pExaPixmap->fb_pitch > max_pitch)
|
||||
pExaPixmap->accel_blocked |= EXA_RANGE_PITCH;
|
||||
}
|
||||
|
||||
if (pExaScr->info->maxPitchBytes &&
|
||||
pExaPixmap->fb_pitch > pExaScr->info->maxPitchBytes)
|
||||
pExaPixmap->accel_blocked |= EXA_RANGE_PITCH;
|
||||
|
||||
if (w > pExaScr->info->maxX)
|
||||
pExaPixmap->accel_blocked |= EXA_RANGE_WIDTH;
|
||||
|
||||
if (h > pExaScr->info->maxY)
|
||||
pExaPixmap->accel_blocked |= EXA_RANGE_HEIGHT;
|
||||
exaSetAccelBlock(pExaScr, pExaPixmap,
|
||||
w, h, bpp);
|
||||
|
||||
return pPixmap;
|
||||
}
|
||||
|
@ -373,12 +384,25 @@ exaModifyPixmapHeader(PixmapPtr pPixmap, int width, int height, int depth,
|
|||
if (!pPixmap)
|
||||
return FALSE;
|
||||
|
||||
pExaScr = ExaGetScreenPriv(pPixmap->drawable.pScreen);
|
||||
pExaPixmap = ExaGetPixmapPriv(pPixmap);
|
||||
|
||||
if (pExaPixmap)
|
||||
pExaPixmap->sys_ptr = pPixData;
|
||||
if (pExaPixmap) {
|
||||
if (pPixData)
|
||||
pExaPixmap->sys_ptr = pPixData;
|
||||
|
||||
if (devKind > 0)
|
||||
pExaPixmap->sys_pitch = devKind;
|
||||
|
||||
if (width > 0 && height > 0 && bitsPerPixel > 0) {
|
||||
exaSetFbPitch(pExaScr, pExaPixmap,
|
||||
width, height, bitsPerPixel);
|
||||
|
||||
exaSetAccelBlock(pExaScr, pExaPixmap,
|
||||
width, height, bitsPerPixel);
|
||||
}
|
||||
}
|
||||
|
||||
pExaScr = ExaGetScreenPriv(pPixmap->drawable.pScreen);
|
||||
|
||||
if (pExaScr->info->ModifyPixmapHeader) {
|
||||
ret = pExaScr->info->ModifyPixmapHeader(pPixmap, width, height, depth,
|
||||
|
@ -675,6 +699,34 @@ exaBitmapToRegion(PixmapPtr pPix)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static Bool
|
||||
exaCreateScreenResources(ScreenPtr pScreen)
|
||||
{
|
||||
ExaScreenPriv(pScreen);
|
||||
PixmapPtr pScreenPixmap;
|
||||
Bool b;
|
||||
|
||||
pScreen->CreateScreenResources = pExaScr->SavedCreateScreenResources;
|
||||
b = pScreen->CreateScreenResources(pScreen);
|
||||
pScreen->CreateScreenResources = exaCreateScreenResources;
|
||||
|
||||
if (!b)
|
||||
return FALSE;
|
||||
|
||||
pScreenPixmap = pScreen->GetScreenPixmap(pScreen);
|
||||
|
||||
if (pScreenPixmap) {
|
||||
ExaPixmapPriv(pScreenPixmap);
|
||||
|
||||
exaSetAccelBlock(pExaScr, pExaPixmap,
|
||||
pScreenPixmap->drawable.width,
|
||||
pScreenPixmap->drawable.height,
|
||||
pScreenPixmap->drawable.bitsPerPixel);
|
||||
}
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* exaCloseScreen() unwraps its wrapped screen functions and tears down EXA's
|
||||
* screen private, before calling down to the next CloseSccreen.
|
||||
|
@ -696,6 +748,7 @@ exaCloseScreen(int i, ScreenPtr pScreen)
|
|||
pScreen->CopyWindow = pExaScr->SavedCopyWindow;
|
||||
pScreen->ChangeWindowAttributes = pExaScr->SavedChangeWindowAttributes;
|
||||
pScreen->BitmapToRegion = pExaScr->SavedBitmapToRegion;
|
||||
pScreen->CreateScreenResources = pExaScr->SavedCreateScreenResources;
|
||||
#ifdef RENDER
|
||||
if (ps) {
|
||||
ps->Composite = pExaScr->SavedComposite;
|
||||
|
@ -853,6 +906,9 @@ exaDriverInit (ScreenPtr pScreen,
|
|||
pExaScr->SavedBitmapToRegion = pScreen->BitmapToRegion;
|
||||
pScreen->BitmapToRegion = exaBitmapToRegion;
|
||||
|
||||
pExaScr->SavedCreateScreenResources = pScreen->CreateScreenResources;
|
||||
pScreen->CreateScreenResources = exaCreateScreenResources;
|
||||
|
||||
#ifdef RENDER
|
||||
if (ps) {
|
||||
pExaScr->SavedComposite = ps->Composite;
|
||||
|
|
|
@ -64,6 +64,8 @@ struct _ExaOffscreenArea {
|
|||
ExaOffscreenState state;
|
||||
|
||||
ExaOffscreenArea *next;
|
||||
|
||||
unsigned eviction_cost;
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
|
@ -527,16 +527,36 @@ exaCopyNtoN (DrawablePtr pSrcDrawable,
|
|||
pDstExaPixmap = ExaGetPixmapPriv (pDstPixmap);
|
||||
|
||||
/* Check whether the accelerator can use this pixmap.
|
||||
* FIXME: If it cannot, use temporary pixmaps so that the drawing
|
||||
* happens within limits.
|
||||
* If the pitch of the pixmaps is out of range, there's nothing
|
||||
* we can do but fall back to software rendering.
|
||||
*/
|
||||
if (pSrcExaPixmap->accel_blocked || pDstExaPixmap->accel_blocked)
|
||||
{
|
||||
if (pSrcExaPixmap->accel_blocked & EXA_RANGE_PITCH ||
|
||||
pDstExaPixmap->accel_blocked & EXA_RANGE_PITCH)
|
||||
goto fallback;
|
||||
} else {
|
||||
exaDoMigration (pixmaps, 2, TRUE);
|
||||
|
||||
/* If the width or the height of either of the pixmaps
|
||||
* is out of range, check whether the boxes are actually out of the
|
||||
* addressable range as well. If they aren't, we can still do
|
||||
* the copying in hardware.
|
||||
*/
|
||||
if (pSrcExaPixmap->accel_blocked || pDstExaPixmap->accel_blocked) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < nbox; i++) {
|
||||
/* src */
|
||||
if ((pbox[i].x2 + dx + src_off_x) >= pExaScr->info->maxX ||
|
||||
(pbox[i].y2 + dy + src_off_y) >= pExaScr->info->maxY)
|
||||
goto fallback;
|
||||
|
||||
/* dst */
|
||||
if ((pbox[i].x2 + dst_off_x) >= pExaScr->info->maxX ||
|
||||
(pbox[i].y2 + dst_off_y) >= pExaScr->info->maxY)
|
||||
goto fallback;
|
||||
}
|
||||
}
|
||||
|
||||
exaDoMigration (pixmaps, 2, TRUE);
|
||||
|
||||
/* Mixed directions must be handled specially if the card is lame */
|
||||
if ((pExaScr->info->flags & EXA_TWO_BITBLT_DIRECTIONS) &&
|
||||
reverse != upsidedown) {
|
||||
|
|
|
@ -21,11 +21,9 @@
|
|||
*/
|
||||
|
||||
/** @file
|
||||
* This allocator allocates blocks of memory by maintaining a list of areas
|
||||
* and a score for each area. As an area is marked used, its score is
|
||||
* incremented, and periodically all of the areas have their scores decayed by
|
||||
* a fraction. When allocating, the contiguous block of areas with the minimum
|
||||
* score is found and evicted in order to make room for the new allocation.
|
||||
* This allocator allocates blocks of memory by maintaining a list of areas.
|
||||
* When allocating, the contiguous block of areas with the minimum eviction
|
||||
* cost is found and evicted in order to make room for the new allocation.
|
||||
*/
|
||||
|
||||
#include "exa_priv.h"
|
||||
|
@ -71,19 +69,36 @@ ExaOffscreenKickOut (ScreenPtr pScreen, ExaOffscreenArea *area)
|
|||
return exaOffscreenFree (pScreen, area);
|
||||
}
|
||||
|
||||
#define AREA_SCORE(area) (area->size / (double)(pExaScr->offScreenCounter - area->last_use))
|
||||
static void
|
||||
exaUpdateEvictionCost(ExaOffscreenArea *area, unsigned offScreenCounter)
|
||||
{
|
||||
unsigned age;
|
||||
|
||||
if (area->state == ExaOffscreenAvail)
|
||||
return;
|
||||
|
||||
age = offScreenCounter - area->last_use;
|
||||
|
||||
/* This is unlikely to happen, but could result in a division by zero... */
|
||||
if (age > (UINT_MAX / 2)) {
|
||||
age = UINT_MAX / 2;
|
||||
area->last_use = offScreenCounter - age;
|
||||
}
|
||||
|
||||
area->eviction_cost = area->size / age;
|
||||
}
|
||||
|
||||
static ExaOffscreenArea *
|
||||
exaFindAreaToEvict(ExaScreenPrivPtr pExaScr, int size, int align)
|
||||
{
|
||||
ExaOffscreenArea *begin, *end, *best;
|
||||
double score, best_score;
|
||||
unsigned cost, best_cost;
|
||||
int avail, real_size, tmp;
|
||||
|
||||
best_score = UINT_MAX;
|
||||
best_cost = UINT_MAX;
|
||||
begin = end = pExaScr->info->offScreenAreas;
|
||||
avail = 0;
|
||||
score = 0;
|
||||
cost = 0;
|
||||
best = 0;
|
||||
|
||||
while (end != NULL)
|
||||
|
@ -106,23 +121,24 @@ exaFindAreaToEvict(ExaScreenPrivPtr pExaScr, int size, int align)
|
|||
if (end->state == ExaOffscreenLocked) {
|
||||
/* Can't more room here, restart after this locked area */
|
||||
avail = 0;
|
||||
score = 0;
|
||||
cost = 0;
|
||||
begin = end;
|
||||
goto restart;
|
||||
}
|
||||
avail += end->size;
|
||||
score += AREA_SCORE(end);
|
||||
exaUpdateEvictionCost(end, pExaScr->offScreenCounter);
|
||||
cost += end->eviction_cost;
|
||||
end = end->next;
|
||||
}
|
||||
|
||||
/* Check the score, update best */
|
||||
if (avail >= real_size && score < best_score) {
|
||||
/* Check the cost, update best */
|
||||
if (avail >= real_size && cost < best_cost) {
|
||||
best = begin;
|
||||
best_score = score;
|
||||
best_cost = cost;
|
||||
}
|
||||
|
||||
avail -= begin->size;
|
||||
score -= AREA_SCORE(begin);
|
||||
cost -= begin->eviction_cost;
|
||||
begin = begin->next;
|
||||
}
|
||||
|
||||
|
@ -244,6 +260,7 @@ exaOffscreenAlloc (ScreenPtr pScreen, int size, int align,
|
|||
new_area->state = ExaOffscreenAvail;
|
||||
new_area->save = NULL;
|
||||
new_area->last_use = 0;
|
||||
new_area->eviction_cost = 0;
|
||||
new_area->next = area->next;
|
||||
area->next = new_area;
|
||||
area->size = real_size;
|
||||
|
@ -409,6 +426,7 @@ exaOffscreenFree (ScreenPtr pScreen, ExaOffscreenArea *area)
|
|||
area->state = ExaOffscreenAvail;
|
||||
area->save = NULL;
|
||||
area->last_use = 0;
|
||||
area->eviction_cost = 0;
|
||||
/*
|
||||
* Find previous area
|
||||
*/
|
||||
|
@ -474,6 +492,7 @@ exaOffscreenInit (ScreenPtr pScreen)
|
|||
area->save = NULL;
|
||||
area->next = NULL;
|
||||
area->last_use = 0;
|
||||
area->eviction_cost = 0;
|
||||
|
||||
/* Add it to the free areas */
|
||||
pExaScr->info->offScreenAreas = area;
|
||||
|
|
|
@ -107,6 +107,7 @@ typedef struct {
|
|||
CopyWindowProcPtr SavedCopyWindow;
|
||||
ChangeWindowAttributesProcPtr SavedChangeWindowAttributes;
|
||||
BitmapToRegionProcPtr SavedBitmapToRegion;
|
||||
CreateScreenResourcesProcPtr SavedCreateScreenResources;
|
||||
ModifyPixmapHeaderProcPtr SavedModifyPixmapHeader;
|
||||
#ifdef RENDER
|
||||
CompositeProcPtr SavedComposite;
|
||||
|
|
|
@ -51,6 +51,9 @@ static void exaCompositeFallbackPictDesc(PicturePtr pict, char *string, int n)
|
|||
case PICT_a8r8g8b8:
|
||||
snprintf(format, 20, "ARGB8888");
|
||||
break;
|
||||
case PICT_x8r8g8b8:
|
||||
snprintf(format, 20, "XRGB8888");
|
||||
break;
|
||||
case PICT_r5g6b5:
|
||||
snprintf(format, 20, "RGB565 ");
|
||||
break;
|
||||
|
@ -650,7 +653,7 @@ exaComposite(CARD8 op,
|
|||
!pSrc->transform &&
|
||||
pSrc->repeatType == RepeatNormal)
|
||||
{
|
||||
DDXPointRec srcOrg;
|
||||
DDXPointRec patOrg;
|
||||
|
||||
/* Let's see if the driver can do the repeat in one go */
|
||||
if (pExaScr->info->PrepareComposite && !pSrc->alphaMap &&
|
||||
|
@ -674,12 +677,14 @@ exaComposite(CARD8 op,
|
|||
width, height))
|
||||
goto done;
|
||||
|
||||
srcOrg.x = (xSrc - xDst) % pSrc->pDrawable->width;
|
||||
srcOrg.y = (ySrc - yDst) % pSrc->pDrawable->height;
|
||||
/* pattern origin is the point in the destination drawable
|
||||
* corresponding to (0,0) in the source */
|
||||
patOrg.x = xDst - xSrc;
|
||||
patOrg.y = yDst - ySrc;
|
||||
|
||||
ret = exaFillRegionTiled(pDst->pDrawable, ®ion,
|
||||
(PixmapPtr)pSrc->pDrawable,
|
||||
&srcOrg, FB_ALLONES, GXcopy);
|
||||
&patOrg, FB_ALLONES, GXcopy);
|
||||
|
||||
REGION_UNINIT(pDst->pDrawable->pScreen, ®ion);
|
||||
|
||||
|
|
|
@ -7,7 +7,7 @@ INCLUDES = \
|
|||
AM_CFLAGS = $(DIX_CFLAGS)
|
||||
|
||||
if XORG
|
||||
sdk_HEADERS = fb.h fbrop.h fbpseudocolor.h fboverlay.h wfbrename.h
|
||||
sdk_HEADERS = fb.h fbrop.h fboverlay.h wfbrename.h
|
||||
endif
|
||||
|
||||
libfb_la_CFLAGS = $(AM_CFLAGS)
|
||||
|
@ -49,9 +49,7 @@ libfb_la_SOURCES = \
|
|||
fbtile.c \
|
||||
fbtrap.c \
|
||||
fbutil.c \
|
||||
fbwindow.c \
|
||||
fbpseudocolor.c \
|
||||
fbpseudocolor.h
|
||||
fbwindow.c
|
||||
|
||||
libwfb_la_SOURCES = $(libfb_la_SOURCES)
|
||||
|
||||
|
|
2
fb/fb.h
2
fb/fb.h
|
@ -141,7 +141,7 @@ typedef unsigned __int64 FbBits;
|
|||
defined(ia64) || defined(__ia64__) || \
|
||||
defined(__sparc64__) || defined(_LP64) || \
|
||||
defined(__s390x__) || \
|
||||
defined(amd64) || defined (__amd64__) || \
|
||||
defined(amd64) || defined (__amd64__) || defined(__x86_64__) || \
|
||||
defined (__powerpc64__) || \
|
||||
(defined(sgi) && (_MIPS_SZLONG == 64))
|
||||
typedef unsigned long FbBits;
|
||||
|
|
2248
fb/fbpseudocolor.c
2248
fb/fbpseudocolor.c
File diff suppressed because it is too large
Load Diff
|
@ -1,20 +0,0 @@
|
|||
#ifndef _FB_XX_H_
|
||||
# define _FB_XX_H_
|
||||
|
||||
typedef void (*xxSyncFunc)(ScreenPtr);
|
||||
extern Bool xxSetup(ScreenPtr pScreen, int myDepth,
|
||||
int baseDepth, char *addr, xxSyncFunc sync);
|
||||
extern void xxPrintVisuals(void);
|
||||
|
||||
|
||||
#endif /* _FB_XX_H_ */
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -187,12 +187,4 @@
|
|||
#define fbZeroSegment wfbZeroSegment
|
||||
#define free_pixman_pict wfb_free_pixman_pict
|
||||
#define image_from_pict wfb_image_from_pict
|
||||
#define xxScrPrivateKey wfbxxScrPrivateKey
|
||||
#define xxGCPrivateKey wfbxxGCPrivateKey
|
||||
#define xxColormapPrivateKey wfbxxColormapPrivateKey
|
||||
#define xxGeneration wfbxxGeneration
|
||||
#define xxPrintVisuals wfbxxPrintVisuals
|
||||
#define xxGCFuncs wfbxxGCFuncs
|
||||
#define xxGCOps wfbxxGCOps
|
||||
#define xxSetup wfbxxSetup
|
||||
#define composeFunctions wfbComposeFunctions
|
||||
|
|
|
@ -83,8 +83,6 @@
|
|||
#undef XF86MISC
|
||||
#undef XFreeXDGA
|
||||
#undef XF86DRI
|
||||
#undef TOGCUP
|
||||
#undef MITMISC
|
||||
#undef SCREENSAVER
|
||||
#undef RANDR
|
||||
#undef XFIXES
|
||||
|
|
|
@ -1350,7 +1350,6 @@ int dmxAttachScreen(int idx, DMXScreenAttributesPtr attr)
|
|||
* RTContext
|
||||
* TagResType
|
||||
* StalledResType
|
||||
* RT_APPGROUP
|
||||
* SecurityAuthorizationResType
|
||||
* RTEventClient
|
||||
* __glXContextRes
|
||||
|
|
|
@ -28,7 +28,6 @@
|
|||
#ifdef HAVE_CONFIG_H
|
||||
#include <kdrive-config.h>
|
||||
#endif
|
||||
#undef NDEBUG /* No, really. The whole point of this module is to crash. */
|
||||
|
||||
#include "ephyr.h"
|
||||
#include "exa_priv.h"
|
||||
|
|
|
@ -31,11 +31,11 @@
|
|||
#include <assert.h>
|
||||
#include "os.h"
|
||||
|
||||
#ifdef NDEBUG
|
||||
#ifndef DEBUG
|
||||
/*we are not in debug mode*/
|
||||
#define EPHYR_LOG(...)
|
||||
#define EPHYR_LOG_ERROR(...)
|
||||
#endif /*NDEBUG*/
|
||||
#endif /*!DEBUG*/
|
||||
|
||||
#define ERROR_LOG_LEVEL 3
|
||||
#define INFO_LOG_LEVEL 4
|
||||
|
|
|
@ -1739,7 +1739,7 @@ KdClassifyInput (KdPointerInfo *pi, int type, int x, int y, int z, int b)
|
|||
return keyboard;
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
#ifdef DEBUG
|
||||
char *kdStateNames[] = {
|
||||
"start",
|
||||
"button_1_pend",
|
||||
|
@ -1772,7 +1772,7 @@ char *kdActionNames[] = {
|
|||
"gen_down_2",
|
||||
"gen_up_2",
|
||||
};
|
||||
#endif
|
||||
#endif /* DEBUG */
|
||||
|
||||
static void
|
||||
KdQueueEvent (DeviceIntPtr pDev, xEvent *ev)
|
||||
|
|
|
@ -16,20 +16,16 @@ if MFB
|
|||
MFB_SUBDIR = xf1bpp xf4bpp
|
||||
endif
|
||||
|
||||
if CFB
|
||||
CFB_SUBDIR = xf8_32bpp
|
||||
endif
|
||||
|
||||
DOC_SUBDIR = doc
|
||||
|
||||
SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support parser rac \
|
||||
ramdac shadowfb vbe vgahw xaa $(MFB_SUBDIR) $(CFB_SUBDIR) \
|
||||
ramdac shadowfb vbe vgahw xaa $(MFB_SUBDIR) \
|
||||
xf8_16bpp loader dixmods exa modes \
|
||||
$(DRI_SUBDIR) $(DRI2_SUBDIR) $(XF86UTILS_SUBDIR) $(DOC_SUBDIR)
|
||||
|
||||
DIST_SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support \
|
||||
parser rac ramdac shadowfb vbe vgahw xaa xf1bpp xf4bpp \
|
||||
xf8_16bpp xf8_32bpp loader dixmods dri dri2 exa modes \
|
||||
xf8_16bpp loader dixmods dri dri2 exa modes \
|
||||
utils doc
|
||||
|
||||
bin_PROGRAMS = Xorg
|
||||
|
|
|
@ -498,7 +498,7 @@ extern unsigned int inb(unsigned long port);
|
|||
extern unsigned int inw(unsigned long port);
|
||||
extern unsigned int inl(unsigned long port);
|
||||
|
||||
# elif defined(linux) && defined(__amd64__)
|
||||
# elif defined(linux) && (defined(__amd64__) || defined(__x86_64__))
|
||||
|
||||
# include <inttypes.h>
|
||||
|
||||
|
|
|
@ -71,6 +71,7 @@ extern Bool sbusSlotClaimed;
|
|||
#endif
|
||||
extern confDRIRec xf86ConfigDRI;
|
||||
extern Bool xf86inSuspend;
|
||||
extern Bool xf86DRI2Enabled(void);
|
||||
|
||||
#define XF86SCRNINFO(p) ((ScrnInfoPtr)dixLookupPrivate(&(p)->devPrivates, \
|
||||
xf86ScreenKey))
|
||||
|
|
|
@ -146,7 +146,11 @@ videoPtrToDriverName(struct pci_device *dev)
|
|||
|
||||
switch (dev->vendor_id)
|
||||
{
|
||||
case 0x1022: return "amd";
|
||||
case 0x1022:
|
||||
if (dev->device_id == 0x2081)
|
||||
return "geode";
|
||||
else
|
||||
return NULL;
|
||||
case 0x1142: return "apm";
|
||||
case 0xedd8: return "ark";
|
||||
case 0x1a03: return "ast";
|
||||
|
@ -449,7 +453,7 @@ chooseVideoDriver(void)
|
|||
if (info != NULL)
|
||||
chosen_driver = videoPtrToDriverName(info);
|
||||
if (chosen_driver == NULL) {
|
||||
#if defined __i386__ || defined __amd64__ || defined __hurd__
|
||||
#if defined __i386__ || defined __amd64__ || defined __x86_64__ || defined __hurd__
|
||||
chosen_driver = "vesa";
|
||||
#elif defined __sparc__
|
||||
chosen_driver = "sunffb";
|
||||
|
|
|
@ -766,6 +766,7 @@ typedef enum {
|
|||
FLAG_AUTO_ADD_DEVICES,
|
||||
FLAG_AUTO_ENABLE_DEVICES,
|
||||
FLAG_GLX_VISUALS,
|
||||
FLAG_DRI2,
|
||||
} FlagValues;
|
||||
|
||||
static OptionInfoRec FlagOptions[] = {
|
||||
|
@ -837,16 +838,18 @@ static OptionInfoRec FlagOptions[] = {
|
|||
{0}, FALSE },
|
||||
{ FLAG_ALLOW_EMPTY_INPUT, "AllowEmptyInput", OPTV_BOOLEAN,
|
||||
{0}, FALSE },
|
||||
{ FLAG_IGNORE_ABI, "IgnoreABI", OPTV_BOOLEAN,
|
||||
{ FLAG_IGNORE_ABI, "IgnoreABI", OPTV_BOOLEAN,
|
||||
{0}, FALSE },
|
||||
{ FLAG_USE_DEFAULT_FONT_PATH, "UseDefaultFontPath", OPTV_BOOLEAN,
|
||||
{ FLAG_USE_DEFAULT_FONT_PATH, "UseDefaultFontPath", OPTV_BOOLEAN,
|
||||
{0}, FALSE },
|
||||
{ FLAG_AUTO_ADD_DEVICES, "AutoAddDevices", OPTV_BOOLEAN,
|
||||
{ FLAG_AUTO_ADD_DEVICES, "AutoAddDevices", OPTV_BOOLEAN,
|
||||
{0}, TRUE },
|
||||
{ FLAG_AUTO_ENABLE_DEVICES, "AutoEnableDevices", OPTV_BOOLEAN,
|
||||
{ FLAG_AUTO_ENABLE_DEVICES, "AutoEnableDevices", OPTV_BOOLEAN,
|
||||
{0}, TRUE },
|
||||
{ FLAG_GLX_VISUALS, "GlxVisuals", OPTV_STRING,
|
||||
{0}, FALSE },
|
||||
{ FLAG_DRI2, "DRI2", OPTV_BOOLEAN,
|
||||
{0}, FALSE },
|
||||
{ -1, NULL, OPTV_NONE,
|
||||
{0}, FALSE },
|
||||
};
|
||||
|
@ -1179,9 +1182,23 @@ configServerFlags(XF86ConfFlagsPtr flagsconf, XF86OptionPtr layoutopts)
|
|||
xf86Msg(from, "Xinerama: enabled\n");
|
||||
#endif
|
||||
|
||||
#ifdef DRI2
|
||||
xf86Info.dri2 = FALSE;
|
||||
xf86Info.dri2From = X_DEFAULT;
|
||||
if (xf86GetOptValBool(FlagOptions, FLAG_DRI2, &value)) {
|
||||
xf86Info.dri2 = value;
|
||||
xf86Info.dri2From = X_CONFIG;
|
||||
}
|
||||
#endif
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
Bool xf86DRI2Enabled(void)
|
||||
{
|
||||
return xf86Info.dri2;
|
||||
}
|
||||
|
||||
/*
|
||||
* Locate the core input devices. These can be specified/located in
|
||||
* the following ways, in order of priority:
|
||||
|
@ -1338,8 +1355,8 @@ checkCoreInputDevices(serverLayoutPtr servlayoutp, Bool implicitLayout)
|
|||
/* 5. Built-in default. */
|
||||
if (!foundPointer) {
|
||||
bzero(&defPtr, sizeof(defPtr));
|
||||
defPtr.inp_identifier = "<default pointer>";
|
||||
defPtr.inp_driver = "mouse";
|
||||
defPtr.inp_identifier = strdup("<default pointer>");
|
||||
defPtr.inp_driver = strdup("mouse");
|
||||
confInput = &defPtr;
|
||||
foundPointer = TRUE;
|
||||
from = X_DEFAULT;
|
||||
|
@ -1385,8 +1402,8 @@ checkCoreInputDevices(serverLayoutPtr servlayoutp, Bool implicitLayout)
|
|||
if (!found) {
|
||||
xf86Msg(X_INFO, "No default mouse found, adding one\n");
|
||||
bzero(&defPtr, sizeof(defPtr));
|
||||
defPtr.inp_identifier = "<default pointer>";
|
||||
defPtr.inp_driver = "mouse";
|
||||
defPtr.inp_identifier = strdup("<default pointer>");
|
||||
defPtr.inp_driver = strdup("mouse");
|
||||
confInput = &defPtr;
|
||||
foundPointer = configInput(&Pointer, confInput, from);
|
||||
if (foundPointer) {
|
||||
|
@ -1474,8 +1491,8 @@ checkCoreInputDevices(serverLayoutPtr servlayoutp, Bool implicitLayout)
|
|||
/* 5. Built-in default. */
|
||||
if (!foundKeyboard) {
|
||||
bzero(&defKbd, sizeof(defKbd));
|
||||
defKbd.inp_identifier = "<default keyboard>";
|
||||
defKbd.inp_driver = "kbd";
|
||||
defKbd.inp_identifier = strdup("<default keyboard>");
|
||||
defKbd.inp_driver = strdup("kbd");
|
||||
confInput = &defKbd;
|
||||
foundKeyboard = TRUE;
|
||||
keyboardMsg = "default keyboard configuration";
|
||||
|
|
|
@ -149,6 +149,9 @@ typedef struct {
|
|||
Bool autoAddDevices; /* Whether to succeed NIDR, or ignore. */
|
||||
Bool autoEnableDevices; /* Whether to enable, or let the client
|
||||
* control. */
|
||||
|
||||
Bool dri2;
|
||||
MessageType dri2From;
|
||||
} xf86InfoRec, *xf86InfoPtr;
|
||||
|
||||
#ifdef DPMSExtension
|
||||
|
|
|
@ -480,11 +480,19 @@ void
|
|||
DeleteInputDeviceRequest(DeviceIntPtr pDev)
|
||||
{
|
||||
LocalDevicePtr pInfo = (LocalDevicePtr) pDev->public.devicePrivate;
|
||||
InputDriverPtr drv = pInfo->drv;
|
||||
IDevRec *idev = pInfo->conf_idev;
|
||||
InputDriverPtr drv;
|
||||
IDevRec *idev;
|
||||
|
||||
if (pInfo) /* need to get these before RemoveDevice */
|
||||
{
|
||||
drv = pInfo->drv;
|
||||
idev = pInfo->conf_idev;
|
||||
}
|
||||
RemoveDevice(pDev);
|
||||
|
||||
if (!pInfo) /* VCP and VCK */
|
||||
return;
|
||||
|
||||
if(drv->UnInit)
|
||||
drv->UnInit(drv, pInfo, 0);
|
||||
else
|
||||
|
|
|
@ -18,10 +18,6 @@ if AFB
|
|||
AFBMOD = libafb.la
|
||||
endif
|
||||
|
||||
if CFB
|
||||
CFBMOD = libcfb.la libcfb32.la
|
||||
endif
|
||||
|
||||
if MFB
|
||||
MFBMOD = libmfb.la
|
||||
endif
|
||||
|
@ -31,7 +27,6 @@ RECORDMOD = librecord.la
|
|||
endif
|
||||
|
||||
module_LTLIBRARIES = $(AFBMOD) \
|
||||
$(CFBMOD) \
|
||||
libfb.la \
|
||||
libwfb.la \
|
||||
$(MFBMOD) \
|
||||
|
@ -61,14 +56,6 @@ libafb_la_LDFLAGS = -avoid-version
|
|||
libafb_la_LIBADD = $(top_builddir)/afb/libafb.la
|
||||
libafb_la_SOURCES = afbmodule.c
|
||||
|
||||
libcfb_la_LDFLAGS = -avoid-version
|
||||
libcfb_la_LIBADD = $(top_builddir)/cfb/libcfb.la
|
||||
libcfb_la_SOURCES = cfbmodule.c
|
||||
|
||||
libcfb32_la_LDFLAGS = -avoid-version
|
||||
libcfb32_la_LIBADD = $(top_builddir)/cfb32/libcfb32.la
|
||||
libcfb32_la_SOURCES = cfb32module.c
|
||||
|
||||
libdbe_la_LDFLAGS = -avoid-version
|
||||
libdbe_la_LIBADD = $(top_builddir)/dbe/libdbe.la
|
||||
libdbe_la_SOURCES = dbemodule.c
|
||||
|
|
|
@ -1,57 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1998 The XFree86 Project, Inc. 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 THE
|
||||
* XFREE86 PROJECT 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.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_XORG_CONFIG_H
|
||||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#include "xf86Module.h"
|
||||
|
||||
static MODULESETUPPROTO(cfb32Setup);
|
||||
|
||||
static XF86ModuleVersionInfo VersRec =
|
||||
{
|
||||
"cfb32",
|
||||
MODULEVENDORSTRING,
|
||||
MODINFOSTRING1,
|
||||
MODINFOSTRING2,
|
||||
XORG_VERSION_CURRENT,
|
||||
1, 0, 0,
|
||||
ABI_CLASS_ANSIC, /* Only need the ansic layer */
|
||||
ABI_ANSIC_VERSION,
|
||||
MOD_CLASS_NONE,
|
||||
{0,0,0,0} /* signature, to be patched into the file by a tool */
|
||||
};
|
||||
|
||||
_X_EXPORT XF86ModuleData cfb32ModuleData = { &VersRec, cfb32Setup, NULL };
|
||||
|
||||
static pointer
|
||||
cfb32Setup(pointer module, pointer opts, int *errmaj, int *errmin)
|
||||
{
|
||||
/* This modules requires cfb, so load it */
|
||||
return LoadSubModule(module, "cfb", NULL, NULL, NULL, NULL,
|
||||
errmaj, errmin);
|
||||
}
|
|
@ -1,57 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1998 The XFree86 Project, Inc. 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 THE
|
||||
* XFREE86 PROJECT 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.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_XORG_CONFIG_H
|
||||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#include "xf86Module.h"
|
||||
|
||||
static MODULESETUPPROTO(cfbSetup);
|
||||
|
||||
static XF86ModuleVersionInfo VersRec =
|
||||
{
|
||||
"cfb",
|
||||
MODULEVENDORSTRING,
|
||||
MODINFOSTRING1,
|
||||
MODINFOSTRING2,
|
||||
XORG_VERSION_CURRENT,
|
||||
1, 0, 0,
|
||||
ABI_CLASS_ANSIC, /* Only need the ansic layer */
|
||||
ABI_ANSIC_VERSION,
|
||||
MOD_CLASS_NONE,
|
||||
{0,0,0,0} /* signature, to be patched into the file by a tool */
|
||||
};
|
||||
|
||||
_X_EXPORT XF86ModuleData cfbModuleData = { &VersRec, cfbSetup, NULL };
|
||||
|
||||
static pointer
|
||||
cfbSetup(pointer module, pointer opts, int *errmaj, int *errmin)
|
||||
{
|
||||
/* This modules requires mfb, so load it */
|
||||
return LoadSubModule(module, "mfb", NULL, NULL, NULL, NULL,
|
||||
errmaj, errmin);
|
||||
}
|
|
@ -23,7 +23,6 @@ AM_CFLAGS = @DIX_CFLAGS@ @XORG_CFLAGS@
|
|||
INCLUDES = @XORG_INCS@ \
|
||||
-I$(top_srcdir)/afb \
|
||||
-I$(top_srcdir)/mfb \
|
||||
-I$(top_srcdir)/cfb \
|
||||
-I$(top_srcdir)/dbe \
|
||||
-I$(top_srcdir)/hw/xfree86/loader \
|
||||
-I$(top_srcdir)/miext/shadow
|
||||
|
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user