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

So long, and thanks for all the cfb.

This commit is contained in:
Adam Jackson 2008-04-11 09:47:51 -04:00
parent 059b4876e6
commit 0dab6fa358
71 changed files with 3 additions and 28981 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Makefile.am
View File

@ -9,11 +9,6 @@ if XTRAP
XTRAP_DIR=XTrap XTRAP_DIR=XTrap
endif endif
if CFB
CFB_DIR=cfb
CFB32_DIR=cfb32
endif
if AFB if AFB
AFB_DIR=afb AFB_DIR=afb
endif endif
@ -50,8 +45,6 @@ SUBDIRS = \
$(DBE_DIR) \ $(DBE_DIR) \
$(MFB_DIR) \ $(MFB_DIR) \
$(AFB_DIR) \ $(AFB_DIR) \
$(CFB_DIR) \
$(CFB32_DIR) \
$(RECORD_DIR) \ $(RECORD_DIR) \
xfixes \ xfixes \
damageext \ damageext \
@ -96,8 +89,6 @@ DIST_SUBDIRS = \
dbe \ dbe \
mfb \ mfb \
afb \ afb \
cfb \
cfb32 \
record \ record \
xfixes \ xfixes \
damageext \ damageext \

21
cfb/Makefile.am
View File

@ -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

153
cfb/Makefile.am.inc
View File

@ -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

1268
cfb/cfb.h
View File

File diff suppressed because it is too large Load Diff

93
cfb/cfb16.h
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

1503
cfb/cfb8line.c
View File

File diff suppressed because it is too large Load Diff

70
cfb/cfballpriv.c
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

933
cfb/cfbblt.c
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

799
cfb/cfbgc.c
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

854
cfb/cfbmskbits.h
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

589
cfb/cfbteblt8.c
View File

@ -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
View File

@ -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
View File

@ -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
View File

File diff suppressed because it is too large Load Diff

161
cfb/cfbunmap.h
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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
View File

@ -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

9
cfb32/Makefile.am
View File

@ -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)

8
configure.ac
View File

@ -575,7 +575,6 @@ AC_ARG_ENABLE(xglx, AS_HELP_STRING([--enable-xglx], [Build Xglx xgl mo
AC_ARG_ENABLE(xegl, AS_HELP_STRING([--enable-xegl], [Build Xegl xgl module (default: no)]), [XEGL=$enableval], [XEGL=no]) AC_ARG_ENABLE(xegl, AS_HELP_STRING([--enable-xegl], [Build Xegl xgl module (default: no)]), [XEGL=$enableval], [XEGL=no])
dnl legacy fb support 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(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(afb, AS_HELP_STRING([--enable-afb], [Build legacy advanced framebuffer support (default: enabled)]), [AFB=$enableval], [AFB=$XORG])
dnl kdrive and its subsystems 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(kdrive, AS_HELP_STRING([--enable-kdrive], [Build kdrive servers (default: no)]), [KDRIVE=$enableval], [KDRIVE=no])
@ -1581,12 +1580,10 @@ AM_CONDITIONAL([XF86VIDMODE], [test "x$XF86VIDMODE" = xyes])
dnl legacy fb support dnl legacy fb support
test "x$MFB" = xauto && MFB="$XORG" test "x$MFB" = xauto && MFB="$XORG"
test "x$CFB" = xauto && CFB="$XORG"
test "x$AFB" = xauto && AFB="$XORG" test "x$AFB" = xauto && AFB="$XORG"
AM_CONDITIONAL(MFB, [test "x$MFB" = xyes]) AM_CONDITIONAL(MFB, [test "x$MFB" = xyes])
AM_CONDITIONAL(CFB, [test "x$CFB" = xyes])
AM_CONDITIONAL(AFB, [test "x$AFB" = 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 if test "x$XORG" != xyes; then
AC_MSG_ERROR([legacy fb support requires the Xorg server]) AC_MSG_ERROR([legacy fb support requires the Xorg server])
fi fi
@ -2135,8 +2132,6 @@ fb/Makefile
record/Makefile record/Makefile
XTrap/Makefile XTrap/Makefile
mfb/Makefile mfb/Makefile
cfb/Makefile
cfb32/Makefile
config/Makefile config/Makefile
mi/Makefile mi/Makefile
miext/Makefile miext/Makefile
@ -2195,7 +2190,6 @@ hw/xfree86/xaa/Makefile
hw/xfree86/xf1bpp/Makefile hw/xfree86/xf1bpp/Makefile
hw/xfree86/xf4bpp/Makefile hw/xfree86/xf4bpp/Makefile
hw/xfree86/xf8_16bpp/Makefile hw/xfree86/xf8_16bpp/Makefile
hw/xfree86/xf8_32bpp/Makefile
hw/xfree86/utils/Makefile hw/xfree86/utils/Makefile
hw/xfree86/utils/cvt/Makefile hw/xfree86/utils/cvt/Makefile
hw/xfree86/utils/gtf/Makefile hw/xfree86/utils/gtf/Makefile

8
hw/xfree86/Makefile.am
View File

@ -16,20 +16,16 @@ if MFB
MFB_SUBDIR = xf1bpp xf4bpp MFB_SUBDIR = xf1bpp xf4bpp
endif endif
if CFB
CFB_SUBDIR = xf8_32bpp
endif
DOC_SUBDIR = doc DOC_SUBDIR = doc
SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support parser rac \ 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 \ xf8_16bpp loader dixmods exa modes \
$(DRI_SUBDIR) $(DRI2_SUBDIR) $(XF86UTILS_SUBDIR) $(DOC_SUBDIR) $(DRI_SUBDIR) $(DRI2_SUBDIR) $(XF86UTILS_SUBDIR) $(DOC_SUBDIR)
DIST_SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support \ DIST_SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support \
parser rac ramdac shadowfb vbe vgahw xaa xf1bpp xf4bpp \ 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 utils doc
bin_PROGRAMS = Xorg bin_PROGRAMS = Xorg

13
hw/xfree86/dixmods/Makefile.am
View File

@ -18,10 +18,6 @@ if AFB
AFBMOD = libafb.la AFBMOD = libafb.la
endif endif
if CFB
CFBMOD = libcfb.la libcfb32.la
endif
if MFB if MFB
MFBMOD = libmfb.la MFBMOD = libmfb.la
endif endif
@ -31,7 +27,6 @@ RECORDMOD = librecord.la
endif endif
module_LTLIBRARIES = $(AFBMOD) \ module_LTLIBRARIES = $(AFBMOD) \
$(CFBMOD) \
libfb.la \ libfb.la \
libwfb.la \ libwfb.la \
$(MFBMOD) \ $(MFBMOD) \
@ -61,14 +56,6 @@ libafb_la_LDFLAGS = -avoid-version
libafb_la_LIBADD = $(top_builddir)/afb/libafb.la libafb_la_LIBADD = $(top_builddir)/afb/libafb.la
libafb_la_SOURCES = afbmodule.c 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_LDFLAGS = -avoid-version
libdbe_la_LIBADD = $(top_builddir)/dbe/libdbe.la libdbe_la_LIBADD = $(top_builddir)/dbe/libdbe.la
libdbe_la_SOURCES = dbemodule.c libdbe_la_SOURCES = dbemodule.c

57
hw/xfree86/dixmods/cfb32module.c
View File

@ -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);
}

57
hw/xfree86/dixmods/cfbmodule.c
View File

@ -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);
}

1
hw/xfree86/dixmods/extmod/Makefile.am
View File

@ -23,7 +23,6 @@ AM_CFLAGS = @DIX_CFLAGS@ @XORG_CFLAGS@
INCLUDES = @XORG_INCS@ \ INCLUDES = @XORG_INCS@ \
-I$(top_srcdir)/afb \ -I$(top_srcdir)/afb \
-I$(top_srcdir)/mfb \ -I$(top_srcdir)/mfb \
-I$(top_srcdir)/cfb \
-I$(top_srcdir)/dbe \ -I$(top_srcdir)/dbe \
-I$(top_srcdir)/hw/xfree86/loader \ -I$(top_srcdir)/hw/xfree86/loader \
-I$(top_srcdir)/miext/shadow -I$(top_srcdir)/miext/shadow

37
hw/xfree86/xf8_32bpp/Makefile.am
View File

@ -1,37 +0,0 @@
module_LTLIBRARIES = libxf8_32bpp.la
sdk_HEADERS = cfb8_32.h
INCLUDES = $(XORG_INCS) -I$(top_srcdir)/mfb -I$(top_srcdir)/cfb
AM_CFLAGS = $(DIX_CFLAGS) $(XORG_CFLAGS)
libxf8_32bpp_la_LDFLAGS = -avoid-version
libxf8_32bpp_la_SOURCES = \
cfbcpyarea.c \
cfbcpyplane.c \
cfbgcmisc.c \
cfbimage.c \
cfbpntwin.c \
cfbscrinit.c \
cfbwindow.c \
xf86overlay.c \
cfb8_32module.c \
cfbgc8.c \
cfbgc32.c \
cfbgcunder.c
libxf8_32bpp_la_LIBADD = $(top_builddir)/cfb32/libcfb32.la
EXTRA_DIST = cfbgc.c
cfbgc8.c: $(srcdir)/cfbgc.c
echo '#define PSZ 8' > $@
echo '#include "$(srcdir)/cfbgc.c"' >> $@
cfbgc32.c: $(srcdir)/cfbgc.c
echo '#define PSZ 32' > $@
echo '#include "$(srcdir)/cfbgc.c"' >> $@
DISTCLEANFILES = cfbgc8.c cfbgc32.c

191
hw/xfree86/xf8_32bpp/cfb8_32.h
View File

@ -1,191 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#ifndef _CFB8_32_H
#define _CFB8_32_H
#include "gcstruct.h"
typedef struct {
GCOps *Ops8bpp;
GCOps *Ops32bpp;
unsigned long changes;
Bool OpsAre8bpp;
} cfb8_32GCRec, *cfb8_32GCPtr;
typedef struct {
unsigned char key;
void (*EnableDisableFBAccess)(int scrnIndex, Bool enable);
pointer visualData;
} cfb8_32ScreenRec, *cfb8_32ScreenPtr;
extern DevPrivateKey cfb8_32GetGCPrivateKey(void);
extern DevPrivateKey cfb8_32GetScreenPrivateKey(void);
RegionPtr
cfb8_32CopyArea(
DrawablePtr pSrcDraw,
DrawablePtr pDstDraw,
GC *pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty
);
void
cfbDoBitblt8To32(
DrawablePtr pSrc,
DrawablePtr pDst,
int rop,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
unsigned long planemask
);
void
cfbDoBitblt32To8(
DrawablePtr pSrc,
DrawablePtr pDst,
int rop,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
unsigned long planemask
);
void
cfb8_32ValidateGC8(
GCPtr pGC,
unsigned long changes,
DrawablePtr pDrawable
);
void
cfb8_32ValidateGC32(
GCPtr pGC,
unsigned long changes,
DrawablePtr pDrawable
);
void
cfb32ValidateGC_Underlay(
GCPtr pGC,
unsigned long changes,
DrawablePtr pDrawable
);
Bool cfb8_32CreateGC(GCPtr pGC);
void
cfb8_32GetSpans(
DrawablePtr pDraw,
int wMax,
DDXPointPtr ppt,
int *pwidth,
int nspans,
char *pchardstStart
);
void
cfb8_32PutImage (
DrawablePtr pDraw,
GCPtr pGC,
int depth,
int x, int y, int w, int h,
int leftPad,
int format,
char *pImage
);
void
cfb8_32GetImage (
DrawablePtr pDraw,
int sx, int sy, int w, int h,
unsigned int format,
unsigned long planeMask,
char *pdstLine
);
Bool
cfb8_32ScreenInit (
ScreenPtr pScreen,
pointer pbits,
int xsize, int ysize,
int dpix, int dpiy,
int width
);
void
cfb8_32FillBoxSolid8 (
DrawablePtr pDraw,
int nbox,
BoxPtr pBox,
unsigned long color
);
RegionPtr
cfb8_32CopyPlane(
DrawablePtr pSrc,
DrawablePtr pDst,
GCPtr pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty,
unsigned long bitPlane
);
void
cfbDoBitblt8To8GXcopy(
DrawablePtr pSrc,
DrawablePtr pDst,
int rop,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
unsigned long pm
);
void
cfbDoBitblt24To24GXcopy(
DrawablePtr pSrc,
DrawablePtr pDst,
int rop,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
unsigned long pm
);
Bool cfb8_32CreateWindow(WindowPtr pWin);
Bool cfb8_32DestroyWindow(WindowPtr pWin);
Bool
cfb8_32PositionWindow(
WindowPtr pWin,
int x, int y
);
void
cfb8_32CopyWindow(
WindowPtr pWin,
DDXPointRec ptOldOrg,
RegionPtr prgnSrc
);
Bool
cfb8_32ChangeWindowAttributes(
WindowPtr pWin,
unsigned long mask
);
#define CFB8_32_GET_GC_PRIVATE(pGC) ((cfb8_32GCPtr) \
dixLookupPrivate(&(pGC)->devPrivates, cfb8_32GetGCPrivateKey()))
#define CFB8_32_GET_SCREEN_PRIVATE(pScreen) ((cfb8_32ScreenPtr) \
dixLookupPrivate(&(pScreen)->devPrivates, cfb8_32GetScreenPrivateKey()))
Bool xf86Overlay8Plus32Init (ScreenPtr pScreen);
#endif /* _CFB8_32_H */

39
hw/xfree86/xf8_32bpp/cfb8_32module.c
View File

@ -1,39 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include "xf86Module.h"
static MODULESETUPPROTO(xf8_32bppSetup);
static XF86ModuleVersionInfo VersRec =
{
"xf8_32bpp",
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 xf8_32bppModuleData = {
&VersRec,
xf8_32bppSetup,
NULL
};
static pointer
xf8_32bppSetup(pointer module, pointer opts, int *errmaj, int *errmin)
{
if (!LoadSubModule(module, "cfb", NULL, NULL, NULL, NULL,
errmaj, errmin))
return NULL;
if (!LoadSubModule(module, "cfb32", NULL, NULL, NULL, NULL,
errmaj, errmin))
return NULL;
return (pointer)1; /* non-NULL required to indicate success */
}

549
hw/xfree86/xf8_32bpp/cfbcpyarea.c
View File

@ -1,549 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <stdlib.h>
#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"
#define PSZ 8
#include "cfb.h"
#undef PSZ
#include "cfb32.h"
#include "cfb8_32.h"
#include "mi.h"
#include "mistruct.h"
#include "dix.h"
#include "mibstore.h"
RegionPtr
cfb8_32CopyArea(
DrawablePtr pSrcDraw,
DrawablePtr pDstDraw,
GC *pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty
){
if(pSrcDraw->bitsPerPixel == 32) {
if(pDstDraw->bitsPerPixel == 32) {
if((pGC->alu == GXcopy) && (pGC->planemask == 0xff000000)) {
return cfb32BitBlt (pSrcDraw, pDstDraw,
pGC, srcx, srcy, width, height, dstx, dsty,
cfbDoBitblt8To8GXcopy, 0L);
}
return(cfb32CopyArea(pSrcDraw, pDstDraw, pGC, srcx, srcy,
width, height, dstx, dsty));
} else {
/* have to translate 32 -> 8 copies */
return cfb32BitBlt (pSrcDraw, pDstDraw,
pGC, srcx, srcy, width, height, dstx, dsty,
cfbDoBitblt32To8, 0L);
}
} else {
if(pDstDraw->bitsPerPixel == 32) {
/* have to translate 8 -> 32 copies */
return cfb32BitBlt (pSrcDraw, pDstDraw,
pGC, srcx, srcy, width, height, dstx, dsty,
cfbDoBitblt8To32, 0L);
} else {
return(cfbCopyArea(pSrcDraw, pDstDraw, pGC, srcx, srcy,
width, height, dstx, dsty));
}
}
}
void
cfbDoBitblt8To32(
DrawablePtr pSrc,
DrawablePtr pDst,
int rop,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
unsigned long pm
){
BoxPtr pbox = REGION_RECTS(prgnDst);
int nbox = REGION_NUM_RECTS(prgnDst);
unsigned char *ptr8, *ptr32;
unsigned char *data8, *data32;
int pitch8, pitch32;
int height, width, i;
cfbGetByteWidthAndPointer(pSrc, pitch8, ptr8);
cfbGetByteWidthAndPointer(pDst, pitch32, ptr32);
ptr32 += 3; /* point to the top byte */
pm >>= 24;
if((pm == 0xff) && (rop == GXcopy)) {
for(;nbox; pbox++, pptSrc++, nbox--) {
data8 = ptr8 + (pptSrc->y * pitch8) + pptSrc->x;
data32 = ptr32 + (pbox->y1 * pitch32) + (pbox->x1 << 2);
width = pbox->x2 - pbox->x1;
height = pbox->y2 - pbox->y1;
while(height--) {
for(i = 0; i < width; i++)
data32[i << 2] = data8[i];
data8 += pitch8;
data32 += pitch32;
}
}
} else { /* it ain't pretty, but hey */
for(;nbox; pbox++, pptSrc++, nbox--) {
data8 = ptr8 + (pptSrc->y * pitch8) + pptSrc->x;
data32 = ptr32 + (pbox->y1 * pitch32) + (pbox->x1 << 2);
width = pbox->x2 - pbox->x1;
height = pbox->y2 - pbox->y1;
while(height--) {
switch(rop) {
case GXcopy:
for(i = 0; i < width; i++)
data32[i<<2] = (data8[i] & pm) | (data32[i<<2] & ~pm);
break;
case GXor:
for(i = 0; i < width; i++)
data32[i<<2] |= data8[i] & pm;
break;
case GXclear:
for(i = 0; i < width; i++)
data32[i<<2] &= ~pm;
break;
case GXand:
for(i = 0; i < width; i++)
data32[i<<2] &= data8[i] | ~pm;
break;
case GXandReverse:
for(i = 0; i < width; i++)
data32[i<<2] = ~data32[i<<2] & (data8[i] | ~pm);
break;
case GXandInverted:
for(i = 0; i < width; i++)
data32[i<<2] &= ~data8[i] | ~pm;
break;
case GXnoop:
return;
case GXxor:
for(i = 0; i < width; i++)
data32[i<<2] ^= data8[i] & pm;
break;
case GXnor:
for(i = 0; i < width; i++)
data32[i<<2] = ~(data32[i<<2] | (data8[i] & pm));
break;
case GXequiv:
for(i = 0; i < width; i++)
data32[i<<2] = ~(data32[i<<2] ^ (data8[i] & pm));
break;
case GXinvert:
for(i = 0; i < width; i++)
data32[i<<2] ^= pm;
break;
case GXorReverse:
for(i = 0; i < width; i++)
data32[i<<2] = ~data32[i<<2] | (data8[i] & pm);
break;
case GXcopyInverted:
for(i = 0; i < width; i++)
data32[i<<2] = (~data8[i] & pm) | (data32[i<<2] & ~pm);
break;
case GXorInverted:
for(i = 0; i < width; i++)
data32[i<<2] |= ~data8[i] & pm;
break;
case GXnand:
for(i = 0; i < width; i++)
data32[i<<2] = ~(data32[i<<2] & (data8[i] | ~pm));
break;
case GXset:
for(i = 0; i < width; i++)
data32[i<<2] |= pm;
break;
}
data8 += pitch8;
data32 += pitch32;
}
}
}
}
void
cfbDoBitblt32To8(
DrawablePtr pSrc,
DrawablePtr pDst,
int rop,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
unsigned long pm
){
BoxPtr pbox = REGION_RECTS(prgnDst);
int nbox = REGION_NUM_RECTS(prgnDst);
unsigned char *ptr8, *ptr32;
unsigned char *data8, *data32;
int pitch8, pitch32;
int height, width, i;
cfbGetByteWidthAndPointer(pDst, pitch8, ptr8);
cfbGetByteWidthAndPointer(pSrc, pitch32, ptr32);
ptr32 += 3; /* point to the top byte */
if(((pm & 0xff) == 0xff) && (rop == GXcopy)) {
for(;nbox; pbox++, pptSrc++, nbox--) {
data8 = ptr8 + (pbox->y1 * pitch8) + pbox->x1;
data32 = ptr32 + (pptSrc->y * pitch32) + (pptSrc->x << 2);
width = pbox->x2 - pbox->x1;
height = pbox->y2 - pbox->y1;
while(height--) {
for(i = 0; i < width; i++)
data8[i] = data32[i << 2];
data8 += pitch8;
data32 += pitch32;
}
}
} else {
for(;nbox; pbox++, pptSrc++, nbox--) {
data8 = ptr8 + (pbox->y1 * pitch8) + pbox->x1;
data32 = ptr32 + (pptSrc->y * pitch32) + (pptSrc->x << 2);
width = pbox->x2 - pbox->x1;
height = pbox->y2 - pbox->y1;
while(height--) {
switch(rop) {
case GXcopy:
for(i = 0; i < width; i++)
data8[i] = (data32[i<<2] & pm) | (data8[i] & ~pm);
break;
case GXor:
for(i = 0; i < width; i++)
data8[i] |= data32[i<<2] & pm;
break;
case GXclear:
for(i = 0; i < width; i++)
data8[i] &= ~pm;
break;
case GXand:
for(i = 0; i < width; i++)
data8[i] &= data32[i<<2] | ~pm;
break;
case GXandReverse:
for(i = 0; i < width; i++)
data8[i] = ~data8[i] & (data32[i<<2] | ~pm);
break;
case GXandInverted:
for(i = 0; i < width; i++)
data8[i] &= ~data32[i<<2] | ~pm;
break;
case GXnoop:
return;
case GXxor:
for(i = 0; i < width; i++)
data8[i] ^= data32[i<<2] & pm;
break;
case GXnor:
for(i = 0; i < width; i++)
data8[i] = ~(data8[i] | (data32[i<<2] & pm));
break;
case GXequiv:
for(i = 0; i < width; i++)
data8[i] = ~(data8[i] ^ (data32[i<<2] & pm));
break;
case GXinvert:
for(i = 0; i < width; i++)
data8[i] ^= pm;
break;
case GXorReverse:
for(i = 0; i < width; i++)
data8[i] = ~data8[i] | (data32[i<<2] & pm);
break;
case GXcopyInverted:
for(i = 0; i < width; i++)
data8[i] = (~data32[i<<2] & pm) | (data8[i] & ~pm);
break;
case GXorInverted:
for(i = 0; i < width; i++)
data8[i] |= ~data32[i<<2] & pm;
break;
case GXnand:
for(i = 0; i < width; i++)
data8[i] = ~(data8[i] & (data32[i<<2] | ~pm));
break;
case GXset:
for(i = 0; i < width; i++)
data8[i] |= pm;
break;
}
data8 += pitch8;
data32 += pitch32;
}
}
}
}
static void
Do8To8Blt(
unsigned char *SrcPtr,
int SrcPitch,
unsigned char *DstPtr,
int DstPitch,
int nbox,
DDXPointPtr pptSrc,
BoxPtr pbox,
int xdir, int ydir
){
int i, j, width, height, ydir2;
CARD8 *src, *dst;
SrcPtr += 3;
DstPtr += 3;
xdir *= 4;
ydir2 = ydir * DstPitch;
ydir *= SrcPitch;
for(;nbox; pbox++, pptSrc++, nbox--) {
src = SrcPtr + (pptSrc->y * SrcPitch) + (pptSrc->x << 2);
dst = DstPtr + (pbox->y1 * DstPitch) + (pbox->x1 << 2);
width = pbox->x2 - pbox->x1;
height = pbox->y2 - pbox->y1;
if(ydir < 0) {
src += (height - 1) * SrcPitch;
dst += (height - 1) * DstPitch;
}
if(xdir < 0) {
register int tmp = (width - 1) << 2;
src += tmp;
dst += tmp;
}
while(height--) {
for(i = width, j = 0; i--; j+=xdir)
dst[j] = src[j];
src += ydir;
dst += ydir2;
}
}
}
static void
Do24To24Blt(
unsigned char *SrcPtr,
int SrcPitch,
unsigned char *DstPtr,
int DstPitch,
int nbox,
DDXPointPtr pptSrc,
BoxPtr pbox,
int xdir, int ydir
){
int i, j, width, height, ydir2;
CARD8 *src, *dst;
xdir *= 4;
ydir2 = ydir * DstPitch;
ydir *= SrcPitch;
for(;nbox; pbox++, pptSrc++, nbox--) {
src = SrcPtr + (pptSrc->y * SrcPitch) + (pptSrc->x << 2);
dst = DstPtr + (pbox->y1 * DstPitch) + (pbox->x1 << 2);
width = pbox->x2 - pbox->x1;
height = pbox->y2 - pbox->y1;
if(ydir < 0) {
src += (height - 1) * SrcPitch;
dst += (height - 1) * DstPitch;
}
if(xdir < 0) {
register int tmp = (width - 1) << 2;
src += tmp;
dst += tmp;
}
while(height--) {
for(i = width, j = 0; i--; j+=xdir) {
*((CARD16*)(dst + j)) = *((CARD32*)(src + j));
dst[j + 2] = src[j + 2];
}
src += ydir;
dst += ydir2;
}
}
}
static void
cfb8_32DoBitBlt(
DrawablePtr pSrc,
DrawablePtr pDst,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
void (*DoBlt)(
unsigned char *SrcPtr,
int SrcPitch,
unsigned char *DstPtr,
int DstPitch,
int nbox,
DDXPointPtr pptSrc,
BoxPtr pbox,
int xdir, int ydir)
){
int nbox, careful, SrcPitch, DstPitch;
BoxPtr pbox, pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
DDXPointPtr pptTmp, pptNew1, pptNew2;
int xdir, ydir;
unsigned char *SrcPtr, *DstPtr;
/* 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;
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;
}
cfbGetByteWidthAndPointer(pSrc, SrcPitch, SrcPtr);
cfbGetByteWidthAndPointer(pDst, DstPitch, DstPtr);
(*DoBlt)(SrcPtr,SrcPitch,DstPtr,DstPitch,nbox,pptSrc,pbox,xdir,ydir);
if (pboxNew2) {
xfree(pptNew2);
xfree(pboxNew2);
}
if (pboxNew1) {
xfree(pptNew1);
xfree(pboxNew1);
}
}
/* A couple routines to speed up full planemask copies */
void
cfbDoBitblt8To8GXcopy(
DrawablePtr pSrc,
DrawablePtr pDst,
int rop,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
unsigned long pm
){
cfb8_32DoBitBlt(pSrc, pDst, prgnDst, pptSrc, Do8To8Blt);
}
void
cfbDoBitblt24To24GXcopy(
DrawablePtr pSrc,
DrawablePtr pDst,
int rop,
RegionPtr prgnDst,
DDXPointPtr pptSrc,
unsigned long pm
){
cfb8_32DoBitBlt(pSrc, pDst, prgnDst, pptSrc, Do24To24Blt);
}

41
hw/xfree86/xf8_32bpp/cfbcpyplane.c
View File

@ -1,41 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#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"
#define PSZ 8
#include "cfb.h"
#undef PSZ
#include "cfb32.h"
#include "cfb8_32.h"
#include "mi.h"
RegionPtr
cfb8_32CopyPlane(
DrawablePtr pSrc,
DrawablePtr pDst,
GCPtr pGC,
int srcx, int srcy,
int width, int height,
int dstx, int dsty,
unsigned long bitPlane
){
/* There's actually much more to it than this */
if((pDst->bitsPerPixel == 8) && (pSrc->bitsPerPixel != 32)){
return(cfbCopyPlane(pSrc, pDst,
pGC, srcx, srcy, width, height, dstx, dsty, bitPlane));
}
return(miCopyPlane (pSrc, pDst,
pGC, srcx, srcy, width, height, dstx, dsty, bitPlane));
}

646
hw/xfree86/xf8_32bpp/cfbgc.c
View File

@ -1,646 +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.
******************************************************************/
/*
PSZ 8 16 24 32
PIXEL_ADDR True True True True
NO_ONE_RECT False False False False
WriteBitGroup True True True True
FOUR_BIT_CODE True False False False
LOWMEMFTPT False False False False
*/
/* This gets built twice. Once for 8bpp and another for 32bpp */
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-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 "pixmapstr.h"
#include "scrnintstr.h"
#include "region.h"
#include "mistruct.h"
#include "mibstore.h"
#include "migc.h"
#include "mioverlay.h"
#include "cfb8_32.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
#ifdef FOUR_BIT_CODE
# define usePushPixels cfbPushPixels8
#else
# define usePushPixels mfbPushPixels
#endif
#ifdef PIXEL_ADDR
# define ZeroPolyArc cfbZeroPolyArcSS8Copy
#else
# define ZeroPolyArc miZeroPolyArc
#endif
static GCOps cfb8_32TEOps1Rect = {
cfbSolidSpansCopy,
cfbSetSpans,
cfb8_32PutImage,
cfb8_32CopyArea,
cfb8_32CopyPlane,
cfbPolyPoint,
#ifdef PIXEL_ADDR
cfb8LineSS1Rect,
cfb8SegmentSS1Rect,
#else
cfbLineSS,
cfbSegmentSS,
#endif
miPolyRectangle,
ZeroPolyArc,
cfbFillPoly1RectCopy,
cfbPolyFillRect,
cfbPolyFillArcSolidCopy,
miPolyText8,
miPolyText16,
miImageText8,
miImageText16,
useTEGlyphBlt,
usePolyGlyphBlt,
usePushPixels
};
static GCOps cfb8_32NonTEOps1Rect = {
cfbSolidSpansCopy,
cfbSetSpans,
cfb8_32PutImage,
cfb8_32CopyArea,
cfb8_32CopyPlane,
cfbPolyPoint,
#ifdef PIXEL_ADDR
cfb8LineSS1Rect,
cfb8SegmentSS1Rect,
#else
cfbLineSS,
cfbSegmentSS,
#endif
miPolyRectangle,
ZeroPolyArc,
cfbFillPoly1RectCopy,
cfbPolyFillRect,
cfbPolyFillArcSolidCopy,
miPolyText8,
miPolyText16,
miImageText8,
miImageText16,
useImageGlyphBlt,
usePolyGlyphBlt,
usePushPixels
};
static GCOps cfb8_32TEOps = {
cfbSolidSpansCopy,
cfbSetSpans,
cfb8_32PutImage,
cfb8_32CopyArea,
cfb8_32CopyPlane,
cfbPolyPoint,
cfbLineSS,
cfbSegmentSS,
miPolyRectangle,
ZeroPolyArc,
miFillPolygon,
cfbPolyFillRect,
cfbPolyFillArcSolidCopy,
miPolyText8,
miPolyText16,
miImageText8,
miImageText16,
useTEGlyphBlt,
usePolyGlyphBlt,
usePushPixels
};
static GCOps cfb8_32NonTEOps = {
cfbSolidSpansCopy,
cfbSetSpans,
cfb8_32PutImage,
cfb8_32CopyArea,
cfb8_32CopyPlane,
cfbPolyPoint,
cfbLineSS,
cfbSegmentSS,
miPolyRectangle,
#ifdef PIXEL_ADDR
cfbZeroPolyArcSS8Copy,
#else
miZeroPolyArc,
#endif
miFillPolygon,
cfbPolyFillRect,
cfbPolyFillArcSolidCopy,
miPolyText8,
miPolyText16,
miImageText8,
miImageText16,
useImageGlyphBlt,
usePolyGlyphBlt,
usePushPixels
};
static GCOps *
cfb8_32MatchCommon (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 &cfb8_32TEOps1Rect;
#else
if (devPriv->oneRect)
return &cfb8_32TEOps1Rect;
else
return &cfb8_32TEOps;
#endif
else
#ifdef NO_ONE_RECT
return &cfb8_32NonTEOps1Rect;
#else
if (devPriv->oneRect)
return &cfb8_32NonTEOps1Rect;
else
return &cfb8_32NonTEOps;
#endif
}
return 0;
}
/* 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
#if PSZ == 8
cfb8_32ValidateGC8(
#else
cfb8_32ValidateGC32(
#endif
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;
/* flags for changing the proc vector */
cfbPrivGCPtr devPriv;
int oneRect;
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;
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:
new_fillspans = TRUE;
new_fillarea = TRUE;
break;
case GCTileStipXOrigin:
case GCTileStipYOrigin:
break;
case GCFont:
new_text = TRUE;
break;
case GCSubwindowMode:
case GCGraphicsExposures:
case GCClipXOrigin:
case GCClipYOrigin:
case GCClipMask:
case GCDashOffset:
case GCDashList:
case GCArcMode:
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_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(!pGC->ops)
pGC->ops = & cfb8_32NonTEOps;
if (new_rrop || new_fillspans || new_text || new_fillarea || new_line)
{
GCOps *newops;
if ((newops = cfb8_32MatchCommon (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:
pGC->ops->FillSpans = cfbUnnaturalTileFS;
break;
case FillStippled:
case FillOpaqueStippled:
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 = mfbPushPixels;
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;
}
}
}
}

150
hw/xfree86/xf8_32bpp/cfbgcmisc.c
View File

@ -1,150 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include <X11/Xmd.h>
#include <X11/Xproto.h>
#define PSZ 8
#include "cfb.h"
#undef PSZ
#include "cfb32.h"
#include "cfb8_32.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"
static void cfb8_32ValidateGC(GCPtr, unsigned long, DrawablePtr);
static void cfb8_32DestroyGC(GCPtr pGC);
static void cfb32DestroyGC_Underlay(GCPtr pGC);
static
GCFuncs cfb8_32GCFuncs = {
cfb8_32ValidateGC,
miChangeGC,
miCopyGC,
cfb8_32DestroyGC,
miChangeClip,
miDestroyClip,
miCopyClip,
};
static
GCFuncs cfb32GCFuncs_Underlay = {
cfb32ValidateGC_Underlay,
miChangeGC,
miCopyGC,
cfb32DestroyGC_Underlay,
miChangeClip,
miDestroyClip,
miCopyClip,
};
static void
cfb32DestroyGC_Underlay(GCPtr pGC)
{
if (pGC->freeCompClip)
REGION_DESTROY(pGC->pScreen, pGC->pCompositeClip);
if(pGC->ops)
miDestroyGCOps(pGC->ops);
}
static void
cfb8_32DestroyGC(GCPtr pGC)
{
cfb8_32GCPtr pGCPriv = CFB8_32_GET_GC_PRIVATE(pGC);
if (pGC->freeCompClip)
REGION_DESTROY(pGC->pScreen, pGC->pCompositeClip);
if(pGCPriv->Ops8bpp)
miDestroyGCOps(pGCPriv->Ops8bpp);
if(pGCPriv->Ops32bpp)
miDestroyGCOps(pGCPriv->Ops32bpp);
}
Bool
cfb8_32CreateGC(GCPtr pGC)
{
cfb8_32GCPtr pGCPriv;
cfbPrivGC *pPriv;
if (PixmapWidthPaddingInfo[pGC->depth].padPixelsLog2 == LOG2_BITMAP_PAD)
return (mfbCreateGC(pGC));
pGC->clientClip = NULL;
pGC->clientClipType = CT_NONE;
pGC->miTranslate = 1;
pGC->fExpose = TRUE;
pGC->freeCompClip = FALSE;
pGC->pRotatedPixmap = (PixmapPtr) NULL;
pPriv = cfbGetGCPrivate(pGC);
pPriv->rop = pGC->alu;
pPriv->oneRect = FALSE;
pGC->ops = NULL;
if (pGC->depth == 8) {
pGC->funcs = &cfb8_32GCFuncs;
pGCPriv = CFB8_32_GET_GC_PRIVATE(pGC);
pGCPriv->Ops8bpp = NULL;
pGCPriv->Ops32bpp = NULL;
pGCPriv->OpsAre8bpp = FALSE;
pGCPriv->changes = 0;
} else
pGC->funcs = &cfb32GCFuncs_Underlay;
return TRUE;
}
static void
cfb8_32ValidateGC(
GCPtr pGC,
unsigned long changes,
DrawablePtr pDraw
){
cfb8_32GCPtr pGCPriv = CFB8_32_GET_GC_PRIVATE(pGC);
if(pDraw->bitsPerPixel == 32) {
if(pGCPriv->OpsAre8bpp) {
int origChanges = changes;
pGC->ops = pGCPriv->Ops32bpp;
changes |= pGCPriv->changes;
pGCPriv->changes = origChanges;
pGCPriv->OpsAre8bpp = FALSE;
} else
pGCPriv->changes |= changes;
cfb8_32ValidateGC32(pGC, changes, pDraw);
pGCPriv->Ops32bpp = pGC->ops;
} else { /* bitsPerPixel == 8 */
if(!pGCPriv->OpsAre8bpp) {
int origChanges = changes;
pGC->ops = pGCPriv->Ops8bpp;
changes |= pGCPriv->changes;
pGCPriv->changes = origChanges;
pGCPriv->OpsAre8bpp = TRUE;
} else
pGCPriv->changes |= changes;
cfb8_32ValidateGC8(pGC, changes, pDraw);
pGCPriv->Ops8bpp = pGC->ops;
}
}

620
hw/xfree86/xf8_32bpp/cfbgcunder.c
View File

@ -1,620 +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.
******************************************************************/
#define PSZ 32
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-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 "pixmapstr.h"
#include "scrnintstr.h"
#include "region.h"
#include "mistruct.h"
#include "mibstore.h"
#include "migc.h"
#include "mioverlay.h"
#include "cfbmskbits.h"
#include "cfb8bit.h"
#include "cfb8_32.h"
#ifdef WriteBitGroup
# define useTEGlyphBlt cfbImageGlyphBlt8
#else
# define useTEGlyphBlt cfbTEGlyphBlt
#endif
#ifdef WriteBitGroup
# define useImageGlyphBlt cfbImageGlyphBlt8
# define usePolyGlyphBlt cfbPolyGlyphBlt8
#else
# define useImageGlyphBlt miImageGlyphBlt
# define usePolyGlyphBlt miPolyGlyphBlt
#endif
#ifdef FOUR_BIT_CODE
# define usePushPixels cfbPushPixels8
#else
# define usePushPixels mfbPushPixels
#endif
#ifdef PIXEL_ADDR
# define ZeroPolyArc cfbZeroPolyArcSS8Copy
#else
# define ZeroPolyArc miZeroPolyArc
#endif
static 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
};
static 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
};
static GCOps cfbTEOps = {
cfbSolidSpansCopy,
cfbSetSpans,
cfbPutImage,
cfbCopyArea,
cfbCopyPlane,
cfbPolyPoint,
cfbLineSS,
cfbSegmentSS,
miPolyRectangle,
ZeroPolyArc,
miFillPolygon,
cfbPolyFillRect,
cfbPolyFillArcSolidCopy,
miPolyText8,
miPolyText16,
miImageText8,
miImageText16,
useTEGlyphBlt,
usePolyGlyphBlt,
usePushPixels
};
static 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
};
static GCOps *
cfb32MatchCommon_Underlay(
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;
}
void
cfb32ValidateGC_Underlay(
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;
/* flags for changing the proc vector */
cfbPrivGCPtr devPriv;
int oneRect;
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))
)
{
if(pDrawable->type == DRAWABLE_WINDOW)
miOverlayComputeCompositeClip (pGC, (WindowPtr)pDrawable);
else
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;
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:
new_fillspans = TRUE;
new_fillarea = TRUE;
break;
case GCTileStipXOrigin:
case GCTileStipYOrigin:
break;
case GCFont:
new_text = TRUE;
break;
case GCSubwindowMode:
case GCGraphicsExposures:
case GCClipXOrigin:
case GCClipYOrigin:
case GCClipMask:
case GCDashOffset:
case GCDashList:
case GCArcMode:
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_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(!pGC->ops)
pGC->ops = & cfbNonTEOps;
if (new_rrop || new_fillspans || new_text || new_fillarea || new_line)
{
GCOps *newops;
if ((newops = cfb32MatchCommon_Underlay (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:
pGC->ops->FillSpans = cfbUnnaturalTileFS;
break;
case FillStippled:
case FillOpaqueStippled:
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 = mfbPushPixels;
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;
}
}
}
}

174
hw/xfree86/xf8_32bpp/cfbimage.c
View File

@ -1,174 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <X11/X.h>
#include "windowstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#include "gcstruct.h"
#define PSZ 8
#include "cfb.h"
#undef PSZ
#include "cfb32.h"
#include "cfb8_32.h"
#include "servermd.h"
#include "mi.h"
void
cfb8_32GetImage (
DrawablePtr pDraw,
int sx, int sy, int w, int h,
unsigned int format,
unsigned long planemask,
char *pdstLine
){
if(!w || !h) return;
if (!cfbDrawableEnabled (pDraw))
return;
if(pDraw->depth == 24){
cfb32GetImage(pDraw, sx, sy, w, h, format, planemask, pdstLine);
return;
}
if((pDraw->bitsPerPixel == 8) || (pDraw->bitsPerPixel == 1)){
cfbGetImage(pDraw, sx, sy, w, h, format, planemask, pdstLine);
return;
}
/* source is depth 8, 32 bpp */
if(format != ZPixmap) {
miGetImage(pDraw, sx, sy, w, h, format, planemask, pdstLine);
return;
} else {
BoxRec box;
DDXPointRec ptSrc;
RegionRec rgnDst;
ScreenPtr pScreen;
PixmapPtr pPixmap;
pScreen = pDraw->pScreen;
pPixmap = GetScratchPixmapHeader(pScreen, w, h, 8, 8,
PixmapBytePad(w,8), (pointer)pdstLine);
if (!pPixmap)
return;
if ((planemask & 0xff) != 0xff)
memset((char *)pdstLine, 0, pPixmap->devKind * h);
ptSrc.x = sx + pDraw->x;
ptSrc.y = sy + pDraw->y;
box.x1 = 0;
box.y1 = 0;
box.x2 = w;
box.y2 = h;
REGION_INIT(pScreen, &rgnDst, &box, 1);
cfbDoBitblt32To8(pDraw, (DrawablePtr)pPixmap, GXcopy, &rgnDst,
&ptSrc, planemask);
REGION_UNINIT(pScreen, &rgnDst);
FreeScratchPixmapHeader(pPixmap);
}
}
void
cfb8_32PutImage (
DrawablePtr pDraw,
GCPtr pGC,
int depth,
int x, int y, int w, int h,
int leftPad,
int format,
char *pImage
){
if(!w || !h) return;
if((pDraw->bitsPerPixel == 8) || (format != XYPixmap)){
cfbPutImage(pDraw, pGC, depth, x, y, w, h, leftPad, format, pImage);
return;
} else { /* moving an 8bpp XYPixmap to a 32bpp screen */
unsigned long oldFg, oldBg;
XID gcv[3];
unsigned long oldPlanemask;
unsigned long i;
long bytesPer;
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 = 0x80000000; i & 0xff000000; 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
cfb8_32GetSpans(
DrawablePtr pDraw,
int wMax,
DDXPointPtr ppt,
int *pwidth,
int nspans,
char *pDst
){
int pitch, i;
CARD8 *ptr, *ptrBase;
if (!cfbDrawableEnabled (pDraw))
return;
if(pDraw->bitsPerPixel == 1) {
mfbGetSpans(pDraw, wMax, ppt, pwidth, nspans, pDst);
return;
}
if(pDraw->depth == 24) {
cfb32GetSpans(pDraw, wMax, ppt, pwidth, nspans, pDst);
return;
} else if(pDraw->bitsPerPixel == 8) {
cfbGetSpans(pDraw, wMax, ppt, pwidth, nspans, pDst);
return;
}
/* gotta get spans from a depth 8 window */
cfbGetByteWidthAndPointer(pDraw, pitch, ptrBase);
ptrBase += 3; /* point to top byte */
while(nspans--) {
ptr = ptrBase + (ppt->y * pitch) + (ppt->x << 2);
for(i = *pwidth; i--; ptr += 4)
*(pDst++) = *ptr;
pDst = (char*)((long)(pDst + 3) & ~3L);
ppt++; pwidth++;
}
}

51
hw/xfree86/xf8_32bpp/cfbpntwin.c
View File

@ -1,51 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <X11/X.h>
#include "windowstr.h"
#include "regionstr.h"
#include "pixmapstr.h"
#include "scrnintstr.h"
#define PSZ 8
#include "cfb.h"
#undef PSZ
#include "cfb32.h"
#include "cfb8_32.h"
#include "mi.h"
#ifdef PANORAMIX
#include "panoramiX.h"
#include "panoramiXsrv.h"
#endif
void
cfb8_32FillBoxSolid8(
DrawablePtr pDraw,
int nbox,
BoxPtr pbox,
unsigned long color
){
CARD8 *ptr, *data;
int pitch, height, width, i;
CARD8 c = (CARD8)color;
cfbGetByteWidthAndPointer(pDraw, pitch, ptr);
ptr += 3; /* point to the top byte */
while(nbox--) {
data = ptr + (pbox->y1 * pitch) + (pbox->x1 << 2);
width = (pbox->x2 - pbox->x1) << 2;
height = pbox->y2 - pbox->y1;
while(height--) {
for(i = 0; i < width; i+=4)
data[i] = c;
data += pitch;
}
pbox++;
}
}

311
hw/xfree86/xf8_32bpp/cfbscrinit.c
View File

@ -1,311 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <X11/X.h>
#include <X11/Xmd.h>
#include "misc.h"
#include "servermd.h"
#include "scrnintstr.h"
#include "pixmapstr.h"
#include "resource.h"
#include "colormap.h"
#include "colormapst.h"
#define PSZ 8
#include "cfb.h"
#undef PSZ
#include "cfb32.h"
#include "cfb8_32.h"
#include "mi.h"
#include "micmap.h"
#include "mistruct.h"
#include "dix.h"
#include "mibstore.h"
#include "mioverlay.h"
#include "xf86.h"
#include "xf86str.h"
#include "globals.h"
/* CAUTION: We require that cfb8 and cfb32 were NOT
compiled with CFB_NEED_SCREEN_PRIVATE */
static DevPrivateKey cfb8_32GCPrivateKey = &cfb8_32GCPrivateKey;
DevPrivateKey cfb8_32GetGCPrivateKey(void)
{
return cfb8_32GCPrivateKey;
}
static DevPrivateKey cfb8_32ScreenPrivateKey = &cfb8_32ScreenPrivateKey;
DevPrivateKey cfb8_32GetScreenPrivateKey(void)
{
return cfb8_32ScreenPrivateKey;
}
static Bool
cfb8_32AllocatePrivates(ScreenPtr pScreen)
{
cfb8_32ScreenPtr pScreenPriv;
if (!(pScreenPriv = xalloc(sizeof(cfb8_32ScreenRec))))
return FALSE;
dixSetPrivate(&pScreen->devPrivates, cfb8_32ScreenPrivateKey, pScreenPriv);
/* All cfb will have the same GC and Window private indicies */
if(!mfbAllocatePrivates(pScreen, &cfbGCPrivateKey))
return FALSE;
if(!dixRequestPrivate(cfbGCPrivateKey, sizeof(cfbPrivGC)))
return FALSE;
if(!dixRequestPrivate(cfb8_32GCPrivateKey, sizeof(cfb8_32GCRec)))
return FALSE;
return TRUE;
}
static void DestroyColormapNoop(
ColormapPtr pColormap)
{
/* NOOP */
}
static void StoreColorsNoop(
ColormapPtr pColormap,
int ndef,
xColorItem * pdef)
{
/* NOOP */
}
static Bool
cfb8_32SetupScreen(
ScreenPtr pScreen,
pointer pbits, /* pointer to screen bitmap */
int xsize, int ysize, /* in pixels */
int dpix, int dpiy, /* dots per inch */
int width /* pixel width of frame buffer */
){
if (!cfb8_32AllocatePrivates(pScreen))
return FALSE;
pScreen->defColormap = FakeClientID(0);
/* let CreateDefColormap do whatever it wants for pixels */
pScreen->blackPixel = pScreen->whitePixel = (Pixel) 0;
pScreen->QueryBestSize = mfbQueryBestSize;
/* SaveScreen */
pScreen->GetImage = cfb8_32GetImage;
pScreen->GetSpans = cfb8_32GetSpans;
pScreen->CreateWindow = cfb8_32CreateWindow;
pScreen->DestroyWindow = cfb8_32DestroyWindow;
pScreen->PositionWindow = cfb8_32PositionWindow;
pScreen->ChangeWindowAttributes = cfb8_32ChangeWindowAttributes;
pScreen->RealizeWindow = cfb32MapWindow; /* OK */
pScreen->UnrealizeWindow = cfb32UnmapWindow; /* OK */
pScreen->CopyWindow = cfb8_32CopyWindow;
pScreen->CreatePixmap = cfb32CreatePixmap; /* OK */
pScreen->DestroyPixmap = cfb32DestroyPixmap; /* OK */
pScreen->RealizeFont = mfbRealizeFont;
pScreen->UnrealizeFont = mfbUnrealizeFont;
pScreen->CreateGC = cfb8_32CreateGC;
pScreen->CreateColormap = miInitializeColormap;
pScreen->DestroyColormap = DestroyColormapNoop;
pScreen->InstallColormap = miInstallColormap;
pScreen->UninstallColormap = miUninstallColormap;
pScreen->ListInstalledColormaps = miListInstalledColormaps;
pScreen->StoreColors = StoreColorsNoop;
pScreen->ResolveColor = miResolveColor;
pScreen->BitmapToRegion = mfbPixmapToRegion;
mfbRegisterCopyPlaneProc (pScreen, cfb8_32CopyPlane);
return TRUE;
}
typedef struct {
pointer pbits;
int width;
} miScreenInitParmsRec, *miScreenInitParmsPtr;
static Bool
cfb8_32CreateScreenResources(ScreenPtr pScreen)
{
miScreenInitParmsPtr pScrInitParms;
int pitch;
Bool retval;
/* get the pitch before mi destroys it */
pScrInitParms = (miScreenInitParmsPtr)pScreen->devPrivate;
pitch = pScrInitParms->width << 2;
if((retval = miCreateScreenResources(pScreen))) {
/* fix the screen pixmap */
PixmapPtr pPix = (PixmapPtr)pScreen->devPrivate;
pPix->drawable.bitsPerPixel = 32;
pPix->drawable.depth = 8;
pPix->devKind = pitch;
}
return retval;
}
static Bool
cfb8_32CloseScreen (int i, ScreenPtr pScreen)
{
cfb8_32ScreenPtr pScreenPriv = CFB8_32_GET_SCREEN_PRIVATE(pScreen);
if(pScreenPriv->visualData)
xfree(pScreenPriv->visualData);
xfree((pointer) pScreenPriv);
dixSetPrivate(&pScreen->devPrivates, cfb8_32ScreenPrivateKey, NULL);
return(cfb32CloseScreen(i, pScreen));
}
static void
cfb8_32TransFunc(
ScreenPtr pScreen,
int nbox,
BoxPtr pbox
){
cfb8_32FillBoxSolid8(&(WindowTable[pScreen->myNum]->drawable),
nbox, pbox, xf86Screens[pScreen->myNum]->colorKey);
}
static Bool
cfb8_32InOverlayFunc(WindowPtr pWin)
{
return (pWin->drawable.depth == 8);
}
static Bool
cfb8_32FinishScreenInit(
ScreenPtr pScreen,
pointer pbits, /* pointer to screen bitmap */
int xsize, int ysize, /* in pixels */
int dpix, int dpiy, /* dots per inch */
int width /* pixel width of frame buffer */
){
VisualPtr visuals;
DepthPtr depths;
int nvisuals;
int ndepths;
int rootdepth;
VisualID defaultVisual;
rootdepth = 0;
if (!miInitVisuals (&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
&defaultVisual,((unsigned long)1<<(32-1)), 8, -1))
return FALSE;
if (! miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
rootdepth, ndepths, depths,
defaultVisual, nvisuals, visuals))
return FALSE;
pScreen->CreateScreenResources = cfb8_32CreateScreenResources;
pScreen->CloseScreen = cfb8_32CloseScreen;
pScreen->GetScreenPixmap = cfb32GetScreenPixmap; /* OK */
pScreen->SetScreenPixmap = cfb32SetScreenPixmap; /* OK */
if (! miInitOverlay(pScreen, cfb8_32InOverlayFunc, cfb8_32TransFunc))
return FALSE;
return TRUE;
}
static void
cfb8_32EnableDisableFBAccess (
int index,
Bool enable
){
ScreenPtr pScreen = screenInfo.screens[index];
cfb8_32ScreenPtr pScreenPriv = CFB8_32_GET_SCREEN_PRIVATE(pScreen);
miOverlaySetRootClip(pScreen, enable);
(*pScreenPriv->EnableDisableFBAccess) (index, enable);
}
static Atom overlayVisualsAtom;
typedef struct {
CARD32 overlay_visual;
CARD32 transparent_type;
CARD32 value;
CARD32 layer;
} overlayVisualRec;
static void
cfb8_32SetupVisuals (ScreenPtr pScreen)
{
cfb8_32ScreenPtr pScreenPriv = CFB8_32_GET_SCREEN_PRIVATE(pScreen);
char atomString[] = {"SERVER_OVERLAY_VISUALS"};
overlayVisualRec *overlayVisuals;
VisualID *visuals = NULL;
int numVisuals = 0;
DepthPtr pDepth = pScreen->allowedDepths;
int numDepths = pScreen->numDepths;
int i;
/* find depth 8 visuals */
for(i = 0; i < numDepths; i++, pDepth++) {
if(pDepth->depth == 8) {
numVisuals = pDepth->numVids;
visuals = pDepth->vids;
break;
}
}
if(!numVisuals || !visuals) {
ErrorF("No overlay visuals found!\n");
return;
}
if(!(overlayVisuals = xalloc(numVisuals * sizeof(overlayVisualRec))))
return;
for(i = 0; i < numVisuals; i++) {
overlayVisuals[i].overlay_visual = visuals[i];
overlayVisuals[i].transparent_type = 1; /* transparent pixel */
overlayVisuals[i].value = pScreenPriv->key;
overlayVisuals[i].layer = 1;
}
overlayVisualsAtom = MakeAtom(atomString, sizeof(atomString) - 1, TRUE);
xf86RegisterRootWindowProperty(pScreen->myNum, overlayVisualsAtom,
overlayVisualsAtom, 32, numVisuals * 4, overlayVisuals);
pScreenPriv->visualData = (pointer)overlayVisuals;
}
Bool
cfb8_32ScreenInit(
ScreenPtr pScreen,
pointer pbits, /* pointer to screen bitmap */
int xsize, int ysize, /* in pixels */
int dpix, int dpiy, /* dots per inch */
int w /* pixel width of frame buffer */
){
cfb8_32ScreenPtr pScreenPriv;
ScrnInfoPtr pScrn = xf86Screens[pScreen->myNum];
if (!cfb8_32SetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, w))
return FALSE;
pScreenPriv = CFB8_32_GET_SCREEN_PRIVATE(pScreen);
pScreenPriv->key = pScrn->colorKey;
pScreenPriv->visualData = NULL;
pScreenPriv->EnableDisableFBAccess = pScrn->EnableDisableFBAccess;
pScrn->EnableDisableFBAccess = cfb8_32EnableDisableFBAccess;
if(cfb8_32FinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, w))
{
cfb8_32SetupVisuals(pScreen);
return TRUE;
}
return FALSE;
}

116
hw/xfree86/xf8_32bpp/cfbwindow.c
View File

@ -1,116 +0,0 @@
#ifdef HAVE_XORG_CONFIG_H
#include <xorg-config.h>
#endif
#include <stdlib.h>
#include <X11/X.h>
#include "scrnintstr.h"
#include "windowstr.h"
#define PSZ 8
#include "cfb.h"
#undef PSZ
#include "cfb32.h"
#include "cfb8_32.h"
#include "mistruct.h"
#include "regionstr.h"
#include "cfbmskbits.h"
#include "mioverlay.h"
/* We don't bother with cfb's fastBackground/Border so we don't
need to use the Window privates */
Bool
cfb8_32CreateWindow(WindowPtr pWin)
{
pWin->drawable.bitsPerPixel = 32;
return TRUE;
}
Bool
cfb8_32DestroyWindow(WindowPtr pWin)
{
return TRUE;
}
Bool
cfb8_32PositionWindow(
WindowPtr pWin,
int x, int y
){
return TRUE;
}
void
cfb8_32CopyWindow(pWin, ptOldOrg, prgnSrc)
WindowPtr pWin;
DDXPointRec ptOldOrg;
RegionPtr prgnSrc;
{
ScreenPtr pScreen = pWin->drawable.pScreen;
DDXPointPtr ppt, pptSrc;
RegionRec rgnDst;
RegionPtr borderClip = &pWin->borderClip;
BoxPtr pbox;
int dx, dy, i, nbox;
WindowPtr pwinRoot;
Bool doUnderlay = miOverlayCopyUnderlay(pScreen);
Bool freeReg = FALSE;
pwinRoot = WindowTable[pScreen->myNum];
if(doUnderlay)
freeReg = miOverlayCollectUnderlayRegions(pWin, &borderClip);
REGION_NULL(pScreen, &rgnDst);
dx = ptOldOrg.x - pWin->drawable.x;
dy = ptOldOrg.y - pWin->drawable.y;
REGION_TRANSLATE(pScreen, prgnSrc, -dx, -dy);
REGION_INTERSECT(pScreen, &rgnDst, borderClip, prgnSrc);
pbox = REGION_RECTS(&rgnDst);
nbox = REGION_NUM_RECTS(&rgnDst);
if(!nbox ||
!(pptSrc = (DDXPointPtr )xalloc(nbox * sizeof(DDXPointRec))))
{
REGION_UNINIT(pScreen, &rgnDst);
return;
}
ppt = pptSrc;
for (i = nbox; --i >= 0; ppt++, pbox++)
{
ppt->x = pbox->x1 + dx;
ppt->y = pbox->y1 + dy;
}
if(doUnderlay)
cfbDoBitblt24To24GXcopy((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
GXcopy, &rgnDst, pptSrc, ~0);
else
cfbDoBitblt8To8GXcopy((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
GXcopy, &rgnDst, pptSrc, ~0);
xfree(pptSrc);
REGION_UNINIT(pScreen, &rgnDst);
if(freeReg)
REGION_DESTROY(pScreen, borderClip);
}
Bool
cfb8_32ChangeWindowAttributes(
WindowPtr pWin,
unsigned long mask
){
return TRUE;
}

1179
hw/xfree86/xf8_32bpp/xf86overlay.c
View File

File diff suppressed because it is too large Load Diff