So long, and thanks for all the cfb.
This commit is contained in:
parent
059b4876e6
commit
0dab6fa358
|
@ -9,11 +9,6 @@ if XTRAP
|
|||
XTRAP_DIR=XTrap
|
||||
endif
|
||||
|
||||
if CFB
|
||||
CFB_DIR=cfb
|
||||
CFB32_DIR=cfb32
|
||||
endif
|
||||
|
||||
if AFB
|
||||
AFB_DIR=afb
|
||||
endif
|
||||
|
@ -50,8 +45,6 @@ SUBDIRS = \
|
|||
$(DBE_DIR) \
|
||||
$(MFB_DIR) \
|
||||
$(AFB_DIR) \
|
||||
$(CFB_DIR) \
|
||||
$(CFB32_DIR) \
|
||||
$(RECORD_DIR) \
|
||||
xfixes \
|
||||
damageext \
|
||||
|
@ -96,8 +89,6 @@ DIST_SUBDIRS = \
|
|||
dbe \
|
||||
mfb \
|
||||
afb \
|
||||
cfb \
|
||||
cfb32 \
|
||||
record \
|
||||
xfixes \
|
||||
damageext \
|
||||
|
|
|
@ -1,21 +0,0 @@
|
|||
noinst_LTLIBRARIES = libcfb.la
|
||||
|
||||
include Makefile.am.inc
|
||||
|
||||
DISTCLEANFILES += cfbglrop8.c
|
||||
|
||||
libcfb_la_SOURCES = cfb8bit.c cfbteblt8.c cfbglrop8.c cfbpush8.c cfbrctstp8.c \
|
||||
$(libcfb_gen_sources) $(libcfb_common_sources)
|
||||
|
||||
libcfb_la_LIBADD = ../mfb/libmfb.la
|
||||
|
||||
AM_CFLAGS = -DPSZ=8 $(DIX_CFLAGS) $(PLATFORMDEFS)
|
||||
|
||||
INCLUDES = $(CFB_INCLUDES) -I$(top_srcdir)/hw/xfree86/os-support -I$(top_srcdir)/hw/xfree86/common
|
||||
|
||||
EXTRA_DIST = cfbline.c cfbfillarc.c cfbzerarc.c cfbblt.c cfbsolid.c \
|
||||
cfbtileodd.c cfbtile32.c cfb8line.c cfbply1rct.c cfbglblt8.c \
|
||||
cfb16.h cfb24.h cfb32.h cfb8bit.h cfbrrop.h \
|
||||
stip68kgnu.h stipmips.s stipsparc.s stipsprc32.s
|
||||
|
||||
sdk_HEADERS = cfb.h cfb32.h cfb16.h cfbmap.h cfbunmap.h cfbmskbits.h
|
|
@ -1,153 +0,0 @@
|
|||
libcfb_gen_sources = cfbseg.c cfbfillarcC.c cfbfillarcG.c cfbzerarcC.c cfbzerarcX.c cfbzerarcG.c \
|
||||
cfbbltC.c cfbbltX.c cfbbltO.c cfbbltG.c cfbsolidC.c cfbsolidX.c cfbsolidG.c cfbtileoddC.c \
|
||||
cfbtileoddG.c cfbtile32C.c cfbtile32G.c cfb8lineCO.c cfb8lineCP.c cfb8lineX.c cfb8lineG.c \
|
||||
cfb8segCS.c cfb8segC.c cfb8segX.c cfb8setG.c cfbply1rctC.c cfbply1rctG.c
|
||||
|
||||
DISTCLEANFILES = $(libcfb_gen_sources)
|
||||
|
||||
CFB_INCLUDES = -I$(top_srcdir)/mfb -I$(top_srcdir)/cfb
|
||||
|
||||
libcfb_common_sources = $(top_srcdir)/cfb/cfbgc.c $(top_srcdir)/cfb/cfbrrop.c \
|
||||
$(top_srcdir)/cfb/cfbwindow.c \
|
||||
$(top_srcdir)/cfb/cfbmskbits.c $(top_srcdir)/cfb/cfbpixmap.c \
|
||||
$(top_srcdir)/cfb/cfbbitblt.c $(top_srcdir)/cfb/cfbfillsp.c \
|
||||
$(top_srcdir)/cfb/cfbsetsp.c $(top_srcdir)/cfb/cfbscrinit.c \
|
||||
$(top_srcdir)/cfb/cfballpriv.c $(top_srcdir)/cfb/cfbgetsp.c \
|
||||
$(top_srcdir)/cfb/cfbfillrct.c $(top_srcdir)/cfb/cfbigblt8.c \
|
||||
$(top_srcdir)/cfb/cfbglblt8.c $(top_srcdir)/cfb/cfbtegblt.c \
|
||||
$(top_srcdir)/cfb/cfbpolypnt.c \
|
||||
$(top_srcdir)/cfb/cfbbres.c $(top_srcdir)/cfb/cfbline.c \
|
||||
$(top_srcdir)/cfb/cfbhrzvert.c $(top_srcdir)/cfb/cfbbresd.c \
|
||||
$(top_srcdir)/cfb/cfbimage.c $(top_srcdir)/cfb/cfbcppl.c \
|
||||
$(top_srcdir)/cfb/cfbcmap.c
|
||||
|
||||
cfbseg.c:
|
||||
echo "#define POLYSEGMENT" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbline.c\"" >> $@
|
||||
|
||||
cfbfillarcC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbfillarc.c\"" >> $@
|
||||
|
||||
cfbfillarcG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbfillarc.c\"" >> $@
|
||||
|
||||
cfbzerarcC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbzerarc.c\"" >> $@
|
||||
|
||||
cfbzerarcX.c:
|
||||
echo "#define RROP GXxor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbzerarc.c\"" >> $@
|
||||
|
||||
cfbzerarcG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbzerarc.c\"" >> $@
|
||||
|
||||
cfbbltC.c:
|
||||
echo "#define MROP Mcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbblt.c\"" >> $@
|
||||
|
||||
cfbbltX.c:
|
||||
echo "#define MROP Mxor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbblt.c\"" >> $@
|
||||
|
||||
cfbbltO.c:
|
||||
echo "#define MROP Mor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbblt.c\"" >> $@
|
||||
|
||||
cfbbltG.c:
|
||||
echo "#define MROP 0" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbblt.c\"" >> $@
|
||||
|
||||
cfbsolidC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbsolid.c\"" >> $@
|
||||
|
||||
cfbsolidX.c:
|
||||
echo "#define RROP GXxor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbsolid.c\"" >> $@
|
||||
|
||||
cfbsolidG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbsolid.c\"" >> $@
|
||||
|
||||
cfbtileoddC.c:
|
||||
echo "#define MROP Mcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbtileodd.c\"" >> $@
|
||||
|
||||
cfbtileoddG.c:
|
||||
echo "#define MROP 0" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbtileodd.c\"" >> $@
|
||||
|
||||
cfbtile32C.c:
|
||||
echo "#define MROP Mcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbtile32.c\"" >> $@
|
||||
|
||||
cfbtile32G.c:
|
||||
echo "#define MROP 0" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbtile32.c\"" >> $@
|
||||
|
||||
cfb8lineCO.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8lineCP.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#define PREVIOUS" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8lineX.c:
|
||||
echo "#define RROP GXxor" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8lineG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8segCS.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#define POLYSEGMENT" >> $@
|
||||
echo "#define WIDTH_SHIFT" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8segC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#define POLYSEGMENT" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8segX.c:
|
||||
echo "#define RROP GXxor" > $@
|
||||
echo "#define POLYSEGMENT" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfb8setG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#define POLYSEGMENT" >> $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfb8line.c\"" >> $@
|
||||
|
||||
cfbply1rctC.c:
|
||||
echo "#define RROP GXcopy" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbply1rct.c\"" >> $@
|
||||
|
||||
cfbply1rctG.c:
|
||||
echo "#define RROP GXset" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbply1rct.c\"" >> $@
|
||||
|
||||
cfbglrop8.c:
|
||||
echo "#define GLYPHROP" > $@
|
||||
echo "#include \"$(top_srcdir)/cfb/cfbglblt8.c\"" >> $@
|
||||
|
||||
|
||||
if XPRINT
|
||||
|
||||
PLATFORMDEFS = -DXFREE86
|
||||
|
||||
cfb8bit.o: compiler.h
|
||||
|
||||
compiler.h:
|
||||
echo "#include \"$(top_srcdir)/hw/xfree86/common/compiler.h\"" >> $@
|
||||
|
||||
endif
|
||||
|
93
cfb/cfb16.h
93
cfb/cfb16.h
|
@ -1,93 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1994-1998 The XFree86 Project, Inc. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifndef _CFB16_H_
|
||||
#define _CFB16_H_
|
||||
|
||||
/*
|
||||
* C's preprocessing language substitutes >text<, not values...
|
||||
*/
|
||||
|
||||
#ifdef OLDPSZ
|
||||
# undef OLDPSZ
|
||||
#endif
|
||||
|
||||
#ifdef PSZ
|
||||
|
||||
# if (PSZ == 8)
|
||||
# define OLDPSZ 8
|
||||
# endif
|
||||
|
||||
# if (PSZ == 16)
|
||||
# define OLDPSZ 16
|
||||
# endif
|
||||
|
||||
# if (PSZ == 24)
|
||||
# define OLDPSZ 24
|
||||
# endif
|
||||
|
||||
# if (PSZ == 32)
|
||||
# define OLDPSZ 32
|
||||
# endif
|
||||
|
||||
# ifndef OLDPSZ
|
||||
/* Maybe an #error here ? */
|
||||
# endif
|
||||
|
||||
# undef PSZ
|
||||
|
||||
#endif
|
||||
|
||||
#define PSZ 16
|
||||
#define CFB_PROTOTYPES_ONLY
|
||||
#include "cfb.h"
|
||||
#undef CFB_PROTOTYPES_ONLY
|
||||
#include "cfbunmap.h"
|
||||
|
||||
#undef PSZ
|
||||
#ifdef OLDPSZ
|
||||
|
||||
# if (OLDPSZ == 8)
|
||||
# define PSZ 8
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 16)
|
||||
# define PSZ 16
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 24)
|
||||
# define PSZ 24
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 32)
|
||||
# define PSZ 32
|
||||
# endif
|
||||
|
||||
# undef OLDPSZ
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* _CFB16_H_ */
|
97
cfb/cfb24.h
97
cfb/cfb24.h
|
@ -1,97 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1994-1998 The XFree86 Project, Inc. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#ifndef _CFB24_H_
|
||||
#define _CFB24_H_
|
||||
|
||||
/*
|
||||
* C's preprocessing language substitutes >text<, not values...
|
||||
*/
|
||||
|
||||
#ifdef OLDPSZ
|
||||
# undef OLDPSZ
|
||||
#endif
|
||||
|
||||
#ifdef PSZ
|
||||
|
||||
# if (PSZ == 8)
|
||||
# define OLDPSZ 8
|
||||
# endif
|
||||
|
||||
# if (PSZ == 16)
|
||||
# define OLDPSZ 16
|
||||
# endif
|
||||
|
||||
# if (PSZ == 24)
|
||||
# define OLDPSZ 24
|
||||
# endif
|
||||
|
||||
# if (PSZ == 32)
|
||||
# define OLDPSZ 32
|
||||
# endif
|
||||
|
||||
# ifndef OLDPSZ
|
||||
/* Maybe an #error here ? */
|
||||
# endif
|
||||
|
||||
# undef PSZ
|
||||
|
||||
#endif
|
||||
|
||||
#define PSZ 24
|
||||
#define CFB_PROTOTYPES_ONLY
|
||||
#include "cfb.h"
|
||||
#undef CFB_PROTOTYPES_ONLY
|
||||
#include "cfbunmap.h"
|
||||
|
||||
#undef PSZ
|
||||
#ifdef OLDPSZ
|
||||
|
||||
# if (OLDPSZ == 8)
|
||||
# define PSZ 8
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 16)
|
||||
# define PSZ 16
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 24)
|
||||
# define PSZ 24
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 32)
|
||||
# define PSZ 32
|
||||
# endif
|
||||
|
||||
# undef OLDPSZ
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* _CFB24_H_ */
|
93
cfb/cfb32.h
93
cfb/cfb32.h
|
@ -1,93 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1994-1998 The XFree86 Project, Inc. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifndef _CFB32_H_
|
||||
#define _CFB32_H_
|
||||
|
||||
/*
|
||||
* C's preprocessing language substitutes >text<, not values...
|
||||
*/
|
||||
|
||||
#ifdef OLDPSZ
|
||||
# undef OLDPSZ
|
||||
#endif
|
||||
|
||||
#ifdef PSZ
|
||||
|
||||
# if (PSZ == 8)
|
||||
# define OLDPSZ 8
|
||||
# endif
|
||||
|
||||
# if (PSZ == 16)
|
||||
# define OLDPSZ 16
|
||||
# endif
|
||||
|
||||
# if (PSZ == 24)
|
||||
# define OLDPSZ 24
|
||||
# endif
|
||||
|
||||
# if (PSZ == 32)
|
||||
# define OLDPSZ 32
|
||||
# endif
|
||||
|
||||
# ifndef OLDPSZ
|
||||
/* Maybe an #error here ? */
|
||||
# endif
|
||||
|
||||
# undef PSZ
|
||||
|
||||
#endif
|
||||
|
||||
#define PSZ 32
|
||||
#define CFB_PROTOTYPES_ONLY
|
||||
#include "cfb.h"
|
||||
#undef CFB_PROTOTYPES_ONLY
|
||||
#include "cfbunmap.h"
|
||||
|
||||
#undef PSZ
|
||||
#ifdef OLDPSZ
|
||||
|
||||
# if (OLDPSZ == 8)
|
||||
# define PSZ 8
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 16)
|
||||
# define PSZ 16
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 24)
|
||||
# define PSZ 24
|
||||
# endif
|
||||
|
||||
# if (OLDPSZ == 32)
|
||||
# define PSZ 32
|
||||
# endif
|
||||
|
||||
# undef OLDPSZ
|
||||
|
||||
#endif
|
||||
|
||||
#endif /* _CFB32_H_ */
|
469
cfb/cfb8bit.c
469
cfb/cfb8bit.c
|
@ -1,469 +0,0 @@
|
|||
/*
|
||||
|
||||
Copyright 1989, 1994, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included
|
||||
in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
||||
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
||||
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
||||
OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall
|
||||
not be used in advertising or otherwise to promote the sale, use or
|
||||
other dealings in this Software without prior written authorization
|
||||
from The Open Group.
|
||||
|
||||
*/
|
||||
|
||||
/*
|
||||
* cfb8bit.c
|
||||
*
|
||||
* 8 bit color frame buffer utility routines
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
PixelGroup cfb8StippleMasks[NUM_MASKS] = {
|
||||
#if NUM_MASKS == 16
|
||||
0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff,
|
||||
0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff,
|
||||
0xff000000, 0xff0000ff, 0xff00ff00, 0xff00ffff,
|
||||
0xffff0000, 0xffff00ff, 0xffffff00, 0xffffffff
|
||||
#else /* NUM_MASKS == 256 */
|
||||
0x0000000000000000, 0x00000000000000ff,
|
||||
0x000000000000ff00, 0x000000000000ffff,
|
||||
0x0000000000ff0000, 0x0000000000ff00ff,
|
||||
0x0000000000ffff00, 0x0000000000ffffff,
|
||||
0x00000000ff000000, 0x00000000ff0000ff,
|
||||
0x00000000ff00ff00, 0x00000000ff00ffff,
|
||||
0x00000000ffff0000, 0x00000000ffff00ff,
|
||||
0x00000000ffffff00, 0x00000000ffffffff,
|
||||
0x000000ff00000000, 0x000000ff000000ff,
|
||||
0x000000ff0000ff00, 0x000000ff0000ffff,
|
||||
0x000000ff00ff0000, 0x000000ff00ff00ff,
|
||||
0x000000ff00ffff00, 0x000000ff00ffffff,
|
||||
0x000000ffff000000, 0x000000ffff0000ff,
|
||||
0x000000ffff00ff00, 0x000000ffff00ffff,
|
||||
0x000000ffffff0000, 0x000000ffffff00ff,
|
||||
0x000000ffffffff00, 0x000000ffffffffff,
|
||||
0x0000ff0000000000, 0x0000ff00000000ff,
|
||||
0x0000ff000000ff00, 0x0000ff000000ffff,
|
||||
0x0000ff0000ff0000, 0x0000ff0000ff00ff,
|
||||
0x0000ff0000ffff00, 0x0000ff0000ffffff,
|
||||
0x0000ff00ff000000, 0x0000ff00ff0000ff,
|
||||
0x0000ff00ff00ff00, 0x0000ff00ff00ffff,
|
||||
0x0000ff00ffff0000, 0x0000ff00ffff00ff,
|
||||
0x0000ff00ffffff00, 0x0000ff00ffffffff,
|
||||
0x0000ffff00000000, 0x0000ffff000000ff,
|
||||
0x0000ffff0000ff00, 0x0000ffff0000ffff,
|
||||
0x0000ffff00ff0000, 0x0000ffff00ff00ff,
|
||||
0x0000ffff00ffff00, 0x0000ffff00ffffff,
|
||||
0x0000ffffff000000, 0x0000ffffff0000ff,
|
||||
0x0000ffffff00ff00, 0x0000ffffff00ffff,
|
||||
0x0000ffffffff0000, 0x0000ffffffff00ff,
|
||||
0x0000ffffffffff00, 0x0000ffffffffffff,
|
||||
0x00ff000000000000, 0x00ff0000000000ff,
|
||||
0x00ff00000000ff00, 0x00ff00000000ffff,
|
||||
0x00ff000000ff0000, 0x00ff000000ff00ff,
|
||||
0x00ff000000ffff00, 0x00ff000000ffffff,
|
||||
0x00ff0000ff000000, 0x00ff0000ff0000ff,
|
||||
0x00ff0000ff00ff00, 0x00ff0000ff00ffff,
|
||||
0x00ff0000ffff0000, 0x00ff0000ffff00ff,
|
||||
0x00ff0000ffffff00, 0x00ff0000ffffffff,
|
||||
0x00ff00ff00000000, 0x00ff00ff000000ff,
|
||||
0x00ff00ff0000ff00, 0x00ff00ff0000ffff,
|
||||
0x00ff00ff00ff0000, 0x00ff00ff00ff00ff,
|
||||
0x00ff00ff00ffff00, 0x00ff00ff00ffffff,
|
||||
0x00ff00ffff000000, 0x00ff00ffff0000ff,
|
||||
0x00ff00ffff00ff00, 0x00ff00ffff00ffff,
|
||||
0x00ff00ffffff0000, 0x00ff00ffffff00ff,
|
||||
0x00ff00ffffffff00, 0x00ff00ffffffffff,
|
||||
0x00ffff0000000000, 0x00ffff00000000ff,
|
||||
0x00ffff000000ff00, 0x00ffff000000ffff,
|
||||
0x00ffff0000ff0000, 0x00ffff0000ff00ff,
|
||||
0x00ffff0000ffff00, 0x00ffff0000ffffff,
|
||||
0x00ffff00ff000000, 0x00ffff00ff0000ff,
|
||||
0x00ffff00ff00ff00, 0x00ffff00ff00ffff,
|
||||
0x00ffff00ffff0000, 0x00ffff00ffff00ff,
|
||||
0x00ffff00ffffff00, 0x00ffff00ffffffff,
|
||||
0x00ffffff00000000, 0x00ffffff000000ff,
|
||||
0x00ffffff0000ff00, 0x00ffffff0000ffff,
|
||||
0x00ffffff00ff0000, 0x00ffffff00ff00ff,
|
||||
0x00ffffff00ffff00, 0x00ffffff00ffffff,
|
||||
0x00ffffffff000000, 0x00ffffffff0000ff,
|
||||
0x00ffffffff00ff00, 0x00ffffffff00ffff,
|
||||
0x00ffffffffff0000, 0x00ffffffffff00ff,
|
||||
0x00ffffffffffff00, 0x00ffffffffffffff,
|
||||
0xff00000000000000, 0xff000000000000ff,
|
||||
0xff0000000000ff00, 0xff0000000000ffff,
|
||||
0xff00000000ff0000, 0xff00000000ff00ff,
|
||||
0xff00000000ffff00, 0xff00000000ffffff,
|
||||
0xff000000ff000000, 0xff000000ff0000ff,
|
||||
0xff000000ff00ff00, 0xff000000ff00ffff,
|
||||
0xff000000ffff0000, 0xff000000ffff00ff,
|
||||
0xff000000ffffff00, 0xff000000ffffffff,
|
||||
0xff0000ff00000000, 0xff0000ff000000ff,
|
||||
0xff0000ff0000ff00, 0xff0000ff0000ffff,
|
||||
0xff0000ff00ff0000, 0xff0000ff00ff00ff,
|
||||
0xff0000ff00ffff00, 0xff0000ff00ffffff,
|
||||
0xff0000ffff000000, 0xff0000ffff0000ff,
|
||||
0xff0000ffff00ff00, 0xff0000ffff00ffff,
|
||||
0xff0000ffffff0000, 0xff0000ffffff00ff,
|
||||
0xff0000ffffffff00, 0xff0000ffffffffff,
|
||||
0xff00ff0000000000, 0xff00ff00000000ff,
|
||||
0xff00ff000000ff00, 0xff00ff000000ffff,
|
||||
0xff00ff0000ff0000, 0xff00ff0000ff00ff,
|
||||
0xff00ff0000ffff00, 0xff00ff0000ffffff,
|
||||
0xff00ff00ff000000, 0xff00ff00ff0000ff,
|
||||
0xff00ff00ff00ff00, 0xff00ff00ff00ffff,
|
||||
0xff00ff00ffff0000, 0xff00ff00ffff00ff,
|
||||
0xff00ff00ffffff00, 0xff00ff00ffffffff,
|
||||
0xff00ffff00000000, 0xff00ffff000000ff,
|
||||
0xff00ffff0000ff00, 0xff00ffff0000ffff,
|
||||
0xff00ffff00ff0000, 0xff00ffff00ff00ff,
|
||||
0xff00ffff00ffff00, 0xff00ffff00ffffff,
|
||||
0xff00ffffff000000, 0xff00ffffff0000ff,
|
||||
0xff00ffffff00ff00, 0xff00ffffff00ffff,
|
||||
0xff00ffffffff0000, 0xff00ffffffff00ff,
|
||||
0xff00ffffffffff00, 0xff00ffffffffffff,
|
||||
0xffff000000000000, 0xffff0000000000ff,
|
||||
0xffff00000000ff00, 0xffff00000000ffff,
|
||||
0xffff000000ff0000, 0xffff000000ff00ff,
|
||||
0xffff000000ffff00, 0xffff000000ffffff,
|
||||
0xffff0000ff000000, 0xffff0000ff0000ff,
|
||||
0xffff0000ff00ff00, 0xffff0000ff00ffff,
|
||||
0xffff0000ffff0000, 0xffff0000ffff00ff,
|
||||
0xffff0000ffffff00, 0xffff0000ffffffff,
|
||||
0xffff00ff00000000, 0xffff00ff000000ff,
|
||||
0xffff00ff0000ff00, 0xffff00ff0000ffff,
|
||||
0xffff00ff00ff0000, 0xffff00ff00ff00ff,
|
||||
0xffff00ff00ffff00, 0xffff00ff00ffffff,
|
||||
0xffff00ffff000000, 0xffff00ffff0000ff,
|
||||
0xffff00ffff00ff00, 0xffff00ffff00ffff,
|
||||
0xffff00ffffff0000, 0xffff00ffffff00ff,
|
||||
0xffff00ffffffff00, 0xffff00ffffffffff,
|
||||
0xffffff0000000000, 0xffffff00000000ff,
|
||||
0xffffff000000ff00, 0xffffff000000ffff,
|
||||
0xffffff0000ff0000, 0xffffff0000ff00ff,
|
||||
0xffffff0000ffff00, 0xffffff0000ffffff,
|
||||
0xffffff00ff000000, 0xffffff00ff0000ff,
|
||||
0xffffff00ff00ff00, 0xffffff00ff00ffff,
|
||||
0xffffff00ffff0000, 0xffffff00ffff00ff,
|
||||
0xffffff00ffffff00, 0xffffff00ffffffff,
|
||||
0xffffffff00000000, 0xffffffff000000ff,
|
||||
0xffffffff0000ff00, 0xffffffff0000ffff,
|
||||
0xffffffff00ff0000, 0xffffffff00ff00ff,
|
||||
0xffffffff00ffff00, 0xffffffff00ffffff,
|
||||
0xffffffffff000000, 0xffffffffff0000ff,
|
||||
0xffffffffff00ff00, 0xffffffffff00ffff,
|
||||
0xffffffffffff0000, 0xffffffffffff00ff,
|
||||
0xffffffffffffff00, 0xffffffffffffffff
|
||||
#endif
|
||||
};
|
||||
|
||||
int cfb8StippleMode, cfb8StippleAlu, cfb8StippleRRop;
|
||||
PixelGroup cfb8StippleFg, cfb8StippleBg, cfb8StipplePm;
|
||||
PixelGroup cfb8StippleAnd[NUM_MASKS], cfb8StippleXor[NUM_MASKS];
|
||||
|
||||
int
|
||||
cfb8SetStipple (alu, fg, planemask)
|
||||
int alu;
|
||||
CfbBits fg, planemask;
|
||||
{
|
||||
CfbBits and, xor, rrop;
|
||||
int s;
|
||||
CfbBits c;
|
||||
|
||||
cfb8StippleMode = FillStippled;
|
||||
cfb8StippleAlu = alu;
|
||||
cfb8StippleFg = fg & PMSK;
|
||||
cfb8StipplePm = planemask & PMSK;
|
||||
rrop = cfbReduceRasterOp (alu, fg, planemask, &and, &xor);
|
||||
cfb8StippleRRop = rrop;
|
||||
/*
|
||||
* create the appropriate pixel-fill bits for current
|
||||
* foreground
|
||||
*/
|
||||
for (s = 0; s < NUM_MASKS; s++)
|
||||
{
|
||||
c = cfb8StippleMasks[s];
|
||||
cfb8StippleAnd[s] = and | ~c;
|
||||
cfb8StippleXor[s] = xor & c;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
int
|
||||
cfb8SetOpaqueStipple (alu, fg, bg, planemask)
|
||||
int alu;
|
||||
CfbBits fg, bg, planemask;
|
||||
{
|
||||
CfbBits andfg, xorfg, andbg, xorbg, rropfg, rropbg;
|
||||
int s;
|
||||
CfbBits c;
|
||||
|
||||
cfb8StippleMode = FillOpaqueStippled;
|
||||
cfb8StippleAlu = alu;
|
||||
cfb8StippleFg = fg & PMSK;
|
||||
cfb8StippleBg = bg & PMSK;
|
||||
cfb8StipplePm = planemask & PMSK;
|
||||
rropfg = cfbReduceRasterOp (alu, cfb8StippleFg, cfb8StipplePm, &andfg, &xorfg);
|
||||
rropbg = cfbReduceRasterOp (alu, cfb8StippleBg, cfb8StipplePm, &andbg, &xorbg);
|
||||
if (rropfg == rropbg)
|
||||
cfb8StippleRRop = rropfg;
|
||||
else
|
||||
cfb8StippleRRop = GXset;
|
||||
/*
|
||||
* create the appropriate pixel-fill bits for current
|
||||
* foreground
|
||||
*/
|
||||
for (s = 0; s < NUM_MASKS; s++)
|
||||
{
|
||||
c = cfb8StippleMasks[s];
|
||||
cfb8StippleAnd[s] = (andfg | ~c) & (andbg | c);
|
||||
cfb8StippleXor[s] = (xorfg & c) | (xorbg & ~c);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/*
|
||||
* a grungy little routine. This computes clip masks
|
||||
* for partial character blts. Returns rgnOUT if the
|
||||
* entire character is clipped; returns rgnIN if the entire
|
||||
* character is unclipped; returns rgnPART if a portion of
|
||||
* the character is visible. Computes clip masks for each
|
||||
* longword of the character -- and those with the
|
||||
* contents of the glyph to compute the visible bits.
|
||||
*/
|
||||
|
||||
#if PGSZ == 32
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
PixelGroup cfb8BitLenMasks[PGSZ] = {
|
||||
0xffffffff, 0x7fffffff, 0x3fffffff, 0x1fffffff,
|
||||
0x0fffffff, 0x07ffffff, 0x03ffffff, 0x01ffffff,
|
||||
0x00ffffff, 0x007fffff, 0x003fffff, 0x001fffff,
|
||||
0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff,
|
||||
0x0000ffff, 0x00007fff, 0x00003fff, 0x00001fff,
|
||||
0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff,
|
||||
0x000000ff, 0x0000007f, 0x0000003f, 0x0000001f,
|
||||
0x0000000f, 0x00000007, 0x00000003, 0x00000001,
|
||||
};
|
||||
#else
|
||||
PixelGroup cfb8BitLenMasks[PGSZ] = {
|
||||
0xffffffff, 0xfffffffe, 0xfffffffc, 0xfffffff8,
|
||||
0xfffffff0, 0xffffffe0, 0xffffffc0, 0xffffff80,
|
||||
0xffffff00, 0xfffffe00, 0xfffffc00, 0xfffff800,
|
||||
0xfffff000, 0xffffe000, 0xffffc000, 0xffff8000,
|
||||
0xffff0000, 0xfffe0000, 0xfffc0000, 0xfff80000,
|
||||
0xfff00000, 0xffe00000, 0xffc00000, 0xff800000,
|
||||
0xff000000, 0xfe000000, 0xfc000000, 0xf8000000,
|
||||
0xf0000000, 0xe0000000, 0xc0000000, 0x80000000,
|
||||
};
|
||||
#endif /* BITMAP_BIT_ORDER */
|
||||
#else /* PGSZ == 64 */
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
PixelGroup cfb8BitLenMasks[PGSZ] = {
|
||||
0xffffffffffffffff, 0x7fffffffffffffff,
|
||||
0x3fffffffffffffff, 0x1fffffffffffffff,
|
||||
0x0fffffffffffffff, 0x07ffffffffffffff,
|
||||
0x03ffffffffffffff, 0x01ffffffffffffff,
|
||||
0x00ffffffffffffff, 0x007fffffffffffff,
|
||||
0x003fffffffffffff, 0x001fffffffffffff,
|
||||
0x000fffffffffffff, 0x0007ffffffffffff,
|
||||
0x0003ffffffffffff, 0x0001ffffffffffff,
|
||||
0x0000ffffffffffff, 0x00007fffffffffff,
|
||||
0x00003fffffffffff, 0x00001fffffffffff,
|
||||
0x00000fffffffffff, 0x000007ffffffffff,
|
||||
0x000003ffffffffff, 0x000001ffffffffff,
|
||||
0x000000ffffffffff, 0x0000007fffffffff,
|
||||
0x0000003fffffffff, 0x0000001fffffffff,
|
||||
0x0000000fffffffff, 0x00000007ffffffff,
|
||||
0x00000003ffffffff, 0x00000001ffffffff,
|
||||
0x00000000ffffffff, 0x000000007fffffff,
|
||||
0x000000003fffffff, 0x000000001fffffff,
|
||||
0x000000000fffffff, 0x0000000007ffffff,
|
||||
0x0000000003ffffff, 0x0000000001ffffff,
|
||||
0x0000000000ffffff, 0x00000000007fffff,
|
||||
0x00000000003fffff, 0x00000000001fffff,
|
||||
0x00000000000fffff, 0x000000000007ffff,
|
||||
0x000000000003ffff, 0x000000000001ffff,
|
||||
0x000000000000ffff, 0x0000000000007fff,
|
||||
0x0000000000003fff, 0x0000000000001fff,
|
||||
0x0000000000000fff, 0x00000000000007ff,
|
||||
0x00000000000003ff, 0x00000000000001ff,
|
||||
0x00000000000000ff, 0x000000000000007f,
|
||||
0x000000000000003f, 0x000000000000001f,
|
||||
0x000000000000000f, 0x0000000000000007,
|
||||
0x0000000000000003, 0x0000000000000001
|
||||
};
|
||||
#else
|
||||
PixelGroup cfb8BitLenMasks[PGSZ] = {
|
||||
0xffffffffffffffff, 0xfffffffffffffffe,
|
||||
0xfffffffffffffffc, 0xfffffffffffffff8,
|
||||
0xfffffffffffffff0, 0xffffffffffffffe0,
|
||||
0xffffffffffffffc0, 0xffffffffffffff80,
|
||||
0xffffffffffffff00, 0xfffffffffffffe00,
|
||||
0xfffffffffffffc00, 0xfffffffffffff800,
|
||||
0xfffffffffffff000, 0xffffffffffffe000,
|
||||
0xffffffffffffc000, 0xffffffffffff8000,
|
||||
0xffffffffffff0000, 0xfffffffffffe0000,
|
||||
0xfffffffffffc0000, 0xfffffffffff80000,
|
||||
0xfffffffffff00000, 0xffffffffffe00000,
|
||||
0xffffffffffc00000, 0xffffffffff800000,
|
||||
0xffffffffff000000, 0xfffffffffe000000,
|
||||
0xfffffffffc000000, 0xfffffffff8000000,
|
||||
0xfffffffff0000000, 0xffffffffe0000000,
|
||||
0xffffffffc0000000, 0xffffffff80000000,
|
||||
0xffffffff00000000, 0xfffffffe00000000,
|
||||
0xfffffffc00000000, 0xfffffff800000000,
|
||||
0xfffffff000000000, 0xffffffe000000000,
|
||||
0xffffffc000000000, 0xffffff8000000000,
|
||||
0xffffff0000000000, 0xfffffe0000000000,
|
||||
0xfffffc0000000000, 0xfffff80000000000,
|
||||
0xfffff00000000000, 0xffffe00000000000,
|
||||
0xffffc00000000000, 0xffff800000000000,
|
||||
0xffff000000000000, 0xfffe000000000000,
|
||||
0xfffc000000000000, 0xfff8000000000000,
|
||||
0xfff0000000000000, 0xffe0000000000000,
|
||||
0xffc0000000000000, 0xff80000000000000,
|
||||
0xff00000000000000, 0xfe00000000000000,
|
||||
0xfc00000000000000, 0xf800000000000000,
|
||||
0xf000000000000000, 0xe000000000000000,
|
||||
0xc000000000000000, 0x8000000000000000
|
||||
};
|
||||
#endif /* BITMAP_BIT_ORDER */
|
||||
#endif /* PGSZ */
|
||||
|
||||
|
||||
|
||||
int
|
||||
cfb8ComputeClipMasks32 (pBox, numRects, x, y, w, h, clips)
|
||||
BoxPtr pBox;
|
||||
int numRects;
|
||||
int x, y, w, h;
|
||||
CARD32 *clips;
|
||||
{
|
||||
int yBand, yBandBot;
|
||||
int ch;
|
||||
CfbBits clip;
|
||||
int partIN = FALSE, partOUT = FALSE;
|
||||
int result;
|
||||
|
||||
if (numRects == 0)
|
||||
return rgnOUT;
|
||||
while (numRects && pBox->y2 <= y)
|
||||
{
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
if (!numRects || pBox->y1 >= y + h)
|
||||
return rgnOUT;
|
||||
yBand = pBox->y1;
|
||||
while (numRects && pBox->y1 == yBand && pBox->x2 <= x)
|
||||
{
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
if (!numRects || pBox->y1 >= y + h)
|
||||
return rgnOUT;
|
||||
if (numRects &&
|
||||
x >= pBox->x1 &&
|
||||
x + w <= pBox->x2 &&
|
||||
y >= pBox->y1 &&
|
||||
y + h <= pBox->y2)
|
||||
{
|
||||
return rgnIN;
|
||||
}
|
||||
ch = 0;
|
||||
while (numRects && pBox->y1 < y + h)
|
||||
{
|
||||
yBand = pBox->y1;
|
||||
yBandBot = pBox->y2;
|
||||
while (ch < h && y + ch < yBand)
|
||||
{
|
||||
partOUT = TRUE;
|
||||
clips[ch++] = 0;
|
||||
}
|
||||
if (ch >= h)
|
||||
break;
|
||||
while (numRects && pBox->y1 == yBand && pBox->x2 <= x)
|
||||
{
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
if (!numRects)
|
||||
break;
|
||||
clip = 0;
|
||||
while (numRects && pBox->y1 == yBand && pBox->x1 < x + w)
|
||||
{
|
||||
if (x < pBox->x1)
|
||||
if (pBox->x2 < x + w)
|
||||
clip |= cfb8BitLenMasks[pBox->x1 - x] & ~cfb8BitLenMasks[pBox->x2 - x];
|
||||
else
|
||||
clip |= cfb8BitLenMasks[pBox->x1 - x];
|
||||
else
|
||||
if (pBox->x2 < x + w)
|
||||
clip |= ~cfb8BitLenMasks[pBox->x2 - x];
|
||||
else
|
||||
clip = ~0;
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
if (clip != 0)
|
||||
partIN = TRUE;
|
||||
if (clip != ~0)
|
||||
partOUT = TRUE;
|
||||
while (ch < h && y + ch < yBandBot)
|
||||
clips[ch++] = clip;
|
||||
while (numRects && pBox->y1 == yBand)
|
||||
{
|
||||
--numRects;
|
||||
++pBox;
|
||||
}
|
||||
}
|
||||
while (ch < h)
|
||||
{
|
||||
partOUT = TRUE;
|
||||
clips[ch++] = 0;
|
||||
}
|
||||
result = rgnOUT;
|
||||
if (partIN)
|
||||
{
|
||||
if (partOUT)
|
||||
result = rgnPART;
|
||||
else
|
||||
result = rgnIN;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
#endif /* PSZ == 8 */
|
1570
cfb/cfb8bit.h
1570
cfb/cfb8bit.h
File diff suppressed because it is too large
Load Diff
1503
cfb/cfb8line.c
1503
cfb/cfb8line.c
File diff suppressed because it is too large
Load Diff
|
@ -1,70 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1991, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "resource.h"
|
||||
#include "colormap.h"
|
||||
#include "colormapst.h"
|
||||
#include "cfb.h"
|
||||
#include "mi.h"
|
||||
#include "mistruct.h"
|
||||
#include "dix.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mibstore.h"
|
||||
|
||||
#if 1 || PSZ==8
|
||||
DevPrivateKey cfbGCPrivateKey = &cfbGCPrivateKey;
|
||||
#endif
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
DevPrivateKey cfbScreenPrivateKey = &cfbScreenPrivateKey;
|
||||
#endif
|
||||
|
||||
|
||||
Bool
|
||||
cfbAllocatePrivates(ScreenPtr pScreen, DevPrivateKey *gc_key)
|
||||
{
|
||||
if (!gc_key || !*gc_key)
|
||||
{
|
||||
if (!mfbAllocatePrivates(pScreen, &cfbGCPrivateKey))
|
||||
return FALSE;
|
||||
if (gc_key)
|
||||
*gc_key = cfbGCPrivateKey;
|
||||
}
|
||||
else
|
||||
{
|
||||
cfbGCPrivateKey = *gc_key;
|
||||
}
|
||||
return dixRequestPrivate(cfbGCPrivateKey, sizeof(cfbPrivGC));
|
||||
}
|
1455
cfb/cfbbitblt.c
1455
cfb/cfbbitblt.c
File diff suppressed because it is too large
Load Diff
933
cfb/cfbblt.c
933
cfb/cfbblt.c
|
@ -1,933 +0,0 @@
|
|||
/*
|
||||
* cfb copy area
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
Author: Keith Packard
|
||||
|
||||
*/
|
||||
|
||||
/* 24-bit bug fixes: Peter Wainwright, 1998/11/28 */
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
#include "fastblt.h"
|
||||
#include "mergerop.h"
|
||||
|
||||
#ifdef notdef /* XXX fails right now, walks off end of pixmaps */
|
||||
#if defined (FAST_UNALIGNED_READS) && PSZ == 8
|
||||
#define DO_UNALIGNED_BITBLT
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(FAST_MEMCPY) && (MROP == Mcopy) && PSZ == 8
|
||||
#define DO_MEMCPY
|
||||
#endif
|
||||
|
||||
/* ................................................. */
|
||||
/* SPECIAL CODE FOR 24 BITS by Peter Wainwright */
|
||||
|
||||
#if PSZ == 24 && (MROP) == 0
|
||||
|
||||
/* The default macros are defined in mergerop.h, and none of them are
|
||||
really appropriate for what we want to do.
|
||||
|
||||
There are two ways of fixing this: either define SLOW_24BIT_COPY
|
||||
to copy pixel by pixel, or (by default) use the following macros
|
||||
modified from mergerop.h
|
||||
|
||||
MROP_SOLID and MROP_MASK are defined for each of the operations,
|
||||
i.e. each value of MROP.
|
||||
|
||||
There are special cases for Mcopy, McopyInverted, Mxor, and Mor.
|
||||
There is a completely generic version for MROP=0, and a simplified
|
||||
generic version which works for (Mcopy|Mxor|MandReverse|Mor).
|
||||
|
||||
However, the generic version does not work for the 24-bit case
|
||||
because the pixels cannot be packed exactly into a machine word (32
|
||||
bits).
|
||||
|
||||
Alternative macros MROP_SOLID24 and MROP_MASK24 are provided for
|
||||
the 24-bit case. However, these each copy a single *pixel*, not a
|
||||
single machine word. They take an rvalue source pixel, an lvalue
|
||||
destination, and the pixel index. The latter is used to find the
|
||||
position of the pixel data within the two words *dst and *(dst+1).
|
||||
|
||||
Further macros MROP_SOLID24P and MROP_MASK24P are used to copy from
|
||||
an lvalue source to an lvalue destination. MROP_PIXEL24 is used to
|
||||
assemble the source pixel from the adjacent words *src and
|
||||
*(src+1), and this is then split between the destination words
|
||||
using the non-P macros above.
|
||||
|
||||
But we want to copy entire words for the sake of efficiency.
|
||||
Unfortunately if a plane mask is specified this must be shifted
|
||||
from one word to the next. Fortunately the pattern repeats after 3
|
||||
words, so we unroll the planemask here and redefine MROP_SOLID
|
||||
and MROP_MASK. */
|
||||
|
||||
|
||||
#endif /* MROP == 0 && PSZ == 24 */
|
||||
|
||||
/* ................................................. */
|
||||
|
||||
#if PSZ == 24
|
||||
#define BYPP 3
|
||||
#if PGSZ == 32
|
||||
#define P3W 4 /* pixels in 3 machine words */
|
||||
#define PAM 3 /* pixel align mask; PAM = P3W -1 */
|
||||
#define P2WSH 2
|
||||
#else
|
||||
#define P3W 8 /* pixels in 3 machine words */
|
||||
#define PAM 7 /* pixel align mask; PAM = P3W -1 */
|
||||
#define P2WSH 3
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void
|
||||
MROP_NAME(cfbDoBitblt)(
|
||||
DrawablePtr pSrc,
|
||||
DrawablePtr pDst,
|
||||
int alu,
|
||||
RegionPtr prgnDst,
|
||||
DDXPointPtr pptSrc,
|
||||
unsigned long planemask)
|
||||
{
|
||||
CfbBits *psrcBase, *pdstBase;
|
||||
/* start of src and dst bitmaps */
|
||||
int widthSrc, widthDst; /* add to get to same position in next line */
|
||||
|
||||
BoxPtr pbox;
|
||||
int nbox;
|
||||
|
||||
BoxPtr pboxTmp, pboxNext, pboxBase, pboxNew1, pboxNew2;
|
||||
/* temporaries for shuffling rectangles */
|
||||
DDXPointPtr pptTmp, pptNew1, pptNew2;
|
||||
/* shuffling boxes entails shuffling the
|
||||
source points too */
|
||||
int w, h;
|
||||
int xdir; /* 1 = left right, -1 = right left/ */
|
||||
int ydir; /* 1 = top down, -1 = bottom up */
|
||||
|
||||
CfbBits *psrcLine, *pdstLine;
|
||||
/* pointers to line with current src and dst */
|
||||
register CfbBits *psrc;/* pointer to current src longword */
|
||||
register CfbBits *pdst;/* pointer to current dst longword */
|
||||
|
||||
MROP_DECLARE_REG()
|
||||
|
||||
/* following used for looping through a line */
|
||||
CfbBits startmask, endmask; /* masks for writing ends of dst */
|
||||
int nlMiddle; /* whole longwords in dst */
|
||||
int xoffSrc, xoffDst;
|
||||
register int nl; /* temp copy of nlMiddle */
|
||||
int careful;
|
||||
|
||||
#if (PSZ != 24) || (MROP != 0)
|
||||
register int leftShift, rightShift;
|
||||
register CfbBits bits;
|
||||
register CfbBits bits1;
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#ifdef DO_MEMCPY
|
||||
int w2;
|
||||
#endif
|
||||
|
||||
#if MROP == 0
|
||||
int widthSrcBytes = cfbGetByteWidth(pSrc);
|
||||
int widthDstBytes = cfbGetByteWidth(pDst);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
MROP_INITIALIZE(alu,planemask)
|
||||
|
||||
cfbGetLongWidthAndPointer (pSrc, widthSrc, psrcBase)
|
||||
|
||||
cfbGetLongWidthAndPointer (pDst, widthDst, pdstBase)
|
||||
|
||||
/* XXX we have to err on the side of safety when both are windows,
|
||||
* because we don't know if IncludeInferiors is being used.
|
||||
*/
|
||||
careful = ((pSrc == pDst) ||
|
||||
((pSrc->type == DRAWABLE_WINDOW) &&
|
||||
(pDst->type == DRAWABLE_WINDOW)));
|
||||
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
nbox = REGION_NUM_RECTS(prgnDst);
|
||||
|
||||
pboxNew1 = NULL;
|
||||
pptNew1 = NULL;
|
||||
pboxNew2 = NULL;
|
||||
pptNew2 = NULL;
|
||||
if (careful && (pptSrc->y < pbox->y1))
|
||||
{
|
||||
/* walk source botttom to top */
|
||||
ydir = -1;
|
||||
widthSrc = -widthSrc;
|
||||
widthDst = -widthDst;
|
||||
|
||||
if (nbox > 1)
|
||||
{
|
||||
/* keep ordering in each band, reverse order of bands */
|
||||
pboxNew1 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
|
||||
if(!pboxNew1)
|
||||
return;
|
||||
pptNew1 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
|
||||
if(!pptNew1)
|
||||
{
|
||||
xfree(pboxNew1);
|
||||
return;
|
||||
}
|
||||
pboxBase = pboxNext = pbox+nbox-1;
|
||||
while (pboxBase >= pbox)
|
||||
{
|
||||
while ((pboxNext >= pbox) &&
|
||||
(pboxBase->y1 == pboxNext->y1))
|
||||
pboxNext--;
|
||||
pboxTmp = pboxNext+1;
|
||||
pptTmp = pptSrc + (pboxTmp - pbox);
|
||||
while (pboxTmp <= pboxBase)
|
||||
{
|
||||
*pboxNew1++ = *pboxTmp++;
|
||||
*pptNew1++ = *pptTmp++;
|
||||
}
|
||||
pboxBase = pboxNext;
|
||||
}
|
||||
pboxNew1 -= nbox;
|
||||
pbox = pboxNew1;
|
||||
pptNew1 -= nbox;
|
||||
pptSrc = pptNew1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* walk source top to bottom */
|
||||
ydir = 1;
|
||||
}
|
||||
|
||||
if (careful && (pptSrc->x < pbox->x1))
|
||||
{
|
||||
/* walk source right to left */
|
||||
xdir = -1;
|
||||
|
||||
if (nbox > 1)
|
||||
{
|
||||
/* reverse order of rects in each band */
|
||||
pboxNew2 = (BoxPtr)xalloc(sizeof(BoxRec) * nbox);
|
||||
pptNew2 = (DDXPointPtr)xalloc(sizeof(DDXPointRec) * nbox);
|
||||
if(!pboxNew2 || !pptNew2)
|
||||
{
|
||||
if (pptNew2) xfree(pptNew2);
|
||||
if (pboxNew2) xfree(pboxNew2);
|
||||
if (pboxNew1)
|
||||
{
|
||||
xfree(pptNew1);
|
||||
xfree(pboxNew1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
pboxBase = pboxNext = pbox;
|
||||
while (pboxBase < pbox+nbox)
|
||||
{
|
||||
while ((pboxNext < pbox+nbox) &&
|
||||
(pboxNext->y1 == pboxBase->y1))
|
||||
pboxNext++;
|
||||
pboxTmp = pboxNext;
|
||||
pptTmp = pptSrc + (pboxTmp - pbox);
|
||||
while (pboxTmp != pboxBase)
|
||||
{
|
||||
*pboxNew2++ = *--pboxTmp;
|
||||
*pptNew2++ = *--pptTmp;
|
||||
}
|
||||
pboxBase = pboxNext;
|
||||
}
|
||||
pboxNew2 -= nbox;
|
||||
pbox = pboxNew2;
|
||||
pptNew2 -= nbox;
|
||||
pptSrc = pptNew2;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* walk source left to right */
|
||||
xdir = 1;
|
||||
}
|
||||
|
||||
while(nbox--)
|
||||
{
|
||||
w = pbox->x2 - pbox->x1;
|
||||
h = pbox->y2 - pbox->y1;
|
||||
|
||||
#if PSZ == 24
|
||||
#ifdef DO_MEMCPY
|
||||
w2 = w * BYPP;
|
||||
#endif
|
||||
#endif
|
||||
if (ydir == -1) /* start at last scanline of rectangle */
|
||||
{
|
||||
psrcLine = psrcBase + ((pptSrc->y+h-1) * -widthSrc);
|
||||
pdstLine = pdstBase + ((pbox->y2-1) * -widthDst);
|
||||
}
|
||||
else /* start at first scanline */
|
||||
{
|
||||
psrcLine = psrcBase + (pptSrc->y * widthSrc);
|
||||
pdstLine = pdstBase + (pbox->y1 * widthDst);
|
||||
}
|
||||
#if PSZ == 24
|
||||
if (w == 1 && ((pbox->x1 & PAM) == 0 || (pbox->x1 & PAM) == PAM))
|
||||
#else
|
||||
if ((pbox->x1 & PIM) + w <= PPW)
|
||||
#endif
|
||||
{
|
||||
maskpartialbits (pbox->x1, w, endmask);
|
||||
startmask = 0;
|
||||
nlMiddle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(pbox->x1, w, startmask, endmask, nlMiddle);
|
||||
}
|
||||
|
||||
#if PSZ == 24
|
||||
#if 0
|
||||
nlMiddle = w - (pbox->x2 &PAM);;
|
||||
if(pbox->x1 & PAM){
|
||||
nlMiddle -= (PAM+1 - (pbox->x1 &PAM));
|
||||
}
|
||||
nlMiddle >>= P2WSH;
|
||||
if(nlMiddle < 0)
|
||||
nlMiddle = 0;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef DO_MEMCPY
|
||||
/* If the src and dst scanline don't overlap, do forward case. */
|
||||
|
||||
if ((xdir == 1) || (pptSrc->y != pbox->y1)
|
||||
|| (pptSrc->x + w <= pbox->x1))
|
||||
{
|
||||
#if PSZ == 24
|
||||
char *psrc = (char *) psrcLine + (pptSrc->x * BYPP);
|
||||
char *pdst = (char *) pdstLine + (pbox->x1 * BYPP);
|
||||
#else
|
||||
char *psrc = (char *) psrcLine + pptSrc->x;
|
||||
char *pdst = (char *) pdstLine + pbox->x1;
|
||||
#endif
|
||||
while (h--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
memcpy(pdst, psrc, w2);
|
||||
#else
|
||||
memcpy(pdst, psrc, w);
|
||||
#endif
|
||||
pdst += widthDst << PWSH;
|
||||
psrc += widthSrc << PWSH;
|
||||
}
|
||||
}
|
||||
#else /* ! DO_MEMCPY */
|
||||
if (xdir == 1)
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* Note: x is a pixel number; the byte offset is 3*x;
|
||||
therefore the offset within a word is (3*x) & 3 ==
|
||||
(4*x-x) & 3 == (-x) & 3. The offsets therefore
|
||||
DECREASE by 1 for each pixel.
|
||||
*/
|
||||
xoffSrc = ( - pptSrc->x) & PAM;
|
||||
xoffDst = ( - pbox->x1) & PAM;
|
||||
#if 1
|
||||
if((int)xoffSrc != (int)xoffDst /* Alignments must be same. */
|
||||
|| ((widthDstBytes & PAM) != (widthSrcBytes & PAM) && h > 1))
|
||||
#else
|
||||
if(1)
|
||||
#endif
|
||||
/* Width also must be same, if hight > 1 */
|
||||
{
|
||||
/* ...otherwise, pixel by pixel operation */
|
||||
while (h--)
|
||||
{
|
||||
register int i, si, sii, di;
|
||||
|
||||
for (i = 0, si = pptSrc->x, di = pbox->x1;
|
||||
i < w;
|
||||
i++, si++, di++) {
|
||||
psrc = psrcLine + ((si * BYPP) >> P2WSH);
|
||||
pdst = pdstLine + ((di * BYPP) >> P2WSH);
|
||||
sii = (si & 3);
|
||||
MROP_SOLID24P(psrc, pdst, sii, di);
|
||||
}
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
|
||||
#if PSZ == 24
|
||||
|
||||
#if MROP != 0
|
||||
xoffSrc = ( - pptSrc->x) & PAM;
|
||||
xoffDst = ( - pbox->x1) & PAM;
|
||||
#endif
|
||||
pdstLine += (pbox->x1 * BYPP) >> P2WSH;
|
||||
psrcLine += (pptSrc->x * BYPP) >> P2WSH;
|
||||
#else
|
||||
xoffSrc = pptSrc->x & PIM;
|
||||
xoffDst = pbox->x1 & PIM;
|
||||
pdstLine += (pbox->x1 >> PWSH);
|
||||
psrcLine += (pptSrc->x >> PWSH);
|
||||
#endif
|
||||
#ifdef DO_UNALIGNED_BITBLT
|
||||
nl = xoffSrc - xoffDst;
|
||||
psrcLine = (CfbBits *)
|
||||
(((unsigned char *) psrcLine) + nl);
|
||||
#else
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* alredy satisfied */
|
||||
#else
|
||||
if (xoffSrc == xoffDst)
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
register int index;
|
||||
register int im3;
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
#if PSZ == 24 && MROP == 0
|
||||
index = (int)(pdst - pdstBase);
|
||||
im3 = index % 3;
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
if (startmask)
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
*pdst = DoMaskMergeRop24u(*psrc, *pdst, startmask, im3);
|
||||
index++;
|
||||
im3 = index % 3;
|
||||
#else /* PSZ != 24 || MROP != 0 */
|
||||
*pdst = MROP_MASK(*psrc, *pdst, startmask);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
psrc++;
|
||||
pdst++;
|
||||
}
|
||||
|
||||
nl = nlMiddle;
|
||||
#ifdef LARGE_INSTRUCTION_CACHE
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
|
||||
psrc += nl & (UNROLL-1);
|
||||
pdst += nl & (UNROLL-1);
|
||||
|
||||
#if PSZ == 24 && MROP == 0
|
||||
#define BodyOdd(n) pdst[-n] = DoMergeRop24u(psrc[-n], pdst[-n], ((int)(pdst - n - pdstBase))%3);
|
||||
#define BodyEven(n) pdst[-n] = DoMergeRop24u(psrc[-n], pdst[-n], ((int)(pdst - n - pdstBase))%3);
|
||||
#else /* PSZ != 24 || MROP != 0 */
|
||||
#define BodyOdd(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
|
||||
#define BodyEven(n) pdst[-n] = MROP_SOLID (psrc[-n], pdst[-n]);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
|
||||
#define LoopReset \
|
||||
pdst += UNROLL; \
|
||||
psrc += UNROLL;
|
||||
|
||||
#else
|
||||
|
||||
#if PSZ == 24 && MROP == 0
|
||||
#define BodyOdd(n) *pdst = DoMergeRop24u(*psrc, *pdst, im3); pdst++; psrc++; index++; im3 = index % 3;
|
||||
#define BodyEven(n) BodyOdd(n)
|
||||
#else /* PSZ != 24 || MROP != 0 */
|
||||
#define BodyOdd(n) *pdst = MROP_SOLID (*psrc, *pdst); pdst++; psrc++;
|
||||
#define BodyEven(n) BodyOdd(n)
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
|
||||
#define LoopReset ;
|
||||
|
||||
#endif
|
||||
PackedLoop
|
||||
|
||||
#undef BodyOdd
|
||||
#undef BodyEven
|
||||
#undef LoopReset
|
||||
|
||||
#else
|
||||
#ifdef NOTDEF
|
||||
/* you'd think this would be faster --
|
||||
* a single instruction instead of 6
|
||||
* but measurements show it to be ~15% slower
|
||||
*/
|
||||
while ((nl -= 6) >= 0)
|
||||
{
|
||||
asm ("moveml %1+,#0x0c0f;moveml#0x0c0f,%0"
|
||||
: "=m" (*(char *)pdst)
|
||||
: "m" (*(char *)psrc)
|
||||
: "d0", "d1", "d2", "d3",
|
||||
"a2", "a3");
|
||||
pdst += 6;
|
||||
}
|
||||
nl += 6;
|
||||
while (nl--)
|
||||
*pdst++ = *psrc++;
|
||||
#endif
|
||||
#if 0 /*PSZ == 24 && MROP == 0*/
|
||||
DuffL(nl, label1,
|
||||
*pdst = DoMergeRop24u(*psrc, *pdst, im3);
|
||||
pdst++; psrc++; index++;im3 = index % 3;)
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
DuffL(nl, label1,
|
||||
*pdst = MROP_SOLID (*psrc, *pdst);
|
||||
pdst++; psrc++;)
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
#endif
|
||||
|
||||
if (endmask)
|
||||
#if PSZ == 24 && MROP == 0
|
||||
*pdst = DoMaskMergeRop24u(*psrc, *pdst, endmask, (int)(pdst - pdstBase) % 3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
*pdst = MROP_MASK(*psrc, *pdst, endmask);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
}
|
||||
}
|
||||
#ifndef DO_UNALIGNED_BITBLT
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* can not happen */
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
else /* xoffSrc != xoffDst */
|
||||
{
|
||||
if (xoffSrc > xoffDst)
|
||||
{
|
||||
#if PSZ == 24
|
||||
leftShift = (xoffSrc - xoffDst) << 3;
|
||||
#else
|
||||
#if PGSZ == 32
|
||||
leftShift = (xoffSrc - xoffDst) << (5 - PWSH);
|
||||
#else /* PGSZ == 64 */
|
||||
leftShift = (xoffSrc - xoffDst) << (6 - PWSH);
|
||||
#endif /* PGSZ */
|
||||
#endif
|
||||
rightShift = PGSZ - leftShift;
|
||||
}
|
||||
else
|
||||
{
|
||||
#if PSZ == 24
|
||||
rightShift = (xoffDst - xoffSrc) << 3;
|
||||
#else
|
||||
#if PGSZ == 32
|
||||
rightShift = (xoffDst - xoffSrc) << (5 - PWSH);
|
||||
#else /* PGSZ == 64 */
|
||||
rightShift = (xoffDst - xoffSrc) << (6 - PWSH);
|
||||
#endif /* PGSZ */
|
||||
#endif
|
||||
leftShift = PGSZ - rightShift;
|
||||
}
|
||||
while (h--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
bits = 0;
|
||||
if (xoffSrc > xoffDst)
|
||||
bits = *psrc++;
|
||||
if (startmask)
|
||||
{
|
||||
bits1 = BitLeft(bits,leftShift);
|
||||
bits = *psrc++;
|
||||
bits1 |= BitRight(bits,rightShift);
|
||||
*pdst = MROP_MASK(bits1, *pdst, startmask);
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
#ifdef LARGE_INSTRUCTION_CACHE
|
||||
bits1 = bits;
|
||||
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
|
||||
psrc += nl & (UNROLL-1);
|
||||
pdst += nl & (UNROLL-1);
|
||||
|
||||
#define BodyOdd(n) \
|
||||
bits = psrc[-n]; \
|
||||
pdst[-n] = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), pdst[-n]);
|
||||
|
||||
#define BodyEven(n) \
|
||||
bits1 = psrc[-n]; \
|
||||
pdst[-n] = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), pdst[-n]);
|
||||
|
||||
#define LoopReset \
|
||||
pdst += UNROLL; \
|
||||
psrc += UNROLL;
|
||||
|
||||
#else
|
||||
|
||||
#define BodyOdd(n) \
|
||||
bits = *psrc++; \
|
||||
*pdst = MROP_SOLID(BitLeft(bits1, leftShift) | BitRight(bits, rightShift), *pdst); \
|
||||
pdst++;
|
||||
|
||||
#define BodyEven(n) \
|
||||
bits1 = *psrc++; \
|
||||
*pdst = MROP_SOLID(BitLeft(bits, leftShift) | BitRight(bits1, rightShift), *pdst); \
|
||||
pdst++;
|
||||
|
||||
#define LoopReset ;
|
||||
|
||||
#endif /* !FAST_CONSTANT_OFFSET_MODE */
|
||||
|
||||
PackedLoop
|
||||
|
||||
#undef BodyOdd
|
||||
#undef BodyEven
|
||||
#undef LoopReset
|
||||
|
||||
#else
|
||||
DuffL (nl,label2,
|
||||
bits1 = BitLeft(bits, leftShift);
|
||||
bits = *psrc++;
|
||||
*pdst = MROP_SOLID (bits1 | BitRight(bits, rightShift), *pdst);
|
||||
pdst++;
|
||||
)
|
||||
#endif
|
||||
|
||||
if (endmask)
|
||||
{
|
||||
bits1 = BitLeft(bits, leftShift);
|
||||
if (BitLeft(endmask, rightShift))
|
||||
{
|
||||
bits = *psrc;
|
||||
bits1 |= BitRight(bits, rightShift);
|
||||
}
|
||||
*pdst = MROP_MASK (bits1, *pdst, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* (PSZ == 24 && MROP == 0) */
|
||||
#endif /* DO_UNALIGNED_BITBLT */
|
||||
|
||||
}
|
||||
}
|
||||
#endif /* ! DO_MEMCPY */
|
||||
else /* xdir == -1 */
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
xoffSrc = (-(pptSrc->x + w)) & PAM;
|
||||
xoffDst = (-pbox->x2) & PAM;
|
||||
#if 1
|
||||
if(xoffSrc != xoffDst /* Alignments must be same. */
|
||||
|| ((widthDstBytes & PAM) != (widthSrcBytes & PAM) && h > 1))
|
||||
#else
|
||||
if(1)
|
||||
#endif
|
||||
/* Width also must be same, if hight > 1 */
|
||||
{
|
||||
/* ...otherwise, pixel by pixel operation */
|
||||
while (h--)
|
||||
{
|
||||
register int i, si, sii, di;
|
||||
|
||||
for (i = 0, si = pptSrc->x + w - 1, di = pbox->x2 - 1;
|
||||
i < w;
|
||||
i++, si--, di--) {
|
||||
psrc = psrcLine + ((si * BYPP) >> P2WSH);
|
||||
pdst = pdstLine + ((di * BYPP) >> P2WSH);
|
||||
sii = (si & PAM);
|
||||
MROP_SOLID24P(psrc, pdst, sii, di);
|
||||
}
|
||||
psrcLine += widthSrc;
|
||||
pdstLine += widthDst;
|
||||
}
|
||||
}else
|
||||
#endif /* MROP == 0 && PSZ == 24 */
|
||||
{
|
||||
|
||||
#if PSZ == 24
|
||||
#if MROP == 0
|
||||
/* already calculated */
|
||||
#else
|
||||
xoffSrc = (pptSrc->x + w) & PAM;
|
||||
xoffDst = pbox->x2 & PAM;
|
||||
#endif
|
||||
pdstLine += ((pbox->x2 * BYPP - 1) >> P2WSH) + 1;
|
||||
psrcLine += (((pptSrc->x+w) * BYPP - 1) >> P2WSH) + 1;
|
||||
#else
|
||||
xoffSrc = (pptSrc->x + w - 1) & PIM;
|
||||
xoffDst = (pbox->x2 - 1) & PIM;
|
||||
pdstLine += ((pbox->x2-1) >> PWSH) + 1;
|
||||
psrcLine += ((pptSrc->x+w - 1) >> PWSH) + 1;
|
||||
#endif
|
||||
#ifdef DO_UNALIGNED_BITBLT
|
||||
#if PSZ == 24
|
||||
nl = xoffDst - xoffSrc;
|
||||
#else
|
||||
nl = xoffSrc - xoffDst;
|
||||
#endif
|
||||
psrcLine = (CfbBits *)
|
||||
(((unsigned char *) psrcLine) + nl);
|
||||
#else
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* already satisfied */
|
||||
#else
|
||||
if (xoffSrc == xoffDst)
|
||||
#endif
|
||||
#endif
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
#if PSZ == 24 && MROP == 0
|
||||
register int index;
|
||||
register int im3;
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
#if PSZ == 24 && MROP == 0
|
||||
index = (int)(pdst - pdstBase);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
|
||||
if (endmask)
|
||||
{
|
||||
pdst--;
|
||||
psrc--;
|
||||
#if PSZ == 24 && MROP == 0
|
||||
index--;
|
||||
im3 = index % 3;
|
||||
*pdst = DoMaskMergeRop24u(*psrc, *pdst, endmask, im3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
*pdst = MROP_MASK (*psrc, *pdst, endmask);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
}
|
||||
nl = nlMiddle;
|
||||
#ifdef LARGE_INSTRUCTION_CACHE
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
psrc -= nl & (UNROLL - 1);
|
||||
pdst -= nl & (UNROLL - 1);
|
||||
|
||||
#if PSZ == 24 && MROP == 0
|
||||
#define BodyOdd(n) pdst[n-1] = DoMergeRop24u(psrc[n-1], pdst[n-1], ((int)(pdst - (n - 1) -pdstBase)) % 3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
#define BodyOdd(n) pdst[n-1] = MROP_SOLID (psrc[n-1], pdst[n-1]);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
|
||||
#define BodyEven(n) BodyOdd(n)
|
||||
|
||||
#define LoopReset \
|
||||
pdst -= UNROLL;\
|
||||
psrc -= UNROLL;
|
||||
|
||||
#else
|
||||
|
||||
#if PSZ == 24 && MROP == 0
|
||||
#define BodyOdd(n) --pdst; --psrc; --index; im3 = index % 3;*pdst = DoMergeRop24u(*psrc, *pdst, im3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
#define BodyOdd(n) --pdst; --psrc; *pdst = MROP_SOLID(*psrc, *pdst);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
#define BodyEven(n) BodyOdd(n)
|
||||
#define LoopReset ;
|
||||
|
||||
#endif
|
||||
PackedLoop
|
||||
|
||||
#undef BodyOdd
|
||||
#undef BodyEven
|
||||
#undef LoopReset
|
||||
|
||||
#else
|
||||
#if PSZ == 24 && MROP == 0
|
||||
DuffL(nl,label3,
|
||||
--pdst; --psrc; --index; im3= index%3;*pdst = DoMergeRop24u(*psrc, *pdst, im3);)
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
DuffL(nl,label3,
|
||||
--pdst; --psrc; *pdst = MROP_SOLID (*psrc, *pdst);)
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
#endif
|
||||
|
||||
if (startmask)
|
||||
{
|
||||
--pdst;
|
||||
--psrc;
|
||||
#if PSZ == 24 && MROP == 0
|
||||
*pdst = DoMaskMergeRop24u(*psrc, *pdst, startmask, (int)(pdst - pdstBase) % 3);
|
||||
#else /* !(PSZ == 24 && MROP == 0) */
|
||||
*pdst = MROP_MASK(*psrc, *pdst, startmask);
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifndef DO_UNALIGNED_BITBLT
|
||||
#if PSZ == 24 && MROP == 0
|
||||
/* can not happen */
|
||||
#else /* !( PSZ == 24 && MROP == 0) */
|
||||
else
|
||||
{
|
||||
if (xoffDst > xoffSrc)
|
||||
{
|
||||
#if PSZ == 24
|
||||
leftShift = (xoffDst - xoffSrc) << 3;
|
||||
rightShift = PGSZ - leftShift;
|
||||
#else
|
||||
#if PGSZ == 32
|
||||
rightShift = (xoffDst - xoffSrc) << (5 - PWSH);
|
||||
#else /* PGSZ == 64 */
|
||||
rightShift = (xoffDst - xoffSrc) << (6 - PWSH);
|
||||
#endif /* PGSZ */
|
||||
leftShift = PGSZ - rightShift;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#if PSZ == 24
|
||||
rightShift = (xoffSrc - xoffDst) << 3;
|
||||
leftShift = PGSZ - rightShift;
|
||||
#else
|
||||
#if PGSZ == 32
|
||||
leftShift = (xoffSrc - xoffDst) << (5 - PWSH);
|
||||
#else /* PGSZ == 64 */
|
||||
leftShift = (xoffSrc - xoffDst) << (6 - PWSH);
|
||||
#endif /* PGSZ */
|
||||
rightShift = PGSZ - leftShift;
|
||||
#endif
|
||||
}
|
||||
while (h--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
pdstLine += widthDst;
|
||||
psrcLine += widthSrc;
|
||||
bits = 0;
|
||||
#if PSZ == 24
|
||||
if (xoffSrc > xoffDst)
|
||||
#else
|
||||
if (xoffDst > xoffSrc)
|
||||
#endif
|
||||
bits = *--psrc;
|
||||
if (endmask)
|
||||
{
|
||||
bits1 = BitRight(bits, rightShift);
|
||||
bits = *--psrc;
|
||||
bits1 |= BitLeft(bits, leftShift);
|
||||
pdst--;
|
||||
*pdst = MROP_MASK(bits1, *pdst, endmask);
|
||||
}
|
||||
nl = nlMiddle;
|
||||
#ifdef LARGE_INSTRUCTION_CACHE
|
||||
bits1 = bits;
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
psrc -= nl & (UNROLL - 1);
|
||||
pdst -= nl & (UNROLL - 1);
|
||||
|
||||
#define BodyOdd(n) \
|
||||
bits = psrc[n-1]; \
|
||||
pdst[n-1] = MROP_SOLID(BitRight(bits1, rightShift) | BitLeft(bits, leftShift),pdst[n-1]);
|
||||
|
||||
#define BodyEven(n) \
|
||||
bits1 = psrc[n-1]; \
|
||||
pdst[n-1] = MROP_SOLID(BitRight(bits, rightShift) | BitLeft(bits1, leftShift),pdst[n-1]);
|
||||
|
||||
#define LoopReset \
|
||||
pdst -= UNROLL; \
|
||||
psrc -= UNROLL;
|
||||
|
||||
#else
|
||||
|
||||
#define BodyOdd(n) \
|
||||
bits = *--psrc; --pdst; \
|
||||
*pdst = MROP_SOLID(BitRight(bits1, rightShift) | BitLeft(bits, leftShift),*pdst);
|
||||
|
||||
#define BodyEven(n) \
|
||||
bits1 = *--psrc; --pdst; \
|
||||
*pdst = MROP_SOLID(BitRight(bits, rightShift) | BitLeft(bits1, leftShift),*pdst);
|
||||
|
||||
#define LoopReset ;
|
||||
|
||||
#endif
|
||||
|
||||
PackedLoop
|
||||
|
||||
#undef BodyOdd
|
||||
#undef BodyEven
|
||||
#undef LoopReset
|
||||
|
||||
#else
|
||||
DuffL (nl, label4,
|
||||
bits1 = BitRight(bits, rightShift);
|
||||
bits = *--psrc;
|
||||
--pdst;
|
||||
*pdst = MROP_SOLID(bits1 | BitLeft(bits, leftShift),*pdst);
|
||||
)
|
||||
#endif
|
||||
|
||||
if (startmask)
|
||||
{
|
||||
bits1 = BitRight(bits, rightShift);
|
||||
if (BitRight (startmask, leftShift))
|
||||
{
|
||||
bits = *--psrc;
|
||||
bits1 |= BitLeft(bits, leftShift);
|
||||
}
|
||||
--pdst;
|
||||
*pdst = MROP_MASK(bits1, *pdst, startmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* PSZ == 24 && MROP == 0 */
|
||||
#endif
|
||||
}
|
||||
}
|
||||
pbox++;
|
||||
pptSrc++;
|
||||
}
|
||||
if (pboxNew2)
|
||||
{
|
||||
xfree(pptNew2);
|
||||
xfree(pboxNew2);
|
||||
}
|
||||
if (pboxNew1)
|
||||
{
|
||||
xfree(pptNew1);
|
||||
xfree(pboxNew1);
|
||||
}
|
||||
}
|
340
cfb/cfbbres.c
340
cfb/cfbbres.c
|
@ -1,340 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "misc.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "servermd.h"
|
||||
#include "miline.h"
|
||||
|
||||
/* Solid bresenham line */
|
||||
/* NOTES
|
||||
e2 is used less often than e1, so it's not in a register
|
||||
*/
|
||||
|
||||
void
|
||||
cfbBresS(rop, and, xor, addrl, nlwidth, signdx, signdy, axis, x1, y1, e, e1,
|
||||
e2, len)
|
||||
int rop;
|
||||
CfbBits and, xor;
|
||||
CfbBits *addrl; /* pointer to base of bitmap */
|
||||
int nlwidth; /* width in longwords of bitmap */
|
||||
register int signdx;
|
||||
int signdy; /* signs of directions */
|
||||
int axis; /* major axis (Y_AXIS or X_AXIS) */
|
||||
int x1, y1; /* initial point */
|
||||
register int e; /* error accumulator */
|
||||
register int e1; /* bresenham increments */
|
||||
int e2;
|
||||
int len; /* length of line */
|
||||
{
|
||||
register int e3 = e2-e1;
|
||||
#if PSZ == 24
|
||||
CfbBits piQxelXor[3],piQxelAnd[3];
|
||||
char *addrb;
|
||||
int nlwidth3, signdx3;
|
||||
#endif
|
||||
#ifdef PIXEL_ADDR
|
||||
register PixelType *addrp; /* Pixel pointer */
|
||||
|
||||
if (len == 0)
|
||||
return;
|
||||
/* point to first point */
|
||||
nlwidth <<= PWSH;
|
||||
#if PSZ == 24
|
||||
addrp = (PixelType *)(addrl) + (y1 * nlwidth);
|
||||
addrb = (char *)addrp + x1 * 3;
|
||||
|
||||
piQxelXor[0] = (xor << 24) | xor;
|
||||
piQxelXor[1] = (xor << 16)| (xor >> 8);
|
||||
piQxelXor[2] = (xor << 8) | (xor >> 16);
|
||||
piQxelAnd[0] = (and << 24) | and;
|
||||
piQxelAnd[1] = (and << 16)| (and >> 8);
|
||||
piQxelAnd[2] = (and << 8) | (and >> 16);
|
||||
#else
|
||||
addrp = (PixelType *)(addrl) + (y1 * nlwidth) + x1;
|
||||
#endif
|
||||
if (signdy < 0)
|
||||
nlwidth = -nlwidth;
|
||||
e = e-e1; /* to make looping easier */
|
||||
#if PSZ == 24
|
||||
nlwidth3 = nlwidth * sizeof (CfbBits);
|
||||
signdx3 = signdx * 3;
|
||||
#endif
|
||||
|
||||
if (axis == Y_AXIS)
|
||||
{
|
||||
int t;
|
||||
|
||||
t = nlwidth;
|
||||
nlwidth = signdx;
|
||||
signdx = t;
|
||||
#if PSZ == 24
|
||||
t = nlwidth3;
|
||||
nlwidth3 = signdx3;
|
||||
signdx3 = t;
|
||||
#endif
|
||||
}
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
--len;
|
||||
#if PSZ == 24
|
||||
#define body_copy \
|
||||
addrp = (PixelType *)((unsigned long)addrb & ~0x03); \
|
||||
switch((unsigned long)addrb & 3){ \
|
||||
case 0: \
|
||||
*addrp = ((*addrp)&0xFF000000)|(piQxelXor[0] & 0xFFFFFF); \
|
||||
break; \
|
||||
case 1: \
|
||||
*addrp = ((*addrp)&0xFF)|(piQxelXor[2] & 0xFFFFFF00); \
|
||||
break; \
|
||||
case 3: \
|
||||
*addrp = ((*addrp)&0xFFFFFF)|(piQxelXor[0] & 0xFF000000); \
|
||||
*(addrp+1) = ((*(addrp+1))&0xFFFF0000)|(piQxelXor[1] & 0xFFFF); \
|
||||
break; \
|
||||
case 2: \
|
||||
*addrp = ((*addrp)&0xFFFF)|(piQxelXor[1] & 0xFFFF0000); \
|
||||
*(addrp+1) = ((*(addrp+1))&0xFFFFFF00)|(piQxelXor[2] & 0xFF); \
|
||||
break; \
|
||||
}
|
||||
#define body {\
|
||||
body_copy \
|
||||
addrb += signdx3; \
|
||||
e += e1; \
|
||||
if (e >= 0) \
|
||||
{ \
|
||||
addrb += nlwidth3; \
|
||||
e += e3; \
|
||||
} \
|
||||
}
|
||||
#else /* PSZ == 24 */
|
||||
#define body {\
|
||||
*addrp = xor; \
|
||||
addrp += signdx; \
|
||||
e += e1; \
|
||||
if (e >= 0) \
|
||||
{ \
|
||||
addrp += nlwidth; \
|
||||
e += e3; \
|
||||
} \
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
while (len >= 4)
|
||||
{
|
||||
body body body body
|
||||
len -= 4;
|
||||
}
|
||||
switch (len)
|
||||
{
|
||||
case 3: body case 2: body case 1: body
|
||||
}
|
||||
#undef body
|
||||
#if PSZ == 24
|
||||
body_copy
|
||||
# undef body_copy
|
||||
#else
|
||||
*addrp = xor;
|
||||
#endif
|
||||
}
|
||||
else /* not GXcopy */
|
||||
{
|
||||
while(len--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
addrp = (PixelType *)((unsigned long)addrb & ~0x03);
|
||||
switch((unsigned long)addrb & 3){
|
||||
case 0:
|
||||
*addrp = (*addrp & (piQxelAnd[0]|0xFF000000))
|
||||
^ (piQxelXor[0] & 0xFFFFFF);
|
||||
break;
|
||||
case 1:
|
||||
*addrp = (*addrp & (piQxelAnd[2]|0xFF))
|
||||
^ (piQxelXor[2] & 0xFFFFFF00);
|
||||
break;
|
||||
case 3:
|
||||
*addrp = (*addrp & (piQxelAnd[0]|0xFFFFFF))
|
||||
^ (piQxelXor[0] & 0xFF000000);
|
||||
*(addrp+1) = (*(addrp+1) & (piQxelAnd[1]|0xFFFF0000))
|
||||
^ (piQxelXor[1] & 0xFFFF);
|
||||
break;
|
||||
case 2:
|
||||
*addrp = (*addrp & (piQxelAnd[1]|0xFFFF))
|
||||
^ (piQxelXor[1] & 0xFFFF0000);
|
||||
*(addrp+1) = (*(addrp+1) & (piQxelAnd[2]|0xFFFFFF00))
|
||||
^ (piQxelXor[2] & 0xFF);
|
||||
break;
|
||||
}
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
addrb += nlwidth3;
|
||||
e += e3;
|
||||
}
|
||||
addrb += signdx3;
|
||||
#else /* PSZ == 24 */
|
||||
*addrp = DoRRop (*addrp, and, xor);
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
addrp += nlwidth;
|
||||
e += e3;
|
||||
}
|
||||
addrp += signdx;
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
}
|
||||
#else /* !PIXEL_ADDR */
|
||||
register CfbBits tmp, bit;
|
||||
CfbBits leftbit, rightbit;
|
||||
|
||||
/* point to longword containing first point */
|
||||
#if PSZ == 24
|
||||
addrl = (addrl + (y1 * nlwidth) + ((x1 * 3) >>2);
|
||||
#else
|
||||
addrl = (addrl + (y1 * nlwidth) + (x1 >> PWSH));
|
||||
#endif
|
||||
if (signdy < 0)
|
||||
nlwidth = -nlwidth;
|
||||
e = e-e1; /* to make looping easier */
|
||||
|
||||
leftbit = cfbmask[0];
|
||||
#if PSZ == 24
|
||||
rightbit = cfbmask[(PPW-1)<<1];
|
||||
bit = cfbmask[(x1 & 3)<<1];
|
||||
#else
|
||||
rightbit = cfbmask[PPW-1];
|
||||
bit = cfbmask[x1 & PIM];
|
||||
#endif
|
||||
|
||||
if (axis == X_AXIS)
|
||||
{
|
||||
if (signdx > 0)
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, bit);
|
||||
bit = SCRRIGHT(bit,1);
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
addrl += nlwidth;
|
||||
e += e3;
|
||||
}
|
||||
if (!bit)
|
||||
{
|
||||
bit = leftbit;
|
||||
addrl++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (len--)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, bit);
|
||||
e += e1;
|
||||
bit = SCRLEFT(bit,1);
|
||||
if (e >= 0)
|
||||
{
|
||||
addrl += nlwidth;
|
||||
e += e3;
|
||||
}
|
||||
if (!bit)
|
||||
{
|
||||
bit = rightbit;
|
||||
addrl--;
|
||||
}
|
||||
}
|
||||
}
|
||||
} /* if X_AXIS */
|
||||
else
|
||||
{
|
||||
if (signdx > 0)
|
||||
{
|
||||
while(len--)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, bit);
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
bit = SCRRIGHT(bit,1);
|
||||
if (!bit)
|
||||
{
|
||||
bit = leftbit;
|
||||
addrl++;
|
||||
}
|
||||
e += e3;
|
||||
}
|
||||
addrl += nlwidth;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while(len--)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, bit);
|
||||
e += e1;
|
||||
if (e >= 0)
|
||||
{
|
||||
bit = SCRLEFT(bit,1);
|
||||
if (!bit)
|
||||
{
|
||||
bit = rightbit;
|
||||
addrl--;
|
||||
}
|
||||
e += e3;
|
||||
}
|
||||
addrl += nlwidth;
|
||||
}
|
||||
}
|
||||
} /* else Y_AXIS */
|
||||
#endif
|
||||
}
|
404
cfb/cfbbresd.c
404
cfb/cfbbresd.c
|
@ -1,404 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "misc.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "miline.h"
|
||||
|
||||
/* Dashed bresenham line */
|
||||
|
||||
void
|
||||
cfbBresD(rrops,
|
||||
pdashIndex, pDash, numInDashList, pdashOffset, isDoubleDash,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, x1, y1, e, e1, e2, len)
|
||||
cfbRRopPtr rrops;
|
||||
int *pdashIndex; /* current dash */
|
||||
unsigned char *pDash; /* dash list */
|
||||
int numInDashList; /* total length of dash list */
|
||||
int *pdashOffset; /* offset into current dash */
|
||||
int isDoubleDash;
|
||||
CfbBits *addrl; /* pointer to base of bitmap */
|
||||
int nlwidth; /* width in longwords of bitmap */
|
||||
int signdx, signdy; /* signs of directions */
|
||||
int axis; /* major axis (Y_AXIS or X_AXIS) */
|
||||
int x1, y1; /* initial point */
|
||||
register int e; /* error accumulator */
|
||||
register int e1; /* bresenham increments */
|
||||
int e2;
|
||||
int len; /* length of line */
|
||||
{
|
||||
#ifdef PIXEL_ADDR
|
||||
register PixelType *addrp;
|
||||
#endif
|
||||
register int e3 = e2-e1;
|
||||
int dashIndex;
|
||||
int dashOffset;
|
||||
int dashRemaining;
|
||||
CfbBits xorFg, andFg, xorBg, andBg;
|
||||
Bool isCopy;
|
||||
int thisDash;
|
||||
#if PSZ == 24
|
||||
CfbBits xorPiQxlFg[3], andPiQxlFg[3], xorPiQxlBg[3], andPiQxlBg[3];
|
||||
char *addrb;
|
||||
int signdx3, signdy3;
|
||||
#endif
|
||||
|
||||
dashOffset = *pdashOffset;
|
||||
dashIndex = *pdashIndex;
|
||||
isCopy = (rrops[0].rop == GXcopy && rrops[1].rop == GXcopy);
|
||||
#if PSZ == 24
|
||||
xorFg = rrops[0].xor & 0xffffff;
|
||||
andFg = rrops[0].and & 0xffffff;
|
||||
xorBg = rrops[1].xor & 0xffffff;
|
||||
andBg = rrops[1].and & 0xffffff;
|
||||
xorPiQxlFg[0] = xorFg | (xorFg << 24);
|
||||
xorPiQxlFg[1] = (xorFg >> 8) | (xorFg << 16);
|
||||
xorPiQxlFg[2] = (xorFg >> 16) | (xorFg << 8);
|
||||
andPiQxlFg[0] = andFg | (andFg << 24);
|
||||
andPiQxlFg[1] = (andFg >> 8) | (andFg << 16);
|
||||
andPiQxlFg[2] = (andFg >> 16) | (andFg << 8);
|
||||
xorPiQxlBg[0] = xorBg | (xorBg << 24);
|
||||
xorPiQxlBg[1] = (xorBg >> 8) | (xorBg << 16);
|
||||
xorPiQxlBg[2] = (xorBg >> 16) | (xorBg << 8);
|
||||
andPiQxlBg[0] = andBg | (andBg << 24);
|
||||
andPiQxlBg[1] = (andBg >> 8) | (andBg << 16);
|
||||
andPiQxlBg[2] = (andFg >> 16) | (andBg << 8);
|
||||
#else
|
||||
xorFg = rrops[0].xor;
|
||||
andFg = rrops[0].and;
|
||||
xorBg = rrops[1].xor;
|
||||
andBg = rrops[1].and;
|
||||
#endif
|
||||
dashRemaining = pDash[dashIndex] - dashOffset;
|
||||
if ((thisDash = dashRemaining) >= len)
|
||||
{
|
||||
thisDash = len;
|
||||
dashRemaining -= len;
|
||||
}
|
||||
e = e-e1; /* to make looping easier */
|
||||
|
||||
#define BresStep(minor,major) {if ((e += e1) >= 0) { e += e3; minor; } major;}
|
||||
|
||||
#define NextDash {\
|
||||
dashIndex++; \
|
||||
if (dashIndex == numInDashList) \
|
||||
dashIndex = 0; \
|
||||
dashRemaining = pDash[dashIndex]; \
|
||||
if ((thisDash = dashRemaining) >= len) \
|
||||
{ \
|
||||
dashRemaining -= len; \
|
||||
thisDash = len; \
|
||||
} \
|
||||
}
|
||||
|
||||
#ifdef PIXEL_ADDR
|
||||
|
||||
#if PSZ == 24
|
||||
#define Loop(store) while (thisDash--) {\
|
||||
store; \
|
||||
BresStep(addrb+=signdy3,addrb+=signdx3) \
|
||||
}
|
||||
/* point to first point */
|
||||
nlwidth <<= PWSH;
|
||||
addrp = (PixelType *)(addrl) + (y1 * nlwidth);
|
||||
addrb = (char *)addrp + x1 * 3;
|
||||
|
||||
#else
|
||||
#define Loop(store) while (thisDash--) {\
|
||||
store; \
|
||||
BresStep(addrp+=signdy,addrp+=signdx) \
|
||||
}
|
||||
/* point to first point */
|
||||
nlwidth <<= PWSH;
|
||||
addrp = (PixelType *)(addrl) + (y1 * nlwidth) + x1;
|
||||
#endif
|
||||
signdy *= nlwidth;
|
||||
#if PSZ == 24
|
||||
signdx3 = signdx * 3;
|
||||
signdy3 = signdy * sizeof (CfbBits);
|
||||
#endif
|
||||
if (axis == Y_AXIS)
|
||||
{
|
||||
int t;
|
||||
|
||||
t = signdx;
|
||||
signdx = signdy;
|
||||
signdy = t;
|
||||
#if PSZ == 24
|
||||
t = signdx3;
|
||||
signdx3 = signdy3;
|
||||
signdy3 = t;
|
||||
#endif
|
||||
}
|
||||
|
||||
if (isCopy)
|
||||
{
|
||||
#if PSZ == 24
|
||||
#define body_copy(pix) { \
|
||||
addrp = (PixelType *)((unsigned long)addrb & ~0x03); \
|
||||
switch((unsigned long)addrb & 3){ \
|
||||
case 0: \
|
||||
*addrp = (*addrp & 0xFF000000)|((pix)[0] & 0xFFFFFF); \
|
||||
break; \
|
||||
case 1: \
|
||||
*addrp = (*addrp & 0xFF)|((pix)[2] & 0xFFFFFF00); \
|
||||
break; \
|
||||
case 3: \
|
||||
*addrp = (*addrp & 0xFFFFFF)|((pix)[0] & 0xFF000000); \
|
||||
*(addrp+1) = (*(addrp+1) & 0xFFFF0000)|((pix)[1] & 0xFFFF); \
|
||||
break; \
|
||||
case 2: \
|
||||
*addrp = (*addrp & 0xFFFF)|((pix)[1] & 0xFFFF0000); \
|
||||
*(addrp+1) = (*(addrp+1) & 0xFFFFFF00)|((pix)[2] & 0xFF); \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
|
||||
for (;;)
|
||||
{
|
||||
len -= thisDash;
|
||||
if (dashIndex & 1) {
|
||||
if (isDoubleDash) {
|
||||
#if PSZ == 24
|
||||
Loop(body_copy(xorPiQxlBg))
|
||||
#else
|
||||
Loop(*addrp = xorBg)
|
||||
#endif
|
||||
} else {
|
||||
Loop(;)
|
||||
}
|
||||
} else {
|
||||
#if PSZ == 24
|
||||
Loop(body_copy(xorPiQxlFg))
|
||||
#else
|
||||
Loop(*addrp = xorFg)
|
||||
#endif
|
||||
}
|
||||
if (!len)
|
||||
break;
|
||||
NextDash
|
||||
}
|
||||
#undef body_copy
|
||||
}
|
||||
else
|
||||
{
|
||||
#define body_set(and, xor) { \
|
||||
addrp = (PixelType *)((unsigned long)addrb & ~0x03); \
|
||||
switch((unsigned long)addrb & 3){ \
|
||||
case 0: \
|
||||
*addrp = (*addrp & ((and)[0]|0xFF000000)) ^ ((xor)[0] & 0xFFFFFF); \
|
||||
break; \
|
||||
case 1: \
|
||||
*addrp = (*addrp & ((and)[2]|0xFF)) ^ ((xor)[2] & 0xFFFFFF00); \
|
||||
break; \
|
||||
case 3: \
|
||||
*addrp = (*addrp & ((and)[0]|0xFFFFFF)) ^ ((xor)[0] & 0xFF000000); \
|
||||
*(addrp+1)=(*(addrp+1)&((and)[1]|0xFFFF0000)) ^ ((xor)[1]&0xFFFF); \
|
||||
break; \
|
||||
case 2: \
|
||||
*addrp = (*addrp & ((and)[1]|0xFFFF)) ^ ((xor)[1] & 0xFFFF0000); \
|
||||
*(addrp+1)=(*(addrp+1)&((and)[2]|0xFFFFFF00)) ^ ((xor)[2] & 0xFF); \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
|
||||
for (;;)
|
||||
{
|
||||
len -= thisDash;
|
||||
if (dashIndex & 1) {
|
||||
if (isDoubleDash) {
|
||||
#if PSZ == 24
|
||||
Loop(body_set(andPiQxlBg, xorPiQxlBg))
|
||||
#else
|
||||
Loop(*addrp = DoRRop(*addrp,andBg, xorBg))
|
||||
#endif
|
||||
} else {
|
||||
Loop(;)
|
||||
}
|
||||
} else {
|
||||
#if PSZ == 24
|
||||
Loop(body_set(andPiQxlFg, xorPiQxlFg))
|
||||
#else
|
||||
Loop(*addrp = DoRRop(*addrp,andFg, xorFg))
|
||||
#endif
|
||||
}
|
||||
if (!len)
|
||||
break;
|
||||
NextDash
|
||||
}
|
||||
#undef body_set
|
||||
}
|
||||
#else /* !PIXEL_ADDR */
|
||||
{
|
||||
register CfbBits tmp;
|
||||
CfbBits startbit, bit;
|
||||
|
||||
/* point to longword containing first point */
|
||||
#if PSZ == 24
|
||||
addrl = (addrl + (y1 * nlwidth) + ((x1*3) >> 2);
|
||||
#else
|
||||
addrl = (addrl + (y1 * nlwidth) + (x1 >> PWSH));
|
||||
#endif
|
||||
signdy = signdy * nlwidth;
|
||||
|
||||
if (signdx > 0)
|
||||
startbit = cfbmask[0];
|
||||
else
|
||||
#if PSZ == 24
|
||||
startbit = cfbmask[(PPW-1)<<1];
|
||||
bit = cfbmask[(x1 & 3)<<1];
|
||||
#else
|
||||
startbit = cfbmask[PPW-1];
|
||||
bit = cfbmask[x1 & PIM];
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#define X_Loop(store) while(thisDash--) {\
|
||||
store; \
|
||||
BresStep(addrl += signdy, \
|
||||
if (signdx > 0) \
|
||||
bit = SCRRIGHT(bit,1); \
|
||||
else \
|
||||
bit = SCRLEFT(bit,1); \
|
||||
if (!bit) \
|
||||
{ \
|
||||
bit = startbit; \
|
||||
addrl += signdx; \
|
||||
}) \
|
||||
}
|
||||
#define Y_Loop(store) while(thisDash--) {\
|
||||
store; \
|
||||
BresStep(if (signdx > 0) \
|
||||
bit = SCRRIGHT(bit,1); \
|
||||
else \
|
||||
bit = SCRLEFT(bit,1); \
|
||||
if (!bit) \
|
||||
{ \
|
||||
bit = startbit; \
|
||||
addrl += signdx; \
|
||||
}, \
|
||||
addrl += signdy) \
|
||||
}
|
||||
#else
|
||||
#define X_Loop(store) while(thisDash--) {\
|
||||
store; \
|
||||
BresStep(addrl += signdy, \
|
||||
if (signdx > 0) \
|
||||
bit = SCRRIGHT(bit,1); \
|
||||
else \
|
||||
bit = SCRLEFT(bit,1); \
|
||||
if (!bit) \
|
||||
{ \
|
||||
bit = startbit; \
|
||||
addrl += signdx; \
|
||||
}) \
|
||||
}
|
||||
#define Y_Loop(store) while(thisDash--) {\
|
||||
store; \
|
||||
BresStep(if (signdx > 0) \
|
||||
bit = SCRRIGHT(bit,1); \
|
||||
else \
|
||||
bit = SCRLEFT(bit,1); \
|
||||
if (!bit) \
|
||||
{ \
|
||||
bit = startbit; \
|
||||
addrl += signdx; \
|
||||
}, \
|
||||
addrl += signdy) \
|
||||
}
|
||||
#endif
|
||||
|
||||
if (axis == X_AXIS)
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
len -= thisDash;
|
||||
if (dashIndex & 1) {
|
||||
if (isDoubleDash) {
|
||||
X_Loop(*addrl = DoMaskRRop(*addrl, andBg, xorBg, bit));
|
||||
} else {
|
||||
X_Loop(;)
|
||||
}
|
||||
} else {
|
||||
X_Loop(*addrl = DoMaskRRop(*addrl, andFg, xorFg, bit));
|
||||
}
|
||||
if (!len)
|
||||
break;
|
||||
NextDash
|
||||
}
|
||||
} /* if X_AXIS */
|
||||
else
|
||||
{
|
||||
for (;;)
|
||||
{
|
||||
len -= thisDash;
|
||||
if (dashIndex & 1) {
|
||||
if (isDoubleDash) {
|
||||
Y_Loop(*addrl = DoMaskRRop(*addrl, andBg, xorBg, bit));
|
||||
} else {
|
||||
Y_Loop(;)
|
||||
}
|
||||
} else {
|
||||
Y_Loop(*addrl = DoMaskRRop(*addrl, andFg, xorFg, bit));
|
||||
}
|
||||
if (!len)
|
||||
break;
|
||||
NextDash
|
||||
}
|
||||
} /* else Y_AXIS */
|
||||
}
|
||||
#endif
|
||||
*pdashIndex = dashIndex;
|
||||
*pdashOffset = pDash[dashIndex] - dashRemaining;
|
||||
}
|
119
cfb/cfbcmap.c
119
cfb/cfbcmap.c
|
@ -1,119 +0,0 @@
|
|||
/************************************************************
|
||||
Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose and without
|
||||
fee is hereby granted, provided that the above copyright no-
|
||||
tice appear in all copies and that both that copyright no-
|
||||
tice and this permission notice appear in supporting docu-
|
||||
mentation, and that the names of Sun or The Open Group
|
||||
not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific prior
|
||||
written permission. Sun and The Open Group make no
|
||||
representations about the suitability of this software for
|
||||
any purpose. It is provided "as is" without any express or
|
||||
implied warranty.
|
||||
|
||||
SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
|
||||
NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
|
||||
ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
||||
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
||||
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
********************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "scrnintstr.h"
|
||||
#include "colormapst.h"
|
||||
#include "resource.h"
|
||||
#include "micmap.h"
|
||||
#include "cfb.h"
|
||||
|
||||
int
|
||||
cfbListInstalledColormaps(ScreenPtr pScreen, Colormap *pmaps)
|
||||
{
|
||||
return miListInstalledColormaps(pScreen, pmaps);
|
||||
}
|
||||
|
||||
void
|
||||
cfbInstallColormap(ColormapPtr pmap)
|
||||
{
|
||||
miInstallColormap(pmap);
|
||||
}
|
||||
|
||||
void
|
||||
cfbUninstallColormap(ColormapPtr pmap)
|
||||
{
|
||||
miUninstallColormap(pmap);
|
||||
}
|
||||
|
||||
void
|
||||
cfbResolveColor(unsigned short *pred,
|
||||
unsigned short *pgreen,
|
||||
unsigned short *pblue,
|
||||
VisualPtr pVisual)
|
||||
{
|
||||
miResolveColor(pred, pgreen, pblue, pVisual);
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbInitializeColormap(ColormapPtr pmap)
|
||||
{
|
||||
return miInitializeColormap(pmap);
|
||||
}
|
||||
|
||||
int
|
||||
cfbExpandDirectColors (ColormapPtr pmap, int ndef,
|
||||
xColorItem *indefs, xColorItem *outdefs)
|
||||
{
|
||||
return miExpandDirectColors(pmap, ndef, indefs, outdefs);
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbCreateDefColormap(ScreenPtr pScreen)
|
||||
{
|
||||
return miCreateDefColormap(pScreen);
|
||||
}
|
||||
|
||||
void
|
||||
cfbClearVisualTypes(void)
|
||||
{
|
||||
miClearVisualTypes();
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbSetVisualTypes (int depth, int visuals, int bitsPerRGB)
|
||||
{
|
||||
return miSetVisualTypes(depth, visuals, bitsPerRGB, -1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Given a list of formats for a screen, create a list
|
||||
* of visuals and depths for the screen which coorespond to
|
||||
* the set which can be used with this version of cfb.
|
||||
*/
|
||||
|
||||
Bool
|
||||
cfbInitVisuals (VisualPtr *visualp,
|
||||
DepthPtr *depthp,
|
||||
int *nvisualp,
|
||||
int *ndepthp,
|
||||
int *rootDepthp,
|
||||
VisualID *defaultVisp,
|
||||
unsigned long sizes,
|
||||
int bitsPerRGB)
|
||||
{
|
||||
return miInitVisuals(visualp, depthp, nvisualp, ndepthp, rootDepthp,
|
||||
defaultVisp, sizes, bitsPerRGB, -1);
|
||||
}
|
486
cfb/cfbcppl.c
486
cfb/cfbcppl.c
|
@ -1,486 +0,0 @@
|
|||
/*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "gcstruct.h"
|
||||
#include "window.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
#include "cfb.h"
|
||||
#if PSZ == 8
|
||||
#undef PSZ /* for maskbits.h */
|
||||
#include "maskbits.h"
|
||||
#define PSZ 8
|
||||
#include "mergerop.h"
|
||||
#endif
|
||||
|
||||
|
||||
void
|
||||
cfbCopyImagePlane(
|
||||
DrawablePtr pSrcDrawable,
|
||||
DrawablePtr pDstDrawable,
|
||||
int rop,
|
||||
RegionPtr prgnDst,
|
||||
DDXPointPtr pptSrc,
|
||||
unsigned long planemask)
|
||||
{
|
||||
/* note: there must be some sort of trick behind,
|
||||
passing a planemask value with all bits set
|
||||
whilst using the current planemask for the bitPlane value. */
|
||||
#if PSZ == 8
|
||||
cfbCopyPlane8to1 (pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
|
||||
(unsigned long) ~0L, planemask);
|
||||
#endif
|
||||
#if PSZ == 16
|
||||
cfbCopyPlane16to1 (pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
|
||||
(unsigned long) ~0L, planemask);
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
cfbCopyPlane24to1 (pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
|
||||
(unsigned long) ~0L, planemask);
|
||||
#endif
|
||||
#if PSZ == 32
|
||||
cfbCopyPlane32to1 (pSrcDrawable, pDstDrawable, rop, prgnDst, pptSrc,
|
||||
(unsigned long) ~0L, planemask);
|
||||
#endif
|
||||
}
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#if BITMAP_BIT_ORDER == MSBFirst
|
||||
#define LeftMost (MFB_PPW-1)
|
||||
#define StepBit(bit, inc) ((bit) -= (inc))
|
||||
#else
|
||||
#define LeftMost 0
|
||||
#define StepBit(bit, inc) ((bit) += (inc))
|
||||
#endif
|
||||
|
||||
#define GetBits(psrc, nBits, curBit, bitPos, bits) {\
|
||||
bits = 0; \
|
||||
while (nBits--) \
|
||||
{ \
|
||||
bits |= (PixelType)(((*psrc++ >> bitPos) & 1)) << curBit; \
|
||||
StepBit (curBit, 1); \
|
||||
} \
|
||||
}
|
||||
|
||||
void
|
||||
cfbCopyPlane8to1(
|
||||
DrawablePtr pSrcDrawable,
|
||||
DrawablePtr pDstDrawable,
|
||||
int rop,
|
||||
RegionPtr prgnDst,
|
||||
DDXPointPtr pptSrc,
|
||||
unsigned long planemask,
|
||||
unsigned long bitPlane)
|
||||
{
|
||||
int srcx, srcy, dstx, dsty, width, height;
|
||||
unsigned char *psrcBase;
|
||||
PixelType *pdstBase;
|
||||
int widthSrc, widthDst;
|
||||
unsigned char *psrcLine;
|
||||
PixelType *pdstLine;
|
||||
register unsigned char *psrc;
|
||||
register int i;
|
||||
register int curBit;
|
||||
register int bitPos;
|
||||
register CfbBits bits;
|
||||
register PixelType *pdst;
|
||||
PixelType startmask, endmask;
|
||||
int niStart = 0, niEnd = 0;
|
||||
int bitStart = 0, bitEnd = 0;
|
||||
int nl, nlMiddle;
|
||||
int nbox;
|
||||
BoxPtr pbox;
|
||||
MROP_DECLARE()
|
||||
|
||||
if (!(planemask & 1))
|
||||
return;
|
||||
|
||||
if (rop != GXcopy)
|
||||
MROP_INITIALIZE (rop, planemask);
|
||||
|
||||
cfbGetByteWidthAndPointer (pSrcDrawable, widthSrc, psrcBase)
|
||||
|
||||
mfbGetPixelWidthAndPointer (pDstDrawable, widthDst, pdstBase)
|
||||
|
||||
bitPos = ffs (bitPlane) - 1;
|
||||
|
||||
nbox = REGION_NUM_RECTS(prgnDst);
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
while (nbox--)
|
||||
{
|
||||
dstx = pbox->x1;
|
||||
dsty = pbox->y1;
|
||||
srcx = pptSrc->x;
|
||||
srcy = pptSrc->y;
|
||||
width = pbox->x2 - pbox->x1;
|
||||
height = pbox->y2 - pbox->y1;
|
||||
pbox++;
|
||||
pptSrc++;
|
||||
psrcLine = psrcBase + srcy * widthSrc + srcx;
|
||||
pdstLine = mfbScanline(pdstBase, dstx, dsty, widthDst);
|
||||
dstx &= MFB_PIM;
|
||||
if (dstx + width <= MFB_PPW)
|
||||
{
|
||||
maskpartialbits(dstx, width, startmask);
|
||||
nlMiddle = 0;
|
||||
endmask = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (dstx, width, startmask, endmask, nlMiddle);
|
||||
}
|
||||
if (startmask)
|
||||
{
|
||||
niStart = min(MFB_PPW - dstx, width);
|
||||
bitStart = LeftMost;
|
||||
StepBit (bitStart, dstx);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
niEnd = (dstx + width) & MFB_PIM;
|
||||
bitEnd = LeftMost;
|
||||
}
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
while (height--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
psrcLine += widthSrc;
|
||||
mfbScanlineInc(pdstLine, widthDst);
|
||||
if (startmask)
|
||||
{
|
||||
i = niStart;
|
||||
curBit = bitStart;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = (*pdst & ~startmask) | bits;
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
i = MFB_PPW;
|
||||
curBit = LeftMost;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst++ = bits;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
i = niEnd;
|
||||
curBit = bitEnd;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = (*pdst & ~endmask) | bits;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (height--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
psrcLine += widthSrc;
|
||||
mfbScanlineInc(pdstLine, widthDst);
|
||||
if (startmask)
|
||||
{
|
||||
i = niStart;
|
||||
curBit = bitStart;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = MROP_MASK(bits, *pdst, startmask);
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
i = MFB_PPW;
|
||||
curBit = LeftMost;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = MROP_SOLID(bits, *pdst);
|
||||
pdst++;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
i = niEnd;
|
||||
curBit = bitEnd;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst = MROP_MASK (bits, *pdst, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#else /* PSZ == 8 */
|
||||
|
||||
#define mfbmaskbits(x, w, startmask, endmask, nlw) \
|
||||
startmask = mfbGetstarttab((x)&0x1f); \
|
||||
endmask = mfbGetendtab(((x)+(w)) & 0x1f); \
|
||||
if (startmask) \
|
||||
nlw = (((w) - (32 - ((x)&0x1f))) >> 5); \
|
||||
else \
|
||||
nlw = (w) >> 5;
|
||||
|
||||
#define mfbmaskpartialbits(x, w, mask) \
|
||||
mask = mfbGetpartmasks((x)&0x1f,(w)&0x1f);
|
||||
|
||||
#define LeftMost 0
|
||||
#define StepBit(bit, inc) ((bit) += (inc))
|
||||
|
||||
|
||||
#if PSZ == 24
|
||||
#define GetBits(psrc, nBits, curBit, bitPos, bits) {\
|
||||
bits = 0; \
|
||||
while (nBits--) \
|
||||
{ \
|
||||
if (bitPos < 8) \
|
||||
{ \
|
||||
bits |= ((*psrc++ >> bitPos) & 1) << curBit; \
|
||||
psrc += 2; \
|
||||
} \
|
||||
else if (bitPos < 16) \
|
||||
{ \
|
||||
psrc++; \
|
||||
bits |= ((*psrc++ >> (bitPos - 8)) & 1) << curBit; \
|
||||
psrc++; \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
psrc += 2; \
|
||||
bits |= ((*psrc++ >> (bitPos - 16)) & 1) << curBit; \
|
||||
} \
|
||||
StepBit (curBit, 1); \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define GetBits(psrc, nBits, curBit, bitPos, bits) {\
|
||||
bits = 0; \
|
||||
while (nBits--) \
|
||||
{ \
|
||||
bits |= ((*psrc++ >> bitPos) & 1) << curBit; \
|
||||
StepBit (curBit, 1); \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
#if PSZ == 16
|
||||
cfbCopyPlane16to1
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
cfbCopyPlane24to1
|
||||
#endif
|
||||
#if PSZ == 32
|
||||
cfbCopyPlane32to1
|
||||
#endif
|
||||
(
|
||||
DrawablePtr pSrcDrawable,
|
||||
DrawablePtr pDstDrawable,
|
||||
int rop,
|
||||
RegionPtr prgnDst,
|
||||
DDXPointPtr pptSrc,
|
||||
unsigned long planemask,
|
||||
unsigned long bitPlane)
|
||||
{
|
||||
int srcx, srcy, dstx, dsty, width, height;
|
||||
CfbBits *psrcBase;
|
||||
CfbBits *pdstBase;
|
||||
int widthSrc, widthDst;
|
||||
#if PSZ == 16
|
||||
unsigned short *psrcLine;
|
||||
register unsigned short *psrc;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
unsigned char *psrcLine;
|
||||
register unsigned char *psrc;
|
||||
#endif
|
||||
#if PSZ == 32
|
||||
unsigned int *psrcLine;
|
||||
register unsigned int *psrc;
|
||||
#endif
|
||||
unsigned int *pdstLine;
|
||||
register unsigned int *pdst;
|
||||
register int i;
|
||||
register int curBit;
|
||||
register int bitPos;
|
||||
register unsigned int bits;
|
||||
unsigned int startmask = 0, endmask = 0;
|
||||
int niStart = 0, niEnd = 0;
|
||||
int bitStart = 0, bitEnd = 0;
|
||||
int nl, nlMiddle;
|
||||
int nbox;
|
||||
BoxPtr pbox;
|
||||
int result;
|
||||
|
||||
|
||||
if (!(planemask & 1))
|
||||
return;
|
||||
|
||||
/* must explicitly ask for "int" widths, as code below expects it */
|
||||
/* on some machines (Alpha), "long" and "int" are not the same size */
|
||||
cfbGetTypedWidthAndPointer (pSrcDrawable, widthSrc, psrcBase, int, CfbBits)
|
||||
cfbGetTypedWidthAndPointer (pDstDrawable, widthDst, pdstBase, int, CfbBits)
|
||||
|
||||
#if PSZ == 16
|
||||
widthSrc <<= 1;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
widthSrc <<= 2;
|
||||
#endif
|
||||
|
||||
bitPos = ffs (bitPlane) - 1;
|
||||
|
||||
nbox = REGION_NUM_RECTS(prgnDst);
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
while (nbox--)
|
||||
{
|
||||
dstx = pbox->x1;
|
||||
dsty = pbox->y1;
|
||||
srcx = pptSrc->x;
|
||||
srcy = pptSrc->y;
|
||||
width = pbox->x2 - pbox->x1;
|
||||
height = pbox->y2 - pbox->y1;
|
||||
pbox++;
|
||||
pptSrc++;
|
||||
#if PSZ == 16
|
||||
psrcLine = (unsigned short *)psrcBase + srcy * widthSrc + srcx;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
psrcLine = (unsigned char *)psrcBase + srcy * widthSrc + srcx * 3;
|
||||
#endif
|
||||
#if PSZ == 32
|
||||
psrcLine = (unsigned int *)psrcBase + srcy * widthSrc + srcx;
|
||||
#endif
|
||||
pdstLine = (unsigned int *)pdstBase + dsty * widthDst + (dstx >> 5);
|
||||
if (dstx + width <= 32)
|
||||
{
|
||||
mfbmaskpartialbits(dstx, width, startmask);
|
||||
nlMiddle = 0;
|
||||
endmask = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
mfbmaskbits (dstx, width, startmask, endmask, nlMiddle);
|
||||
}
|
||||
if (startmask)
|
||||
{
|
||||
niStart = 32 - (dstx & 0x1f);
|
||||
bitStart = LeftMost;
|
||||
StepBit (bitStart, (dstx & 0x1f));
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
niEnd = (dstx + width) & 0x1f;
|
||||
bitEnd = LeftMost;
|
||||
}
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
while (height--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
psrcLine += widthSrc;
|
||||
pdstLine += widthDst;
|
||||
if (startmask)
|
||||
{
|
||||
i = niStart;
|
||||
curBit = bitStart;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
|
||||
*pdst = (*pdst & ~startmask) | bits;
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
i = 32;
|
||||
curBit = LeftMost;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
*pdst++ = bits;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
i = niEnd;
|
||||
curBit = bitEnd;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
|
||||
*pdst = (*pdst & ~endmask) | bits;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (height--)
|
||||
{
|
||||
psrc = psrcLine;
|
||||
pdst = pdstLine;
|
||||
psrcLine += widthSrc;
|
||||
pdstLine += widthDst;
|
||||
if (startmask)
|
||||
{
|
||||
i = niStart;
|
||||
curBit = bitStart;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
DoRop (result, rop, bits, *pdst);
|
||||
|
||||
*pdst = (*pdst & ~startmask) |
|
||||
(result & startmask);
|
||||
pdst++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
i = 32;
|
||||
curBit = LeftMost;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
DoRop (result, rop, bits, *pdst);
|
||||
*pdst = result;
|
||||
++pdst;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
i = niEnd;
|
||||
curBit = bitEnd;
|
||||
GetBits (psrc, i, curBit, bitPos, bits);
|
||||
DoRop (result, rop, bits, *pdst);
|
||||
|
||||
*pdst = (*pdst & ~endmask) |
|
||||
(result & endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* PSZ == 8 */
|
374
cfb/cfbfillarc.c
374
cfb/cfbfillarc.c
|
@ -1,374 +0,0 @@
|
|||
/************************************************************
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
********************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xprotostr.h>
|
||||
#include "regionstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mifillarc.h"
|
||||
#include "cfbrrop.h"
|
||||
#include "mi.h"
|
||||
|
||||
/* gcc 1.35 is stupid */
|
||||
#if defined(__GNUC__) && __GNUC__ < 2 && defined(mc68020)
|
||||
#define STUPID volatile
|
||||
#else
|
||||
#define STUPID
|
||||
#endif
|
||||
|
||||
static void
|
||||
RROP_NAME(cfbFillEllipseSolid)(
|
||||
DrawablePtr pDraw,
|
||||
GCPtr pGC,
|
||||
xArc *arc)
|
||||
{
|
||||
STUPID int x, y, e;
|
||||
STUPID int yk, xk, ym, xm, dx, dy, xorg, yorg;
|
||||
miFillArcRec info;
|
||||
#if PSZ == 24
|
||||
unsigned char *addrlt, *addrlb;
|
||||
#else
|
||||
CfbBits *addrlt, *addrlb;
|
||||
#endif
|
||||
register CfbBits *addrl;
|
||||
register int n;
|
||||
int nlwidth;
|
||||
RROP_DECLARE
|
||||
register int xpos;
|
||||
register int slw;
|
||||
CfbBits startmask, endmask;
|
||||
int nlmiddle;
|
||||
#if PSZ == 24
|
||||
register int pidx;
|
||||
int xpos3;
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
cfbGetByteWidthAndPointer (pDraw, nlwidth, addrlt)
|
||||
#else
|
||||
cfbGetLongWidthAndPointer (pDraw, nlwidth, addrlt)
|
||||
#endif
|
||||
|
||||
RROP_FETCH_GC(pGC);
|
||||
miFillArcSetup(arc, &info);
|
||||
MIFILLARCSETUP();
|
||||
xorg += pDraw->x;
|
||||
yorg += pDraw->y;
|
||||
addrlb = addrlt;
|
||||
addrlt += nlwidth * (yorg - y);
|
||||
addrlb += nlwidth * (yorg + y + dy);
|
||||
while (y)
|
||||
{
|
||||
addrlt += nlwidth;
|
||||
addrlb -= nlwidth;
|
||||
MIFILLARCSTEP(slw);
|
||||
if (!slw)
|
||||
continue;
|
||||
xpos = xorg - x;
|
||||
#if PSZ == 24
|
||||
xpos3 = (xpos * 3) & ~0x03;
|
||||
addrl = (CfbBits *)((char *)addrlt + xpos3);
|
||||
if (slw == 1){
|
||||
RROP_SOLID24(addrl, xpos);
|
||||
if (miFillArcLower(slw)){
|
||||
addrl = (CfbBits *)((char *)addrlb + xpos3);
|
||||
RROP_SOLID24(addrl, xpos);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
maskbits(xpos, slw, startmask, endmask, nlmiddle);
|
||||
xpos &= 3;
|
||||
pidx = xpos;
|
||||
if (startmask){
|
||||
RROP_SOLID_MASK(addrl, startmask, pidx-1);
|
||||
addrl++;
|
||||
if (pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
n = nlmiddle;
|
||||
while (--n >= 0){
|
||||
RROP_SOLID(addrl, pidx);
|
||||
addrl++;
|
||||
if (++pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addrl, endmask, pidx);
|
||||
if (!miFillArcLower(slw))
|
||||
continue;
|
||||
addrl = (CfbBits *)((char *)addrlb + xpos3);
|
||||
pidx = xpos;
|
||||
if (startmask){
|
||||
RROP_SOLID_MASK(addrl, startmask, pidx-1);
|
||||
addrl++;
|
||||
if (pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
n = nlmiddle;
|
||||
while (--n >= 0){
|
||||
RROP_SOLID(addrl, pidx);
|
||||
addrl++;
|
||||
if (++pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addrl, endmask, pidx);
|
||||
#else /* PSZ == 24 */
|
||||
addrl = addrlt + (xpos >> PWSH);
|
||||
if (((xpos & PIM) + slw) <= PPW)
|
||||
{
|
||||
maskpartialbits(xpos, slw, startmask);
|
||||
RROP_SOLID_MASK(addrl,startmask);
|
||||
if (miFillArcLower(slw))
|
||||
{
|
||||
addrl = addrlb + (xpos >> PWSH);
|
||||
RROP_SOLID_MASK(addrl, startmask);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
maskbits(xpos, slw, startmask, endmask, nlmiddle);
|
||||
if (startmask)
|
||||
{
|
||||
RROP_SOLID_MASK(addrl, startmask);
|
||||
addrl++;
|
||||
}
|
||||
n = nlmiddle;
|
||||
RROP_SPAN(addrl,n)
|
||||
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addrl, endmask);
|
||||
if (!miFillArcLower(slw))
|
||||
continue;
|
||||
addrl = addrlb + (xpos >> PWSH);
|
||||
if (startmask)
|
||||
{
|
||||
RROP_SOLID_MASK(addrl, startmask);
|
||||
addrl++;
|
||||
}
|
||||
n = nlmiddle;
|
||||
RROP_SPAN(addrl, n);
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addrl, endmask);
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
RROP_UNDECLARE
|
||||
}
|
||||
|
||||
#if PSZ == 24
|
||||
#define FILLSPAN(xl,xr,addr) \
|
||||
if (xr >= xl){ \
|
||||
n = xr - xl + 1; \
|
||||
addrl = (CfbBits *)((char *)addr + ((xl * 3) & ~0x03)); \
|
||||
if (n <= 1){ \
|
||||
if (n) \
|
||||
RROP_SOLID24(addrl, xl); \
|
||||
} else { \
|
||||
maskbits(xl, n, startmask, endmask, n); \
|
||||
pidx = xl & 3; \
|
||||
if (startmask){ \
|
||||
RROP_SOLID_MASK(addrl, startmask, pidx-1); \
|
||||
addrl++; \
|
||||
if (pidx == 3) \
|
||||
pidx = 0; \
|
||||
} \
|
||||
while (--n >= 0){ \
|
||||
RROP_SOLID(addrl, pidx); \
|
||||
addrl++; \
|
||||
if (++pidx == 3) \
|
||||
pidx = 0; \
|
||||
} \
|
||||
if (endmask) \
|
||||
RROP_SOLID_MASK(addrl, endmask, pidx); \
|
||||
} \
|
||||
}
|
||||
#else /* PSZ == 24 */
|
||||
#define FILLSPAN(xl,xr,addr) \
|
||||
if (xr >= xl) \
|
||||
{ \
|
||||
n = xr - xl + 1; \
|
||||
addrl = addr + (xl >> PWSH); \
|
||||
if (((xl & PIM) + n) <= PPW) \
|
||||
{ \
|
||||
maskpartialbits(xl, n, startmask); \
|
||||
RROP_SOLID_MASK(addrl, startmask); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
maskbits(xl, n, startmask, endmask, n); \
|
||||
if (startmask) \
|
||||
{ \
|
||||
RROP_SOLID_MASK(addrl, startmask); \
|
||||
addrl++; \
|
||||
} \
|
||||
while (n--) \
|
||||
{ \
|
||||
RROP_SOLID(addrl); \
|
||||
++addrl; \
|
||||
} \
|
||||
if (endmask) \
|
||||
RROP_SOLID_MASK(addrl, endmask); \
|
||||
} \
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
|
||||
#define FILLSLICESPANS(flip,addr) \
|
||||
if (!flip) \
|
||||
{ \
|
||||
FILLSPAN(xl, xr, addr); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
xc = xorg - x; \
|
||||
FILLSPAN(xc, xr, addr); \
|
||||
xc += slw - 1; \
|
||||
FILLSPAN(xl, xc, addr); \
|
||||
}
|
||||
|
||||
static void
|
||||
RROP_NAME(cfbFillArcSliceSolid)(
|
||||
DrawablePtr pDraw,
|
||||
GCPtr pGC,
|
||||
xArc *arc)
|
||||
{
|
||||
int yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
|
||||
register int x, y, e;
|
||||
miFillArcRec info;
|
||||
miArcSliceRec slice;
|
||||
int xl, xr, xc;
|
||||
#if PSZ == 24
|
||||
unsigned char *addrlt, *addrlb;
|
||||
#else
|
||||
CfbBits *addrlt, *addrlb;
|
||||
#endif
|
||||
register CfbBits *addrl;
|
||||
register int n;
|
||||
int nlwidth;
|
||||
RROP_DECLARE
|
||||
CfbBits startmask, endmask;
|
||||
#if PSZ == 24
|
||||
register int pidx;
|
||||
#endif /* PSZ == 24 */
|
||||
|
||||
#if PSZ == 24
|
||||
cfbGetByteWidthAndPointer (pDraw, nlwidth, addrlt)
|
||||
#else
|
||||
cfbGetLongWidthAndPointer (pDraw, nlwidth, addrlt)
|
||||
#endif
|
||||
|
||||
RROP_FETCH_GC(pGC);
|
||||
miFillArcSetup(arc, &info);
|
||||
miFillArcSliceSetup(arc, &slice, pGC);
|
||||
MIFILLARCSETUP();
|
||||
xorg += pDraw->x;
|
||||
yorg += pDraw->y;
|
||||
addrlb = addrlt;
|
||||
addrlt += nlwidth * (yorg - y);
|
||||
addrlb += nlwidth * (yorg + y + dy);
|
||||
slice.edge1.x += pDraw->x;
|
||||
slice.edge2.x += pDraw->x;
|
||||
while (y > 0)
|
||||
{
|
||||
addrlt += nlwidth;
|
||||
addrlb -= nlwidth;
|
||||
MIFILLARCSTEP(slw);
|
||||
MIARCSLICESTEP(slice.edge1);
|
||||
MIARCSLICESTEP(slice.edge2);
|
||||
if (miFillSliceUpper(slice))
|
||||
{
|
||||
MIARCSLICEUPPER(xl, xr, slice, slw);
|
||||
FILLSLICESPANS(slice.flip_top, addrlt);
|
||||
}
|
||||
if (miFillSliceLower(slice))
|
||||
{
|
||||
MIARCSLICELOWER(xl, xr, slice, slw);
|
||||
FILLSLICESPANS(slice.flip_bot, addrlb);
|
||||
}
|
||||
}
|
||||
RROP_UNDECLARE
|
||||
}
|
||||
|
||||
void
|
||||
RROP_NAME(cfbPolyFillArcSolid) (pDraw, pGC, narcs, parcs)
|
||||
DrawablePtr pDraw;
|
||||
GCPtr pGC;
|
||||
int narcs;
|
||||
xArc *parcs;
|
||||
{
|
||||
register xArc *arc;
|
||||
register int i;
|
||||
int x2, y2;
|
||||
BoxRec box;
|
||||
RegionPtr cclip;
|
||||
|
||||
cclip = cfbGetCompositeClip(pGC);
|
||||
for (arc = parcs, i = narcs; --i >= 0; arc++)
|
||||
{
|
||||
if (miFillArcEmpty(arc))
|
||||
continue;
|
||||
if (miCanFillArc(arc))
|
||||
{
|
||||
box.x1 = arc->x + pDraw->x;
|
||||
box.y1 = arc->y + pDraw->y;
|
||||
/*
|
||||
* Because box.x2 and box.y2 get truncated to 16 bits, and the
|
||||
* RECT_IN_REGION test treats the resulting number as a signed
|
||||
* integer, the RECT_IN_REGION test alone can go the wrong way.
|
||||
* This can result in a server crash because the rendering
|
||||
* routines in this file deal directly with cpu addresses
|
||||
* of pixels to be stored, and do not clip or otherwise check
|
||||
* that all such addresses are within their respective pixmaps.
|
||||
* So we only allow the RECT_IN_REGION test to be used for
|
||||
* values that can be expressed correctly in a signed short.
|
||||
*/
|
||||
x2 = box.x1 + (int)arc->width + 1;
|
||||
box.x2 = x2;
|
||||
y2 = box.y1 + (int)arc->height + 1;
|
||||
box.y2 = y2;
|
||||
if ( (x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&
|
||||
(RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
|
||||
{
|
||||
if ((arc->angle2 >= FULLCIRCLE) ||
|
||||
(arc->angle2 <= -FULLCIRCLE))
|
||||
RROP_NAME(cfbFillEllipseSolid)(pDraw, pGC, arc);
|
||||
else
|
||||
RROP_NAME(cfbFillArcSliceSolid)(pDraw, pGC, arc);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
miPolyFillArc(pDraw, pGC, 1, arc);
|
||||
}
|
||||
}
|
305
cfb/cfbfillrct.c
305
cfb/cfbfillrct.c
|
@ -1,305 +0,0 @@
|
|||
/*
|
||||
* Fill rectangles.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "gcstruct.h"
|
||||
#include "window.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
#include "mi.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mergerop.h"
|
||||
|
||||
|
||||
void
|
||||
cfbFillBoxTileOdd (pDrawable, n, rects, tile, xrot, yrot)
|
||||
DrawablePtr pDrawable;
|
||||
int n;
|
||||
BoxPtr rects;
|
||||
PixmapPtr tile;
|
||||
int xrot, yrot;
|
||||
{
|
||||
#if PSZ == 24
|
||||
if (tile->drawable.width & 3)
|
||||
#else
|
||||
if (tile->drawable.width & PIM)
|
||||
#endif
|
||||
cfbFillBoxTileOddCopy (pDrawable, n, rects, tile, xrot, yrot, GXcopy, ~0L);
|
||||
else
|
||||
cfbFillBoxTile32sCopy (pDrawable, n, rects, tile, xrot, yrot, GXcopy, ~0L);
|
||||
}
|
||||
|
||||
void
|
||||
cfbFillRectTileOdd (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox;
|
||||
BoxPtr pBox;
|
||||
{
|
||||
int xrot, yrot;
|
||||
void (*fill)(DrawablePtr, int, BoxPtr, PixmapPtr, int, int, int, unsigned long);
|
||||
|
||||
xrot = pDrawable->x + pGC->patOrg.x;
|
||||
yrot = pDrawable->y + pGC->patOrg.y;
|
||||
#if PSZ == 24
|
||||
if (pGC->tile.pixmap->drawable.width & 3)
|
||||
#else
|
||||
if (pGC->tile.pixmap->drawable.width & PIM)
|
||||
#endif
|
||||
{
|
||||
fill = cfbFillBoxTileOddGeneral;
|
||||
if ((pGC->planemask & PMSK) == PMSK)
|
||||
{
|
||||
if (pGC->alu == GXcopy)
|
||||
fill = cfbFillBoxTileOddCopy;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
fill = cfbFillBoxTile32sGeneral;
|
||||
if ((pGC->planemask & PMSK) == PMSK)
|
||||
{
|
||||
if (pGC->alu == GXcopy)
|
||||
fill = cfbFillBoxTile32sCopy;
|
||||
}
|
||||
}
|
||||
(*fill) (pDrawable, nBox, pBox, pGC->tile.pixmap, xrot, yrot, pGC->alu, pGC->planemask);
|
||||
}
|
||||
|
||||
#define NUM_STACK_RECTS 1024
|
||||
|
||||
void
|
||||
cfbPolyFillRect(pDrawable, pGC, nrectFill, prectInit)
|
||||
DrawablePtr pDrawable;
|
||||
register GCPtr pGC;
|
||||
int nrectFill; /* number of rectangles to fill */
|
||||
xRectangle *prectInit; /* Pointer to first rectangle to fill */
|
||||
{
|
||||
xRectangle *prect;
|
||||
RegionPtr prgnClip;
|
||||
register BoxPtr pbox;
|
||||
register BoxPtr pboxClipped;
|
||||
BoxPtr pboxClippedBase;
|
||||
BoxPtr pextent;
|
||||
BoxRec stackRects[NUM_STACK_RECTS];
|
||||
cfbPrivGC *priv;
|
||||
int numRects;
|
||||
void (*BoxFill)(DrawablePtr, GCPtr, int, BoxPtr);
|
||||
int n;
|
||||
int xorg, yorg;
|
||||
|
||||
#if PSZ != 8
|
||||
if ((pGC->fillStyle == FillStippled) ||
|
||||
(pGC->fillStyle == FillOpaqueStippled)) {
|
||||
miPolyFillRect(pDrawable, pGC, nrectFill, prectInit);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
priv = cfbGetGCPrivate(pGC);
|
||||
prgnClip = pGC->pCompositeClip;
|
||||
|
||||
BoxFill = 0;
|
||||
switch (pGC->fillStyle)
|
||||
{
|
||||
case FillSolid:
|
||||
switch (priv->rop) {
|
||||
case GXcopy:
|
||||
BoxFill = cfbFillRectSolidCopy;
|
||||
break;
|
||||
case GXxor:
|
||||
BoxFill = cfbFillRectSolidXor;
|
||||
break;
|
||||
default:
|
||||
BoxFill = cfbFillRectSolidGeneral;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case FillTiled:
|
||||
if (!pGC->pRotatedPixmap)
|
||||
BoxFill = cfbFillRectTileOdd;
|
||||
else
|
||||
{
|
||||
if (pGC->alu == GXcopy && (pGC->planemask & PMSK) == PMSK)
|
||||
BoxFill = cfbFillRectTile32Copy;
|
||||
else
|
||||
BoxFill = cfbFillRectTile32General;
|
||||
}
|
||||
break;
|
||||
#if PSZ == 8
|
||||
case FillStippled:
|
||||
if (!pGC->pRotatedPixmap)
|
||||
BoxFill = cfb8FillRectStippledUnnatural;
|
||||
else
|
||||
BoxFill = cfb8FillRectTransparentStippled32;
|
||||
break;
|
||||
case FillOpaqueStippled:
|
||||
if (!pGC->pRotatedPixmap)
|
||||
BoxFill = cfb8FillRectStippledUnnatural;
|
||||
else
|
||||
BoxFill = cfb8FillRectOpaqueStippled32;
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
prect = prectInit;
|
||||
xorg = pDrawable->x;
|
||||
yorg = pDrawable->y;
|
||||
if (xorg || yorg)
|
||||
{
|
||||
prect = prectInit;
|
||||
n = nrectFill;
|
||||
while(n--)
|
||||
{
|
||||
prect->x += xorg;
|
||||
prect->y += yorg;
|
||||
prect++;
|
||||
}
|
||||
}
|
||||
|
||||
prect = prectInit;
|
||||
|
||||
numRects = REGION_NUM_RECTS(prgnClip) * nrectFill;
|
||||
if (numRects > NUM_STACK_RECTS)
|
||||
{
|
||||
pboxClippedBase = (BoxPtr)xalloc(numRects * sizeof(BoxRec));
|
||||
if (!pboxClippedBase)
|
||||
return;
|
||||
}
|
||||
else
|
||||
pboxClippedBase = stackRects;
|
||||
|
||||
pboxClipped = pboxClippedBase;
|
||||
|
||||
if (REGION_NUM_RECTS(prgnClip) == 1)
|
||||
{
|
||||
int x1, y1, x2, y2, bx2, by2;
|
||||
|
||||
pextent = REGION_RECTS(prgnClip);
|
||||
x1 = pextent->x1;
|
||||
y1 = pextent->y1;
|
||||
x2 = pextent->x2;
|
||||
y2 = pextent->y2;
|
||||
while (nrectFill--)
|
||||
{
|
||||
if ((pboxClipped->x1 = prect->x) < x1)
|
||||
pboxClipped->x1 = x1;
|
||||
|
||||
if ((pboxClipped->y1 = prect->y) < y1)
|
||||
pboxClipped->y1 = y1;
|
||||
|
||||
bx2 = (int) prect->x + (int) prect->width;
|
||||
if (bx2 > x2)
|
||||
bx2 = x2;
|
||||
pboxClipped->x2 = bx2;
|
||||
|
||||
by2 = (int) prect->y + (int) prect->height;
|
||||
if (by2 > y2)
|
||||
by2 = y2;
|
||||
pboxClipped->y2 = by2;
|
||||
|
||||
prect++;
|
||||
if ((pboxClipped->x1 < pboxClipped->x2) &&
|
||||
(pboxClipped->y1 < pboxClipped->y2))
|
||||
{
|
||||
pboxClipped++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int x1, y1, x2, y2, bx2, by2;
|
||||
|
||||
pextent = REGION_EXTENTS(pGC->pScreen, prgnClip);
|
||||
x1 = pextent->x1;
|
||||
y1 = pextent->y1;
|
||||
x2 = pextent->x2;
|
||||
y2 = pextent->y2;
|
||||
while (nrectFill--)
|
||||
{
|
||||
BoxRec box;
|
||||
|
||||
if ((box.x1 = prect->x) < x1)
|
||||
box.x1 = x1;
|
||||
|
||||
if ((box.y1 = prect->y) < y1)
|
||||
box.y1 = y1;
|
||||
|
||||
bx2 = (int) prect->x + (int) prect->width;
|
||||
if (bx2 > x2)
|
||||
bx2 = x2;
|
||||
box.x2 = bx2;
|
||||
|
||||
by2 = (int) prect->y + (int) prect->height;
|
||||
if (by2 > y2)
|
||||
by2 = y2;
|
||||
box.y2 = by2;
|
||||
|
||||
prect++;
|
||||
|
||||
if ((box.x1 >= box.x2) || (box.y1 >= box.y2))
|
||||
continue;
|
||||
|
||||
n = REGION_NUM_RECTS (prgnClip);
|
||||
pbox = REGION_RECTS(prgnClip);
|
||||
|
||||
/* clip the rectangle to each box in the clip region
|
||||
this is logically equivalent to calling Intersect()
|
||||
*/
|
||||
while(n--)
|
||||
{
|
||||
pboxClipped->x1 = max(box.x1, pbox->x1);
|
||||
pboxClipped->y1 = max(box.y1, pbox->y1);
|
||||
pboxClipped->x2 = min(box.x2, pbox->x2);
|
||||
pboxClipped->y2 = min(box.y2, pbox->y2);
|
||||
pbox++;
|
||||
|
||||
/* see if clipping left anything */
|
||||
if(pboxClipped->x1 < pboxClipped->x2 &&
|
||||
pboxClipped->y1 < pboxClipped->y2)
|
||||
{
|
||||
pboxClipped++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (pboxClipped != pboxClippedBase)
|
||||
(*BoxFill) (pDrawable, pGC,
|
||||
pboxClipped-pboxClippedBase, pboxClippedBase);
|
||||
if (pboxClippedBase != stackRects)
|
||||
xfree(pboxClippedBase);
|
||||
}
|
1004
cfb/cfbfillsp.c
1004
cfb/cfbfillsp.c
File diff suppressed because it is too large
Load Diff
799
cfb/cfbgc.c
799
cfb/cfbgc.c
|
@ -1,799 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "region.h"
|
||||
|
||||
#include "mistruct.h"
|
||||
#include "mibstore.h"
|
||||
#include "migc.h"
|
||||
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
#if PSZ == 8
|
||||
# define useTEGlyphBlt cfbTEGlyphBlt8
|
||||
#else
|
||||
# ifdef WriteBitGroup
|
||||
# define useTEGlyphBlt cfbImageGlyphBlt8
|
||||
# else
|
||||
# define useTEGlyphBlt cfbTEGlyphBlt
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifdef WriteBitGroup
|
||||
# define useImageGlyphBlt cfbImageGlyphBlt8
|
||||
# define usePolyGlyphBlt cfbPolyGlyphBlt8
|
||||
#else
|
||||
# define useImageGlyphBlt miImageGlyphBlt
|
||||
# define usePolyGlyphBlt miPolyGlyphBlt
|
||||
#endif
|
||||
|
||||
static void cfbUnPushPixels (GCPtr, PixmapPtr, DrawablePtr, int, int, int, int);
|
||||
|
||||
#ifdef FOUR_BIT_CODE
|
||||
# define usePushPixels cfbPushPixels8
|
||||
#else
|
||||
# define usePushPixels cfbUnPushPixels
|
||||
#endif
|
||||
|
||||
#ifdef PIXEL_ADDR
|
||||
# define ZeroPolyArc cfbZeroPolyArcSS8Copy
|
||||
#else
|
||||
# define ZeroPolyArc miZeroPolyArc
|
||||
#endif
|
||||
|
||||
GCFuncs cfbGCFuncs = {
|
||||
cfbValidateGC,
|
||||
miChangeGC,
|
||||
miCopyGC,
|
||||
miDestroyGC,
|
||||
miChangeClip,
|
||||
miDestroyClip,
|
||||
miCopyClip,
|
||||
};
|
||||
|
||||
GCOps cfbTEOps1Rect = {
|
||||
cfbSolidSpansCopy,
|
||||
cfbSetSpans,
|
||||
cfbPutImage,
|
||||
cfbCopyArea,
|
||||
cfbCopyPlane,
|
||||
cfbPolyPoint,
|
||||
#ifdef PIXEL_ADDR
|
||||
cfb8LineSS1Rect,
|
||||
cfb8SegmentSS1Rect,
|
||||
#else
|
||||
cfbLineSS,
|
||||
cfbSegmentSS,
|
||||
#endif
|
||||
miPolyRectangle,
|
||||
ZeroPolyArc,
|
||||
cfbFillPoly1RectCopy,
|
||||
cfbPolyFillRect,
|
||||
cfbPolyFillArcSolidCopy,
|
||||
miPolyText8,
|
||||
miPolyText16,
|
||||
miImageText8,
|
||||
miImageText16,
|
||||
useTEGlyphBlt,
|
||||
usePolyGlyphBlt,
|
||||
usePushPixels
|
||||
};
|
||||
|
||||
GCOps cfbNonTEOps1Rect = {
|
||||
cfbSolidSpansCopy,
|
||||
cfbSetSpans,
|
||||
cfbPutImage,
|
||||
cfbCopyArea,
|
||||
cfbCopyPlane,
|
||||
cfbPolyPoint,
|
||||
#ifdef PIXEL_ADDR
|
||||
cfb8LineSS1Rect,
|
||||
cfb8SegmentSS1Rect,
|
||||
#else
|
||||
cfbLineSS,
|
||||
cfbSegmentSS,
|
||||
#endif
|
||||
miPolyRectangle,
|
||||
ZeroPolyArc,
|
||||
cfbFillPoly1RectCopy,
|
||||
cfbPolyFillRect,
|
||||
cfbPolyFillArcSolidCopy,
|
||||
miPolyText8,
|
||||
miPolyText16,
|
||||
miImageText8,
|
||||
miImageText16,
|
||||
useImageGlyphBlt,
|
||||
usePolyGlyphBlt,
|
||||
usePushPixels
|
||||
};
|
||||
|
||||
GCOps cfbTEOps = {
|
||||
cfbSolidSpansCopy,
|
||||
cfbSetSpans,
|
||||
cfbPutImage,
|
||||
cfbCopyArea,
|
||||
cfbCopyPlane,
|
||||
cfbPolyPoint,
|
||||
cfbLineSS,
|
||||
cfbSegmentSS,
|
||||
miPolyRectangle,
|
||||
ZeroPolyArc,
|
||||
miFillPolygon,
|
||||
cfbPolyFillRect,
|
||||
cfbPolyFillArcSolidCopy,
|
||||
miPolyText8,
|
||||
miPolyText16,
|
||||
miImageText8,
|
||||
miImageText16,
|
||||
useTEGlyphBlt,
|
||||
usePolyGlyphBlt,
|
||||
usePushPixels
|
||||
};
|
||||
|
||||
GCOps cfbNonTEOps = {
|
||||
cfbSolidSpansCopy,
|
||||
cfbSetSpans,
|
||||
cfbPutImage,
|
||||
cfbCopyArea,
|
||||
cfbCopyPlane,
|
||||
cfbPolyPoint,
|
||||
cfbLineSS,
|
||||
cfbSegmentSS,
|
||||
miPolyRectangle,
|
||||
#ifdef PIXEL_ADDR
|
||||
cfbZeroPolyArcSS8Copy,
|
||||
#else
|
||||
miZeroPolyArc,
|
||||
#endif
|
||||
miFillPolygon,
|
||||
cfbPolyFillRect,
|
||||
cfbPolyFillArcSolidCopy,
|
||||
miPolyText8,
|
||||
miPolyText16,
|
||||
miImageText8,
|
||||
miImageText16,
|
||||
useImageGlyphBlt,
|
||||
usePolyGlyphBlt,
|
||||
usePushPixels
|
||||
};
|
||||
|
||||
GCOps *
|
||||
cfbMatchCommon (pGC, devPriv)
|
||||
GCPtr pGC;
|
||||
cfbPrivGCPtr devPriv;
|
||||
{
|
||||
if (pGC->lineWidth != 0)
|
||||
return 0;
|
||||
if (pGC->lineStyle != LineSolid)
|
||||
return 0;
|
||||
if (pGC->fillStyle != FillSolid)
|
||||
return 0;
|
||||
if (devPriv->rop != GXcopy)
|
||||
return 0;
|
||||
if (pGC->font &&
|
||||
FONTMAXBOUNDS(pGC->font,rightSideBearing) -
|
||||
FONTMINBOUNDS(pGC->font,leftSideBearing) <= 32 &&
|
||||
FONTMINBOUNDS(pGC->font,characterWidth) >= 0)
|
||||
{
|
||||
if (TERMINALFONT(pGC->font)
|
||||
#ifdef FOUR_BIT_CODE
|
||||
&& FONTMAXBOUNDS(pGC->font,characterWidth) >= PGSZB
|
||||
#endif
|
||||
)
|
||||
#ifdef NO_ONE_RECT
|
||||
return &cfbTEOps1Rect;
|
||||
#else
|
||||
if (devPriv->oneRect)
|
||||
return &cfbTEOps1Rect;
|
||||
else
|
||||
return &cfbTEOps;
|
||||
#endif
|
||||
else
|
||||
#ifdef NO_ONE_RECT
|
||||
return &cfbNonTEOps1Rect;
|
||||
#else
|
||||
if (devPriv->oneRect)
|
||||
return &cfbNonTEOps1Rect;
|
||||
else
|
||||
return &cfbNonTEOps;
|
||||
#endif
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbCreateGC(pGC)
|
||||
register GCPtr pGC;
|
||||
{
|
||||
cfbPrivGC *pPriv;
|
||||
|
||||
if (PixmapWidthPaddingInfo[pGC->depth].padPixelsLog2 == LOG2_BITMAP_PAD)
|
||||
return (mfbCreateGC(pGC));
|
||||
pGC->clientClip = NULL;
|
||||
pGC->clientClipType = CT_NONE;
|
||||
|
||||
if (cfbNonTEOps.PushPixels == cfbUnPushPixels)
|
||||
{
|
||||
cfbTEOps1Rect.PushPixels = mfbPushPixelsWeak();
|
||||
cfbNonTEOps1Rect.PushPixels = mfbPushPixelsWeak();
|
||||
cfbTEOps.PushPixels = mfbPushPixelsWeak();
|
||||
cfbNonTEOps.PushPixels = mfbPushPixelsWeak();
|
||||
}
|
||||
|
||||
/*
|
||||
* some of the output primitives aren't really necessary, since they
|
||||
* will be filled in ValidateGC because of dix/CreateGC() setting all
|
||||
* the change bits. Others are necessary because although they depend
|
||||
* on being a color frame buffer, they don't change
|
||||
*/
|
||||
|
||||
pGC->ops = &cfbNonTEOps;
|
||||
pGC->funcs = &cfbGCFuncs;
|
||||
|
||||
/* cfb wants to translate before scan conversion */
|
||||
pGC->miTranslate = 1;
|
||||
|
||||
pPriv = cfbGetGCPrivate(pGC);
|
||||
pPriv->rop = pGC->alu;
|
||||
pPriv->oneRect = FALSE;
|
||||
pGC->fExpose = TRUE;
|
||||
pGC->freeCompClip = FALSE;
|
||||
pGC->pRotatedPixmap = (PixmapPtr) NULL;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* Clipping conventions
|
||||
if the drawable is a window
|
||||
CT_REGION ==> pCompositeClip really is the composite
|
||||
CT_other ==> pCompositeClip is the window clip region
|
||||
if the drawable is a pixmap
|
||||
CT_REGION ==> pCompositeClip is the translated client region
|
||||
clipped to the pixmap boundary
|
||||
CT_other ==> pCompositeClip is the pixmap bounding box
|
||||
*/
|
||||
|
||||
void
|
||||
cfbValidateGC(pGC, changes, pDrawable)
|
||||
register GCPtr pGC;
|
||||
unsigned long changes;
|
||||
DrawablePtr pDrawable;
|
||||
{
|
||||
int mask; /* stateChanges */
|
||||
int index; /* used for stepping through bitfields */
|
||||
int new_rrop;
|
||||
int new_line, new_text, new_fillspans, new_fillarea;
|
||||
int new_rotate;
|
||||
int xrot, yrot;
|
||||
/* flags for changing the proc vector */
|
||||
cfbPrivGCPtr devPriv;
|
||||
int oneRect;
|
||||
|
||||
new_rotate = pGC->lastWinOrg.x != pDrawable->x ||
|
||||
pGC->lastWinOrg.y != pDrawable->y;
|
||||
|
||||
pGC->lastWinOrg.x = pDrawable->x;
|
||||
pGC->lastWinOrg.y = pDrawable->y;
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
|
||||
new_rrop = FALSE;
|
||||
new_line = FALSE;
|
||||
new_text = FALSE;
|
||||
new_fillspans = FALSE;
|
||||
new_fillarea = FALSE;
|
||||
|
||||
/*
|
||||
* if the client clip is different or moved OR the subwindowMode has
|
||||
* changed OR the window's clip has changed since the last validation
|
||||
* we need to recompute the composite clip
|
||||
*/
|
||||
|
||||
if ((changes & (GCClipXOrigin|GCClipYOrigin|GCClipMask|GCSubwindowMode)) ||
|
||||
(pDrawable->serialNumber != (pGC->serialNumber & DRAWABLE_SERIAL_BITS))
|
||||
)
|
||||
{
|
||||
miComputeCompositeClip (pGC, pDrawable);
|
||||
#ifdef NO_ONE_RECT
|
||||
devPriv->oneRect = FALSE;
|
||||
#else
|
||||
oneRect = REGION_NUM_RECTS(pGC->pCompositeClip) == 1;
|
||||
if (oneRect != devPriv->oneRect)
|
||||
new_line = TRUE;
|
||||
devPriv->oneRect = oneRect;
|
||||
#endif
|
||||
}
|
||||
|
||||
mask = changes;
|
||||
while (mask) {
|
||||
index = lowbit (mask);
|
||||
mask &= ~index;
|
||||
|
||||
/*
|
||||
* this switch acculmulates a list of which procedures might have
|
||||
* to change due to changes in the GC. in some cases (e.g.
|
||||
* changing one 16 bit tile for another) we might not really need
|
||||
* a change, but the code is being paranoid. this sort of batching
|
||||
* wins if, for example, the alu and the font have been changed,
|
||||
* or any other pair of items that both change the same thing.
|
||||
*/
|
||||
switch (index) {
|
||||
case GCFunction:
|
||||
case GCForeground:
|
||||
new_rrop = TRUE;
|
||||
break;
|
||||
case GCPlaneMask:
|
||||
new_rrop = TRUE;
|
||||
new_text = TRUE;
|
||||
break;
|
||||
case GCBackground:
|
||||
break;
|
||||
case GCLineStyle:
|
||||
case GCLineWidth:
|
||||
new_line = TRUE;
|
||||
break;
|
||||
case GCJoinStyle:
|
||||
case GCCapStyle:
|
||||
break;
|
||||
case GCFillStyle:
|
||||
new_text = TRUE;
|
||||
new_fillspans = TRUE;
|
||||
new_line = TRUE;
|
||||
new_fillarea = TRUE;
|
||||
break;
|
||||
case GCFillRule:
|
||||
break;
|
||||
case GCTile:
|
||||
new_fillspans = TRUE;
|
||||
new_fillarea = TRUE;
|
||||
break;
|
||||
|
||||
case GCStipple:
|
||||
if (pGC->stipple)
|
||||
{
|
||||
int width = pGC->stipple->drawable.width;
|
||||
PixmapPtr nstipple;
|
||||
|
||||
if ((width <= PGSZ) && !(width & (width - 1)) &&
|
||||
(nstipple = cfbCopyPixmap(pGC->stipple)))
|
||||
{
|
||||
cfbPadPixmap(nstipple);
|
||||
(*pGC->pScreen->DestroyPixmap)(pGC->stipple);
|
||||
pGC->stipple = nstipple;
|
||||
}
|
||||
}
|
||||
new_fillspans = TRUE;
|
||||
new_fillarea = TRUE;
|
||||
break;
|
||||
|
||||
case GCTileStipXOrigin:
|
||||
new_rotate = TRUE;
|
||||
break;
|
||||
|
||||
case GCTileStipYOrigin:
|
||||
new_rotate = TRUE;
|
||||
break;
|
||||
|
||||
case GCFont:
|
||||
new_text = TRUE;
|
||||
break;
|
||||
case GCSubwindowMode:
|
||||
break;
|
||||
case GCGraphicsExposures:
|
||||
break;
|
||||
case GCClipXOrigin:
|
||||
break;
|
||||
case GCClipYOrigin:
|
||||
break;
|
||||
case GCClipMask:
|
||||
break;
|
||||
case GCDashOffset:
|
||||
break;
|
||||
case GCDashList:
|
||||
break;
|
||||
case GCArcMode:
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* If the drawable has changed, ensure suitable
|
||||
* entries are in the proc vector.
|
||||
*/
|
||||
if (pDrawable->serialNumber != (pGC->serialNumber & (DRAWABLE_SERIAL_BITS))) {
|
||||
new_fillspans = TRUE; /* deal with FillSpans later */
|
||||
}
|
||||
|
||||
if (new_rotate || new_fillspans)
|
||||
{
|
||||
Bool new_pix = FALSE;
|
||||
|
||||
xrot = pGC->patOrg.x + pDrawable->x;
|
||||
yrot = pGC->patOrg.y + pDrawable->y;
|
||||
|
||||
switch (pGC->fillStyle)
|
||||
{
|
||||
case FillTiled:
|
||||
if (!pGC->tileIsPixel)
|
||||
{
|
||||
int width = pGC->tile.pixmap->drawable.width * PSZ;
|
||||
|
||||
if ((width <= PGSZ) && !(width & (width - 1)))
|
||||
{
|
||||
cfbCopyRotatePixmap(pGC->tile.pixmap, &pGC->pRotatedPixmap,
|
||||
xrot, yrot);
|
||||
new_pix = TRUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
#ifdef FOUR_BIT_CODE
|
||||
case FillStippled:
|
||||
case FillOpaqueStippled:
|
||||
{
|
||||
int width = pGC->stipple->drawable.width;
|
||||
|
||||
if ((width <= PGSZ) && !(width & (width - 1)))
|
||||
{
|
||||
mfbCopyRotatePixmap(pGC->stipple, &pGC->pRotatedPixmap,
|
||||
xrot, yrot);
|
||||
new_pix = TRUE;
|
||||
}
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
if (!new_pix && pGC->pRotatedPixmap)
|
||||
{
|
||||
(*pGC->pScreen->DestroyPixmap)(pGC->pRotatedPixmap);
|
||||
pGC->pRotatedPixmap = (PixmapPtr) NULL;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_rrop)
|
||||
{
|
||||
int old_rrop;
|
||||
|
||||
old_rrop = devPriv->rop;
|
||||
devPriv->rop = cfbReduceRasterOp (pGC->alu, pGC->fgPixel,
|
||||
pGC->planemask,
|
||||
&devPriv->and, &devPriv->xor);
|
||||
if (old_rrop == devPriv->rop)
|
||||
new_rrop = FALSE;
|
||||
else
|
||||
{
|
||||
#ifdef PIXEL_ADDR
|
||||
new_line = TRUE;
|
||||
#endif
|
||||
#ifdef WriteBitGroup
|
||||
new_text = TRUE;
|
||||
#endif
|
||||
new_fillspans = TRUE;
|
||||
new_fillarea = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_rrop || new_fillspans || new_text || new_fillarea || new_line)
|
||||
{
|
||||
GCOps *newops;
|
||||
|
||||
if ((newops = cfbMatchCommon (pGC, devPriv)))
|
||||
{
|
||||
if (pGC->ops->devPrivate.val)
|
||||
miDestroyGCOps (pGC->ops);
|
||||
pGC->ops = newops;
|
||||
new_rrop = new_line = new_fillspans = new_text = new_fillarea = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!pGC->ops->devPrivate.val)
|
||||
{
|
||||
pGC->ops = miCreateGCOps (pGC->ops);
|
||||
pGC->ops->devPrivate.val = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* deal with the changes we've collected */
|
||||
if (new_line)
|
||||
{
|
||||
pGC->ops->FillPolygon = miFillPolygon;
|
||||
#ifdef NO_ONE_RECT
|
||||
if (pGC->fillStyle == FillSolid)
|
||||
{
|
||||
switch (devPriv->rop) {
|
||||
case GXcopy:
|
||||
pGC->ops->FillPolygon = cfbFillPoly1RectCopy;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->FillPolygon = cfbFillPoly1RectGeneral;
|
||||
break;
|
||||
}
|
||||
}
|
||||
#else
|
||||
if (devPriv->oneRect && pGC->fillStyle == FillSolid)
|
||||
{
|
||||
switch (devPriv->rop) {
|
||||
case GXcopy:
|
||||
pGC->ops->FillPolygon = cfbFillPoly1RectCopy;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->FillPolygon = cfbFillPoly1RectGeneral;
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
if (pGC->lineWidth == 0)
|
||||
{
|
||||
#ifdef PIXEL_ADDR
|
||||
if ((pGC->lineStyle == LineSolid) && (pGC->fillStyle == FillSolid))
|
||||
{
|
||||
switch (devPriv->rop)
|
||||
{
|
||||
case GXxor:
|
||||
pGC->ops->PolyArc = cfbZeroPolyArcSS8Xor;
|
||||
break;
|
||||
case GXcopy:
|
||||
pGC->ops->PolyArc = cfbZeroPolyArcSS8Copy;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->PolyArc = cfbZeroPolyArcSS8General;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
pGC->ops->PolyArc = miZeroPolyArc;
|
||||
}
|
||||
else
|
||||
pGC->ops->PolyArc = miPolyArc;
|
||||
pGC->ops->PolySegment = miPolySegment;
|
||||
switch (pGC->lineStyle)
|
||||
{
|
||||
case LineSolid:
|
||||
if(pGC->lineWidth == 0)
|
||||
{
|
||||
if (pGC->fillStyle == FillSolid)
|
||||
{
|
||||
#if defined(PIXEL_ADDR) && !defined(NO_ONE_RECT)
|
||||
if (devPriv->oneRect &&
|
||||
((pDrawable->x >= pGC->pScreen->width - 32768) &&
|
||||
(pDrawable->y >= pGC->pScreen->height - 32768)))
|
||||
{
|
||||
pGC->ops->Polylines = cfb8LineSS1Rect;
|
||||
pGC->ops->PolySegment = cfb8SegmentSS1Rect;
|
||||
} else
|
||||
#endif
|
||||
#ifdef NO_ONE_RECT
|
||||
{
|
||||
pGC->ops->Polylines = cfb8LineSS1Rect;
|
||||
pGC->ops->PolySegment = cfb8SegmentSS1Rect;
|
||||
}
|
||||
#else
|
||||
{
|
||||
pGC->ops->Polylines = cfbLineSS;
|
||||
pGC->ops->PolySegment = cfbSegmentSS;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
pGC->ops->Polylines = miZeroLine;
|
||||
}
|
||||
else
|
||||
pGC->ops->Polylines = miWideLine;
|
||||
break;
|
||||
case LineOnOffDash:
|
||||
case LineDoubleDash:
|
||||
if (pGC->lineWidth == 0 && pGC->fillStyle == FillSolid)
|
||||
{
|
||||
pGC->ops->Polylines = cfbLineSD;
|
||||
pGC->ops->PolySegment = cfbSegmentSD;
|
||||
} else
|
||||
pGC->ops->Polylines = miWideDash;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (new_text && (pGC->font))
|
||||
{
|
||||
if (FONTMAXBOUNDS(pGC->font,rightSideBearing) -
|
||||
FONTMINBOUNDS(pGC->font,leftSideBearing) > 32 ||
|
||||
FONTMINBOUNDS(pGC->font,characterWidth) < 0)
|
||||
{
|
||||
pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
|
||||
pGC->ops->ImageGlyphBlt = miImageGlyphBlt;
|
||||
}
|
||||
else
|
||||
{
|
||||
#ifdef WriteBitGroup
|
||||
if (pGC->fillStyle == FillSolid)
|
||||
{
|
||||
if (devPriv->rop == GXcopy)
|
||||
pGC->ops->PolyGlyphBlt = cfbPolyGlyphBlt8;
|
||||
else
|
||||
#ifdef FOUR_BIT_CODE
|
||||
pGC->ops->PolyGlyphBlt = cfbPolyGlyphRop8;
|
||||
#else
|
||||
pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
#endif
|
||||
pGC->ops->PolyGlyphBlt = miPolyGlyphBlt;
|
||||
/* special case ImageGlyphBlt for terminal emulator fonts */
|
||||
#if !defined(WriteBitGroup) || PSZ == 8
|
||||
if (TERMINALFONT(pGC->font) &&
|
||||
(pGC->planemask & PMSK) == PMSK
|
||||
#ifdef FOUR_BIT_CODE
|
||||
&& FONTMAXBOUNDS(pGC->font,characterWidth) >= PGSZB
|
||||
#endif
|
||||
)
|
||||
{
|
||||
pGC->ops->ImageGlyphBlt = useTEGlyphBlt;
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
#ifdef WriteBitGroup
|
||||
if (devPriv->rop == GXcopy &&
|
||||
pGC->fillStyle == FillSolid &&
|
||||
(pGC->planemask & PMSK) == PMSK)
|
||||
pGC->ops->ImageGlyphBlt = cfbImageGlyphBlt8;
|
||||
else
|
||||
#endif
|
||||
pGC->ops->ImageGlyphBlt = miImageGlyphBlt;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (new_fillspans) {
|
||||
switch (pGC->fillStyle) {
|
||||
case FillSolid:
|
||||
switch (devPriv->rop) {
|
||||
case GXcopy:
|
||||
pGC->ops->FillSpans = cfbSolidSpansCopy;
|
||||
break;
|
||||
case GXxor:
|
||||
pGC->ops->FillSpans = cfbSolidSpansXor;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->FillSpans = cfbSolidSpansGeneral;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case FillTiled:
|
||||
if (pGC->pRotatedPixmap)
|
||||
{
|
||||
if (pGC->alu == GXcopy && (pGC->planemask & PMSK) == PMSK)
|
||||
pGC->ops->FillSpans = cfbTile32FSCopy;
|
||||
else
|
||||
pGC->ops->FillSpans = cfbTile32FSGeneral;
|
||||
}
|
||||
else
|
||||
pGC->ops->FillSpans = cfbUnnaturalTileFS;
|
||||
break;
|
||||
case FillStippled:
|
||||
#ifdef FOUR_BIT_CODE
|
||||
if (pGC->pRotatedPixmap)
|
||||
pGC->ops->FillSpans = cfb8Stipple32FS;
|
||||
else
|
||||
#endif
|
||||
pGC->ops->FillSpans = cfbUnnaturalStippleFS;
|
||||
break;
|
||||
case FillOpaqueStippled:
|
||||
#ifdef FOUR_BIT_CODE
|
||||
if (pGC->pRotatedPixmap)
|
||||
pGC->ops->FillSpans = cfb8OpaqueStipple32FS;
|
||||
else
|
||||
#endif
|
||||
pGC->ops->FillSpans = cfbUnnaturalStippleFS;
|
||||
break;
|
||||
default:
|
||||
FatalError("cfbValidateGC: illegal fillStyle\n");
|
||||
}
|
||||
} /* end of new_fillspans */
|
||||
|
||||
if (new_fillarea) {
|
||||
#ifndef FOUR_BIT_CODE
|
||||
pGC->ops->PolyFillRect = miPolyFillRect;
|
||||
if (pGC->fillStyle == FillSolid || pGC->fillStyle == FillTiled)
|
||||
{
|
||||
pGC->ops->PolyFillRect = cfbPolyFillRect;
|
||||
}
|
||||
#endif
|
||||
#ifdef FOUR_BIT_CODE
|
||||
pGC->ops->PushPixels = mfbPushPixelsWeak();
|
||||
if (pGC->fillStyle == FillSolid && devPriv->rop == GXcopy)
|
||||
pGC->ops->PushPixels = cfbPushPixels8;
|
||||
#endif
|
||||
pGC->ops->PolyFillArc = miPolyFillArc;
|
||||
if (pGC->fillStyle == FillSolid)
|
||||
{
|
||||
switch (devPriv->rop)
|
||||
{
|
||||
case GXcopy:
|
||||
pGC->ops->PolyFillArc = cfbPolyFillArcSolidCopy;
|
||||
break;
|
||||
default:
|
||||
pGC->ops->PolyFillArc = cfbPolyFillArcSolidGeneral;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* this is never called, it just exists to have its address
|
||||
* taken in mfbCreateGC.
|
||||
*/
|
||||
static void
|
||||
cfbUnPushPixels (pGC, pBitmap, pDrawable, dx, dy, xOrg, yOrg)
|
||||
GCPtr pGC;
|
||||
PixmapPtr pBitmap;
|
||||
DrawablePtr pDrawable;
|
||||
int dx, dy, xOrg, yOrg;
|
||||
{
|
||||
return;
|
||||
}
|
213
cfb/cfbgetsp.c
213
cfb/cfbgetsp.c
|
@ -1,213 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
|
||||
#include "misc.h"
|
||||
#include "region.h"
|
||||
#include "gc.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
/* GetSpans -- for each span, gets bits from drawable starting at ppt[i]
|
||||
* and continuing for pwidth[i] bits
|
||||
* Each scanline returned will be server scanline padded, i.e., it will come
|
||||
* out to an integral number of words.
|
||||
*/
|
||||
void
|
||||
cfbGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pchardstStart)
|
||||
DrawablePtr pDrawable; /* drawable from which to get bits */
|
||||
int wMax; /* largest value of all *pwidths */
|
||||
register DDXPointPtr ppt; /* points to start copying from */
|
||||
int *pwidth; /* list of number of bits to copy */
|
||||
int nspans; /* number of scanlines to copy */
|
||||
char *pchardstStart; /* where to put the bits */
|
||||
{
|
||||
PixelGroup *pdstStart = (PixelGroup *)pchardstStart;
|
||||
register PixelGroup *pdst; /* where to put the bits */
|
||||
register PixelGroup *psrc; /* where to get the bits */
|
||||
register PixelGroup tmpSrc; /* scratch buffer for bits */
|
||||
PixelGroup *psrcBase; /* start of src bitmap */
|
||||
int widthSrc; /* width of pixmap in bytes */
|
||||
register DDXPointPtr pptLast; /* one past last point to get */
|
||||
int xEnd; /* last pixel to copy from */
|
||||
int nl, srcBit;
|
||||
int w;
|
||||
PixelGroup *pdstNext;
|
||||
#if PSZ == 24
|
||||
register char *psrcb, *pdstb;
|
||||
register int xIndex = 0;
|
||||
#else
|
||||
register int nstart;
|
||||
#if PSZ != 32 || PPW != 1
|
||||
int nend;
|
||||
#endif
|
||||
PixelGroup startmask, endmask;
|
||||
int nlMiddle;
|
||||
#endif
|
||||
|
||||
switch (pDrawable->bitsPerPixel) {
|
||||
case 1:
|
||||
mfbGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pchardstStart);
|
||||
return;
|
||||
case PSZ:
|
||||
break;
|
||||
default:
|
||||
FatalError("cfbGetSpans: invalid depth\n");
|
||||
}
|
||||
|
||||
/*
|
||||
* XFree86 DDX empties the root borderClip when the VT is
|
||||
* switched away; this checks for that case
|
||||
*/
|
||||
if (!cfbDrawableEnabled(pDrawable))
|
||||
return;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, widthSrc, psrcBase)
|
||||
|
||||
#ifdef PIXEL_ADDR
|
||||
# if PSZ != 24
|
||||
if ((nspans == 1) && (*pwidth == 1))
|
||||
{
|
||||
tmpSrc = *((PixelType *)(psrcBase + (ppt->y * widthSrc))
|
||||
+ ppt->x);
|
||||
#if BITMAP_BIT_ORDER == MSBFirst
|
||||
tmpSrc <<= (sizeof (CfbBits) - sizeof (PixelType)) * 8;
|
||||
#endif
|
||||
*pdstStart = tmpSrc;
|
||||
return;
|
||||
}
|
||||
# endif /* PSZ != 24 */
|
||||
#endif
|
||||
pdst = pdstStart;
|
||||
pptLast = ppt + nspans;
|
||||
while(ppt < pptLast)
|
||||
{
|
||||
#if PSZ == 24
|
||||
xEnd = min(ppt->x + *pwidth, widthSrc * sizeof(CfbBits) / 3);
|
||||
w = xEnd - ppt->x;
|
||||
psrc = psrcBase + ppt->y * widthSrc;
|
||||
srcBit = ppt->x;
|
||||
psrcb = (char *)psrc + (ppt->x * 3);
|
||||
xIndex = 0;
|
||||
pdstb = (char *)pdst;
|
||||
pdstNext = pdst + ((w * 3 + 3) >> 2);
|
||||
#else
|
||||
xEnd = min(ppt->x + *pwidth, widthSrc << PWSH);
|
||||
w = xEnd - ppt->x;
|
||||
psrc = psrcBase + ppt->y * widthSrc + (ppt->x >> PWSH);
|
||||
srcBit = ppt->x & PIM;
|
||||
pdstNext = pdst + ((w + PPW - 1) >> PWSH);
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
if (w < 0)
|
||||
FatalError("cfb24GetSpans: Internal error (w < 0)\n");
|
||||
nl = w;
|
||||
while (nl--){
|
||||
psrc = (PixelGroup *)((unsigned long)psrcb & ~0x03);
|
||||
getbits24(psrc, tmpSrc, srcBit);
|
||||
pdst = (PixelGroup *)((unsigned long)pdstb & ~0x03);
|
||||
putbits24(tmpSrc, PPW, pdst, ~((CfbBits)0), xIndex);
|
||||
srcBit++;
|
||||
psrcb += 3;
|
||||
xIndex++;
|
||||
pdstb += 3;
|
||||
}
|
||||
pdst = pdstNext;
|
||||
#else /* PSZ == 24 */
|
||||
if (srcBit + w <= PPW)
|
||||
{
|
||||
getbits(psrc, srcBit, w, tmpSrc);
|
||||
putbits(tmpSrc, 0, w, pdst, ~((CfbBits)0));
|
||||
pdst++;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(ppt->x, w, startmask, endmask, nlMiddle);
|
||||
nstart = 0;
|
||||
if (startmask)
|
||||
{
|
||||
nstart = PPW - srcBit;
|
||||
getbits(psrc, srcBit, nstart, tmpSrc);
|
||||
putbits(tmpSrc, 0, nstart, pdst, ~((CfbBits)0));
|
||||
if(srcBit + nstart >= PPW)
|
||||
psrc++;
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
tmpSrc = *psrc;
|
||||
putbits(tmpSrc, nstart, PPW, pdst, ~((CfbBits)0));
|
||||
psrc++;
|
||||
pdst++;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
#if PSZ != 32 || PPW != 1
|
||||
nend = xEnd & PIM;
|
||||
#endif
|
||||
getbits(psrc, 0, nend, tmpSrc);
|
||||
putbits(tmpSrc, nstart, nend, pdst, ~((CfbBits)0));
|
||||
}
|
||||
pdst = pdstNext;
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
ppt++;
|
||||
pwidth++;
|
||||
}
|
||||
}
|
477
cfb/cfbglblt8.c
477
cfb/cfbglblt8.c
|
@ -1,477 +0,0 @@
|
|||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Poly glyph blt. Accepts an arbitrary font <= 32 bits wide, in Copy mode
|
||||
* only.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
#define BOX_OVERLAP(box1, box2, xoffset, yoffset) \
|
||||
((box1)->x1 <= ((int) (box2)->x2 + (xoffset)) && \
|
||||
((int) (box2)->x1 + (xoffset)) <= (box1)->x2 && \
|
||||
(box1)->y1 <= ((int) (box2)->y2 + (yoffset)) && \
|
||||
((int) (box2)->y1 + (yoffset)) <= (box1)->y2)
|
||||
|
||||
#define BOX_CONTAINS(box1, box2, xoffset, yoffset) \
|
||||
((box1)->x1 <= ((int) (box2)->x1 + (xoffset)) && \
|
||||
((int) (box2)->x2 + (xoffset)) <= (box1)->x2 && \
|
||||
(box1)->y1 <= ((int) (box2)->y1 + (yoffset)) && \
|
||||
((int) (box2)->y2 + (yoffset)) <= (box1)->y2)
|
||||
|
||||
#if defined(FOUR_BIT_CODE) || defined(WriteBitGroup) && !defined(GLYPHROP)
|
||||
|
||||
#if GLYPHPADBYTES != 4
|
||||
#define USE_LEFTBITS
|
||||
#endif
|
||||
|
||||
#ifdef USE_LEFTBITS
|
||||
typedef unsigned char *glyphPointer;
|
||||
|
||||
#define GlyphBits(bits,width,dst) getleftbits(bits,width,dst); \
|
||||
(dst) &= widthMask; \
|
||||
(bits) += widthGlyph;
|
||||
#define GlyphBitsS(bits,width,dst,off) GlyphBits(bits,width,dst); \
|
||||
dst = BitRight (dst, off);
|
||||
#else
|
||||
typedef CARD32 *glyphPointer;
|
||||
|
||||
#define GlyphBits(bits,width,dst) dst = *bits++;
|
||||
#define GlyphBitsS(bits,width,dst,off) dst = BitRight(*bits++, off);
|
||||
#endif
|
||||
|
||||
#ifdef GLYPHROP
|
||||
#define cfbPolyGlyphBlt8 cfbPolyGlyphRop8
|
||||
#define cfbPolyGlyphBlt8Clipped cfbPolyGlyphRop8Clipped
|
||||
|
||||
#undef WriteBitGroup
|
||||
#define WriteBitGroup(dst,pixel,bits) RRopBitGroup(dst,bits)
|
||||
|
||||
#endif
|
||||
|
||||
static void cfbPolyGlyphBlt8Clipped(
|
||||
DrawablePtr pDrawable,
|
||||
GCPtr pGC,
|
||||
int x,
|
||||
int y,
|
||||
unsigned int nglyph,
|
||||
CharInfoPtr *ppci, /* array of character info */
|
||||
unsigned char *pglyphBase); /* start of array of glyphs */
|
||||
|
||||
#if defined(HAS_STIPPLE_CODE) && !defined(GLYPHROP) && !defined(USE_LEFTBITS)
|
||||
#define USE_STIPPLE_CODE
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) && !defined(GLYPHROP) && (defined(mc68020) || defined(mc68000) || defined(__mc68000__)) && PSZ == 8 && !defined(USE_LEFTBITS)
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
#undef USE_STIPPLE_CODE
|
||||
#endif
|
||||
#include "stip68kgnu.h"
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#define DST_INC 3
|
||||
#else
|
||||
#define DST_INC (PGSZB >> PWSH)
|
||||
#endif
|
||||
|
||||
/* cfbStippleStack/cfbStippleStackTE are coded in assembly language.
|
||||
* They are only provided on some architecures.
|
||||
*/
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
extern void cfbStippleStack (), cfbStippleStackTE ();
|
||||
#endif
|
||||
|
||||
void
|
||||
cfbPolyGlyphBlt8 (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int x, y;
|
||||
unsigned int nglyph;
|
||||
CharInfoPtr *ppci; /* array of character info */
|
||||
pointer pglyphBase; /* start of array of glyphs */
|
||||
{
|
||||
#ifndef GLYPHROP
|
||||
register CfbBits pixel;
|
||||
#endif
|
||||
#if !defined(STIPPLE) && !defined(USE_STIPPLE_CODE)
|
||||
register CfbBits c;
|
||||
register CfbBits *dst;
|
||||
#endif
|
||||
register glyphPointer glyphBits;
|
||||
register int xoff;
|
||||
|
||||
FontPtr pfont = pGC->font;
|
||||
CharInfoPtr pci;
|
||||
CfbBits *dstLine;
|
||||
CfbBits *pdstBase;
|
||||
int hTmp;
|
||||
int bwidthDst;
|
||||
int widthDst;
|
||||
int h;
|
||||
BoxRec bbox; /* for clipping */
|
||||
int w;
|
||||
RegionPtr clip;
|
||||
BoxPtr extents;
|
||||
#ifdef USE_LEFTBITS
|
||||
int widthGlyph;
|
||||
CfbBits widthMask;
|
||||
#endif
|
||||
#ifndef STIPPLE
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
void (*stipple)();
|
||||
|
||||
stipple = cfbStippleStack;
|
||||
if (FONTCONSTMETRICS(pfont))
|
||||
stipple = cfbStippleStackTE;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
x += pDrawable->x;
|
||||
y += pDrawable->y;
|
||||
|
||||
/* compute an approximate (but covering) bounding box */
|
||||
bbox.x1 = 0;
|
||||
if ((ppci[0]->metrics.leftSideBearing < 0))
|
||||
bbox.x1 = ppci[0]->metrics.leftSideBearing;
|
||||
h = nglyph - 1;
|
||||
w = ppci[h]->metrics.rightSideBearing;
|
||||
while (--h >= 0)
|
||||
w += ppci[h]->metrics.characterWidth;
|
||||
bbox.x2 = w;
|
||||
bbox.y1 = -FONTMAXBOUNDS(pfont,ascent);
|
||||
bbox.y2 = FONTMAXBOUNDS(pfont,descent);
|
||||
|
||||
clip = cfbGetCompositeClip(pGC);
|
||||
extents = &clip->extents;
|
||||
|
||||
if (!clip->data)
|
||||
{
|
||||
if (!BOX_CONTAINS(extents, &bbox, x, y))
|
||||
{
|
||||
if (BOX_OVERLAP (extents, &bbox, x, y))
|
||||
cfbPolyGlyphBlt8Clipped(pDrawable, pGC, x, y,
|
||||
nglyph, ppci, pglyphBase);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* check to make sure some of the text appears on the screen */
|
||||
if (!BOX_OVERLAP (extents, &bbox, x, y))
|
||||
return;
|
||||
|
||||
bbox.x1 += x;
|
||||
bbox.x2 += x;
|
||||
bbox.y1 += y;
|
||||
bbox.y2 += y;
|
||||
|
||||
switch (RECT_IN_REGION(pGC->pScreen, clip, &bbox))
|
||||
{
|
||||
case rgnPART:
|
||||
cfbPolyGlyphBlt8Clipped(pDrawable, pGC, x, y,
|
||||
nglyph, ppci, pglyphBase);
|
||||
case rgnOUT:
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef GLYPHROP
|
||||
cfb8CheckStipple (pGC->alu, pGC->fgPixel, pGC->planemask);
|
||||
#else
|
||||
pixel = cfbGetGCPrivate(pGC)->xor;
|
||||
#endif
|
||||
|
||||
cfbGetTypedWidthAndPointer (pDrawable, bwidthDst, pdstBase, char, CfbBits)
|
||||
|
||||
widthDst = bwidthDst / PGSZB;
|
||||
while (nglyph--)
|
||||
{
|
||||
pci = *ppci++;
|
||||
glyphBits = (glyphPointer) FONTGLYPHBITS(pglyphBase,pci);
|
||||
xoff = x + pci->metrics.leftSideBearing;
|
||||
#if PSZ == 24
|
||||
dstLine = pdstBase + (y - pci->metrics.ascent) * widthDst +((xoff>> 2)*3);
|
||||
#else
|
||||
dstLine = pdstBase +
|
||||
(y - pci->metrics.ascent) * widthDst + (xoff >> PWSH);
|
||||
#endif
|
||||
x += pci->metrics.characterWidth;
|
||||
if ((hTmp = pci->metrics.descent + pci->metrics.ascent))
|
||||
{
|
||||
#if PSZ == 24
|
||||
xoff &= 0x03;
|
||||
#else
|
||||
xoff &= PIM;
|
||||
#endif /* PSZ == 24 */
|
||||
#ifdef STIPPLE
|
||||
STIPPLE(dstLine,glyphBits,pixel,bwidthDst,hTmp,xoff);
|
||||
#else
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
(*stipple)(dstLine,glyphBits,pixel,bwidthDst,hTmp,xoff);
|
||||
#else
|
||||
#ifdef USE_LEFTBITS
|
||||
w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
|
||||
widthGlyph = PADGLYPHWIDTHBYTES(w);
|
||||
widthMask = mfbGetendtab(w);
|
||||
#endif
|
||||
do {
|
||||
dst = dstLine;
|
||||
dstLine = (CfbBits *) (((char *) dstLine) + bwidthDst);
|
||||
GlyphBits(glyphBits, w, c)
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(BitRight(c,xoff)));
|
||||
dst += DST_INC;
|
||||
c = BitLeft(c,PGSZB - xoff);
|
||||
while (c)
|
||||
{
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst += DST_INC;
|
||||
}
|
||||
} while (--hTmp);
|
||||
#endif /* USE_STIPPLE_CODE else */
|
||||
#endif /* STIPPLE else */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
cfbPolyGlyphBlt8Clipped(
|
||||
DrawablePtr pDrawable,
|
||||
GCPtr pGC,
|
||||
int x,
|
||||
int y,
|
||||
unsigned int nglyph,
|
||||
CharInfoPtr *ppci, /* array of character info */
|
||||
unsigned char *pglyphBase) /* start of array of glyphs */
|
||||
{
|
||||
#ifndef GLYPHROP
|
||||
register CfbBits pixel;
|
||||
#endif
|
||||
#if !defined(STIPPLE) && !defined(USE_STIPPLE_CODE)
|
||||
register CfbBits c;
|
||||
#endif
|
||||
register glyphPointer glyphBits;
|
||||
register int xoff;
|
||||
#if defined(USE_LEFTBITS) || (!defined(STIPPLE) && !defined(USE_STIPPLE_CODE))
|
||||
register CfbBits *dst;
|
||||
#endif
|
||||
|
||||
CharInfoPtr pci;
|
||||
FontPtr pfont = pGC->font;
|
||||
CfbBits *dstLine;
|
||||
CfbBits *pdstBase;
|
||||
#ifdef USE_LEFTBITS
|
||||
CARD32 *cTmp;
|
||||
#endif
|
||||
CARD32 *clips;
|
||||
int maxAscent, maxDescent;
|
||||
int minLeftBearing;
|
||||
int hTmp;
|
||||
int widthDst;
|
||||
int bwidthDst;
|
||||
int xG, yG;
|
||||
BoxPtr pBox;
|
||||
int numRects;
|
||||
int w;
|
||||
RegionPtr pRegion;
|
||||
int yBand;
|
||||
#ifdef GLYPHROP
|
||||
CfbBits bits;
|
||||
#endif
|
||||
#ifdef USE_LEFTBITS
|
||||
int widthGlyph;
|
||||
CfbBits widthMask;
|
||||
#endif
|
||||
|
||||
#ifdef GLYPHROP
|
||||
cfb8CheckStipple (pGC->alu, pGC->fgPixel, pGC->planemask);
|
||||
#else
|
||||
pixel = cfbGetGCPrivate(pGC)->xor;
|
||||
#endif
|
||||
|
||||
cfbGetTypedWidthAndPointer (pDrawable, bwidthDst, pdstBase, char, CfbBits)
|
||||
|
||||
widthDst = bwidthDst / PGSZB;
|
||||
maxAscent = FONTMAXBOUNDS(pfont,ascent);
|
||||
maxDescent = FONTMAXBOUNDS(pfont,descent);
|
||||
minLeftBearing = FONTMINBOUNDS(pfont,leftSideBearing);
|
||||
|
||||
pRegion = cfbGetCompositeClip(pGC);
|
||||
|
||||
pBox = REGION_RECTS(pRegion);
|
||||
numRects = REGION_NUM_RECTS (pRegion);
|
||||
while (numRects && pBox->y2 <= y - maxAscent)
|
||||
{
|
||||
++pBox;
|
||||
--numRects;
|
||||
}
|
||||
if (!numRects || pBox->y1 >= y + maxDescent)
|
||||
return;
|
||||
yBand = pBox->y1;
|
||||
while (numRects && pBox->y1 == yBand && pBox->x2 <= x + minLeftBearing)
|
||||
{
|
||||
++pBox;
|
||||
--numRects;
|
||||
}
|
||||
if (!numRects)
|
||||
return;
|
||||
clips = (CARD32 *)xalloc ((maxAscent + maxDescent) *
|
||||
sizeof (CARD32));
|
||||
while (nglyph--)
|
||||
{
|
||||
pci = *ppci++;
|
||||
glyphBits = (glyphPointer) FONTGLYPHBITS(pglyphBase,pci);
|
||||
w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
|
||||
xG = x + pci->metrics.leftSideBearing;
|
||||
yG = y - pci->metrics.ascent;
|
||||
x += pci->metrics.characterWidth;
|
||||
if ((hTmp = pci->metrics.descent + pci->metrics.ascent))
|
||||
{
|
||||
#if PSZ == 24
|
||||
dstLine = pdstBase + yG * widthDst + ((xG>> 2)*3);
|
||||
/* never use (xG*3)>>2 */
|
||||
#else
|
||||
dstLine = pdstBase + yG * widthDst + (xG >> PWSH);
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
xoff = xG & 3;
|
||||
#else
|
||||
xoff = xG & PIM;
|
||||
#endif
|
||||
#ifdef USE_LEFTBITS
|
||||
w = pci->metrics.rightSideBearing - pci->metrics.leftSideBearing;
|
||||
widthGlyph = PADGLYPHWIDTHBYTES(w);
|
||||
widthMask = mfbGetendtab(w);
|
||||
#endif
|
||||
switch (cfb8ComputeClipMasks32 (pBox, numRects, xG, yG, w, hTmp, clips))
|
||||
{
|
||||
case rgnPART:
|
||||
#ifdef USE_LEFTBITS
|
||||
cTmp = clips;
|
||||
do {
|
||||
dst = dstLine;
|
||||
dstLine = (CfbBits *) (((char *) dstLine) + bwidthDst);
|
||||
GlyphBits(glyphBits, w, c)
|
||||
c &= *cTmp++;
|
||||
if (c)
|
||||
{
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(BitRight(c,xoff)));
|
||||
c = BitLeft(c,PGSZB - xoff);
|
||||
dst += DST_INC;
|
||||
while (c)
|
||||
{
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst += DST_INC;
|
||||
}
|
||||
}
|
||||
} while (--hTmp);
|
||||
break;
|
||||
#else /* !USE_LEFTBITS */
|
||||
{
|
||||
int h;
|
||||
|
||||
h = hTmp;
|
||||
do
|
||||
{
|
||||
--h;
|
||||
clips[h] = clips[h] & glyphBits[h];
|
||||
} while (h);
|
||||
}
|
||||
glyphBits = clips;
|
||||
/* fall through */
|
||||
#endif /* USE_LEFTBITS */
|
||||
case rgnIN:
|
||||
#ifdef STIPPLE
|
||||
STIPPLE(dstLine,glyphBits,pixel,bwidthDst,hTmp,xoff);
|
||||
#else
|
||||
#ifdef USE_STIPPLE_CODE
|
||||
cfbStippleStackTE(dstLine,glyphBits,pixel,bwidthDst,hTmp,xoff);
|
||||
#else
|
||||
do {
|
||||
dst = dstLine;
|
||||
dstLine = (CfbBits *) (((char *) dstLine) + bwidthDst);
|
||||
GlyphBits(glyphBits, w, c)
|
||||
if (c)
|
||||
{
|
||||
/* This code originally could read memory locations
|
||||
* that were not mapped. Hence we have to check the
|
||||
* trailing bits to see whether they are zero and if
|
||||
* then skip them correctly. This is no problem for
|
||||
* the GXcopy case, since there only the pixels that
|
||||
* are non-zero are written ...
|
||||
*/
|
||||
#ifndef GLYPHROP
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(BitRight(c,xoff)));
|
||||
c = BitLeft(c,PGSZB - xoff);
|
||||
dst += DST_INC;
|
||||
#else /* GLYPHROP */
|
||||
if ((bits = GetBitGroup(BitRight(c,xoff))))
|
||||
WriteBitGroup(dst, pixel, bits);
|
||||
c = BitLeft(c,PGSZB - xoff);
|
||||
dst += DST_INC;
|
||||
|
||||
while (c && ((bits = GetBitGroup(c)) == 0))
|
||||
{
|
||||
NextBitGroup(c);
|
||||
dst += DST_INC;
|
||||
}
|
||||
#endif /* GLYPHROP */
|
||||
while (c)
|
||||
{
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst += DST_INC;
|
||||
}
|
||||
}
|
||||
} while (--hTmp);
|
||||
#endif /* USE_STIPPLE_CODE else */
|
||||
#endif /* STIPPLE else */
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
xfree (clips);
|
||||
}
|
||||
|
||||
#endif /* FOUR_BIT_CODE */
|
554
cfb/cfbhrzvert.c
554
cfb/cfbhrzvert.c
|
@ -1,554 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987,1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "gc.h"
|
||||
#include "window.h"
|
||||
#include "pixmap.h"
|
||||
#include "region.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
/* horizontal solid line
|
||||
abs(len) > 1
|
||||
*/
|
||||
void
|
||||
cfbHorzS(rop, and, xor, addrl, nlwidth, x1, y1, len)
|
||||
register int rop;
|
||||
register CfbBits and;
|
||||
register CfbBits xor;
|
||||
register CfbBits *addrl; /* pointer to base of bitmap */
|
||||
int nlwidth; /* width in longwords of bitmap */
|
||||
int x1; /* initial point */
|
||||
int y1;
|
||||
int len; /* length of line */
|
||||
{
|
||||
register int nlmiddle;
|
||||
|
||||
#if PSZ == 24
|
||||
|
||||
int leftIndex, rightIndex;
|
||||
CfbBits piQxelAnd[3], piQxelXor[3];
|
||||
piQxelAnd[0] = (and & 0xFFFFFF) | ((and<<24) & 0xFF000000);
|
||||
piQxelAnd[1] = ((and>>8) & 0xFFFF)| ((and<<16) & 0xFFFF0000);
|
||||
piQxelAnd[2] = ((and<<8) & 0xFFFFFF00) | ((and>>16) & 0xFF);
|
||||
|
||||
piQxelXor[0] = (xor & 0xFFFFFF) | ((xor<<24) & 0xFF000000);
|
||||
piQxelXor[1] = ((xor>>8) & 0xFFFF)| ((xor<<16) & 0xFFFF0000);
|
||||
piQxelXor[2] = ((xor<<8) & 0xFFFFFF00) | ((xor>>16) & 0xFF);
|
||||
|
||||
leftIndex = x1 & 3;
|
||||
rightIndex = ((x1 + len) < 5)?0:(x1 + len)&3;
|
||||
nlmiddle = len;
|
||||
if(leftIndex){
|
||||
nlmiddle -= (4 - leftIndex);
|
||||
}
|
||||
if(rightIndex){
|
||||
nlmiddle -= rightIndex;
|
||||
}
|
||||
if (nlmiddle < 0)
|
||||
nlmiddle = 0;
|
||||
|
||||
nlmiddle >>= 2;
|
||||
|
||||
addrl += (y1 * nlwidth) + (x1 >> 2)*3 + (leftIndex?leftIndex-1:0);
|
||||
|
||||
switch(leftIndex+len){
|
||||
case 4:
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
break;
|
||||
case 1:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
break;
|
||||
case 2:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
break;
|
||||
case 3:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
|
||||
break;
|
||||
case 1:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
|
||||
break;
|
||||
case 2:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
if(leftIndex){
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
|
||||
addrl++;
|
||||
}
|
||||
else{
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
}
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF);
|
||||
break;
|
||||
case 1: /*only if leftIndex = 0 and w = 1*/
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
|
||||
break;
|
||||
case 0: /*never*/
|
||||
break;
|
||||
default:
|
||||
{
|
||||
if (rop == GXcopy){
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl = ((*addrl) & 0xFFFFFF) | (piQxelXor[0] & 0xFF000000);
|
||||
addrl++;
|
||||
*addrl++ = piQxelXor[1];
|
||||
*addrl++ = piQxelXor[2];
|
||||
break;
|
||||
case 2:
|
||||
*addrl = ((*addrl) & 0xFFFF) | (piQxelXor[1] & 0xFFFF0000);
|
||||
addrl++;
|
||||
*addrl++ = piQxelXor[2];
|
||||
break;
|
||||
case 3:
|
||||
*addrl = ((*addrl) & 0xFF) | (piQxelXor[2] & 0xFFFFFF00);
|
||||
addrl++;
|
||||
break;
|
||||
}
|
||||
while(nlmiddle--){
|
||||
*addrl++ = piQxelXor[0];
|
||||
*addrl++ = piQxelXor[1];
|
||||
*addrl++ = piQxelXor[2];
|
||||
}
|
||||
switch(rightIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl = ((*addrl) & 0xFF000000) | (piQxelXor[0] & 0xFFFFFF);
|
||||
break;
|
||||
case 2:
|
||||
*addrl++ = piQxelXor[0];
|
||||
*addrl = ((*addrl) & 0xFFFF0000) | (piQxelXor[1] & 0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
*addrl++ = piQxelXor[0];
|
||||
*addrl++ = piQxelXor[1];
|
||||
*addrl = ((*addrl) & 0xFFFFFF00) | (piQxelXor[2] & 0xFF);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else{
|
||||
if(rop == GXxor){
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl++ ^= (piQxelXor[0]&0xFF000000);
|
||||
*addrl++ ^= piQxelXor[1];
|
||||
*addrl++ ^= piQxelXor[2];
|
||||
break;
|
||||
case 2:
|
||||
*addrl++ ^= (piQxelXor[1]& 0xFFFF0000);
|
||||
*addrl++ ^= piQxelXor[2];
|
||||
break;
|
||||
case 3:
|
||||
*addrl++ ^= (piQxelXor[2]& 0xFFFFFF00);
|
||||
break;
|
||||
}
|
||||
while(nlmiddle--){
|
||||
*addrl++ ^= piQxelXor[0];
|
||||
*addrl++ ^= piQxelXor[1];
|
||||
*addrl++ ^= piQxelXor[2];
|
||||
}
|
||||
switch(rightIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl ^= (piQxelXor[0]& 0xFFFFFF);
|
||||
break;
|
||||
case 2:
|
||||
*addrl++ ^= piQxelXor[0];
|
||||
*addrl ^= (piQxelXor[1]&0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
*addrl++ ^= piQxelXor[0];
|
||||
*addrl++ ^= piQxelXor[1];
|
||||
*addrl ^= (piQxelXor[2]&0xFF);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else{
|
||||
switch(leftIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFF000000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
addrl++;
|
||||
break;
|
||||
case 2:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF0000);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
addrl++;
|
||||
break;
|
||||
case 3:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFFFFFF00);
|
||||
addrl++;
|
||||
break;
|
||||
}
|
||||
while(nlmiddle--){
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[2], piQxelXor[2]);
|
||||
addrl++;
|
||||
}
|
||||
switch(rightIndex){
|
||||
case 0:
|
||||
break;
|
||||
case 1:
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[0], piQxelXor[0], 0xFFFFFF);
|
||||
addrl++;
|
||||
break;
|
||||
case 2:
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[1], piQxelXor[1], 0xFFFF);
|
||||
break;
|
||||
case 3:
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[0], piQxelXor[0]);
|
||||
addrl++;
|
||||
*addrl = DoRRop (*addrl, piQxelAnd[1], piQxelXor[1]);
|
||||
addrl++;
|
||||
*addrl = DoMaskRRop (*addrl, piQxelAnd[2], piQxelXor[2], 0xFF);
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#else
|
||||
register CfbBits startmask;
|
||||
register CfbBits endmask;
|
||||
|
||||
addrl = addrl + (y1 * nlwidth) + (x1 >> PWSH);
|
||||
|
||||
/* all bits inside same longword */
|
||||
if ( ((x1 & PIM) + len) < PPW)
|
||||
{
|
||||
maskpartialbits(x1, len, startmask);
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, startmask);
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(x1, len, startmask, endmask, nlmiddle);
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
if (startmask)
|
||||
{
|
||||
*addrl = (*addrl & ~startmask) | (xor & startmask);
|
||||
addrl++;
|
||||
}
|
||||
while (nlmiddle--)
|
||||
*addrl++ = xor;
|
||||
if (endmask)
|
||||
*addrl = (*addrl & ~endmask) | (xor & endmask);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (startmask)
|
||||
{
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, startmask);
|
||||
addrl++;
|
||||
}
|
||||
if (rop == GXxor)
|
||||
{
|
||||
while (nlmiddle--)
|
||||
*addrl++ ^= xor;
|
||||
}
|
||||
else
|
||||
{
|
||||
while (nlmiddle--)
|
||||
{
|
||||
*addrl = DoRRop (*addrl, and, xor);
|
||||
addrl++;
|
||||
}
|
||||
}
|
||||
if (endmask)
|
||||
*addrl = DoMaskRRop (*addrl, and, xor, endmask);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/* vertical solid line */
|
||||
|
||||
void
|
||||
cfbVertS(rop, and, xor, addrl, nlwidth, x1, y1, len)
|
||||
int rop;
|
||||
register CfbBits and, xor;
|
||||
register CfbBits *addrl; /* pointer to base of bitmap */
|
||||
register int nlwidth; /* width in longwords of bitmap */
|
||||
int x1, y1; /* initial point */
|
||||
register int len; /* length of line */
|
||||
{
|
||||
#if PSZ == 24
|
||||
int xIdx;
|
||||
CfbBits and2 = 0, xor2 = 0, mask = 0, mask2;
|
||||
#endif
|
||||
#ifdef PIXEL_ADDR
|
||||
register PixelType *bits = (PixelType *) addrl;
|
||||
|
||||
#if PSZ == 24
|
||||
nlwidth <<= PWSH;
|
||||
xIdx = x1 & 3;
|
||||
bits = (PixelType *)(addrl + (y1 * nlwidth) + ((x1*3) >> 2));
|
||||
#else
|
||||
nlwidth <<= PWSH;
|
||||
bits = bits + (y1 * nlwidth) + x1;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
mask2 = 0;
|
||||
switch(xIdx){
|
||||
case 0:
|
||||
mask = 0xFF000000;
|
||||
xor &= 0xFFFFFF;
|
||||
and |= 0xFF000000;
|
||||
break;
|
||||
case 3:
|
||||
mask = 0xFF;
|
||||
xor &= 0xFFFFFF;
|
||||
xor <<= 8;
|
||||
and <<= 8;
|
||||
and |= 0xFF;
|
||||
break;
|
||||
case 1:
|
||||
mask = 0xFFFFFF;
|
||||
mask2 = 0xFFFF0000;
|
||||
xor2 = (xor>>8) & 0xFFFF;
|
||||
xor &= 0xFF;
|
||||
xor <<= 24;
|
||||
and2 = (and >> 8 ) | 0xFFFF0000;
|
||||
and <<= 24;
|
||||
and |= 0xFFFFFF;
|
||||
break;
|
||||
case 2:
|
||||
mask = 0x0000FFFF;
|
||||
mask2 = 0xFFFFFF00;
|
||||
xor2 = (xor >> 16) & 0xFF;
|
||||
xor <<= 16;
|
||||
xor &= 0xFFFF0000;
|
||||
and2 = (and >> 16) | 0xFFFFFF00;
|
||||
and <<= 16;
|
||||
and |= 0xFFFF;
|
||||
break;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* special case copy and xor to avoid a test per pixel
|
||||
*/
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
#if PSZ == 24
|
||||
switch(xIdx){
|
||||
case 0:
|
||||
case 3:
|
||||
while (len--){
|
||||
*bits = (*bits & mask)| xor;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
while (len--){
|
||||
*bits = (*bits & mask)| xor;
|
||||
bits++;
|
||||
*bits = (*bits & mask2)| xor2;
|
||||
bits--;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
}
|
||||
#else
|
||||
while (len--)
|
||||
{
|
||||
*bits = xor;
|
||||
bits += nlwidth;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else if (rop == GXxor)
|
||||
{
|
||||
#if PSZ == 24
|
||||
switch(xIdx){
|
||||
case 0:
|
||||
case 3:
|
||||
while (len--){
|
||||
*bits ^= xor;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
case 2:
|
||||
while (len--){
|
||||
*bits ^= xor;
|
||||
bits++;
|
||||
*bits ^= xor2;
|
||||
bits--;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
}
|
||||
#else
|
||||
while (len--)
|
||||
{
|
||||
*bits ^= xor;
|
||||
bits += nlwidth;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
#if PSZ == 24
|
||||
switch(xIdx){
|
||||
case 0:
|
||||
while (len--){
|
||||
*bits = DoMaskRRop(*bits, and, xor, 0x00FFFFFF);
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
while (len--){
|
||||
*bits = DoMaskRRop(*bits, and, xor, 0xFFFFFF00);
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 1:
|
||||
while (len--){
|
||||
*bits = DoMaskRRop(*bits, and, xor, 0xFF000000);
|
||||
bits++;
|
||||
*bits = DoMaskRRop(*bits, and2, xor2, 0x0000FFFF);
|
||||
bits--;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
case 2:
|
||||
while (len--){
|
||||
*bits = DoMaskRRop(*bits, and, xor, 0xFFFF0000);
|
||||
bits++;
|
||||
*bits = DoMaskRRop(*bits, and2, xor2, 0x000000FF);
|
||||
bits--;
|
||||
bits += nlwidth;
|
||||
}
|
||||
break;
|
||||
}
|
||||
#else
|
||||
while (len--)
|
||||
{
|
||||
*bits = DoRRop(*bits, and, xor);
|
||||
bits += nlwidth;
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#else /* !PIXEL_ADDR */
|
||||
#if PSZ == 24
|
||||
addrl = addrl + (y1 * nlwidth) + ((x1*3) >>2);
|
||||
|
||||
and |= ~cfbmask[(x1 & 3)<<1];
|
||||
xor &= cfbmask[(x1 & 3)<<1];
|
||||
#else
|
||||
addrl = addrl + (y1 * nlwidth) + (x1 >> PWSH);
|
||||
|
||||
and |= ~cfbmask[x1 & PIM];
|
||||
xor &= cfbmask[x1 & PIM];
|
||||
#endif
|
||||
|
||||
while (len--)
|
||||
{
|
||||
*addrl = DoRRop (*addrl, and, xor);
|
||||
addrl += nlwidth;
|
||||
}
|
||||
#endif
|
||||
}
|
106
cfb/cfbigblt8.c
106
cfb/cfbigblt8.c
|
@ -1,106 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "mi.h"
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
void
|
||||
cfbImageGlyphBlt8 (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int x, y;
|
||||
unsigned int nglyph;
|
||||
CharInfoPtr *ppci;
|
||||
pointer pglyphBase;
|
||||
{
|
||||
ExtentInfoRec info; /* used by QueryGlyphExtents() */
|
||||
xRectangle backrect;
|
||||
int fgPixel;
|
||||
cfbPrivGC *priv;
|
||||
|
||||
/*
|
||||
* We can't avoid GC validations if calling mi functions.
|
||||
*/
|
||||
if ((pGC->ops->PolyFillRect == miPolyFillRect) ||
|
||||
(pGC->ops->PolyGlyphBlt == miPolyGlyphBlt))
|
||||
{
|
||||
miImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
|
||||
return;
|
||||
}
|
||||
|
||||
QueryGlyphExtents(pGC->font, ppci, (unsigned long)nglyph, &info);
|
||||
|
||||
if (info.overallWidth >= 0)
|
||||
{
|
||||
backrect.x = x;
|
||||
backrect.width = info.overallWidth;
|
||||
}
|
||||
else
|
||||
{
|
||||
backrect.x = x + info.overallWidth;
|
||||
backrect.width = -info.overallWidth;
|
||||
}
|
||||
backrect.y = y - FONTASCENT(pGC->font);
|
||||
backrect.height = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font);
|
||||
|
||||
priv = cfbGetGCPrivate(pGC);
|
||||
|
||||
/* this code cheats by knowing that ValidateGC isn't
|
||||
* necessary for PolyFillRect
|
||||
*/
|
||||
|
||||
fgPixel = pGC->fgPixel;
|
||||
|
||||
pGC->fgPixel = pGC->bgPixel;
|
||||
priv->xor = PFILL(pGC->bgPixel);
|
||||
|
||||
(*pGC->ops->PolyFillRect) (pDrawable, pGC, 1, &backrect);
|
||||
|
||||
pGC->fgPixel = fgPixel;
|
||||
|
||||
priv->xor = PFILL(pGC->fgPixel);
|
||||
|
||||
(*pGC->ops->PolyGlyphBlt) (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
|
||||
|
||||
}
|
206
cfb/cfbimage.c
206
cfb/cfbimage.c
|
@ -1,206 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "servermd.h"
|
||||
#include "mi.h"
|
||||
|
||||
void
|
||||
cfbPutImage(pDraw, pGC, depth, x, y, w, h, leftPad, format, pImage)
|
||||
DrawablePtr pDraw;
|
||||
GCPtr pGC;
|
||||
int depth, x, y, w, h;
|
||||
int leftPad;
|
||||
int format;
|
||||
char *pImage;
|
||||
{
|
||||
PixmapPtr pPixmap;
|
||||
|
||||
if ((w == 0) || (h == 0))
|
||||
return;
|
||||
|
||||
if (format != XYPixmap)
|
||||
{
|
||||
pPixmap = GetScratchPixmapHeader(pDraw->pScreen, w+leftPad, h, depth,
|
||||
BitsPerPixel(depth), PixmapBytePad(w+leftPad, depth),
|
||||
(pointer)pImage);
|
||||
if (!pPixmap)
|
||||
return;
|
||||
|
||||
pGC->fExpose = FALSE;
|
||||
if (format == ZPixmap)
|
||||
(void)(*pGC->ops->CopyArea)((DrawablePtr)pPixmap, pDraw, pGC,
|
||||
leftPad, 0, w, h, x, y);
|
||||
else
|
||||
(void)(*pGC->ops->CopyPlane)((DrawablePtr)pPixmap, pDraw, pGC,
|
||||
leftPad, 0, w, h, x, y, 1);
|
||||
pGC->fExpose = TRUE;
|
||||
FreeScratchPixmapHeader(pPixmap);
|
||||
}
|
||||
else
|
||||
{
|
||||
CfbBits oldFg, oldBg;
|
||||
XID gcv[3];
|
||||
CfbBits oldPlanemask;
|
||||
unsigned long i;
|
||||
long bytesPer;
|
||||
|
||||
depth = pGC->depth;
|
||||
oldPlanemask = pGC->planemask;
|
||||
oldFg = pGC->fgPixel;
|
||||
oldBg = pGC->bgPixel;
|
||||
gcv[0] = ~0L;
|
||||
gcv[1] = 0;
|
||||
DoChangeGC(pGC, GCForeground | GCBackground, gcv, 0);
|
||||
bytesPer = (long)h * BitmapBytePad(w + leftPad);
|
||||
|
||||
for (i = 1 << (depth-1); i != 0; i >>= 1, pImage += bytesPer)
|
||||
{
|
||||
if (i & oldPlanemask)
|
||||
{
|
||||
gcv[0] = i;
|
||||
DoChangeGC(pGC, GCPlaneMask, gcv, 0);
|
||||
ValidateGC(pDraw, pGC);
|
||||
(*pGC->ops->PutImage)(pDraw, pGC, 1, x, y, w, h, leftPad,
|
||||
XYBitmap, pImage);
|
||||
}
|
||||
}
|
||||
gcv[0] = oldPlanemask;
|
||||
gcv[1] = oldFg;
|
||||
gcv[2] = oldBg;
|
||||
DoChangeGC(pGC, GCPlaneMask | GCForeground | GCBackground, gcv, 0);
|
||||
ValidateGC(pDraw, pGC);
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
cfbGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine)
|
||||
DrawablePtr pDrawable;
|
||||
int sx, sy, w, h;
|
||||
unsigned int format;
|
||||
unsigned long planeMask;
|
||||
char *pdstLine;
|
||||
{
|
||||
BoxRec box;
|
||||
DDXPointRec ptSrc;
|
||||
RegionRec rgnDst;
|
||||
ScreenPtr pScreen;
|
||||
PixmapPtr pPixmap;
|
||||
|
||||
if ((w == 0) || (h == 0))
|
||||
return;
|
||||
if (pDrawable->bitsPerPixel == 1)
|
||||
{
|
||||
mfbGetImage(pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
|
||||
return;
|
||||
}
|
||||
pScreen = pDrawable->pScreen;
|
||||
/*
|
||||
* XFree86 DDX empties the root borderClip when the VT is
|
||||
* switched away; this checks for that case
|
||||
*/
|
||||
if (!cfbDrawableEnabled (pDrawable))
|
||||
return;
|
||||
if (format == ZPixmap)
|
||||
{
|
||||
pPixmap = GetScratchPixmapHeader(pScreen, w, h,
|
||||
pDrawable->depth, pDrawable->bitsPerPixel,
|
||||
PixmapBytePad(w,pDrawable->depth), (pointer)pdstLine);
|
||||
if (!pPixmap)
|
||||
return;
|
||||
if ((planeMask & PMSK) != PMSK)
|
||||
bzero((char *)pdstLine, pPixmap->devKind * h);
|
||||
ptSrc.x = sx + pDrawable->x;
|
||||
ptSrc.y = sy + pDrawable->y;
|
||||
box.x1 = 0;
|
||||
box.y1 = 0;
|
||||
box.x2 = w;
|
||||
box.y2 = h;
|
||||
REGION_INIT(pScreen, &rgnDst, &box, 1);
|
||||
cfbDoBitblt(pDrawable, (DrawablePtr)pPixmap, GXcopy, &rgnDst,
|
||||
&ptSrc, planeMask);
|
||||
REGION_UNINIT(pScreen, &rgnDst);
|
||||
FreeScratchPixmapHeader(pPixmap);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
#if IMAGE_BYTE_ORDER == LSBFirst
|
||||
|
||||
pPixmap = GetScratchPixmapHeader(pScreen, w, h, /*depth*/ 1,
|
||||
/*bpp*/ 1, BitmapBytePad(w), (pointer)pdstLine);
|
||||
if (!pPixmap)
|
||||
return;
|
||||
|
||||
ptSrc.x = sx + pDrawable->x;
|
||||
ptSrc.y = sy + pDrawable->y;
|
||||
box.x1 = 0;
|
||||
box.y1 = 0;
|
||||
box.x2 = w;
|
||||
box.y2 = h;
|
||||
REGION_INIT(pScreen, &rgnDst, &box, 1);
|
||||
cfbCopyImagePlane (pDrawable, (DrawablePtr)pPixmap, GXcopy, &rgnDst,
|
||||
&ptSrc, planeMask);
|
||||
REGION_UNINIT(pScreen, &rgnDst);
|
||||
FreeScratchPixmapHeader(pPixmap);
|
||||
#else
|
||||
miGetImage (pDrawable, sx, sy, w, h, format, planeMask, pdstLine);
|
||||
#endif
|
||||
}
|
||||
}
|
756
cfb/cfbline.c
756
cfb/cfbline.c
|
@ -1,756 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "mistruct.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "miline.h"
|
||||
|
||||
/* single-pixel lines on a color frame buffer
|
||||
|
||||
NON-SLOPED LINES
|
||||
horizontal lines are always drawn left to right; we have to
|
||||
move the endpoints right by one after they're swapped.
|
||||
horizontal lines will be confined to a single band of a
|
||||
region. the code finds that band (giving up if the lower
|
||||
bound of the band is above the line we're drawing); then it
|
||||
finds the first box in that band that contains part of the
|
||||
line. we clip the line to subsequent boxes in that band.
|
||||
vertical lines are always drawn top to bottom (y-increasing.)
|
||||
this requires adding one to the y-coordinate of each endpoint
|
||||
after swapping.
|
||||
|
||||
SLOPED LINES
|
||||
when clipping a sloped line, we bring the second point inside
|
||||
the clipping box, rather than one beyond it, and then add 1 to
|
||||
the length of the line before drawing it. this lets us use
|
||||
the same box for finding the outcodes for both endpoints. since
|
||||
the equation for clipping the second endpoint to an edge gives us
|
||||
1 beyond the edge, we then have to move the point towards the
|
||||
first point by one step on the major axis.
|
||||
eventually, there will be a diagram here to explain what's going
|
||||
on. the method uses Cohen-Sutherland outcodes to determine
|
||||
outsideness, and a method similar to Pike's layers for doing the
|
||||
actual clipping.
|
||||
|
||||
*/
|
||||
|
||||
void
|
||||
#ifdef POLYSEGMENT
|
||||
cfbSegmentSS (pDrawable, pGC, nseg, pSeg)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nseg;
|
||||
register xSegment *pSeg;
|
||||
#else
|
||||
cfbLineSS (pDrawable, pGC, mode, npt, pptInit)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int mode; /* Origin or Previous */
|
||||
int npt; /* number of points */
|
||||
DDXPointPtr pptInit;
|
||||
#endif
|
||||
{
|
||||
int nboxInit;
|
||||
register int nbox;
|
||||
BoxPtr pboxInit;
|
||||
register BoxPtr pbox;
|
||||
#ifndef POLYSEGMENT
|
||||
register DDXPointPtr ppt; /* pointer to list of translated points */
|
||||
#endif
|
||||
|
||||
unsigned int oc1; /* outcode of point 1 */
|
||||
unsigned int oc2; /* outcode of point 2 */
|
||||
|
||||
CfbBits *addrl; /* address of destination pixmap */
|
||||
int nlwidth; /* width in longwords of destination pixmap */
|
||||
int xorg, yorg; /* origin of window */
|
||||
|
||||
int adx; /* abs values of dx and dy */
|
||||
int ady;
|
||||
int signdx; /* sign of dx and dy */
|
||||
int signdy;
|
||||
int e, e1, e2; /* bresenham error and increments */
|
||||
int len; /* length of segment */
|
||||
int axis; /* major axis */
|
||||
int octant;
|
||||
unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
|
||||
|
||||
/* a bunch of temporaries */
|
||||
int tmp;
|
||||
register int y1, y2;
|
||||
register int x1, x2;
|
||||
RegionPtr cclip;
|
||||
cfbPrivGCPtr devPriv;
|
||||
CfbBits xor, and;
|
||||
int alu;
|
||||
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
cclip = pGC->pCompositeClip;
|
||||
pboxInit = REGION_RECTS(cclip);
|
||||
nboxInit = REGION_NUM_RECTS(cclip);
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwidth, addrl)
|
||||
|
||||
alu = devPriv->rop;
|
||||
xor = devPriv->xor;
|
||||
and = devPriv->and;
|
||||
xorg = pDrawable->x;
|
||||
yorg = pDrawable->y;
|
||||
#ifdef POLYSEGMENT
|
||||
while (nseg--)
|
||||
#else
|
||||
ppt = pptInit;
|
||||
x2 = ppt->x + xorg;
|
||||
y2 = ppt->y + yorg;
|
||||
while(--npt)
|
||||
#endif
|
||||
{
|
||||
nbox = nboxInit;
|
||||
pbox = pboxInit;
|
||||
|
||||
#ifdef POLYSEGMENT
|
||||
x1 = pSeg->x1 + xorg;
|
||||
y1 = pSeg->y1 + yorg;
|
||||
x2 = pSeg->x2 + xorg;
|
||||
y2 = pSeg->y2 + yorg;
|
||||
pSeg++;
|
||||
#else
|
||||
x1 = x2;
|
||||
y1 = y2;
|
||||
++ppt;
|
||||
if (mode == CoordModePrevious)
|
||||
{
|
||||
xorg = x1;
|
||||
yorg = y1;
|
||||
}
|
||||
x2 = ppt->x + xorg;
|
||||
y2 = ppt->y + yorg;
|
||||
#endif
|
||||
|
||||
if (x1 == x2) /* vertical line */
|
||||
{
|
||||
/* make the line go top to bottom of screen, keeping
|
||||
endpoint semantics
|
||||
*/
|
||||
if (y1 > y2)
|
||||
{
|
||||
register int tmp;
|
||||
|
||||
tmp = y2;
|
||||
y2 = y1 + 1;
|
||||
y1 = tmp + 1;
|
||||
#ifdef POLYSEGMENT
|
||||
if (pGC->capStyle != CapNotLast)
|
||||
y1--;
|
||||
#endif
|
||||
}
|
||||
#ifdef POLYSEGMENT
|
||||
else if (pGC->capStyle != CapNotLast)
|
||||
y2++;
|
||||
#endif
|
||||
/* get to first band that might contain part of line */
|
||||
while ((nbox) && (pbox->y2 <= y1))
|
||||
{
|
||||
pbox++;
|
||||
nbox--;
|
||||
}
|
||||
|
||||
if (nbox)
|
||||
{
|
||||
/* stop when lower edge of box is beyond end of line */
|
||||
while((nbox) && (y2 >= pbox->y1))
|
||||
{
|
||||
if ((x1 >= pbox->x1) && (x1 < pbox->x2))
|
||||
{
|
||||
int y1t, y2t;
|
||||
/* this box has part of the line in it */
|
||||
y1t = max(y1, pbox->y1);
|
||||
y2t = min(y2, pbox->y2);
|
||||
if (y1t != y2t)
|
||||
{
|
||||
cfbVertS (alu, and, xor,
|
||||
addrl, nlwidth,
|
||||
x1, y1t, y2t-y1t);
|
||||
}
|
||||
}
|
||||
nbox--;
|
||||
pbox++;
|
||||
}
|
||||
}
|
||||
#ifndef POLYSEGMENT
|
||||
y2 = ppt->y + yorg;
|
||||
#endif
|
||||
}
|
||||
else if (y1 == y2) /* horizontal line */
|
||||
{
|
||||
/* force line from left to right, keeping
|
||||
endpoint semantics
|
||||
*/
|
||||
if (x1 > x2)
|
||||
{
|
||||
register int tmp;
|
||||
|
||||
tmp = x2;
|
||||
x2 = x1 + 1;
|
||||
x1 = tmp + 1;
|
||||
#ifdef POLYSEGMENT
|
||||
if (pGC->capStyle != CapNotLast)
|
||||
x1--;
|
||||
#endif
|
||||
}
|
||||
#ifdef POLYSEGMENT
|
||||
else if (pGC->capStyle != CapNotLast)
|
||||
x2++;
|
||||
#endif
|
||||
|
||||
/* find the correct band */
|
||||
while( (nbox) && (pbox->y2 <= y1))
|
||||
{
|
||||
pbox++;
|
||||
nbox--;
|
||||
}
|
||||
|
||||
/* try to draw the line, if we haven't gone beyond it */
|
||||
if ((nbox) && (pbox->y1 <= y1))
|
||||
{
|
||||
/* when we leave this band, we're done */
|
||||
tmp = pbox->y1;
|
||||
while((nbox) && (pbox->y1 == tmp))
|
||||
{
|
||||
int x1t, x2t;
|
||||
|
||||
if (pbox->x2 <= x1)
|
||||
{
|
||||
/* skip boxes until one might contain start point */
|
||||
nbox--;
|
||||
pbox++;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* stop if left of box is beyond right of line */
|
||||
if (pbox->x1 >= x2)
|
||||
{
|
||||
nbox = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
x1t = max(x1, pbox->x1);
|
||||
x2t = min(x2, pbox->x2);
|
||||
if (x1t != x2t)
|
||||
{
|
||||
cfbHorzS (alu, and, xor,
|
||||
addrl, nlwidth,
|
||||
x1t, y1, x2t-x1t);
|
||||
}
|
||||
nbox--;
|
||||
pbox++;
|
||||
}
|
||||
}
|
||||
#ifndef POLYSEGMENT
|
||||
x2 = ppt->x + xorg;
|
||||
#endif
|
||||
}
|
||||
else /* sloped line */
|
||||
{
|
||||
CalcLineDeltas(x1, y1, x2, y2, adx, ady, signdx, signdy,
|
||||
1, 1, octant);
|
||||
|
||||
if (adx > ady)
|
||||
{
|
||||
axis = X_AXIS;
|
||||
e1 = ady << 1;
|
||||
e2 = e1 - (adx << 1);
|
||||
e = e1 - adx;
|
||||
}
|
||||
else
|
||||
{
|
||||
axis = Y_AXIS;
|
||||
e1 = adx << 1;
|
||||
e2 = e1 - (ady << 1);
|
||||
e = e1 - ady;
|
||||
SetYMajorOctant(octant);
|
||||
}
|
||||
|
||||
FIXUP_ERROR(e, octant, bias);
|
||||
|
||||
/* we have bresenham parameters and two points.
|
||||
all we have to do now is clip and draw.
|
||||
*/
|
||||
|
||||
while(nbox--)
|
||||
{
|
||||
oc1 = 0;
|
||||
oc2 = 0;
|
||||
OUTCODES(oc1, x1, y1, pbox);
|
||||
OUTCODES(oc2, x2, y2, pbox);
|
||||
if ((oc1 | oc2) == 0)
|
||||
{
|
||||
if (axis == X_AXIS)
|
||||
len = adx;
|
||||
else
|
||||
len = ady;
|
||||
#ifdef POLYSEGMENT
|
||||
if (pGC->capStyle != CapNotLast)
|
||||
len++;
|
||||
#endif
|
||||
cfbBresS (alu, and, xor,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, x1, y1,
|
||||
e, e1, e2, len);
|
||||
break;
|
||||
}
|
||||
else if (oc1 & oc2)
|
||||
{
|
||||
pbox++;
|
||||
}
|
||||
else
|
||||
{
|
||||
int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
|
||||
int clip1 = 0, clip2 = 0;
|
||||
int clipdx, clipdy;
|
||||
int err;
|
||||
|
||||
if (miZeroClipLine(pbox->x1, pbox->y1, pbox->x2-1,
|
||||
pbox->y2-1,
|
||||
&new_x1, &new_y1, &new_x2, &new_y2,
|
||||
adx, ady, &clip1, &clip2,
|
||||
octant, bias, oc1, oc2) == -1)
|
||||
{
|
||||
pbox++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (axis == X_AXIS)
|
||||
len = abs(new_x2 - new_x1);
|
||||
else
|
||||
len = abs(new_y2 - new_y1);
|
||||
#ifdef POLYSEGMENT
|
||||
if (clip2 != 0 || pGC->capStyle != CapNotLast)
|
||||
len++;
|
||||
#else
|
||||
len += (clip2 != 0);
|
||||
#endif
|
||||
if (len)
|
||||
{
|
||||
/* unwind bresenham error term to first point */
|
||||
if (clip1)
|
||||
{
|
||||
clipdx = abs(new_x1 - x1);
|
||||
clipdy = abs(new_y1 - y1);
|
||||
if (axis == X_AXIS)
|
||||
err = e+((clipdy*e2) + ((clipdx-clipdy)*e1));
|
||||
else
|
||||
err = e+((clipdx*e2) + ((clipdy-clipdx)*e1));
|
||||
}
|
||||
else
|
||||
err = e;
|
||||
cfbBresS(alu, and, xor,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, new_x1, new_y1,
|
||||
err, e1, e2, len);
|
||||
}
|
||||
pbox++;
|
||||
}
|
||||
} /* while (nbox--) */
|
||||
} /* sloped line */
|
||||
} /* while (nline--) */
|
||||
|
||||
#ifndef POLYSEGMENT
|
||||
/* paint the last point if the end style isn't CapNotLast.
|
||||
(Assume that a projecting, butt, or round cap that is one
|
||||
pixel wide is the same as the single pixel of the endpoint.)
|
||||
*/
|
||||
|
||||
if ((pGC->capStyle != CapNotLast) &&
|
||||
((ppt->x + xorg != pptInit->x + pDrawable->x) ||
|
||||
(ppt->y + yorg != pptInit->y + pDrawable->y) ||
|
||||
(ppt == pptInit + 1)))
|
||||
{
|
||||
nbox = nboxInit;
|
||||
pbox = pboxInit;
|
||||
while (nbox--)
|
||||
{
|
||||
if ((x2 >= pbox->x1) &&
|
||||
(y2 >= pbox->y1) &&
|
||||
(x2 < pbox->x2) &&
|
||||
(y2 < pbox->y2))
|
||||
{
|
||||
CfbBits mask;
|
||||
CfbBits scrbits;
|
||||
|
||||
#if PSZ == 24
|
||||
mask = cfbmask[(x2 & 3)<<1];
|
||||
addrl += (y2 * nlwidth) + ((x2*3) >> 2);
|
||||
#else
|
||||
mask = cfbmask[x2 & PIM];
|
||||
addrl += (y2 * nlwidth) + (x2 >> PWSH);
|
||||
#endif
|
||||
scrbits = *addrl;
|
||||
*addrl = (scrbits & ~mask) |
|
||||
(DoRRop (scrbits, and, xor) & mask);
|
||||
break;
|
||||
}
|
||||
else
|
||||
pbox++;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
* Draw dashed 1-pixel lines.
|
||||
*/
|
||||
|
||||
void
|
||||
#ifdef POLYSEGMENT
|
||||
cfbSegmentSD (pDrawable, pGC, nseg, pSeg)
|
||||
DrawablePtr pDrawable;
|
||||
register GCPtr pGC;
|
||||
int nseg;
|
||||
register xSegment *pSeg;
|
||||
#else
|
||||
cfbLineSD( pDrawable, pGC, mode, npt, pptInit)
|
||||
DrawablePtr pDrawable;
|
||||
register GCPtr pGC;
|
||||
int mode; /* Origin or Previous */
|
||||
int npt; /* number of points */
|
||||
DDXPointPtr pptInit;
|
||||
#endif
|
||||
{
|
||||
int nboxInit;
|
||||
register int nbox;
|
||||
BoxPtr pboxInit;
|
||||
register BoxPtr pbox;
|
||||
#ifndef POLYSEGMENT
|
||||
register DDXPointPtr ppt; /* pointer to list of translated points */
|
||||
#endif
|
||||
|
||||
register unsigned int oc1; /* outcode of point 1 */
|
||||
register unsigned int oc2; /* outcode of point 2 */
|
||||
|
||||
CfbBits *addrl; /* address of destination pixmap */
|
||||
int nlwidth; /* width in longwords of destination pixmap */
|
||||
int xorg, yorg; /* origin of window */
|
||||
|
||||
int adx; /* abs values of dx and dy */
|
||||
int ady;
|
||||
int signdx; /* sign of dx and dy */
|
||||
int signdy;
|
||||
int e, e1, e2; /* bresenham error and increments */
|
||||
int len; /* length of segment */
|
||||
int axis; /* major axis */
|
||||
int octant;
|
||||
unsigned int bias = miGetZeroLineBias(pDrawable->pScreen);
|
||||
int x1, x2, y1, y2;
|
||||
RegionPtr cclip;
|
||||
cfbRRopRec rrops[2];
|
||||
unsigned char *pDash;
|
||||
int dashOffset;
|
||||
int numInDashList;
|
||||
int dashIndex;
|
||||
int isDoubleDash;
|
||||
int dashIndexTmp, dashOffsetTmp;
|
||||
int unclippedlen;
|
||||
cfbPrivGCPtr devPriv;
|
||||
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
cclip = pGC->pCompositeClip;
|
||||
rrops[0].rop = devPriv->rop;
|
||||
rrops[0].and = devPriv->and;
|
||||
rrops[0].xor = devPriv->xor;
|
||||
if (pGC->alu == GXcopy)
|
||||
{
|
||||
rrops[1].rop = GXcopy;
|
||||
rrops[1].and = 0;
|
||||
rrops[1].xor = PFILL (pGC->bgPixel);
|
||||
}
|
||||
else
|
||||
{
|
||||
rrops[1].rop = cfbReduceRasterOp (pGC->alu,
|
||||
pGC->bgPixel, pGC->planemask,
|
||||
&rrops[1].and, &rrops[1].xor);
|
||||
}
|
||||
pboxInit = REGION_RECTS(cclip);
|
||||
nboxInit = REGION_NUM_RECTS(cclip);
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwidth, addrl)
|
||||
|
||||
/* compute initial dash values */
|
||||
|
||||
pDash = (unsigned char *) pGC->dash;
|
||||
numInDashList = pGC->numInDashList;
|
||||
isDoubleDash = (pGC->lineStyle == LineDoubleDash);
|
||||
dashIndex = 0;
|
||||
dashOffset = 0;
|
||||
miStepDash ((int)pGC->dashOffset, &dashIndex, pDash,
|
||||
numInDashList, &dashOffset);
|
||||
|
||||
xorg = pDrawable->x;
|
||||
yorg = pDrawable->y;
|
||||
#ifdef POLYSEGMENT
|
||||
while (nseg--)
|
||||
#else
|
||||
ppt = pptInit;
|
||||
x2 = ppt->x + xorg;
|
||||
y2 = ppt->y + yorg;
|
||||
while(--npt)
|
||||
#endif
|
||||
{
|
||||
nbox = nboxInit;
|
||||
pbox = pboxInit;
|
||||
|
||||
#ifdef POLYSEGMENT
|
||||
x1 = pSeg->x1 + xorg;
|
||||
y1 = pSeg->y1 + yorg;
|
||||
x2 = pSeg->x2 + xorg;
|
||||
y2 = pSeg->y2 + yorg;
|
||||
pSeg++;
|
||||
#else
|
||||
x1 = x2;
|
||||
y1 = y2;
|
||||
++ppt;
|
||||
if (mode == CoordModePrevious)
|
||||
{
|
||||
xorg = x1;
|
||||
yorg = y1;
|
||||
}
|
||||
x2 = ppt->x + xorg;
|
||||
y2 = ppt->y + yorg;
|
||||
#endif
|
||||
|
||||
CalcLineDeltas(x1, y1, x2, y2, adx, ady, signdx, signdy, 1, 1, octant);
|
||||
|
||||
if (adx > ady)
|
||||
{
|
||||
axis = X_AXIS;
|
||||
e1 = ady << 1;
|
||||
e2 = e1 - (adx << 1);
|
||||
e = e1 - adx;
|
||||
unclippedlen = adx;
|
||||
}
|
||||
else
|
||||
{
|
||||
axis = Y_AXIS;
|
||||
e1 = adx << 1;
|
||||
e2 = e1 - (ady << 1);
|
||||
e = e1 - ady;
|
||||
unclippedlen = ady;
|
||||
SetYMajorOctant(octant);
|
||||
}
|
||||
|
||||
FIXUP_ERROR(e, octant, bias);
|
||||
|
||||
/* we have bresenham parameters and two points.
|
||||
all we have to do now is clip and draw.
|
||||
*/
|
||||
|
||||
while(nbox--)
|
||||
{
|
||||
oc1 = 0;
|
||||
oc2 = 0;
|
||||
OUTCODES(oc1, x1, y1, pbox);
|
||||
OUTCODES(oc2, x2, y2, pbox);
|
||||
if ((oc1 | oc2) == 0)
|
||||
{
|
||||
#ifdef POLYSEGMENT
|
||||
if (pGC->capStyle != CapNotLast)
|
||||
unclippedlen++;
|
||||
dashIndexTmp = dashIndex;
|
||||
dashOffsetTmp = dashOffset;
|
||||
cfbBresD (rrops,
|
||||
&dashIndexTmp, pDash, numInDashList,
|
||||
&dashOffsetTmp, isDoubleDash,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, x1, y1,
|
||||
e, e1, e2, unclippedlen);
|
||||
break;
|
||||
#else
|
||||
cfbBresD (rrops,
|
||||
&dashIndex, pDash, numInDashList,
|
||||
&dashOffset, isDoubleDash,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, x1, y1,
|
||||
e, e1, e2, unclippedlen);
|
||||
goto dontStep;
|
||||
#endif
|
||||
}
|
||||
else if (oc1 & oc2)
|
||||
{
|
||||
pbox++;
|
||||
}
|
||||
else /* have to clip */
|
||||
{
|
||||
int new_x1 = x1, new_y1 = y1, new_x2 = x2, new_y2 = y2;
|
||||
int clip1 = 0, clip2 = 0;
|
||||
int clipdx, clipdy;
|
||||
int err;
|
||||
|
||||
if (miZeroClipLine(pbox->x1, pbox->y1, pbox->x2-1,
|
||||
pbox->y2-1,
|
||||
&new_x1, &new_y1, &new_x2, &new_y2,
|
||||
adx, ady, &clip1, &clip2,
|
||||
octant, bias, oc1, oc2) == -1)
|
||||
{
|
||||
pbox++;
|
||||
continue;
|
||||
}
|
||||
|
||||
dashIndexTmp = dashIndex;
|
||||
dashOffsetTmp = dashOffset;
|
||||
|
||||
if (clip1)
|
||||
{
|
||||
int dlen;
|
||||
|
||||
if (axis == X_AXIS)
|
||||
dlen = abs(new_x1 - x1);
|
||||
else
|
||||
dlen = abs(new_y1 - y1);
|
||||
miStepDash (dlen, &dashIndexTmp, pDash,
|
||||
numInDashList, &dashOffsetTmp);
|
||||
}
|
||||
|
||||
if (axis == X_AXIS)
|
||||
len = abs(new_x2 - new_x1);
|
||||
else
|
||||
len = abs(new_y2 - new_y1);
|
||||
#ifdef POLYSEGMENT
|
||||
if (clip2 != 0 || pGC->capStyle != CapNotLast)
|
||||
len++;
|
||||
#else
|
||||
len += (clip2 != 0);
|
||||
#endif
|
||||
if (len)
|
||||
{
|
||||
/* unwind bresenham error term to first point */
|
||||
if (clip1)
|
||||
{
|
||||
clipdx = abs(new_x1 - x1);
|
||||
clipdy = abs(new_y1 - y1);
|
||||
if (axis == X_AXIS)
|
||||
err = e+((clipdy*e2) + ((clipdx-clipdy)*e1));
|
||||
else
|
||||
err = e+((clipdx*e2) + ((clipdy-clipdx)*e1));
|
||||
}
|
||||
else
|
||||
err = e;
|
||||
cfbBresD (rrops,
|
||||
&dashIndexTmp, pDash, numInDashList,
|
||||
&dashOffsetTmp, isDoubleDash,
|
||||
addrl, nlwidth,
|
||||
signdx, signdy, axis, new_x1, new_y1,
|
||||
err, e1, e2, len);
|
||||
}
|
||||
pbox++;
|
||||
}
|
||||
} /* while (nbox--) */
|
||||
#ifndef POLYSEGMENT
|
||||
/*
|
||||
* walk the dash list around to the next line
|
||||
*/
|
||||
miStepDash (unclippedlen, &dashIndex, pDash,
|
||||
numInDashList, &dashOffset);
|
||||
dontStep: ;
|
||||
#endif
|
||||
} /* while (nline--) */
|
||||
|
||||
#ifndef POLYSEGMENT
|
||||
/* paint the last point if the end style isn't CapNotLast.
|
||||
(Assume that a projecting, butt, or round cap that is one
|
||||
pixel wide is the same as the single pixel of the endpoint.)
|
||||
*/
|
||||
|
||||
if ((pGC->capStyle != CapNotLast) &&
|
||||
((dashIndex & 1) == 0 || isDoubleDash) &&
|
||||
((ppt->x + xorg != pptInit->x + pDrawable->x) ||
|
||||
(ppt->y + yorg != pptInit->y + pDrawable->y) ||
|
||||
(ppt == pptInit + 1)))
|
||||
{
|
||||
nbox = nboxInit;
|
||||
pbox = pboxInit;
|
||||
while (nbox--)
|
||||
{
|
||||
if ((x2 >= pbox->x1) &&
|
||||
(y2 >= pbox->y1) &&
|
||||
(x2 < pbox->x2) &&
|
||||
(y2 < pbox->y2))
|
||||
{
|
||||
CfbBits mask;
|
||||
int pix;
|
||||
|
||||
pix = 0;
|
||||
if (dashIndex & 1)
|
||||
pix = 1;
|
||||
#if PSZ == 24
|
||||
mask = cfbmask[(x2 & 3)<<1];
|
||||
addrl += (y2 * nlwidth) + ((x2 *3)>> 2);
|
||||
#else
|
||||
mask = cfbmask[x2 & PIM];
|
||||
addrl += (y2 * nlwidth) + (x2 >> PWSH);
|
||||
#endif
|
||||
*addrl = DoMaskRRop (*addrl, rrops[pix].and, rrops[pix].xor, mask);
|
||||
break;
|
||||
}
|
||||
else
|
||||
pbox++;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
210
cfb/cfbmap.h
210
cfb/cfbmap.h
|
@ -1,210 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1991, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Map names around so that multiple depths can be supported simultaneously
|
||||
*/
|
||||
|
||||
/* a losing vendor cpp dumps core if we define CFBNAME in terms of CATNAME */
|
||||
|
||||
#if PSZ != 8
|
||||
|
||||
#if PSZ == 32
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CFBNAME(subname) cfb32##subname
|
||||
#else
|
||||
#define CFBNAME(subname) cfb32/**/subname
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CFBNAME(subname) cfb24##subname
|
||||
#else
|
||||
#define CFBNAME(subname) cfb24/**/subname
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if PSZ == 16
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CFBNAME(subname) cfb16##subname
|
||||
#else
|
||||
#define CFBNAME(subname) cfb16/**/subname
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if PSZ == 4
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CFBNAME(subname) cfb4##subname
|
||||
#else
|
||||
#define CFBNAME(subname) cfb4/**/subname
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef CFBNAME
|
||||
cfb can not hack PSZ yet
|
||||
#endif
|
||||
|
||||
#undef CATNAME
|
||||
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define CATNAME(prefix,subname) prefix##subname
|
||||
#else
|
||||
#define CATNAME(prefix,subname) prefix/**/subname
|
||||
#endif
|
||||
|
||||
#define QuartetBitsTable CFBNAME(QuartetBitsTable)
|
||||
#define QuartetPixelMaskTable CFBNAME(QuartetPixelMaskTable)
|
||||
#define cfb8ClippedLineCopy CFBNAME(ClippedLineCopy)
|
||||
#define cfb8ClippedLineGeneral CFBNAME(ClippedLineGeneral )
|
||||
#define cfb8ClippedLineXor CFBNAME(ClippedLineXor)
|
||||
#define cfb8LineSS1Rect CFBNAME(LineSS1Rect)
|
||||
#define cfb8LineSS1RectCopy CFBNAME(LineSS1RectCopy)
|
||||
#define cfb8LineSS1RectGeneral CFBNAME(LineSS1RectGeneral )
|
||||
#define cfb8LineSS1RectPreviousCopy CFBNAME(LineSS1RectPreviousCopy)
|
||||
#define cfb8LineSS1RectXor CFBNAME(LineSS1RectXor)
|
||||
#define cfb8SegmentSS1Rect CFBNAME(SegmentSS1Rect)
|
||||
#define cfb8SegmentSS1RectCopy CFBNAME(SegmentSS1RectCopy)
|
||||
#define cfb8SegmentSS1RectGeneral CFBNAME(SegmentSS1RectGeneral )
|
||||
#define cfb8SegmentSS1RectShiftCopy CFBNAME(SegmentSS1RectShiftCopy)
|
||||
#define cfb8SegmentSS1RectXor CFBNAME(SegmentSS1RectXor)
|
||||
#define cfbAllocatePrivates CFBNAME(AllocatePrivates)
|
||||
#define cfbBSFuncRec CFBNAME(BSFuncRec)
|
||||
#define cfbBitBlt CFBNAME(BitBlt)
|
||||
#define cfbBresD CFBNAME(BresD)
|
||||
#define cfbBresS CFBNAME(BresS)
|
||||
#define cfbChangeWindowAttributes CFBNAME(ChangeWindowAttributes)
|
||||
#define cfbClearVisualTypes CFBNAME(cfbClearVisualTypes)
|
||||
#define cfbCloseScreen CFBNAME(CloseScreen)
|
||||
#define cfbCreateDefColormap CFBNAME (cfbCreateDefColormap)
|
||||
#define cfbCopyArea CFBNAME(CopyArea)
|
||||
#define cfbCopyImagePlane CFBNAME(CopyImagePlane)
|
||||
#define cfbCopyPixmap CFBNAME(CopyPixmap)
|
||||
#define cfbCopyPlane CFBNAME(CopyPlane)
|
||||
#define cfbCopyPlaneReduce CFBNAME(CopyPlaneReduce)
|
||||
#define cfbCopyRotatePixmap CFBNAME(CopyRotatePixmap)
|
||||
#define cfbCopyWindow CFBNAME(CopyWindow)
|
||||
#define cfbCreateGC CFBNAME(CreateGC)
|
||||
#define cfbCreatePixmap CFBNAME(CreatePixmap)
|
||||
#define cfbCreateScreenResources CFBNAME(CreateScreenResources)
|
||||
#define cfbCreateWindow CFBNAME(CreateWindow)
|
||||
#define cfbDestroyPixmap CFBNAME(DestroyPixmap)
|
||||
#define cfbDestroyWindow CFBNAME(DestroyWindow)
|
||||
#define cfbDoBitblt CFBNAME(DoBitblt)
|
||||
#define cfbDoBitbltCopy CFBNAME(DoBitbltCopy)
|
||||
#define cfbDoBitbltGeneral CFBNAME(DoBitbltGeneral)
|
||||
#define cfbDoBitbltOr CFBNAME(DoBitbltOr)
|
||||
#define cfbDoBitbltXor CFBNAME(DoBitbltXor)
|
||||
#define cfbExpandDirectColors CFBNAME(cfbExpandDirectColors)
|
||||
#define cfbFillBoxTile32sCopy CFBNAME(FillBoxTile32sCopy)
|
||||
#define cfbFillBoxTile32sGeneral CFBNAME(FillBoxTile32sGeneral)
|
||||
#define cfbFillBoxTileOdd CFBNAME(FillBoxTileOdd)
|
||||
#define cfbFillBoxTileOddCopy CFBNAME(FillBoxTileOddCopy)
|
||||
#define cfbFillBoxTileOddGeneral CFBNAME(FillBoxTileOddGeneral)
|
||||
#define cfbFillPoly1RectCopy CFBNAME(FillPoly1RectCopy)
|
||||
#define cfbFillPoly1RectGeneral CFBNAME(FillPoly1RectGeneral)
|
||||
#define cfbFillRectSolidCopy CFBNAME(FillRectSolidCopy)
|
||||
#define cfbFillRectSolidGeneral CFBNAME(FillRectSolidGeneral)
|
||||
#define cfbFillRectSolidXor CFBNAME(FillRectSolidXor)
|
||||
#define cfbFillRectTile32Copy CFBNAME(FillRectTile32Copy)
|
||||
#define cfbFillRectTile32General CFBNAME(FillRectTile32General)
|
||||
#define cfbFillRectTileOdd CFBNAME(FillRectTileOdd)
|
||||
#define cfbFillSpanTile32sCopy CFBNAME(FillSpanTile32sCopy)
|
||||
#define cfbFillSpanTile32sGeneral CFBNAME(FillSpanTile32sGeneral)
|
||||
#define cfbFillSpanTileOddCopy CFBNAME(FillSpanTileOddCopy)
|
||||
#define cfbFillSpanTileOddGeneral CFBNAME(FillSpanTileOddGeneral)
|
||||
#define cfbFinishScreenInit CFBNAME(FinishScreenInit)
|
||||
#define cfbGCFuncs CFBNAME(GCFuncs)
|
||||
#define cfbGCPrivateKey CFBNAME(GCPrivateKey)
|
||||
#define cfbGetImage CFBNAME(GetImage)
|
||||
#define cfbGetScreenPixmap CFBNAME(GetScreenPixmap)
|
||||
#define cfbGetSpans CFBNAME(GetSpans)
|
||||
#define cfbHorzS CFBNAME(HorzS)
|
||||
#define cfbImageGlyphBlt8 CFBNAME(ImageGlyphBlt8)
|
||||
#define cfbInitializeColormap CFBNAME(InitializeColormap)
|
||||
#define cfbInitVisuals CFBNAME(cfbInitVisuals)
|
||||
#define cfbInstallColormap CFBNAME(InstallColormap)
|
||||
#define cfbLineSD CFBNAME(LineSD)
|
||||
#define cfbLineSS CFBNAME(LineSS)
|
||||
#define cfbListInstalledColormaps CFBNAME(ListInstalledColormaps)
|
||||
#define cfbMapWindow CFBNAME(MapWindow)
|
||||
#define cfbMatchCommon CFBNAME(MatchCommon)
|
||||
#define cfbNonTEOps CFBNAME(NonTEOps)
|
||||
#define cfbNonTEOps1Rect CFBNAME(NonTEOps1Rect)
|
||||
#define cfbPadPixmap CFBNAME(PadPixmap)
|
||||
#define cfbPolyFillArcSolidCopy CFBNAME(PolyFillArcSolidCopy)
|
||||
#define cfbPolyFillArcSolidGeneral CFBNAME(PolyFillArcSolidGeneral)
|
||||
#define cfbPolyFillRect CFBNAME(PolyFillRect)
|
||||
#define cfbPolyGlyphBlt8 CFBNAME(PolyGlyphBlt8)
|
||||
#define cfbPolyGlyphRop8 CFBNAME(PolyGlyphRop8)
|
||||
#define cfbPolyPoint CFBNAME(PolyPoint)
|
||||
#define cfbPositionWindow CFBNAME(PositionWindow)
|
||||
#define cfbPutImage CFBNAME(PutImage)
|
||||
#define cfbReduceRasterOp CFBNAME(ReduceRasterOp)
|
||||
#define cfbResolveColor CFBNAME(ResolveColor)
|
||||
#define cfbRestoreAreas CFBNAME(RestoreAreas)
|
||||
#define cfbSaveAreas CFBNAME(SaveAreas)
|
||||
#define cfbScreenInit CFBNAME(ScreenInit)
|
||||
#define cfbScreenPrivateKey CFBNAME(ScreenPrivateKey)
|
||||
#define cfbSegmentSD CFBNAME(SegmentSD)
|
||||
#define cfbSegmentSS CFBNAME(SegmentSS)
|
||||
#define cfbSetScanline CFBNAME(SetScanline)
|
||||
#define cfbSetScreenPixmap CFBNAME(SetScreenPixmap)
|
||||
#define cfbSetSpans CFBNAME(SetSpans)
|
||||
#define cfbSetVisualTypes CFBNAME(cfbSetVisualTypes)
|
||||
#define cfbSetupScreen CFBNAME(SetupScreen)
|
||||
#define cfbSolidSpansCopy CFBNAME(SolidSpansCopy)
|
||||
#define cfbSolidSpansGeneral CFBNAME(SolidSpansGeneral)
|
||||
#define cfbSolidSpansXor CFBNAME(SolidSpansXor)
|
||||
#define cfbStippleStack CFBNAME(StippleStack)
|
||||
#define cfbStippleStackTE CFBNAME(StippleStackTE)
|
||||
#define cfbTEGlyphBlt CFBNAME(TEGlyphBlt)
|
||||
#define cfbTEOps CFBNAME(TEOps)
|
||||
#define cfbTEOps1Rect CFBNAME(TEOps1Rect)
|
||||
#define cfbTile32FSCopy CFBNAME(Tile32FSCopy)
|
||||
#define cfbTile32FSGeneral CFBNAME(Tile32FSGeneral)
|
||||
#define cfbUninstallColormap CFBNAME(UninstallColormap)
|
||||
#define cfbUnmapWindow CFBNAME(UnmapWindow)
|
||||
#define cfbUnnaturalStippleFS CFBNAME(UnnaturalStippleFS)
|
||||
#define cfbUnnaturalTileFS CFBNAME(UnnaturalTileFS)
|
||||
#define cfbValidateGC CFBNAME(ValidateGC)
|
||||
#define cfbVertS CFBNAME(VertS)
|
||||
#define cfbWindowPrivateKey CFBNAME(WindowPrivateKey)
|
||||
#define cfbXRotatePixmap CFBNAME(XRotatePixmap)
|
||||
#define cfbYRotatePixmap CFBNAME(YRotatePixmap)
|
||||
#define cfbZeroPolyArcSS8Copy CFBNAME(ZeroPolyArcSSCopy)
|
||||
#define cfbZeroPolyArcSS8General CFBNAME(ZeroPolyArcSSGeneral)
|
||||
#define cfbZeroPolyArcSS8Xor CFBNAME(ZeroPolyArcSSXor)
|
||||
#define cfbendpartial CFBNAME(endpartial)
|
||||
#define cfbendtab CFBNAME(endtab)
|
||||
#define cfbmask CFBNAME(mask)
|
||||
#define cfbrmask CFBNAME(rmask)
|
||||
#define cfbstartpartial CFBNAME(startpartial)
|
||||
#define cfbstarttab CFBNAME(starttab)
|
||||
|
||||
#endif /* PSZ != 8 */
|
1400
cfb/cfbmskbits.c
1400
cfb/cfbmskbits.c
File diff suppressed because it is too large
Load Diff
854
cfb/cfbmskbits.h
854
cfb/cfbmskbits.h
|
@ -1,854 +0,0 @@
|
|||
/************************************************************
|
||||
Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose and without
|
||||
fee is hereby granted, provided that the above copyright no-
|
||||
tice appear in all copies and that both that copyright no-
|
||||
tice and this permission notice appear in supporting docu-
|
||||
mentation, and that the names of Sun or The Open Group
|
||||
not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific prior
|
||||
written permission. Sun and The Open Group make no
|
||||
representations about the suitability of this software for
|
||||
any purpose. It is provided "as is" without any express or
|
||||
implied warranty.
|
||||
|
||||
SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
|
||||
NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
|
||||
ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
||||
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
||||
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
********************************************************/
|
||||
|
||||
/* Optimizations for PSZ == 32 added by Kyle Marvin (marvin@vitec.com) */
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "compiler.h"
|
||||
|
||||
/*
|
||||
* ==========================================================================
|
||||
* Converted from mfb to support memory-mapped color framebuffer by smarks@sun,
|
||||
* April-May 1987.
|
||||
*
|
||||
* The way I did the conversion was to consider each longword as an
|
||||
* array of four bytes instead of an array of 32 one-bit pixels. So
|
||||
* getbits() and putbits() retain much the same calling sequence, but
|
||||
* they move bytes around instead of bits. Of course, this entails the
|
||||
* removal of all of the one-bit-pixel dependencies from the other
|
||||
* files, but the major bit-hacking stuff should be covered here.
|
||||
*
|
||||
* I've created some new macros that make it easier to understand what's
|
||||
* going on in the pixel calculations, and that make it easier to change the
|
||||
* pixel size.
|
||||
*
|
||||
* name explanation
|
||||
* ---- -----------
|
||||
* PSZ pixel size (in bits)
|
||||
* PGSZ pixel group size (in bits)
|
||||
* PGSZB pixel group size (in bytes)
|
||||
* PGSZBMSK mask with lowest PGSZB bits set to 1
|
||||
* PPW pixels per word (pixels per pixel group)
|
||||
* PPWMSK mask with lowest PPW bits set to 1
|
||||
* PLST index of last pixel in a word (should be PPW-1)
|
||||
* PIM pixel index mask (index within a pixel group)
|
||||
* PWSH pixel-to-word shift (should be log2(PPW))
|
||||
* PMSK mask with lowest PSZ bits set to 1
|
||||
*
|
||||
*
|
||||
* Here are some sample values. In the notation cfbA,B: A is PSZ, and
|
||||
* B is PGSZB. All the other values are derived from these
|
||||
* two. This table does not show all combinations!
|
||||
*
|
||||
* name cfb8,4 cfb24,4 cfb32,4 cfb8,8 cfb24,8 cfb32,8
|
||||
* ---- ------ ------- ------ ------ ------ -------
|
||||
* PSZ 8 24 32 8 24 32
|
||||
* PGSZ 32 32 32 64 64 64
|
||||
* PGSZB 4 4 4 8 8 8
|
||||
* PGSZBMSK 0xF 0xF? 0xF 0xFF 0xFF 0xFF
|
||||
* PPW 4 1 1 8 2 2
|
||||
* PPWMSK 0xF 0x1 0x1 0xFF 0x3? 0x3
|
||||
* PLST 3 0 0 7 1 1
|
||||
* PIM 0x3 0x0 0x0 0x7 0x1? 0x1
|
||||
* PWSH 2 0 0 3 1 1
|
||||
* PMSK 0xFF 0xFFFFFF 0xFFFFFFFF 0xFF 0xFFFFFF 0xFFFFFFFF
|
||||
*
|
||||
*
|
||||
* I have also added a new macro, PFILL, that takes one pixel and
|
||||
* replicates it throughout a word. This macro definition is dependent
|
||||
* upon pixel and word size; it doesn't use macros like PPW and so
|
||||
* forth. Examples: for monochrome, PFILL(1) => 0xffffffff, PFILL(0) =>
|
||||
* 0x00000000. For 8-bit color, PFILL(0x5d) => 0x5d5d5d5d. This macro
|
||||
* is used primarily for replicating a plane mask into a word.
|
||||
*
|
||||
* Color framebuffers operations also support the notion of a plane
|
||||
* mask. This mask determines which planes of the framebuffer can be
|
||||
* altered; the others are left unchanged. I have added another
|
||||
* parameter to the putbits and putbitsrop macros that is the plane
|
||||
* mask.
|
||||
* ==========================================================================
|
||||
*
|
||||
* Keith Packard (keithp@suse.com)
|
||||
* 64bit code is no longer supported; it requires DIX support
|
||||
* for repadding images which significantly impacts performance
|
||||
*/
|
||||
|
||||
/*
|
||||
* PSZ needs to be defined before we get here. Usually it comes from a
|
||||
* -DPSZ=foo on the compilation command line.
|
||||
*/
|
||||
|
||||
#ifndef PSZ
|
||||
#define PSZ 8
|
||||
#endif
|
||||
|
||||
/*
|
||||
* PixelGroup is the data type used to operate on groups of pixels.
|
||||
* We typedef it here to CARD32 with the assumption that you
|
||||
* want to manipulate 32 bits worth of pixels at a time as you can. If CARD32
|
||||
* is not appropriate for your server, define it to something else
|
||||
* before including this file. In this case you will also have to define
|
||||
* PGSZB to the size in bytes of PixelGroup.
|
||||
*/
|
||||
#ifndef PixelGroup
|
||||
#define PixelGroup CARD32
|
||||
#define PGSZB 4
|
||||
#endif /* PixelGroup */
|
||||
|
||||
#ifndef CfbBits
|
||||
#define CfbBits CARD32
|
||||
#endif
|
||||
|
||||
#define PGSZ (PGSZB << 3)
|
||||
#define PPW (PGSZ/PSZ)
|
||||
#define PLST (PPW-1)
|
||||
#define PIM PLST
|
||||
#define PMSK (((PixelGroup)1 << PSZ) - 1)
|
||||
#define PPWMSK (((PixelGroup)1 << PPW) - 1) /* instead of BITMSK */
|
||||
#define PGSZBMSK (((PixelGroup)1 << PGSZB) - 1)
|
||||
|
||||
/* set PWSH = log2(PPW) using brute force */
|
||||
|
||||
#if PPW == 1
|
||||
#define PWSH 0
|
||||
#else
|
||||
#if PPW == 2
|
||||
#define PWSH 1
|
||||
#else
|
||||
#if PPW == 4
|
||||
#define PWSH 2
|
||||
#else
|
||||
#if PPW == 8
|
||||
#define PWSH 3
|
||||
#else
|
||||
#if PPW == 16
|
||||
#define PWSH 4
|
||||
#endif /* PPW == 16 */
|
||||
#endif /* PPW == 8 */
|
||||
#endif /* PPW == 4 */
|
||||
#endif /* PPW == 2 */
|
||||
#endif /* PPW == 1 */
|
||||
|
||||
/* Defining PIXEL_ADDR means that individual pixels are addressable by this
|
||||
* machine (as type PixelType). A possible CFB architecture which supported
|
||||
* 8-bits-per-pixel on a non byte-addressable machine would not have this
|
||||
* defined.
|
||||
*
|
||||
* Defining FOUR_BIT_CODE means that cfb knows how to stipple on this machine;
|
||||
* eventually, stippling code for 16 and 32 bit devices should be written
|
||||
* which would allow them to also use FOUR_BIT_CODE. There isn't that
|
||||
* much to do in those cases, but it would make them quite a bit faster.
|
||||
*/
|
||||
|
||||
#if PSZ == 8
|
||||
#define PIXEL_ADDR
|
||||
typedef CARD8 PixelType;
|
||||
#define FOUR_BIT_CODE
|
||||
#endif
|
||||
|
||||
#if PSZ == 16
|
||||
#define PIXEL_ADDR
|
||||
typedef CARD16 PixelType;
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#undef PMSK
|
||||
#define PMSK 0xFFFFFF
|
||||
/*#undef PIM
|
||||
#define PIM 3*/
|
||||
#define PIXEL_ADDR
|
||||
typedef CARD32 PixelType;
|
||||
#endif
|
||||
|
||||
#if PSZ == 32
|
||||
#undef PMSK
|
||||
#define PMSK 0xFFFFFFFF
|
||||
#define PIXEL_ADDR
|
||||
typedef CARD32 PixelType;
|
||||
#endif
|
||||
|
||||
|
||||
/* the following notes use the following conventions:
|
||||
SCREEN LEFT SCREEN RIGHT
|
||||
in this file and maskbits.c, left and right refer to screen coordinates,
|
||||
NOT bit numbering in registers.
|
||||
|
||||
cfbstarttab[n]
|
||||
pixels[0,n-1] = 0's pixels[n,PPW-1] = 1's
|
||||
cfbendtab[n] =
|
||||
pixels[0,n-1] = 1's pixels[n,PPW-1] = 0's
|
||||
|
||||
cfbstartpartial[], cfbendpartial[]
|
||||
these are used as accelerators for doing putbits and masking out
|
||||
bits that are all contained between longword boudaries. the extra
|
||||
256 bytes of data seems a small price to pay -- code is smaller,
|
||||
and narrow things (e.g. window borders) go faster.
|
||||
|
||||
the names may seem misleading; they are derived not from which end
|
||||
of the word the bits are turned on, but at which end of a scanline
|
||||
the table tends to be used.
|
||||
|
||||
look at the tables and macros to understand boundary conditions.
|
||||
(careful readers will note that starttab[n] = ~endtab[n] for n != 0)
|
||||
|
||||
-----------------------------------------------------------------------
|
||||
these two macros depend on the screen's bit ordering.
|
||||
in both of them x is a screen position. they are used to
|
||||
combine bits collected from multiple longwords into a
|
||||
single destination longword, and to unpack a single
|
||||
source longword into multiple destinations.
|
||||
|
||||
SCRLEFT(dst, x)
|
||||
takes dst[x, PPW] and moves them to dst[0, PPW-x]
|
||||
the contents of the rest of dst are 0 ONLY IF
|
||||
dst is UNSIGNED.
|
||||
is cast as an unsigned.
|
||||
this is a right shift on the VAX, left shift on
|
||||
Sun and pc-rt.
|
||||
|
||||
SCRRIGHT(dst, x)
|
||||
takes dst[0,x] and moves them to dst[PPW-x, PPW]
|
||||
the contents of the rest of dst are 0 ONLY IF
|
||||
dst is UNSIGNED.
|
||||
this is a left shift on the VAX, right shift on
|
||||
Sun and pc-rt.
|
||||
|
||||
|
||||
the remaining macros are cpu-independent; all bit order dependencies
|
||||
are built into the tables and the two macros above.
|
||||
|
||||
maskbits(x, w, startmask, endmask, nlw)
|
||||
for a span of width w starting at position x, returns
|
||||
a mask for ragged pixels at start, mask for ragged pixels at end,
|
||||
and the number of whole longwords between the ends.
|
||||
|
||||
maskpartialbits(x, w, mask)
|
||||
works like maskbits(), except all the pixels are in the
|
||||
same longword (i.e. (x&0xPIM + w) <= PPW)
|
||||
|
||||
mask32bits(x, w, startmask, endmask, nlw)
|
||||
as maskbits, but does not calculate nlw. it is used by
|
||||
cfbGlyphBlt to put down glyphs <= PPW bits wide.
|
||||
|
||||
getbits(psrc, x, w, dst)
|
||||
starting at position x in psrc (x < PPW), collect w
|
||||
pixels and put them in the screen left portion of dst.
|
||||
psrc is a longword pointer. this may span longword boundaries.
|
||||
it special-cases fetching all w bits from one longword.
|
||||
|
||||
+--------+--------+ +--------+
|
||||
| | m |n| | ==> | m |n| |
|
||||
+--------+--------+ +--------+
|
||||
x x+w 0 w
|
||||
psrc psrc+1 dst
|
||||
m = PPW - x
|
||||
n = w - m
|
||||
|
||||
implementation:
|
||||
get m pixels, move to screen-left of dst, zeroing rest of dst;
|
||||
get n pixels from next word, move screen-right by m, zeroing
|
||||
lower m pixels of word.
|
||||
OR the two things together.
|
||||
|
||||
putbits(src, x, w, pdst, planemask)
|
||||
starting at position x in pdst, put down the screen-leftmost
|
||||
w bits of src. pdst is a longword pointer. this may
|
||||
span longword boundaries.
|
||||
it special-cases putting all w bits into the same longword.
|
||||
|
||||
+--------+ +--------+--------+
|
||||
| m |n| | ==> | | m |n| |
|
||||
+--------+ +--------+--------+
|
||||
0 w x x+w
|
||||
dst pdst pdst+1
|
||||
m = PPW - x
|
||||
n = w - m
|
||||
|
||||
implementation:
|
||||
get m pixels, shift screen-right by x, zero screen-leftmost x
|
||||
pixels; zero rightmost m bits of *pdst and OR in stuff
|
||||
from before the semicolon.
|
||||
shift src screen-left by m, zero bits n-32;
|
||||
zero leftmost n pixels of *(pdst+1) and OR in the
|
||||
stuff from before the semicolon.
|
||||
|
||||
putbitsrop(src, x, w, pdst, planemask, ROP)
|
||||
like putbits but calls DoRop with the rasterop ROP (see cfb.h for
|
||||
DoRop)
|
||||
|
||||
getleftbits(psrc, w, dst)
|
||||
get the leftmost w (w<=PPW) bits from *psrc and put them
|
||||
in dst. this is used by the cfbGlyphBlt code for glyphs
|
||||
<=PPW bits wide.
|
||||
*/
|
||||
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
#define BitRight(lw,n) ((lw) >> (n))
|
||||
#define BitLeft(lw,n) ((lw) << (n))
|
||||
#else /* (BITMAP_BIT_ORDER == LSBFirst) */
|
||||
#define BitRight(lw,n) ((lw) << (n))
|
||||
#define BitLeft(lw,n) ((lw) >> (n))
|
||||
#endif /* (BITMAP_BIT_ORDER == MSBFirst) */
|
||||
|
||||
#define SCRLEFT(lw, n) BitLeft (lw, (n) * PSZ)
|
||||
#define SCRRIGHT(lw, n) BitRight(lw, (n) * PSZ)
|
||||
|
||||
/*
|
||||
* Note that the shift direction is independent of the byte ordering of the
|
||||
* machine. The following is portable code.
|
||||
*/
|
||||
#if PPW == 16
|
||||
#define PFILL(p) ( ((p)&PMSK) | \
|
||||
((p)&PMSK) << PSZ | \
|
||||
((p)&PMSK) << 2*PSZ | \
|
||||
((p)&PMSK) << 3*PSZ | \
|
||||
((p)&PMSK) << 4*PSZ | \
|
||||
((p)&PMSK) << 5*PSZ | \
|
||||
((p)&PMSK) << 6*PSZ | \
|
||||
((p)&PMSK) << 7*PSZ | \
|
||||
((p)&PMSK) << 8*PSZ | \
|
||||
((p)&PMSK) << 9*PSZ | \
|
||||
((p)&PMSK) << 10*PSZ | \
|
||||
((p)&PMSK) << 11*PSZ | \
|
||||
((p)&PMSK) << 12*PSZ | \
|
||||
((p)&PMSK) << 13*PSZ | \
|
||||
((p)&PMSK) << 14*PSZ | \
|
||||
((p)&PMSK) << 15*PSZ )
|
||||
#define PFILL2(p, pf) { \
|
||||
pf = (p) & PMSK; \
|
||||
pf |= (pf << PSZ); \
|
||||
pf |= (pf << 2*PSZ); \
|
||||
pf |= (pf << 4*PSZ); \
|
||||
pf |= (pf << 8*PSZ); \
|
||||
}
|
||||
#endif /* PPW == 16 */
|
||||
#if PPW == 8
|
||||
#define PFILL(p) ( ((p)&PMSK) | \
|
||||
((p)&PMSK) << PSZ | \
|
||||
((p)&PMSK) << 2*PSZ | \
|
||||
((p)&PMSK) << 3*PSZ | \
|
||||
((p)&PMSK) << 4*PSZ | \
|
||||
((p)&PMSK) << 5*PSZ | \
|
||||
((p)&PMSK) << 6*PSZ | \
|
||||
((p)&PMSK) << 7*PSZ )
|
||||
#define PFILL2(p, pf) { \
|
||||
pf = (p) & PMSK; \
|
||||
pf |= (pf << PSZ); \
|
||||
pf |= (pf << 2*PSZ); \
|
||||
pf |= (pf << 4*PSZ); \
|
||||
}
|
||||
#endif
|
||||
#if PPW == 4
|
||||
#define PFILL(p) ( ((p)&PMSK) | \
|
||||
((p)&PMSK) << PSZ | \
|
||||
((p)&PMSK) << 2*PSZ | \
|
||||
((p)&PMSK) << 3*PSZ )
|
||||
#define PFILL2(p, pf) { \
|
||||
pf = (p) & PMSK; \
|
||||
pf |= (pf << PSZ); \
|
||||
pf |= (pf << 2*PSZ); \
|
||||
}
|
||||
#endif
|
||||
#if PPW == 2
|
||||
#define PFILL(p) ( ((p)&PMSK) | \
|
||||
((p)&PMSK) << PSZ )
|
||||
#define PFILL2(p, pf) { \
|
||||
pf = (p) & PMSK; \
|
||||
pf |= (pf << PSZ); \
|
||||
}
|
||||
#endif
|
||||
#if PPW == 1
|
||||
#define PFILL(p) (p)
|
||||
#define PFILL2(p,pf) (pf = (p))
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Reduced raster op - using precomputed values, perform the above
|
||||
* in three instructions
|
||||
*/
|
||||
|
||||
#define DoRRop(dst, and, xor) (((dst) & (and)) ^ (xor))
|
||||
|
||||
#define DoMaskRRop(dst, and, xor, mask) \
|
||||
(((dst) & ((and) | ~(mask))) ^ (xor & mask))
|
||||
|
||||
#if PSZ != 32 || PPW != 1
|
||||
|
||||
# if (PSZ == 24 && PPW == 1)
|
||||
#define maskbits(x, w, startmask, endmask, nlw) {\
|
||||
startmask = cfbstarttab[(x)&3]; \
|
||||
endmask = cfbendtab[((x)+(w)) & 3]; \
|
||||
nlw = ((((x)+(w))*3)>>2) - (((x)*3 +3)>>2); \
|
||||
}
|
||||
|
||||
#define mask32bits(x, w, startmask, endmask) \
|
||||
startmask = cfbstarttab[(x)&3]; \
|
||||
endmask = cfbendtab[((x)+(w)) & 3];
|
||||
|
||||
#define maskpartialbits(x, w, mask) \
|
||||
mask = cfbstartpartial[(x) & 3] & cfbendpartial[((x)+(w)) & 3];
|
||||
|
||||
#define maskbits24(x, w, startmask, endmask, nlw) \
|
||||
startmask = cfbstarttab24[(x) & 3]; \
|
||||
endmask = cfbendtab24[((x)+(w)) & 3]; \
|
||||
if (startmask){ \
|
||||
nlw = (((w) - (4 - ((x) & 3))) >> 2); \
|
||||
} else { \
|
||||
nlw = (w) >> 2; \
|
||||
}
|
||||
|
||||
#define getbits24(psrc, dst, index) {\
|
||||
register int idx; \
|
||||
switch(idx = ((index)&3)<<1){ \
|
||||
case 0: \
|
||||
dst = (*(psrc) &cfbmask[idx]); \
|
||||
break; \
|
||||
case 6: \
|
||||
dst = BitLeft((*(psrc) &cfbmask[idx]), cfb24Shift[idx]); \
|
||||
break; \
|
||||
default: \
|
||||
dst = BitLeft((*(psrc) &cfbmask[idx]), cfb24Shift[idx]) | \
|
||||
BitRight(((*((psrc)+1)) &cfbmask[idx+1]), cfb24Shift[idx+1]); \
|
||||
}; \
|
||||
}
|
||||
|
||||
#define putbits24(src, w, pdst, planemask, index) {\
|
||||
register PixelGroup dstpixel; \
|
||||
register unsigned int idx; \
|
||||
switch(idx = ((index)&3)<<1){ \
|
||||
case 0: \
|
||||
dstpixel = (*(pdst) &cfbmask[idx]); \
|
||||
break; \
|
||||
case 6: \
|
||||
dstpixel = BitLeft((*(pdst) &cfbmask[idx]), cfb24Shift[idx]); \
|
||||
break; \
|
||||
default: \
|
||||
dstpixel = BitLeft((*(pdst) &cfbmask[idx]), cfb24Shift[idx])| \
|
||||
BitRight(((*((pdst)+1)) &cfbmask[idx+1]), cfb24Shift[idx+1]); \
|
||||
}; \
|
||||
dstpixel &= ~(planemask); \
|
||||
dstpixel |= (src & planemask); \
|
||||
*(pdst) &= cfbrmask[idx]; \
|
||||
switch(idx){ \
|
||||
case 0: \
|
||||
*(pdst) |= (dstpixel & cfbmask[idx]); \
|
||||
break; \
|
||||
case 2: \
|
||||
case 4: \
|
||||
pdst++;idx++; \
|
||||
*(pdst) = ((*(pdst)) & cfbrmask[idx]) | \
|
||||
(BitLeft(dstpixel, cfb24Shift[idx]) & cfbmask[idx]); \
|
||||
pdst--;idx--; \
|
||||
case 6: \
|
||||
*(pdst) |= (BitRight(dstpixel, cfb24Shift[idx]) & cfbmask[idx]); \
|
||||
break; \
|
||||
}; \
|
||||
}
|
||||
|
||||
#define putbitsrop24(src, x, pdst, planemask, rop) \
|
||||
{ \
|
||||
register PixelGroup t1, dstpixel; \
|
||||
register unsigned int idx; \
|
||||
switch(idx = (x)<<1){ \
|
||||
case 0: \
|
||||
dstpixel = (*(pdst) &cfbmask[idx]); \
|
||||
break; \
|
||||
case 6: \
|
||||
dstpixel = BitLeft((*(pdst) &cfbmask[idx]), cfb24Shift[idx]); \
|
||||
break; \
|
||||
default: \
|
||||
dstpixel = BitLeft((*(pdst) &cfbmask[idx]), cfb24Shift[idx])| \
|
||||
BitRight(((*((pdst)+1)) &cfbmask[idx+1]), cfb24Shift[idx+1]); \
|
||||
}; \
|
||||
DoRop(t1, rop, (src), dstpixel); \
|
||||
dstpixel &= ~planemask; \
|
||||
dstpixel |= (t1 & planemask); \
|
||||
*(pdst) &= cfbrmask[idx]; \
|
||||
switch(idx){ \
|
||||
case 0: \
|
||||
*(pdst) |= (dstpixel & cfbmask[idx]); \
|
||||
break; \
|
||||
case 2: \
|
||||
case 4: \
|
||||
*((pdst)+1) = ((*((pdst)+1)) & cfbrmask[idx+1]) | \
|
||||
(BitLeft(dstpixel, cfb24Shift[idx+1]) & (cfbmask[idx+1])); \
|
||||
case 6: \
|
||||
*(pdst) |= (BitRight(dstpixel, cfb24Shift[idx]) & cfbmask[idx]); \
|
||||
}; \
|
||||
}
|
||||
# else /* PSZ == 24 && PPW == 1 */
|
||||
#define maskbits(x, w, startmask, endmask, nlw) \
|
||||
startmask = cfbstarttab[(x)&PIM]; \
|
||||
endmask = cfbendtab[((x)+(w)) & PIM]; \
|
||||
if (startmask) \
|
||||
nlw = (((w) - (PPW - ((x)&PIM))) >> PWSH); \
|
||||
else \
|
||||
nlw = (w) >> PWSH;
|
||||
|
||||
#define maskpartialbits(x, w, mask) \
|
||||
mask = cfbstartpartial[(x) & PIM] & cfbendpartial[((x) + (w)) & PIM];
|
||||
|
||||
#define mask32bits(x, w, startmask, endmask) \
|
||||
startmask = cfbstarttab[(x)&PIM]; \
|
||||
endmask = cfbendtab[((x)+(w)) & PIM];
|
||||
|
||||
/* FIXME */
|
||||
#define maskbits24(x, w, startmask, endmask, nlw) \
|
||||
abort()
|
||||
#define getbits24(psrc, dst, index) \
|
||||
abort()
|
||||
#define putbits24(src, w, pdst, planemask, index) \
|
||||
abort()
|
||||
#define putbitsrop24(src, x, pdst, planemask, rop) \
|
||||
abort()
|
||||
|
||||
#endif /* PSZ == 24 && PPW == 1 */
|
||||
|
||||
#define getbits(psrc, x, w, dst) \
|
||||
if ( ((x) + (w)) <= PPW) \
|
||||
{ \
|
||||
dst = SCRLEFT(*(psrc), (x)); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
int m; \
|
||||
m = PPW-(x); \
|
||||
dst = (SCRLEFT(*(psrc), (x)) & cfbendtab[m]) | \
|
||||
(SCRRIGHT(*((psrc)+1), m) & cfbstarttab[m]); \
|
||||
}
|
||||
|
||||
|
||||
#define putbits(src, x, w, pdst, planemask) \
|
||||
if ( ((x)+(w)) <= PPW) \
|
||||
{ \
|
||||
PixelGroup tmpmask; \
|
||||
maskpartialbits((x), (w), tmpmask); \
|
||||
tmpmask &= PFILL(planemask); \
|
||||
*(pdst) = (*(pdst) & ~tmpmask) | (SCRRIGHT(src, x) & tmpmask); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
unsigned int m; \
|
||||
unsigned int n; \
|
||||
PixelGroup pm = PFILL(planemask); \
|
||||
m = PPW-(x); \
|
||||
n = (w) - m; \
|
||||
*(pdst) = (*(pdst) & (cfbendtab[x] | ~pm)) | \
|
||||
(SCRRIGHT(src, x) & (cfbstarttab[x] & pm)); \
|
||||
*((pdst)+1) = (*((pdst)+1) & (cfbstarttab[n] | ~pm)) | \
|
||||
(SCRLEFT(src, m) & (cfbendtab[n] & pm)); \
|
||||
}
|
||||
#if defined(__GNUC__) && defined(mc68020)
|
||||
#undef getbits
|
||||
#define FASTGETBITS(psrc, x, w, dst) \
|
||||
asm ("bfextu %3{%1:%2},%0" \
|
||||
: "=d" (dst) : "di" (x), "di" (w), "o" (*(char *)(psrc)))
|
||||
|
||||
#define getbits(psrc,x,w,dst) \
|
||||
{ \
|
||||
FASTGETBITS(psrc, (x) * PSZ, (w) * PSZ, dst); \
|
||||
dst = SCRLEFT(dst,PPW-(w)); \
|
||||
}
|
||||
|
||||
#define FASTPUTBITS(src, x, w, pdst) \
|
||||
asm ("bfins %3,%0{%1:%2}" \
|
||||
: "=o" (*(char *)(pdst)) \
|
||||
: "di" (x), "di" (w), "d" (src), "0" (*(char *) (pdst)))
|
||||
|
||||
#undef putbits
|
||||
#define putbits(src, x, w, pdst, planemask) \
|
||||
{ \
|
||||
if (planemask != PMSK) { \
|
||||
PixelGroup _m, _pm; \
|
||||
FASTGETBITS(pdst, (x) * PSZ , (w) * PSZ, _m); \
|
||||
PFILL2(planemask, _pm); \
|
||||
_m &= (~_pm); \
|
||||
_m |= (SCRRIGHT(src, PPW-(w)) & _pm); \
|
||||
FASTPUTBITS(_m, (x) * PSZ, (w) * PSZ, pdst); \
|
||||
} else { \
|
||||
FASTPUTBITS(SCRRIGHT(src, PPW-(w)), (x) * PSZ, (w) * PSZ, pdst); \
|
||||
} \
|
||||
}
|
||||
|
||||
|
||||
#endif /* mc68020 */
|
||||
|
||||
#define putbitsrop(src, x, w, pdst, planemask, rop) \
|
||||
if ( ((x)+(w)) <= PPW) \
|
||||
{ \
|
||||
PixelGroup tmpmask; \
|
||||
PixelGroup t1, t2; \
|
||||
maskpartialbits((x), (w), tmpmask); \
|
||||
PFILL2(planemask, t1); \
|
||||
tmpmask &= t1; \
|
||||
t1 = SCRRIGHT((src), (x)); \
|
||||
DoRop(t2, rop, t1, *(pdst)); \
|
||||
*(pdst) = (*(pdst) & ~tmpmask) | (t2 & tmpmask); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
CfbBits m; \
|
||||
CfbBits n; \
|
||||
PixelGroup t1, t2; \
|
||||
PixelGroup pm; \
|
||||
PFILL2(planemask, pm); \
|
||||
m = PPW-(x); \
|
||||
n = (w) - m; \
|
||||
t1 = SCRRIGHT((src), (x)); \
|
||||
DoRop(t2, rop, t1, *(pdst)); \
|
||||
*(pdst) = (*(pdst) & (cfbendtab[x] | ~pm)) | (t2 & (cfbstarttab[x] & pm));\
|
||||
t1 = SCRLEFT((src), m); \
|
||||
DoRop(t2, rop, t1, *((pdst) + 1)); \
|
||||
*((pdst)+1) = (*((pdst)+1) & (cfbstarttab[n] | ~pm)) | \
|
||||
(t2 & (cfbendtab[n] & pm)); \
|
||||
}
|
||||
|
||||
#else /* PSZ == 32 && PPW == 1*/
|
||||
|
||||
/*
|
||||
* These macros can be optimized for 32-bit pixels since there is no
|
||||
* need to worry about left/right edge masking. These macros were
|
||||
* derived from the above using the following reductions:
|
||||
*
|
||||
* - x & PIW = 0 [since PIW = 0]
|
||||
* - all masking tables are only indexed by 0 [ due to above ]
|
||||
* - cfbstartab[0] and cfbendtab[0] = 0 [ no left/right edge masks]
|
||||
* - cfbstartpartial[0] and cfbendpartial[0] = ~0 [no partial pixel mask]
|
||||
*
|
||||
* Macro reduction based upon constants cannot be performed automatically
|
||||
* by the compiler since it does not know the contents of the masking
|
||||
* arrays in cfbmskbits.c.
|
||||
*/
|
||||
#define maskbits(x, w, startmask, endmask, nlw) \
|
||||
startmask = endmask = 0; \
|
||||
nlw = (w);
|
||||
|
||||
#define maskpartialbits(x, w, mask) \
|
||||
mask = 0xFFFFFFFF;
|
||||
|
||||
#define mask32bits(x, w, startmask, endmask) \
|
||||
startmask = endmask = 0;
|
||||
|
||||
/*
|
||||
* For 32-bit operations, getbits(), putbits(), and putbitsrop()
|
||||
* will only be invoked with x = 0 and w = PPW (1). The getbits()
|
||||
* macro is only called within left/right edge logic, which doesn't
|
||||
* happen for 32-bit pixels.
|
||||
*/
|
||||
#define getbits(psrc, x, w, dst) (dst) = *(psrc)
|
||||
|
||||
#define putbits(src, x, w, pdst, planemask) \
|
||||
*(pdst) = (*(pdst) & ~planemask) | (src & planemask);
|
||||
|
||||
#define putbitsrop(src, x, w, pdst, planemask, rop) \
|
||||
{ \
|
||||
PixelGroup t1; \
|
||||
DoRop(t1, rop, (src), *(pdst)); \
|
||||
*(pdst) = (*(pdst) & ~planemask) | (t1 & planemask); \
|
||||
}
|
||||
|
||||
#endif /* PSZ != 32 */
|
||||
|
||||
/*
|
||||
* Use these macros only when you're using the MergeRop stuff
|
||||
* in ../mfb/mergerop.h
|
||||
*/
|
||||
|
||||
/* useful only when not spanning destination longwords */
|
||||
#if PSZ == 24
|
||||
#define putbitsmropshort24(src,x,w,pdst,index) {\
|
||||
PixelGroup _tmpmask; \
|
||||
PixelGroup _t1; \
|
||||
maskpartialbits ((x), (w), _tmpmask); \
|
||||
_t1 = SCRRIGHT((src), (x)); \
|
||||
DoMaskMergeRop24(_t1, pdst, _tmpmask, index); \
|
||||
}
|
||||
#endif
|
||||
#define putbitsmropshort(src,x,w,pdst) {\
|
||||
PixelGroup _tmpmask; \
|
||||
PixelGroup _t1; \
|
||||
maskpartialbits ((x), (w), _tmpmask); \
|
||||
_t1 = SCRRIGHT((src), (x)); \
|
||||
*pdst = DoMaskMergeRop(_t1, *pdst, _tmpmask); \
|
||||
}
|
||||
|
||||
/* useful only when spanning destination longwords */
|
||||
#define putbitsmroplong(src,x,w,pdst) { \
|
||||
PixelGroup _startmask, _endmask; \
|
||||
int _m; \
|
||||
PixelGroup _t1; \
|
||||
_m = PPW - (x); \
|
||||
_startmask = cfbstarttab[x]; \
|
||||
_endmask = cfbendtab[(w) - _m]; \
|
||||
_t1 = SCRRIGHT((src), (x)); \
|
||||
pdst[0] = DoMaskMergeRop(_t1,pdst[0],_startmask); \
|
||||
_t1 = SCRLEFT ((src),_m); \
|
||||
pdst[1] = DoMaskMergeRop(_t1,pdst[1],_endmask); \
|
||||
}
|
||||
|
||||
#define putbitsmrop(src,x,w,pdst) \
|
||||
if ((x) + (w) <= PPW) {\
|
||||
putbitsmropshort(src,x,w,pdst); \
|
||||
} else { \
|
||||
putbitsmroplong(src,x,w,pdst); \
|
||||
}
|
||||
|
||||
#if GETLEFTBITS_ALIGNMENT == 1
|
||||
#define getleftbits(psrc, w, dst) dst = *((unsigned int *) psrc)
|
||||
#define getleftbits24(psrc, w, dst, idx){ \
|
||||
regiseter int index; \
|
||||
switch(index = ((idx)&3)<<1){ \
|
||||
case 0: \
|
||||
dst = (*((unsigned int *) psrc))&cfbmask[index]; \
|
||||
break; \
|
||||
case 2: \
|
||||
case 4: \
|
||||
dst = BitLeft(((*((unsigned int *) psrc))&cfbmask[index]), cfb24Shift[index]); \
|
||||
dst |= BitRight(((*((unsigned int *) psrc)+1)&cfbmask[index]), cfb4Shift[index]); \
|
||||
break; \
|
||||
case 6: \
|
||||
dst = BitLeft((*((unsigned int *) psrc)),cfb24Shift[index]); \
|
||||
break; \
|
||||
}; \
|
||||
}
|
||||
#endif /* GETLEFTBITS_ALIGNMENT == 1 */
|
||||
|
||||
#define getglyphbits(psrc, x, w, dst) \
|
||||
{ \
|
||||
dst = BitLeft((unsigned) *(psrc), (x)); \
|
||||
if ( ((x) + (w)) > 32) \
|
||||
dst |= (BitRight((unsigned) *((psrc)+1), 32-(x))); \
|
||||
}
|
||||
#if GETLEFTBITS_ALIGNMENT == 2
|
||||
#define getleftbits(psrc, w, dst) \
|
||||
{ \
|
||||
if ( ((int)(psrc)) & 0x01 ) \
|
||||
getglyphbits( ((unsigned int *)(((char *)(psrc))-1)), 8, (w), (dst) ); \
|
||||
else \
|
||||
dst = *((unsigned int *) psrc); \
|
||||
}
|
||||
#endif /* GETLEFTBITS_ALIGNMENT == 2 */
|
||||
|
||||
#if GETLEFTBITS_ALIGNMENT == 4
|
||||
#define getleftbits(psrc, w, dst) \
|
||||
{ \
|
||||
int off, off_b; \
|
||||
off_b = (off = ( ((int)(psrc)) & 0x03)) << 3; \
|
||||
getglyphbits( \
|
||||
(unsigned int *)( ((char *)(psrc)) - off), \
|
||||
(off_b), (w), (dst) \
|
||||
); \
|
||||
}
|
||||
#endif /* GETLEFTBITS_ALIGNMENT == 4 */
|
||||
|
||||
/*
|
||||
* getstipplepixels( psrcstip, x, w, ones, psrcpix, destpix )
|
||||
*
|
||||
* Converts bits to pixels in a reasonable way. Takes w (1 <= w <= PPW)
|
||||
* bits from *psrcstip, starting at bit x; call this a quartet of bits.
|
||||
* Then, takes the pixels from *psrcpix corresponding to the one-bits (if
|
||||
* ones is TRUE) or the zero-bits (if ones is FALSE) of the quartet
|
||||
* and puts these pixels into destpix.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* getstipplepixels( &(0x08192A3B), 17, 4, 1, &(0x4C5D6E7F), dest )
|
||||
*
|
||||
* 0x08192A3B = 0000 1000 0001 1001 0010 1010 0011 1011
|
||||
*
|
||||
* This will take 4 bits starting at bit 17, so the quartet is 0x5 = 0101.
|
||||
* It will take pixels from 0x4C5D6E7F corresponding to the one-bits in this
|
||||
* quartet, so dest = 0x005D007F.
|
||||
*
|
||||
* XXX Works with both byte order.
|
||||
* XXX This works for all values of x and w within a doubleword.
|
||||
*/
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
#define getstipplepixels( psrcstip, x, w, ones, psrcpix, destpix ) \
|
||||
{ \
|
||||
PixelGroup q; \
|
||||
int m; \
|
||||
if ((m = ((x) - ((PPW*PSZ)-PPW))) > 0) { \
|
||||
q = (*(psrcstip)) << m; \
|
||||
if ( (x)+(w) > (PPW*PSZ) ) \
|
||||
q |= *((psrcstip)+1) >> ((PPW*PSZ)-m); \
|
||||
} \
|
||||
else \
|
||||
q = (*(psrcstip)) >> -m; \
|
||||
q = QuartetBitsTable[(w)] & ((ones) ? q : ~q); \
|
||||
*(destpix) = (*(psrcpix)) & QuartetPixelMaskTable[q]; \
|
||||
}
|
||||
/* I just copied this to get the linker satisfied on PowerPC,
|
||||
* so this may not be correct at all.
|
||||
*/
|
||||
#define getstipplepixels24(psrcstip,xt,ones,psrcpix,destpix,stipindex) \
|
||||
{ \
|
||||
PixelGroup q; \
|
||||
q = *(psrcstip) >> (xt); \
|
||||
q = ((ones) ? q : ~q) & 1; \
|
||||
*(destpix) = (*(psrcpix)) & QuartetPixelMaskTable[q]; \
|
||||
}
|
||||
#else /* BITMAP_BIT_ORDER == LSB */
|
||||
|
||||
/* this must load 32 bits worth; for most machines, thats an int */
|
||||
#define CfbFetchUnaligned(x) ldl_u(x)
|
||||
|
||||
#define getstipplepixels( psrcstip, xt, w, ones, psrcpix, destpix ) \
|
||||
{ \
|
||||
PixelGroup q; \
|
||||
q = CfbFetchUnaligned(psrcstip) >> (xt); \
|
||||
if ( ((xt)+(w)) > (PPW*PSZ) ) \
|
||||
q |= (CfbFetchUnaligned((psrcstip)+1)) << ((PPW*PSZ)-(xt)); \
|
||||
q = QuartetBitsTable[(w)] & ((ones) ? q : ~q); \
|
||||
*(destpix) = (*(psrcpix)) & QuartetPixelMaskTable[q]; \
|
||||
}
|
||||
#if PSZ == 24
|
||||
#define getstipplepixels24(psrcstip,xt,ones,psrcpix,destpix,stipindex) \
|
||||
{ \
|
||||
PixelGroup q; \
|
||||
q = *(psrcstip) >> (xt); \
|
||||
q = ((ones) ? q : ~q) & 1; \
|
||||
*(destpix) = (*(psrcpix)) & QuartetPixelMaskTable[q]; \
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
#endif
|
||||
|
||||
extern PixelGroup cfbstarttab[];
|
||||
extern PixelGroup cfbendtab[];
|
||||
extern PixelGroup cfbstartpartial[];
|
||||
extern PixelGroup cfbendpartial[];
|
||||
extern PixelGroup cfbrmask[];
|
||||
extern PixelGroup cfbmask[];
|
||||
extern PixelGroup QuartetBitsTable[];
|
||||
extern PixelGroup QuartetPixelMaskTable[];
|
||||
#if PSZ == 24
|
||||
extern int cfb24Shift[];
|
||||
#endif
|
375
cfb/cfbpixmap.c
375
cfb/cfbpixmap.c
|
@ -1,375 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
/* pixmap management
|
||||
written by drewry, september 1986
|
||||
|
||||
on a monchrome device, a pixmap is a bitmap.
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "mi.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
PixmapPtr
|
||||
cfbCreatePixmap (pScreen, width, height, depth, usage_hint)
|
||||
ScreenPtr pScreen;
|
||||
int width;
|
||||
int height;
|
||||
int depth;
|
||||
unsigned usage_hint;
|
||||
{
|
||||
PixmapPtr pPixmap;
|
||||
size_t datasize;
|
||||
size_t paddedWidth;
|
||||
|
||||
paddedWidth = PixmapBytePad(width, depth);
|
||||
|
||||
if (paddedWidth / 4 > 32767 || height > 32767)
|
||||
return NullPixmap;
|
||||
datasize = height * paddedWidth;
|
||||
pPixmap = AllocatePixmap(pScreen, datasize);
|
||||
if (!pPixmap)
|
||||
return NullPixmap;
|
||||
pPixmap->drawable.type = DRAWABLE_PIXMAP;
|
||||
pPixmap->drawable.class = 0;
|
||||
pPixmap->drawable.pScreen = pScreen;
|
||||
pPixmap->drawable.depth = depth;
|
||||
pPixmap->drawable.bitsPerPixel = BitsPerPixel(depth);
|
||||
pPixmap->drawable.id = 0;
|
||||
pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
|
||||
pPixmap->drawable.x = 0;
|
||||
pPixmap->drawable.y = 0;
|
||||
pPixmap->drawable.width = width;
|
||||
pPixmap->drawable.height = height;
|
||||
pPixmap->devKind = paddedWidth;
|
||||
pPixmap->refcnt = 1;
|
||||
pPixmap->devPrivate.ptr = datasize ?
|
||||
(pointer)((char *)pPixmap + pScreen->totalPixmapSize) : NULL;
|
||||
pPixmap->usage_hint = usage_hint;
|
||||
return pPixmap;
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbDestroyPixmap(pPixmap)
|
||||
PixmapPtr pPixmap;
|
||||
{
|
||||
if(--pPixmap->refcnt)
|
||||
return TRUE;
|
||||
dixFreePrivates(pPixmap->devPrivates);
|
||||
xfree(pPixmap);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
PixmapPtr
|
||||
cfbCopyPixmap(pSrc)
|
||||
register PixmapPtr pSrc;
|
||||
{
|
||||
register PixmapPtr pDst;
|
||||
int size;
|
||||
ScreenPtr pScreen;
|
||||
|
||||
size = pSrc->drawable.height * pSrc->devKind;
|
||||
pScreen = pSrc->drawable.pScreen;
|
||||
pDst = (*pScreen->CreatePixmap) (pScreen, pSrc->drawable.width,
|
||||
pSrc->drawable.height, pSrc->drawable.depth, 0);
|
||||
if (!pDst)
|
||||
return NullPixmap;
|
||||
memmove((char *)pDst->devPrivate.ptr, (char *)pSrc->devPrivate.ptr, size);
|
||||
return pDst;
|
||||
}
|
||||
|
||||
|
||||
/* replicates a pattern to be a full 32 bits wide.
|
||||
relies on the fact that each scnaline is longword padded.
|
||||
doesn't do anything if pixmap is not a factor of 32 wide.
|
||||
changes width field of pixmap if successful, so that the fast
|
||||
cfbXRotatePixmap code gets used if we rotate the pixmap later.
|
||||
cfbYRotatePixmap code gets used if we rotate the pixmap later.
|
||||
|
||||
calculate number of times to repeat
|
||||
for each scanline of pattern
|
||||
zero out area to be filled with replicate
|
||||
left shift and or in original as many times as needed
|
||||
*/
|
||||
void
|
||||
cfbPadPixmap(pPixmap)
|
||||
PixmapPtr pPixmap;
|
||||
{
|
||||
register int width = (pPixmap->drawable.width) * (pPixmap->drawable.bitsPerPixel);
|
||||
register int h;
|
||||
register CfbBits mask;
|
||||
register CfbBits *p;
|
||||
register CfbBits bits; /* real pattern bits */
|
||||
register int i;
|
||||
int rep; /* repeat count for pattern */
|
||||
|
||||
if (width >= PGSZ)
|
||||
return;
|
||||
|
||||
rep = PGSZ/width;
|
||||
if (rep*width != PGSZ)
|
||||
return;
|
||||
|
||||
mask = mfbGetendtab(width);
|
||||
|
||||
p = (CfbBits *)(pPixmap->devPrivate.ptr);
|
||||
for (h=0; h < pPixmap->drawable.height; h++)
|
||||
{
|
||||
*p &= mask;
|
||||
bits = *p;
|
||||
for(i=1; i<rep; i++)
|
||||
{
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
bits >>= width;
|
||||
#else
|
||||
bits <<= width;
|
||||
#endif
|
||||
*p |= bits;
|
||||
}
|
||||
p++;
|
||||
}
|
||||
pPixmap->drawable.width = PGSZ/(pPixmap->drawable.bitsPerPixel);
|
||||
}
|
||||
|
||||
|
||||
#ifdef notdef
|
||||
/*
|
||||
* cfb debugging routine -- assumes pixmap is 1 byte deep
|
||||
*/
|
||||
static cfbdumppixmap(pPix)
|
||||
PixmapPtr pPix;
|
||||
{
|
||||
unsigned int *pw;
|
||||
char *psrc, *pdst;
|
||||
int i, j;
|
||||
char line[66];
|
||||
|
||||
ErrorF( "pPixmap: 0x%x\n", pPix);
|
||||
ErrorF( "%d wide %d high\n", pPix->drawable.width, pPix->drawable.height);
|
||||
if (pPix->drawable.width > 64)
|
||||
{
|
||||
ErrorF( "too wide to see\n");
|
||||
return;
|
||||
}
|
||||
|
||||
pw = (unsigned int *) pPix->devPrivate.ptr;
|
||||
psrc = (char *) pw;
|
||||
|
||||
/*
|
||||
for ( i=0; i<pPix->drawable.height; ++i )
|
||||
ErrorF( "0x%x\n", pw[i] );
|
||||
*/
|
||||
|
||||
for ( i = 0; i < pPix->drawable.height; ++i ) {
|
||||
pdst = line;
|
||||
for(j = 0; j < pPix->drawable.width; j++) {
|
||||
*pdst++ = *psrc++ ? 'X' : ' ' ;
|
||||
}
|
||||
*pdst++ = '\n';
|
||||
*pdst++ = '\0';
|
||||
ErrorF( "%s", line);
|
||||
}
|
||||
}
|
||||
#endif /* notdef */
|
||||
|
||||
/* Rotates pixmap pPix by w pixels to the right on the screen. Assumes that
|
||||
* words are PGSZ bits wide, and that the least significant bit appears on the
|
||||
* left.
|
||||
*/
|
||||
void
|
||||
cfbXRotatePixmap(pPix, rw)
|
||||
PixmapPtr pPix;
|
||||
register int rw;
|
||||
{
|
||||
register CfbBits *pw, *pwFinal;
|
||||
register CfbBits t;
|
||||
int rot;
|
||||
|
||||
if (pPix == NullPixmap)
|
||||
return;
|
||||
|
||||
switch (((DrawablePtr) pPix)->bitsPerPixel) {
|
||||
case PSZ:
|
||||
break;
|
||||
case 1:
|
||||
mfbXRotatePixmap(pPix, rw);
|
||||
return;
|
||||
default:
|
||||
ErrorF("cfbXRotatePixmap: unsupported bitsPerPixel %d\n", ((DrawablePtr) pPix)->bitsPerPixel);
|
||||
return;
|
||||
}
|
||||
pw = (CfbBits *)pPix->devPrivate.ptr;
|
||||
modulus (rw, (int) pPix->drawable.width, rot);
|
||||
if(pPix->drawable.width == PPW)
|
||||
{
|
||||
pwFinal = pw + pPix->drawable.height;
|
||||
while(pw < pwFinal)
|
||||
{
|
||||
t = *pw;
|
||||
*pw++ = SCRRIGHT(t, rot) |
|
||||
(SCRLEFT(t, (PPW-rot)) & cfbendtab[rot]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ErrorF("cfb internal error: trying to rotate odd-sized pixmap.\n");
|
||||
#ifdef notdef
|
||||
register CfbBits *pwTmp;
|
||||
int size, tsize;
|
||||
|
||||
tsize = PixmapBytePad(pPix->drawable.width - rot, pPix->drawable.depth);
|
||||
pwTmp = (CfbBits *) xalloc(pPix->drawable.height * tsize);
|
||||
if (!pwTmp)
|
||||
return;
|
||||
/* divide pw (the pixmap) in two vertically at (w - rot) and swap */
|
||||
tsize >>= 2;
|
||||
size = pPix->devKind >> SIZE0F(PixelGroup);
|
||||
cfbQuickBlt((CfbBits *)pw, (CfbBits *)pwTmp,
|
||||
0, 0, 0, 0,
|
||||
(int)pPix->drawable.width - rot, (int)pPix->drawable.height,
|
||||
size, tsize);
|
||||
cfbQuickBlt((CfbBits *)pw, (CfbBits *)pw,
|
||||
(int)pPix->drawable.width - rot, 0, 0, 0,
|
||||
rot, (int)pPix->drawable.height,
|
||||
size, size);
|
||||
cfbQuickBlt((CfbBits *)pwTmp, (CfbBits *)pw,
|
||||
0, 0, rot, 0,
|
||||
(int)pPix->drawable.width - rot, (int)pPix->drawable.height,
|
||||
tsize, size);
|
||||
xfree(pwTmp);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/* Rotates pixmap pPix by h lines. Assumes that h is always less than
|
||||
pPix->drawable.height
|
||||
works on any width.
|
||||
*/
|
||||
void
|
||||
cfbYRotatePixmap(pPix, rh)
|
||||
register PixmapPtr pPix;
|
||||
int rh;
|
||||
{
|
||||
int nbyDown; /* bytes to move down to row 0; also offset of
|
||||
row rh */
|
||||
int nbyUp; /* bytes to move up to line rh; also
|
||||
offset of first line moved down to 0 */
|
||||
char *pbase;
|
||||
char *ptmp;
|
||||
int rot;
|
||||
|
||||
if (pPix == NullPixmap)
|
||||
return;
|
||||
switch (((DrawablePtr) pPix)->bitsPerPixel) {
|
||||
case PSZ:
|
||||
break;
|
||||
case 1:
|
||||
mfbYRotatePixmap(pPix, rh);
|
||||
return;
|
||||
default:
|
||||
ErrorF("cfbYRotatePixmap: unsupported bitsPerPixel %d\n", ((DrawablePtr) pPix)->bitsPerPixel);
|
||||
return;
|
||||
}
|
||||
|
||||
modulus (rh, (int) pPix->drawable.height, rot);
|
||||
pbase = (char *)pPix->devPrivate.ptr;
|
||||
|
||||
nbyDown = rot * pPix->devKind;
|
||||
nbyUp = (pPix->devKind * pPix->drawable.height) - nbyDown;
|
||||
if(!(ptmp = (char *)xalloc(nbyUp)))
|
||||
return;
|
||||
|
||||
memmove(ptmp, pbase, nbyUp); /* save the low rows */
|
||||
memmove(pbase, pbase+nbyUp, nbyDown); /* slide the top rows down */
|
||||
memmove(pbase+nbyDown, ptmp, nbyUp); /* move lower rows up to row rot */
|
||||
xfree(ptmp);
|
||||
}
|
||||
|
||||
void
|
||||
cfbCopyRotatePixmap(psrcPix, ppdstPix, xrot, yrot)
|
||||
register PixmapPtr psrcPix, *ppdstPix;
|
||||
int xrot, yrot;
|
||||
{
|
||||
register PixmapPtr pdstPix;
|
||||
|
||||
if ((pdstPix = *ppdstPix) &&
|
||||
(pdstPix->devKind == psrcPix->devKind) &&
|
||||
(pdstPix->drawable.height == psrcPix->drawable.height))
|
||||
{
|
||||
memmove((char *)pdstPix->devPrivate.ptr,
|
||||
(char *)psrcPix->devPrivate.ptr,
|
||||
psrcPix->drawable.height * psrcPix->devKind);
|
||||
pdstPix->drawable.width = psrcPix->drawable.width;
|
||||
pdstPix->drawable.depth = psrcPix->drawable.depth;
|
||||
pdstPix->drawable.bitsPerPixel = psrcPix->drawable.bitsPerPixel;
|
||||
pdstPix->drawable.serialNumber = NEXT_SERIAL_NUMBER;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (pdstPix)
|
||||
/* FIX XBUG 6168 */
|
||||
(*pdstPix->drawable.pScreen->DestroyPixmap)(pdstPix);
|
||||
*ppdstPix = pdstPix = cfbCopyPixmap(psrcPix);
|
||||
if (!pdstPix)
|
||||
return;
|
||||
}
|
||||
cfbPadPixmap(pdstPix);
|
||||
if (xrot)
|
||||
cfbXRotatePixmap(pdstPix, xrot);
|
||||
if (yrot)
|
||||
cfbYRotatePixmap(pdstPix, yrot);
|
||||
}
|
363
cfb/cfbply1rct.c
363
cfb/cfbply1rct.c
|
@ -1,363 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "mistruct.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfbrrop.h"
|
||||
|
||||
void
|
||||
RROP_NAME(cfbFillPoly1Rect) (pDrawable, pGC, shape, mode, count, ptsIn)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int shape;
|
||||
int mode;
|
||||
int count;
|
||||
DDXPointPtr ptsIn;
|
||||
{
|
||||
cfbPrivGCPtr devPriv;
|
||||
int nwidth;
|
||||
CfbBits *addrl, *addr;
|
||||
#if PSZ == 24
|
||||
CfbBits startmask, endmask;
|
||||
register int pidx;
|
||||
#else
|
||||
#if PPW > 1
|
||||
CfbBits mask, bits = ~((CfbBits)0);
|
||||
#endif
|
||||
#endif
|
||||
int maxy;
|
||||
int origin;
|
||||
register int vertex1, vertex2;
|
||||
int c = 0;
|
||||
BoxPtr extents;
|
||||
int clip;
|
||||
int y;
|
||||
int *vertex1p = NULL, *vertex2p;
|
||||
int *endp;
|
||||
int x1 = 0, x2 = 0;
|
||||
int dx1 = 0, dx2 = 0;
|
||||
int dy1 = 0, dy2 = 0;
|
||||
int e1 = 0, e2 = 0;
|
||||
int step1 = 0, step2 = 0;
|
||||
int sign1 = 0, sign2 = 0;
|
||||
int h;
|
||||
int l;
|
||||
#if PSZ != 24 && PPW > 1
|
||||
int r;
|
||||
#endif
|
||||
int nmiddle;
|
||||
RROP_DECLARE
|
||||
|
||||
if (mode == CoordModePrevious)
|
||||
{
|
||||
miFillPolygon (pDrawable, pGC, shape, mode, count, ptsIn);
|
||||
return;
|
||||
}
|
||||
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
#ifdef NO_ONE_RECT
|
||||
if (REGION_NUM_RECTS(pGC->pCompositeClip) != 1)
|
||||
{
|
||||
miFillPolygon (pDrawable, pGC, shape, mode, count, ptsIn);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
origin = *((int *) &pDrawable->x);
|
||||
vertex2 = origin - ((origin & 0x8000) << 1);
|
||||
extents = &pGC->pCompositeClip->extents;
|
||||
RROP_FETCH_GCPRIV(devPriv);
|
||||
vertex1 = *((int *) &extents->x1) - vertex2;
|
||||
vertex2 = *((int *) &extents->x2) - vertex2 - 0x00010001;
|
||||
clip = 0;
|
||||
y = 32767;
|
||||
maxy = 0;
|
||||
vertex2p = (int *) ptsIn;
|
||||
endp = vertex2p + count;
|
||||
if (shape == Convex)
|
||||
{
|
||||
while (count--)
|
||||
{
|
||||
c = *vertex2p;
|
||||
clip |= (c - vertex1) | (vertex2 - c);
|
||||
c = intToY(c);
|
||||
if (c < y)
|
||||
{
|
||||
y = c;
|
||||
vertex1p = vertex2p;
|
||||
}
|
||||
vertex2p++;
|
||||
if (c > maxy)
|
||||
maxy = c;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
int yFlip = 0;
|
||||
dx1 = 1;
|
||||
x2 = -1;
|
||||
x1 = -1;
|
||||
while (count--)
|
||||
{
|
||||
c = *vertex2p;
|
||||
clip |= (c - vertex1) | (vertex2 - c);
|
||||
c = intToY(c);
|
||||
if (c < y)
|
||||
{
|
||||
y = c;
|
||||
vertex1p = vertex2p;
|
||||
}
|
||||
vertex2p++;
|
||||
if (c > maxy)
|
||||
maxy = c;
|
||||
if (c == x1)
|
||||
continue;
|
||||
if (dx1 > 0)
|
||||
{
|
||||
if (x2 < 0)
|
||||
x2 = c;
|
||||
else
|
||||
dx2 = dx1 = (c - x1) >> 31;
|
||||
}
|
||||
else
|
||||
if ((c - x1) >> 31 != dx1)
|
||||
{
|
||||
dx1 = ~dx1;
|
||||
yFlip++;
|
||||
}
|
||||
x1 = c;
|
||||
}
|
||||
x1 = (x2 - c) >> 31;
|
||||
if (x1 != dx1)
|
||||
yFlip++;
|
||||
if (x1 != dx2)
|
||||
yFlip++;
|
||||
if (yFlip != 2)
|
||||
clip = 0x8000;
|
||||
}
|
||||
if (y == maxy)
|
||||
return;
|
||||
|
||||
if (clip & 0x80008000)
|
||||
{
|
||||
miFillPolygon (pDrawable, pGC, shape, mode, vertex2p - (int *) ptsIn, ptsIn);
|
||||
return;
|
||||
}
|
||||
|
||||
#define AddrYPlus(a,y) (CfbBits *) (((unsigned char *) (a)) + (y) * nwidth)
|
||||
|
||||
cfbGetTypedWidthAndPointer(pDrawable, nwidth, addrl, unsigned char, CfbBits);
|
||||
addrl = AddrYPlus(addrl,y + pDrawable->y);
|
||||
origin = intToX(origin);
|
||||
vertex2p = vertex1p;
|
||||
vertex2 = vertex1 = *vertex2p++;
|
||||
if (vertex2p == endp)
|
||||
vertex2p = (int *) ptsIn;
|
||||
#define Setup(c,x,vertex,dx,dy,e,sign,step) {\
|
||||
x = intToX(vertex); \
|
||||
if ((dy = intToY(c) - y)) { \
|
||||
dx = intToX(c) - x; \
|
||||
step = 0; \
|
||||
if (dx >= 0) \
|
||||
{ \
|
||||
e = 0; \
|
||||
sign = 1; \
|
||||
if (dx >= dy) {\
|
||||
step = dx / dy; \
|
||||
dx = dx % dy; \
|
||||
} \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
e = 1 - dy; \
|
||||
sign = -1; \
|
||||
dx = -dx; \
|
||||
if (dx >= dy) { \
|
||||
step = - (dx / dy); \
|
||||
dx = dx % dy; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
x += origin; \
|
||||
vertex = c; \
|
||||
}
|
||||
|
||||
#define Step(x,dx,dy,e,sign,step) {\
|
||||
x += step; \
|
||||
if ((e += dx) > 0) \
|
||||
{ \
|
||||
x += sign; \
|
||||
e -= dy; \
|
||||
} \
|
||||
}
|
||||
for (;;)
|
||||
{
|
||||
if (y == intToY(vertex1))
|
||||
{
|
||||
do
|
||||
{
|
||||
if (vertex1p == (int *) ptsIn)
|
||||
vertex1p = endp;
|
||||
c = *--vertex1p;
|
||||
Setup (c,x1,vertex1,dx1,dy1,e1,sign1,step1)
|
||||
} while (y >= intToY(vertex1));
|
||||
h = dy1;
|
||||
}
|
||||
else
|
||||
{
|
||||
Step(x1,dx1,dy1,e1,sign1,step1)
|
||||
h = intToY(vertex1) - y;
|
||||
}
|
||||
if (y == intToY(vertex2))
|
||||
{
|
||||
do
|
||||
{
|
||||
c = *vertex2p++;
|
||||
if (vertex2p == endp)
|
||||
vertex2p = (int *) ptsIn;
|
||||
Setup (c,x2,vertex2,dx2,dy2,e2,sign2,step2)
|
||||
} while (y >= intToY(vertex2));
|
||||
if (dy2 < h)
|
||||
h = dy2;
|
||||
}
|
||||
else
|
||||
{
|
||||
Step(x2,dx2,dy2,e2,sign2,step2)
|
||||
if ((c = (intToY(vertex2) - y)) < h)
|
||||
h = c;
|
||||
}
|
||||
/* fill spans for this segment */
|
||||
y += h;
|
||||
for (;;)
|
||||
{
|
||||
l = x1;
|
||||
#if PSZ != 24 && PPW > 1
|
||||
r = x2;
|
||||
#endif
|
||||
nmiddle = x2 - x1;
|
||||
if (nmiddle < 0)
|
||||
{
|
||||
nmiddle = -nmiddle;
|
||||
l = x2;
|
||||
#if PSZ != 24 && PPW > 1
|
||||
r = x1;
|
||||
#endif
|
||||
}
|
||||
#if PPW > 1
|
||||
c = l & PIM;
|
||||
l -= c;
|
||||
#endif
|
||||
|
||||
#if PGSZ == 32
|
||||
#define LWRD_SHIFT 2
|
||||
#else /* PGSZ == 64 */
|
||||
#define LWRD_SHIFT 3
|
||||
#endif /* PGSZ */
|
||||
|
||||
#if PSZ == 24
|
||||
addr = (CfbBits *)((char *)addrl + ((l * 3) & ~0x03));
|
||||
if (nmiddle <= 1){
|
||||
if (nmiddle)
|
||||
RROP_SOLID24(addr, l);
|
||||
} else {
|
||||
maskbits(l, nmiddle, startmask, endmask, nmiddle);
|
||||
pidx = l & 3;
|
||||
if (startmask){
|
||||
RROP_SOLID_MASK(addr, startmask, pidx-1);
|
||||
addr++;
|
||||
if (pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
while (--nmiddle >= 0){
|
||||
RROP_SOLID(addr, pidx);
|
||||
addr++;
|
||||
if (++pidx == 3)
|
||||
pidx = 0;
|
||||
}
|
||||
if (endmask)
|
||||
RROP_SOLID_MASK(addr, endmask, pidx);
|
||||
}
|
||||
#else /* PSZ == 24 */
|
||||
#if PWSH > LWRD_SHIFT
|
||||
l = l >> (PWSH - LWRD_SHIFT);
|
||||
#endif
|
||||
#if PWSH < LWRD_SHIFT
|
||||
l = l << (LWRD_SHIFT - PWSH);
|
||||
#endif
|
||||
addr = (CfbBits *) (((char *) addrl) + l);
|
||||
#if PPW > 1
|
||||
if (c + nmiddle < PPW)
|
||||
{
|
||||
mask = SCRRIGHT (bits,c) ^ SCRRIGHT (bits,c+nmiddle);
|
||||
RROP_SOLID_MASK(addr,mask);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (c)
|
||||
{
|
||||
mask = SCRRIGHT(bits, c);
|
||||
RROP_SOLID_MASK(addr,mask);
|
||||
nmiddle += c - PPW;
|
||||
addr++;
|
||||
}
|
||||
#endif
|
||||
nmiddle >>= PWSH;
|
||||
while (--nmiddle >= 0) {
|
||||
RROP_SOLID(addr); addr++;
|
||||
}
|
||||
#if PPW > 1
|
||||
if ((mask = ~SCRRIGHT(bits, r & PIM)))
|
||||
RROP_SOLID_MASK(addr,mask);
|
||||
}
|
||||
#endif
|
||||
#endif /* PSZ == 24 */
|
||||
if (!--h)
|
||||
break;
|
||||
addrl = AddrYPlus (addrl, 1);
|
||||
Step(x1,dx1,dy1,e1,sign1,step1)
|
||||
Step(x2,dx2,dy2,e2,sign2,step2)
|
||||
}
|
||||
if (y == maxy)
|
||||
break;
|
||||
addrl = AddrYPlus (addrl, 1);
|
||||
}
|
||||
RROP_UNDECLARE
|
||||
}
|
202
cfb/cfbpolypnt.c
202
cfb/cfbpolypnt.c
|
@ -1,202 +0,0 @@
|
|||
/************************************************************
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
********************************************************/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
#define isClipped(c,ul,lr) ((((c) - (ul)) | ((lr) - (c))) & ClipMask)
|
||||
|
||||
/* WARNING: pbox contains two shorts. This code assumes they are packed
|
||||
* and can be referenced together as an INT32.
|
||||
*/
|
||||
|
||||
#define PointLoop(fill) { \
|
||||
for (nbox = REGION_NUM_RECTS(cclip), pbox = REGION_RECTS(cclip); \
|
||||
--nbox >= 0; \
|
||||
pbox++) \
|
||||
{ \
|
||||
c1 = *((INT32 *) &pbox->x1) - off; \
|
||||
c2 = *((INT32 *) &pbox->x2) - off - 0x00010001; \
|
||||
for (ppt = (INT32 *) pptInit, i = npt; --i >= 0;) \
|
||||
{ \
|
||||
pt = *ppt++; \
|
||||
if (!isClipped(pt,c1,c2)) { \
|
||||
fill \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#if PSZ == 24
|
||||
# include "cfbrrop24.h"
|
||||
#endif
|
||||
|
||||
void
|
||||
cfbPolyPoint(pDrawable, pGC, mode, npt, pptInit)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int mode;
|
||||
int npt;
|
||||
xPoint *pptInit;
|
||||
{
|
||||
register INT32 pt;
|
||||
register INT32 c1, c2;
|
||||
register CARD32 ClipMask = 0x80008000;
|
||||
register CfbBits xor;
|
||||
#ifdef PIXEL_ADDR
|
||||
register PixelType *addrp;
|
||||
register int npwidth;
|
||||
#if PSZ != 24
|
||||
PixelType *addrpt;
|
||||
#endif
|
||||
#else
|
||||
register CfbBits *addrl;
|
||||
register int nlwidth;
|
||||
register int xoffset;
|
||||
CfbBits *addrlt;
|
||||
#endif
|
||||
#if PSZ == 24
|
||||
RROP_DECLARE
|
||||
register int xtmp;
|
||||
register PixelType *p;
|
||||
#endif
|
||||
register INT32 *ppt;
|
||||
RegionPtr cclip;
|
||||
int nbox;
|
||||
register int i;
|
||||
register BoxPtr pbox;
|
||||
CfbBits and;
|
||||
int rop = pGC->alu;
|
||||
int off;
|
||||
cfbPrivGCPtr devPriv;
|
||||
xPoint *pptPrev;
|
||||
|
||||
devPriv =cfbGetGCPrivate(pGC);
|
||||
rop = devPriv->rop;
|
||||
if (rop == GXnoop)
|
||||
return;
|
||||
cclip = pGC->pCompositeClip;
|
||||
xor = devPriv->xor;
|
||||
if ((mode == CoordModePrevious) && (npt > 1))
|
||||
{
|
||||
for (pptPrev = pptInit + 1, i = npt - 1; --i >= 0; pptPrev++)
|
||||
{
|
||||
pptPrev->x += (pptPrev-1)->x;
|
||||
pptPrev->y += (pptPrev-1)->y;
|
||||
}
|
||||
}
|
||||
off = *((int *) &pDrawable->x);
|
||||
off -= (off & 0x8000) << 1;
|
||||
#ifdef PIXEL_ADDR
|
||||
cfbGetPixelWidthAndPointer(pDrawable, npwidth, addrp);
|
||||
#if PSZ == 24
|
||||
addrp = addrp + pDrawable->y * npwidth;
|
||||
#else
|
||||
addrp = addrp + pDrawable->y * npwidth + pDrawable->x;
|
||||
#endif
|
||||
if (rop == GXcopy)
|
||||
{
|
||||
#if PSZ == 24
|
||||
RROP_COPY_SETUP(xor)
|
||||
#endif
|
||||
if (!(npwidth & (npwidth - 1)))
|
||||
{
|
||||
npwidth = ffs(npwidth) - 1;
|
||||
#if PSZ == 24
|
||||
PointLoop(
|
||||
xtmp = pDrawable->x + intToX(pt);
|
||||
p = addrp + (intToY(pt) << npwidth) + ((xtmp * 3) >>2);
|
||||
RROP_SOLID24_COPY(p, xtmp))
|
||||
#else
|
||||
PointLoop(*(addrp + (intToY(pt) << npwidth) + intToX(pt)) = xor;)
|
||||
#endif
|
||||
}
|
||||
#ifdef sun
|
||||
else if (npwidth == 1152)
|
||||
{
|
||||
register int y;
|
||||
PointLoop(y = intToY(pt); *(addrp + (y << 10) + (y << 7) + intToX(pt)) = xor;)
|
||||
}
|
||||
#endif
|
||||
else
|
||||
{
|
||||
#if PSZ == 24
|
||||
PointLoop(
|
||||
xtmp = pDrawable->x + intToX(pt);
|
||||
p = addrp + intToY(pt) * npwidth + ((xtmp * 3) >> 2);
|
||||
RROP_SOLID24_COPY(p, xtmp))
|
||||
#else
|
||||
PointLoop(*(addrp + intToY(pt) * npwidth + intToX(pt)) = xor;)
|
||||
#endif
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
and = devPriv->and;
|
||||
#if PSZ == 24
|
||||
RROP_SET_SETUP(xor, and)
|
||||
PointLoop(
|
||||
xtmp = pDrawable->x + intToX(pt);
|
||||
p = addrp + intToY(pt) * npwidth + ((xtmp * 3) >> 2);
|
||||
RROP_SOLID24_SET(p, xtmp))
|
||||
#else
|
||||
PointLoop( addrpt = addrp + intToY(pt) * npwidth + intToX(pt);
|
||||
*addrpt = DoRRop (*addrpt, and, xor);)
|
||||
#endif
|
||||
}
|
||||
#else /* !PIXEL_ADDR */
|
||||
cfbGetLongWidthAndPointer(pDrawable, nlwidth, addrl);
|
||||
addrl = addrl + pDrawable->y * nlwidth + (pDrawable->x >> PWSH);
|
||||
xoffset = pDrawable->x & PIM;
|
||||
and = devPriv->and;
|
||||
#if PSZ == 24
|
||||
PointLoop( addrlt = addrl + intToY(pt) * nlwidth
|
||||
+ ((intToX(pt) + xoffset) >> PWSH);
|
||||
*addrlt = DoRRop (*addrlt,
|
||||
and | ~cfbmask[(intToX(pt) + xoffset) & PIM],
|
||||
xor & cfbmask[(intToX(pt) + xoffset) & PIM]);
|
||||
)
|
||||
#else
|
||||
PointLoop( addrlt = addrl + intToY(pt) * nlwidth
|
||||
+ ((intToX(pt) + xoffset) >> PWSH);
|
||||
*addrlt = DoRRop (*addrlt,
|
||||
and | ~cfbmask[((intToX(pt) + xoffset) & 3)<<1],
|
||||
xor & cfbmask[((intToX(pt) + xoffset) & 3)<<1]);
|
||||
)
|
||||
#endif
|
||||
#endif /* PIXEL_ADDR */
|
||||
}
|
184
cfb/cfbpush8.c
184
cfb/cfbpush8.c
|
@ -1,184 +0,0 @@
|
|||
/*
|
||||
* Push Pixels for 8 bit displays.
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
#define MFB_CONSTS_ONLY
|
||||
#include "maskbits.h"
|
||||
|
||||
void
|
||||
cfbPushPixels8 (pGC, pBitmap, pDrawable, dx, dy, xOrg, yOrg)
|
||||
GCPtr pGC;
|
||||
PixmapPtr pBitmap;
|
||||
DrawablePtr pDrawable;
|
||||
int dx, dy, xOrg, yOrg;
|
||||
{
|
||||
register CfbBits *src, *dst;
|
||||
register CfbBits pixel;
|
||||
register CfbBits c, bits;
|
||||
CfbBits *pdstLine, *psrcLine;
|
||||
CfbBits *pdstBase;
|
||||
int srcWidth;
|
||||
int dstWidth;
|
||||
int xoff;
|
||||
int nBitmapLongs, nPixmapLongs;
|
||||
int nBitmapTmp, nPixmapTmp;
|
||||
CfbBits rightMask;
|
||||
BoxRec bbox;
|
||||
cfbPrivGCPtr devPriv;
|
||||
|
||||
bbox.x1 = xOrg;
|
||||
bbox.y1 = yOrg;
|
||||
bbox.x2 = bbox.x1 + dx;
|
||||
bbox.y2 = bbox.y1 + dy;
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
|
||||
switch (RECT_IN_REGION(pGC->pScreen, pGC->pCompositeClip, &bbox))
|
||||
{
|
||||
case rgnPART:
|
||||
mfbPushPixels(pGC, pBitmap, pDrawable, dx, dy, xOrg, yOrg);
|
||||
case rgnOUT:
|
||||
return;
|
||||
}
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, dstWidth, pdstBase)
|
||||
|
||||
psrcLine = (CfbBits *) pBitmap->devPrivate.ptr;
|
||||
srcWidth = (int) pBitmap->devKind >> PWSH;
|
||||
|
||||
pixel = devPriv->xor;
|
||||
xoff = xOrg & PIM;
|
||||
nBitmapLongs = (dx + xoff) >> MFB_PWSH;
|
||||
nPixmapLongs = (dx + PGSZB + xoff) >> PWSH;
|
||||
|
||||
rightMask = ~cfb8BitLenMasks[((dx + xoff) & MFB_PIM)];
|
||||
|
||||
pdstLine = pdstBase + (yOrg * dstWidth) + (xOrg >> PWSH);
|
||||
|
||||
while (dy--)
|
||||
{
|
||||
c = 0;
|
||||
nPixmapTmp = nPixmapLongs;
|
||||
nBitmapTmp = nBitmapLongs;
|
||||
src = psrcLine;
|
||||
dst = pdstLine;
|
||||
while (nBitmapTmp--)
|
||||
{
|
||||
bits = *src++;
|
||||
c |= BitRight (bits, xoff);
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
nPixmapTmp -= 8;
|
||||
c = 0;
|
||||
if (xoff)
|
||||
c = BitLeft (bits, PGSZ - xoff);
|
||||
}
|
||||
if (BitLeft (rightMask, xoff))
|
||||
c |= BitRight (*src, xoff);
|
||||
c &= rightMask;
|
||||
switch (nPixmapTmp) {
|
||||
case 8:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 7:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 6:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 5:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 4:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 3:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 2:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 1:
|
||||
WriteBitGroup(dst, pixel, GetBitGroup(c));
|
||||
NextBitGroup(c);
|
||||
dst++;
|
||||
case 0:
|
||||
break;
|
||||
}
|
||||
pdstLine += dstWidth;
|
||||
psrcLine += srcWidth;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
593
cfb/cfbrctstp8.c
593
cfb/cfbrctstp8.c
|
@ -1,593 +0,0 @@
|
|||
/*
|
||||
* Fill 32 bit stippled rectangles for 8 bit frame buffers
|
||||
*/
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
Author: Keith Packard, MIT X Consortium
|
||||
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "gcstruct.h"
|
||||
#include "window.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
#define MFB_CONSTS_ONLY
|
||||
#include "maskbits.h"
|
||||
|
||||
void
|
||||
cfb8FillRectOpaqueStippled32 (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox; /* number of boxes to fill */
|
||||
register BoxPtr pBox; /* pointer to list of boxes to fill */
|
||||
{
|
||||
CfbBits *src;
|
||||
int stippleHeight;
|
||||
|
||||
int nlwDst; /* width in longwords of the dest pixmap */
|
||||
int w; /* width of current box */
|
||||
register int h; /* height of current box */
|
||||
CfbBits startmask;
|
||||
CfbBits endmask; /* masks for reggedy bits at either end of line */
|
||||
int nlwMiddle; /* number of longwords between sides of boxes */
|
||||
register int nlw; /* loop version of nlwMiddle */
|
||||
CfbBits *dstLine;
|
||||
register CfbBits *dst; /* pointer to bits we're writing */
|
||||
CfbBits *dstTmp;
|
||||
int y; /* current scan line */
|
||||
|
||||
CfbBits *pbits;/* pointer to start of pixmap */
|
||||
register CfbBits bits; /* bits from stipple */
|
||||
int rot;
|
||||
register CfbBits xor;
|
||||
PixmapPtr stipple;
|
||||
int wEnd;
|
||||
|
||||
stipple = pGC->pRotatedPixmap;
|
||||
|
||||
cfb8CheckOpaqueStipple(pGC->alu, pGC->fgPixel, pGC->bgPixel, pGC->planemask);
|
||||
|
||||
stippleHeight = stipple->drawable.height;
|
||||
src = (CfbBits *)stipple->devPrivate.ptr;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pbits)
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
w = pBox->x2 - pBox->x1;
|
||||
h = pBox->y2 - pBox->y1;
|
||||
y = pBox->y1;
|
||||
dstLine = pbits + (pBox->y1 * nlwDst) + ((pBox->x1 & ~PIM) >> PWSH);
|
||||
if (((pBox->x1 & PIM) + w) <= PPW)
|
||||
{
|
||||
maskpartialbits(pBox->x1, w, startmask);
|
||||
nlwMiddle = 0;
|
||||
endmask = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (pBox->x1, w, startmask, endmask, nlwMiddle);
|
||||
}
|
||||
rot = (pBox->x1 & ((PGSZ-1) & ~PIM));
|
||||
pBox++;
|
||||
y = y % stippleHeight;
|
||||
#if PPW == 4
|
||||
if (cfb8StippleRRop == GXcopy)
|
||||
{
|
||||
if (w < PGSZ*2)
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot)
|
||||
RotBitsLeft(bits,rot);
|
||||
dst = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
*dst = (*dst & ~startmask) |
|
||||
(GetPixelGroup (bits) & startmask);
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
nlw = nlwMiddle;
|
||||
while (nlw--)
|
||||
{
|
||||
*dst++ = GetPixelGroup(bits);
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
*dst = (*dst & ~endmask) |
|
||||
(GetPixelGroup (bits) & endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
wEnd = 7 - (nlwMiddle & 7);
|
||||
nlwMiddle = (nlwMiddle >> 3) + 1;
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot != 0)
|
||||
RotBitsLeft (bits, rot);
|
||||
dstTmp = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
*dstTmp = (*dstTmp & ~startmask) |
|
||||
(GetPixelGroup (bits) & startmask);
|
||||
dstTmp++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
w = 7 - wEnd;
|
||||
while (w--)
|
||||
{
|
||||
nlw = nlwMiddle;
|
||||
dst = dstTmp;
|
||||
dstTmp++;
|
||||
xor = GetPixelGroup (bits);
|
||||
while (nlw--)
|
||||
{
|
||||
*dst = xor;
|
||||
dst += 8;
|
||||
}
|
||||
NextBitGroup (bits);
|
||||
}
|
||||
nlwMiddle--;
|
||||
w = wEnd + 1;
|
||||
if (endmask)
|
||||
{
|
||||
dst = dstTmp + (nlwMiddle << 3);
|
||||
*dst = (*dst & ~endmask) |
|
||||
(GetPixelGroup(bits) & endmask);
|
||||
}
|
||||
while (w--)
|
||||
{
|
||||
nlw = nlwMiddle;
|
||||
dst = dstTmp;
|
||||
dstTmp++;
|
||||
xor = GetPixelGroup (bits);
|
||||
while (nlw--)
|
||||
{
|
||||
*dst = xor;
|
||||
dst += 8;
|
||||
}
|
||||
NextBitGroup (bits);
|
||||
}
|
||||
nlwMiddle++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif /* PPW == 4 */
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot)
|
||||
RotBitsLeft(bits,rot);
|
||||
dst = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
xor = GetBitGroup(bits);
|
||||
*dst = MaskRRopPixels(*dst, xor, startmask);
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
nlw = nlwMiddle;
|
||||
while (nlw--)
|
||||
{
|
||||
RRopBitGroup(dst, GetBitGroup(bits));
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
xor = GetBitGroup(bits);
|
||||
*dst = MaskRRopPixels(*dst, xor, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
cfb8FillRectTransparentStippled32 (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox; /* number of boxes to fill */
|
||||
BoxPtr pBox; /* pointer to list of boxes to fill */
|
||||
{
|
||||
int x, y, w, h;
|
||||
int nlwMiddle, nlwDst;
|
||||
CfbBits startmask, endmask;
|
||||
register CfbBits *dst;
|
||||
CfbBits *dstLine, *pbits, *dstTmp;
|
||||
CfbBits *src;
|
||||
register CfbBits xor;
|
||||
register CfbBits bits, mask;
|
||||
int rot;
|
||||
int wEnd;
|
||||
cfbPrivGCPtr devPriv;
|
||||
PixmapPtr stipple;
|
||||
int stippleHeight;
|
||||
register int nlw;
|
||||
|
||||
devPriv = cfbGetGCPrivate(pGC);
|
||||
stipple = pGC->pRotatedPixmap;
|
||||
src = (CfbBits *)stipple->devPrivate.ptr;
|
||||
stippleHeight = stipple->drawable.height;
|
||||
|
||||
cfb8CheckStipple (pGC->alu, pGC->fgPixel, pGC->planemask);
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pbits)
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
x = pBox->x1;
|
||||
w = pBox->x2 - x;
|
||||
if (((x & PIM) + w) <= PPW)
|
||||
{
|
||||
maskpartialbits(x, w, startmask);
|
||||
endmask = 0;
|
||||
nlwMiddle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (x, w, startmask, endmask, nlwMiddle);
|
||||
}
|
||||
rot = (x & ((PGSZ-1) & ~PIM));
|
||||
y = pBox->y1;
|
||||
dstLine = pbits + (y * nlwDst) + (x >> PWSH);
|
||||
h = pBox->y2 - y;
|
||||
pBox++;
|
||||
y %= stippleHeight;
|
||||
#if PPW == 4
|
||||
if (cfb8StippleRRop == GXcopy)
|
||||
{
|
||||
xor = devPriv->xor;
|
||||
if (w < PGSZ*2)
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot != 0)
|
||||
RotBitsLeft (bits, rot);
|
||||
dst = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
*dst = (*dst & ~(mask & startmask)) |
|
||||
(xor & (mask & startmask));
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
nlw = nlwMiddle;
|
||||
while (nlw--)
|
||||
{
|
||||
WriteBitGroup (dst,xor,GetBitGroup(bits))
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
*dst = (*dst & ~(mask & endmask)) |
|
||||
(xor & (mask & endmask));
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
wEnd = 7 - (nlwMiddle & 7);
|
||||
nlwMiddle = (nlwMiddle >> 3) + 1;
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot != 0)
|
||||
RotBitsLeft (bits, rot);
|
||||
dstTmp = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
*dstTmp = (*dstTmp & ~(mask & startmask)) |
|
||||
(xor & (mask & startmask));
|
||||
dstTmp++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
w = 7 - wEnd;
|
||||
while (w--)
|
||||
{
|
||||
nlw = nlwMiddle;
|
||||
dst = dstTmp;
|
||||
dstTmp++;
|
||||
#if defined(__GNUC__) && defined(mc68020)
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
xor = xor & mask;
|
||||
mask = ~mask;
|
||||
while (nlw--)
|
||||
{
|
||||
*dst = (*dst & mask) | xor;
|
||||
dst += 8;
|
||||
}
|
||||
xor = devPriv->xor;
|
||||
#else
|
||||
#define SwitchBitsLoop(body) \
|
||||
while (nlw--) \
|
||||
{ \
|
||||
body \
|
||||
dst += 8; \
|
||||
}
|
||||
SwitchBitGroup(dst, xor, GetBitGroup(bits));
|
||||
#undef SwitchBitsLoop
|
||||
#endif
|
||||
NextBitGroup (bits);
|
||||
}
|
||||
nlwMiddle--;
|
||||
w = wEnd + 1;
|
||||
if (endmask)
|
||||
{
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
dst = dstTmp + (nlwMiddle << 3);
|
||||
*dst = (*dst & ~(mask & endmask)) |
|
||||
(xor & (mask & endmask));
|
||||
}
|
||||
while (w--)
|
||||
{
|
||||
nlw = nlwMiddle;
|
||||
dst = dstTmp;
|
||||
dstTmp++;
|
||||
#if defined(__GNUC__) && defined(mc68020)
|
||||
mask = cfb8PixelMasks[GetBitGroup(bits)];
|
||||
xor = xor & mask;
|
||||
mask = ~mask;
|
||||
while (nlw--)
|
||||
{
|
||||
*dst = (*dst & mask) | xor;
|
||||
dst += 8;
|
||||
}
|
||||
xor = devPriv->xor;
|
||||
#else
|
||||
#define SwitchBitsLoop(body) \
|
||||
while (nlw--) \
|
||||
{ \
|
||||
body \
|
||||
dst += 8; \
|
||||
}
|
||||
SwitchBitGroup(dst, xor, GetBitGroup(bits));
|
||||
#undef SwitchBitsLoop
|
||||
#endif
|
||||
NextBitGroup (bits);
|
||||
}
|
||||
nlwMiddle++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif /* PPW == 4 */
|
||||
{
|
||||
while (h--)
|
||||
{
|
||||
bits = src[y];
|
||||
y++;
|
||||
if (y == stippleHeight)
|
||||
y = 0;
|
||||
if (rot != 0)
|
||||
RotBitsLeft (bits, rot);
|
||||
dst = dstLine;
|
||||
dstLine += nlwDst;
|
||||
if (startmask)
|
||||
{
|
||||
xor = GetBitGroup(bits);
|
||||
*dst = MaskRRopPixels(*dst, xor, startmask);
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
nlw = nlwMiddle;
|
||||
while (nlw--)
|
||||
{
|
||||
RRopBitGroup(dst, GetBitGroup(bits));
|
||||
dst++;
|
||||
RotBitsLeft (bits, PGSZB);
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
xor = GetBitGroup(bits);
|
||||
*dst = MaskRRopPixels(*dst, xor, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
cfb8FillRectStippledUnnatural (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox;
|
||||
register BoxPtr pBox;
|
||||
{
|
||||
CfbBits *pdstBase; /* pointer to start of bitmap */
|
||||
CfbBits *pdstLine; /* current destination line */
|
||||
int nlwDst; /* width in longwords of bitmap */
|
||||
PixmapPtr pStipple; /* pointer to stipple we want to fill with */
|
||||
int nlwMiddle;
|
||||
register int nlw;
|
||||
int x, y, w, h, xrem, xSrc, ySrc;
|
||||
int stwidth, stippleWidth;
|
||||
int stippleHeight;
|
||||
register CfbBits bits, inputBits;
|
||||
register int partBitsLeft;
|
||||
int nextPartBits;
|
||||
int bitsLeft, bitsWhole;
|
||||
register CfbBits *pdst; /* pointer to current word in bitmap */
|
||||
CfbBits *srcTemp, *srcStart;
|
||||
CfbBits *psrcBase;
|
||||
CfbBits startmask, endmask;
|
||||
|
||||
if (pGC->fillStyle == FillStippled)
|
||||
cfb8CheckStipple (pGC->alu, pGC->fgPixel, pGC->planemask);
|
||||
else
|
||||
cfb8CheckOpaqueStipple (pGC->alu, pGC->fgPixel, pGC->bgPixel, pGC->planemask);
|
||||
|
||||
if (cfb8StippleRRop == GXnoop)
|
||||
return;
|
||||
|
||||
/*
|
||||
* OK, so what's going on here? We have two Drawables:
|
||||
*
|
||||
* The Stipple:
|
||||
* Depth = 1
|
||||
* Width = stippleWidth
|
||||
* Words per scanline = stwidth
|
||||
* Pointer to pixels = pStipple->devPrivate.ptr
|
||||
*/
|
||||
|
||||
pStipple = pGC->stipple;
|
||||
|
||||
stwidth = pStipple->devKind >> PWSH;
|
||||
stippleWidth = pStipple->drawable.width;
|
||||
stippleHeight = pStipple->drawable.height;
|
||||
psrcBase = (CfbBits *) pStipple->devPrivate.ptr;
|
||||
|
||||
/*
|
||||
* The Target:
|
||||
* Depth = PSZ
|
||||
* Width = determined from *pwidth
|
||||
* Words per scanline = nlwDst
|
||||
* Pointer to pixels = addrlBase
|
||||
*/
|
||||
|
||||
xSrc = pDrawable->x;
|
||||
ySrc = pDrawable->y;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pdstBase)
|
||||
|
||||
/* this replaces rotating the stipple. Instead we just adjust the offset
|
||||
* at which we start grabbing bits from the stipple.
|
||||
* Ensure that ppt->x - xSrc >= 0 and ppt->y - ySrc >= 0,
|
||||
* so that iline and xrem always stay within the stipple bounds.
|
||||
*/
|
||||
|
||||
xSrc += (pGC->patOrg.x % stippleWidth) - stippleWidth;
|
||||
ySrc += (pGC->patOrg.y % stippleHeight) - stippleHeight;
|
||||
|
||||
bitsWhole = stippleWidth;
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
x = pBox->x1;
|
||||
y = pBox->y1;
|
||||
w = pBox->x2 - x;
|
||||
h = pBox->y2 - y;
|
||||
pBox++;
|
||||
pdstLine = pdstBase + y * nlwDst + (x >> PWSH);
|
||||
y = (y - ySrc) % stippleHeight;
|
||||
srcStart = psrcBase + y * stwidth;
|
||||
xrem = ((x & ~PIM) - xSrc) % stippleWidth;
|
||||
if (((x & PIM) + w) < PPW)
|
||||
{
|
||||
maskpartialbits (x, w, startmask);
|
||||
nlwMiddle = 0;
|
||||
endmask = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits (x, w, startmask, endmask, nlwMiddle);
|
||||
}
|
||||
while (h--)
|
||||
{
|
||||
srcTemp = srcStart + (xrem >> MFB_PWSH);
|
||||
bitsLeft = stippleWidth - (xrem & ~MFB_PIM);
|
||||
NextUnnaturalStippleWord
|
||||
NextSomeBits (inputBits, (xrem & MFB_PIM));
|
||||
partBitsLeft -= (xrem & MFB_PIM);
|
||||
NextUnnaturalStippleBits
|
||||
nlw = nlwMiddle;
|
||||
pdst = pdstLine;
|
||||
if (startmask)
|
||||
{
|
||||
*pdst = MaskRRopPixels(*pdst,bits,startmask);
|
||||
pdst++;
|
||||
NextUnnaturalStippleBits
|
||||
}
|
||||
while (nlw--)
|
||||
{
|
||||
*pdst = RRopPixels(*pdst,bits);
|
||||
pdst++;
|
||||
NextUnnaturalStippleBits
|
||||
}
|
||||
if (endmask)
|
||||
*pdst = MaskRRopPixels(*pdst,bits,endmask);
|
||||
pdstLine += nlwDst;
|
||||
y++;
|
||||
srcStart += stwidth;
|
||||
if (y == stippleHeight)
|
||||
{
|
||||
y = 0;
|
||||
srcStart = psrcBase;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* PSZ == 8 */
|
227
cfb/cfbrrop.c
227
cfb/cfbrrop.c
|
@ -1,227 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
/* cfb reduced rasterop computations */
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
/* A description:
|
||||
*
|
||||
* There are four possible operations on each bit in the destination word,
|
||||
*
|
||||
* 1 2 3 4
|
||||
*
|
||||
* 0 0 0 1 1
|
||||
* 1 0 1 0 1
|
||||
*
|
||||
* On examination of the reduced rop equation (dst = (dst & and) ^ xor),
|
||||
* these four fall to reduced rops as follows:
|
||||
*
|
||||
* and 0 1 1 0
|
||||
* xor 0 0 1 1
|
||||
*
|
||||
* or, (if 'and' is expensive) (dst = (dst | or) ^ xor)
|
||||
*
|
||||
* or 1 0 0 1
|
||||
* xor 1 0 1 0
|
||||
*
|
||||
* The trouble with using this later equation is that trivial
|
||||
* rasterop reduction is more difficult; some common rasterops
|
||||
* use complicated expressions of xor/and instead of the simple
|
||||
* ones while other common rasterops are not made any simpler:
|
||||
*
|
||||
* GXcopy: *dst = ~xor instead of *dst = xor
|
||||
* GXand: *dst = *dst & ~or instead of *dst = *dst & and
|
||||
* GXor: *dst = *dst | or instead of *dst = *dst | xor
|
||||
* GXxor: *dst = *dst ^ xor instead of *dst = *dst ^ xor
|
||||
*
|
||||
* If you're really set on using this second mechanism, the changes
|
||||
* are pretty simple.
|
||||
*
|
||||
* All that remains is to provide a mechanism for computing and/xor values
|
||||
* based on the raster op and foreground value.
|
||||
*
|
||||
* The 16 rops fall as follows, with the associated reduced
|
||||
* rop and/xor and or/xor values. The values in parenthesis following the
|
||||
* reduced values gives an equation using the source value for
|
||||
* the reduced value, and is one of {0, src, ~src, 1} as appropriate.
|
||||
*
|
||||
* clear and andReverse copy
|
||||
* src 0 1 0 1 0 1 0 1
|
||||
* dst 0 0 0 0 0 0 0 0 1 0 0 1
|
||||
* 1 0 0 1 0 1 1 0 0 1 0 1
|
||||
*
|
||||
* and 0 0 (0) 0 1 (src) 0 1 (src) 0 0 (0)
|
||||
* xor 0 0 (0) 0 0 (0) 0 1 (src) 0 1 (src)
|
||||
*
|
||||
* or 1 1 (1) 1 0 (~src) 1 0 (~src) 1 1 (1)
|
||||
* xor 1 1 (1) 1 0 (~src) 1 1 (1) 1 0 (~src)
|
||||
*
|
||||
* andInverted noop xor or
|
||||
* src 0 1 0 1 0 1 0 1
|
||||
* dst 0 0 0 0 0 0 0 0 1 0 0 1
|
||||
* 1 1 0 1 1 1 1 1 0 1 1 1
|
||||
*
|
||||
* and 1 0 (~src) 1 1 (1) 1 1 (1) 1 0 (~src)
|
||||
* xor 0 0 (0) 0 0 (0) 0 1 (src) 0 1 (src)
|
||||
*
|
||||
* or 0 1 (src) 0 0 (0) 0 0 (0) 0 1 (src)
|
||||
* xor 0 1 (src) 0 0 (0) 0 1 (src) 0 0 (0)
|
||||
*
|
||||
* nor equiv invert orReverse
|
||||
* src 0 1 0 1 0 1 0 1
|
||||
* dst 0 1 0 0 1 0 0 1 1 0 1 1
|
||||
* 1 0 0 1 0 1 1 0 0 1 0 1
|
||||
*
|
||||
* and 1 0 (~src) 1 1 (1) 1 1 (1) 1 0 (~src)
|
||||
* xor 1 0 (~src) 1 0 (~src) 1 1 (1) 1 1 (1)
|
||||
*
|
||||
* or 0 1 (src) 0 0 (0) 0 0 (0) 0 1 (src)
|
||||
* xor 1 1 (1) 1 0 (~src) 1 1 (1) 1 0 (~src)
|
||||
*
|
||||
* copyInverted orInverted nand set
|
||||
* src 0 1 0 1 0 1 0 1
|
||||
* dst 0 1 0 0 1 0 0 1 1 0 1 1
|
||||
* 1 1 0 1 1 1 1 1 0 1 1 1
|
||||
*
|
||||
* and 0 0 (0) 0 1 (src) 0 1 (src) 0 0 (0)
|
||||
* xor 1 0 (~src) 1 0 (~src) 1 1 (1) 1 1 (1)
|
||||
*
|
||||
* or 1 1 (1) 1 0 (~src) 1 0 (~src) 1 1 (1)
|
||||
* xor 0 1 (src) 0 0 (0) 0 1 (src) 0 0 (0)
|
||||
*/
|
||||
|
||||
int
|
||||
cfbReduceRasterOp (rop, fg, pm, andp, xorp)
|
||||
int rop;
|
||||
CfbBits fg, pm;
|
||||
CfbBits *andp, *xorp;
|
||||
{
|
||||
CfbBits and, xor;
|
||||
int rrop;
|
||||
|
||||
fg = PFILL (fg);
|
||||
pm = PFILL (pm);
|
||||
switch (rop)
|
||||
{
|
||||
case GXclear:
|
||||
and = 0;
|
||||
xor = 0;
|
||||
break;
|
||||
case GXand:
|
||||
and = fg;
|
||||
xor = 0;
|
||||
break;
|
||||
case GXandReverse:
|
||||
and = fg;
|
||||
xor = fg;
|
||||
break;
|
||||
case GXcopy:
|
||||
and = 0;
|
||||
xor = fg;
|
||||
break;
|
||||
case GXandInverted:
|
||||
and = ~fg;
|
||||
xor = 0;
|
||||
break;
|
||||
case GXnoop:
|
||||
and = ~0;
|
||||
xor = 0;
|
||||
break;
|
||||
case GXxor:
|
||||
and = ~0;
|
||||
xor = fg;
|
||||
break;
|
||||
case GXor:
|
||||
and = ~fg;
|
||||
xor = fg;
|
||||
break;
|
||||
case GXnor:
|
||||
and = ~fg;
|
||||
xor = ~fg;
|
||||
break;
|
||||
case GXequiv:
|
||||
and = ~0;
|
||||
xor = ~fg;
|
||||
break;
|
||||
case GXinvert:
|
||||
and = ~0;
|
||||
xor = ~0;
|
||||
break;
|
||||
case GXorReverse:
|
||||
and = ~fg;
|
||||
xor = ~0;
|
||||
break;
|
||||
case GXcopyInverted:
|
||||
and = 0;
|
||||
xor = ~fg;
|
||||
break;
|
||||
case GXorInverted:
|
||||
and = fg;
|
||||
xor = ~fg;
|
||||
break;
|
||||
case GXnand:
|
||||
and = fg;
|
||||
xor = ~0;
|
||||
break;
|
||||
case GXset:
|
||||
and = 0;
|
||||
xor = ~0;
|
||||
break;
|
||||
default:
|
||||
and = xor = 0;
|
||||
break;
|
||||
}
|
||||
and |= ~pm;
|
||||
xor &= pm;
|
||||
*andp = and;
|
||||
*xorp = xor;
|
||||
/* check for some special cases to reduce computation */
|
||||
if (and == 0)
|
||||
rrop = GXcopy;
|
||||
/* nothing checks for GXnoop
|
||||
else if (and == ~0 && xor == 0)
|
||||
rrop = GXnoop;
|
||||
*/
|
||||
else if (and == ~0)
|
||||
rrop = GXxor;
|
||||
else if (xor == 0)
|
||||
rrop = GXand;
|
||||
else if ( (and ^ xor) == ~0) /* fix XBUG 6541 */
|
||||
rrop = GXor;
|
||||
else
|
||||
rrop = GXset; /* rop not reduced */
|
||||
return rrop;
|
||||
}
|
343
cfb/cfbrrop.h
343
cfb/cfbrrop.h
|
@ -1,343 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#ifndef GXcopy
|
||||
#include <X11/X.h>
|
||||
#endif
|
||||
|
||||
#define RROP_FETCH_GC(gc) \
|
||||
RROP_FETCH_GCPRIV((cfbPrivGCPtr)dixLookupPrivate(&(gc)->devPrivates, \
|
||||
cfbGCPrivateKey))
|
||||
|
||||
#ifndef RROP
|
||||
#define RROP GXset
|
||||
#endif
|
||||
|
||||
#if RROP == GXcopy
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_xor; \
|
||||
CfbBits piQxelXor[3], spiQxelXor[8];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_xor = (devPriv)->xor; \
|
||||
spiQxelXor[0] = rrop_xor & 0xFFFFFF; \
|
||||
spiQxelXor[2] = rrop_xor << 24; \
|
||||
spiQxelXor[3] = (rrop_xor & 0xFFFF00)>> 8; \
|
||||
spiQxelXor[4] = rrop_xor << 16; \
|
||||
spiQxelXor[5] = (rrop_xor & 0xFF0000)>> 16; \
|
||||
spiQxelXor[6] = rrop_xor << 8; \
|
||||
spiQxelXor[1] = spiQxelXor[7] = 0; \
|
||||
piQxelXor[0] = (rrop_xor & 0xFFFFFF)|(rrop_xor << 24); \
|
||||
piQxelXor[1] = (rrop_xor << 16)|((rrop_xor & 0xFFFF00)>> 8); \
|
||||
piQxelXor[2] = (rrop_xor << 8)|((rrop_xor & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
register int idx = ((index) & 3)<< 1; \
|
||||
*(dst) = (*(dst) & cfbrmask[idx])|spiQxelXor[idx]; \
|
||||
if (idx == 2 || idx == 4){ \
|
||||
idx++; \
|
||||
*((dst)+1) = (*((dst)+1) & cfbrmask[idx])|spiQxelXor[idx]; \
|
||||
} \
|
||||
}
|
||||
#define RROP_SOLID(dst, idx) \
|
||||
(*(dst) = piQxelXor[(idx)])
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) = (*(dst) & ~(mask))|(piQxelXor[(idx)] & (mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelXor; (void)spiQxelXor;
|
||||
#else
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_xor = (devPriv)->xor;
|
||||
#define RROP_DECLARE register CfbBits rrop_xor;
|
||||
#define RROP_SOLID(dst) (*(dst) = (rrop_xor))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) = (*(dst) & ~(mask)) | ((rrop_xor) & (mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,Copy)
|
||||
#endif /* GXcopy */
|
||||
|
||||
#if RROP == GXxor
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_xor; \
|
||||
CfbBits piQxelXor[3], spiQxelXor[8];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_xor = (devPriv)->xor; \
|
||||
spiQxelXor[0] = rrop_xor & 0xFFFFFF; \
|
||||
spiQxelXor[2] = rrop_xor << 24; \
|
||||
spiQxelXor[3] = (rrop_xor & 0xFFFF00)>> 8; \
|
||||
spiQxelXor[4] = rrop_xor << 16; \
|
||||
spiQxelXor[5] = (rrop_xor & 0xFF0000)>> 16; \
|
||||
spiQxelXor[6] = rrop_xor << 8; \
|
||||
spiQxelXor[1] = spiQxelXor[7] = 0; \
|
||||
piQxelXor[0] = (rrop_xor & 0xFFFFFF)|(rrop_xor << 24); \
|
||||
piQxelXor[1] = (rrop_xor << 16)|((rrop_xor & 0xFFFF00)>> 8); \
|
||||
piQxelXor[2] = (rrop_xor << 8)|((rrop_xor & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
register int idx = ((index) & 3)<< 1; \
|
||||
*(dst) ^= spiQxelXor[idx]; \
|
||||
if (idx == 2 || idx == 4) \
|
||||
*((dst)+1) ^= spiQxelXor[idx+1]; \
|
||||
}
|
||||
#define RROP_SOLID(dst,idx) \
|
||||
(*(dst) ^= piQxelXor[(idx)])
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) ^= (piQxelXor[(idx)] & (mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelXor; (void)spiQxelXor;
|
||||
#else
|
||||
#define RROP_DECLARE register CfbBits rrop_xor;
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_xor = (devPriv)->xor;
|
||||
#define RROP_SOLID(dst) (*(dst) ^= (rrop_xor))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) ^= ((rrop_xor) & (mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,Xor)
|
||||
#endif /* GXxor */
|
||||
|
||||
#if RROP == GXand
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_and; \
|
||||
CfbBits piQxelAnd[3], spiQxelAnd[6];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_and = (devPriv)->and; \
|
||||
spiQxelAnd[0] = (rrop_and & 0xFFFFFF) | 0xFF000000; \
|
||||
spiQxelAnd[2] = (rrop_and << 24) | 0xFFFFFF; \
|
||||
spiQxelAnd[3] = ((rrop_and & 0xFFFF00)>> 8) | 0xFFFF0000; \
|
||||
spiQxelAnd[4] = (rrop_and << 16) | 0xFFFF; \
|
||||
spiQxelAnd[5] = ((rrop_and & 0xFF0000)>> 16) | 0xFFFFFF00; \
|
||||
spiQxelAnd[1] = (rrop_and << 8) | 0xFF; \
|
||||
piQxelAnd[0] = (rrop_and & 0xFFFFFF)|(rrop_and << 24); \
|
||||
piQxelAnd[1] = (rrop_and << 16)|((rrop_and & 0xFFFF00)>> 8); \
|
||||
piQxelAnd[2] = (rrop_and << 8)|((rrop_and & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
switch((index) & 3){ \
|
||||
case 0: \
|
||||
*(dst) &= spiQxelAnd[0]; \
|
||||
break; \
|
||||
case 3: \
|
||||
*(dst) &= spiQxelAnd[1]; \
|
||||
break; \
|
||||
case 1: \
|
||||
*(dst) &= spiQxelAnd[2]; \
|
||||
*((dst)+1) &= spiQxelAnd[3]; \
|
||||
break; \
|
||||
case 2: \
|
||||
*(dst) &= spiQxelAnd[4]; \
|
||||
*((dst)+1) &= spiQxelAnd[5]; \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
#define RROP_SOLID(dst,idx) \
|
||||
(*(dst) &= piQxelAnd[(idx)])
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) &= (piQxelAnd[(idx)] | ~(mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelAnd; (void)spiQxelAnd;
|
||||
#else
|
||||
#define RROP_DECLARE register CfbBits rrop_and;
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_and = (devPriv)->and;
|
||||
#define RROP_SOLID(dst) (*(dst) &= (rrop_and))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) &= ((rrop_and) | ~(mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,And)
|
||||
#endif /* GXand */
|
||||
|
||||
#if RROP == GXor
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_or; \
|
||||
CfbBits piQxelOr[3], spiQxelOr[6];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_or = (devPriv)->xor; \
|
||||
spiQxelOr[0] = rrop_or & 0xFFFFFF; \
|
||||
spiQxelOr[1] = rrop_or << 24; \
|
||||
spiQxelOr[2] = rrop_or << 16; \
|
||||
spiQxelOr[3] = rrop_or << 8; \
|
||||
spiQxelOr[4] = (rrop_or & 0xFFFF00)>> 8; \
|
||||
spiQxelOr[5] = (rrop_or & 0xFF0000)>> 16; \
|
||||
piQxelOr[0] = (rrop_or & 0xFFFFFF)|(rrop_or << 24); \
|
||||
piQxelOr[1] = (rrop_or << 16)|((rrop_or & 0xFFFF00)>> 8); \
|
||||
piQxelOr[2] = (rrop_or << 8)|((rrop_or & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
switch((index) & 3){ \
|
||||
case 0: \
|
||||
*(dst) |= spiQxelOr[0]; \
|
||||
break; \
|
||||
case 3: \
|
||||
*(dst) |= spiQxelOr[3]; \
|
||||
break; \
|
||||
case 1: \
|
||||
*(dst) |= spiQxelOr[1]; \
|
||||
*((dst)+1) |= spiQxelOr[4]; \
|
||||
break; \
|
||||
case 2: \
|
||||
*(dst) |= spiQxelOr[2]; \
|
||||
*((dst)+1) |= spiQxelOr[5]; \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
#define RROP_SOLID(dst,idx) \
|
||||
(*(dst) |= piQxelOr[(idx)])
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) |= (piQxelOr[(idx)] & (mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelOr; (void)spiQxelOr;
|
||||
#else
|
||||
#define RROP_DECLARE register CfbBits rrop_or;
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_or = (devPriv)->xor;
|
||||
#define RROP_SOLID(dst) (*(dst) |= (rrop_or))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) |= ((rrop_or) & (mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,Or)
|
||||
#endif /* GXor */
|
||||
|
||||
#if RROP == GXnoop
|
||||
#define RROP_DECLARE
|
||||
#define RROP_FETCH_GCPRIV(devPriv)
|
||||
#define RROP_SOLID(dst)
|
||||
#define RROP_SOLID_MASK(dst,mask)
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,Noop)
|
||||
#define RROP_UNDECLARE
|
||||
#endif /* GXnoop */
|
||||
|
||||
#if RROP == GXset
|
||||
#if PSZ == 24
|
||||
#define RROP_DECLARE register CfbBits rrop_and, rrop_xor; \
|
||||
CfbBits piQxelAnd[3], piQxelXor[3], spiQxelAnd[6], spiQxelXor[6];
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_and = (devPriv)->and; \
|
||||
rrop_xor = (devPriv)->xor; \
|
||||
spiQxelXor[0] = rrop_xor & 0xFFFFFF; \
|
||||
spiQxelXor[1] = rrop_xor << 24; \
|
||||
spiQxelXor[2] = rrop_xor << 16; \
|
||||
spiQxelXor[3] = rrop_xor << 8; \
|
||||
spiQxelXor[4] = (rrop_xor & 0xFFFF00)>> 8; \
|
||||
spiQxelXor[5] = (rrop_xor & 0xFF0000)>> 16; \
|
||||
spiQxelAnd[0] = (rrop_and & 0xFFFFFF) | 0xFF000000; \
|
||||
spiQxelAnd[1] = (rrop_and << 24) | 0xFFFFFF; \
|
||||
spiQxelAnd[2] = (rrop_and << 16) | 0xFFFF; \
|
||||
spiQxelAnd[3] = (rrop_and << 8) | 0xFF; \
|
||||
spiQxelAnd[4] = ((rrop_and & 0xFFFF00)>> 8) | 0xFFFF0000; \
|
||||
spiQxelAnd[5] = ((rrop_and & 0xFF0000)>> 16) | 0xFFFFFF00; \
|
||||
piQxelAnd[0] = (rrop_and & 0xFFFFFF)|(rrop_and << 24); \
|
||||
piQxelAnd[1] = (rrop_and << 16)|((rrop_and & 0xFFFF00)>> 8); \
|
||||
piQxelAnd[2] = (rrop_and << 8)|((rrop_and & 0xFF0000)>> 16); \
|
||||
piQxelXor[0] = (rrop_xor & 0xFFFFFF)|(rrop_xor << 24); \
|
||||
piQxelXor[1] = (rrop_xor << 16)|((rrop_xor & 0xFFFF00)>> 8); \
|
||||
piQxelXor[2] = (rrop_xor << 8)|((rrop_xor & 0xFF0000)>> 16);
|
||||
#define RROP_SOLID24(dst,index) {\
|
||||
switch((index) & 3){ \
|
||||
case 0: \
|
||||
*(dst) = ((*(dst) & (piQxelAnd[0] |0xFF000000))^(piQxelXor[0] & 0xFFFFFF)); \
|
||||
break; \
|
||||
case 3: \
|
||||
*(dst) = ((*(dst) & (piQxelAnd[2]|0xFF))^(piQxelXor[2] & 0xFFFFFF00)); \
|
||||
break; \
|
||||
case 1: \
|
||||
*(dst) = ((*(dst) & (piQxelAnd[0]|0xFFFFFF))^(piQxelXor[0] & 0xFF000000)); \
|
||||
*((dst)+1) = ((*((dst)+1) & (piQxelAnd[1]|0xFFFF0000))^(piQxelXor[1] & 0xFFFF)); \
|
||||
break; \
|
||||
case 2: \
|
||||
*(dst) = ((*(dst) & (piQxelAnd[1]|0xFFFF))^(piQxelXor[1] & 0xFFFF0000)); \
|
||||
*((dst)+1) = ((*((dst)+1) & (piQxelAnd[2]|0xFFFFFF00))^(piQxelXor[2] & 0xFF)); \
|
||||
break; \
|
||||
} \
|
||||
}
|
||||
#define RROP_SOLID(dst,idx) \
|
||||
(*(dst) = DoRRop (*(dst), piQxelAnd[(idx)], piQxelXor[(idx)]))
|
||||
#define RROP_SOLID_MASK(dst,mask,idx) \
|
||||
(*(dst) = DoMaskRRop (*(dst), piQxelAnd[(idx)], piQxelXor[(idx)], (mask)))
|
||||
#define RROP_UNDECLARE (void)piQxelAnd; (void)piQxelXor; \
|
||||
(void)spiQxelAnd; (void)spiQxelXor;
|
||||
#else
|
||||
#define RROP_DECLARE register CfbBits rrop_and, rrop_xor;
|
||||
#define RROP_FETCH_GCPRIV(devPriv) rrop_and = (devPriv)->and; \
|
||||
rrop_xor = (devPriv)->xor;
|
||||
#define RROP_SOLID(dst) (*(dst) = DoRRop (*(dst), rrop_and, rrop_xor))
|
||||
#define RROP_SOLID_MASK(dst,mask) (*(dst) = DoMaskRRop (*(dst), rrop_and, rrop_xor, (mask)))
|
||||
#define RROP_UNDECLARE
|
||||
#endif
|
||||
#define RROP_NAME(prefix) RROP_NAME_CAT(prefix,General)
|
||||
#endif /* GXset */
|
||||
|
||||
#define RROP_UNROLL_CASE1(p,i) case (i): RROP_SOLID((p) - (i));
|
||||
#define RROP_UNROLL_CASE2(p,i) RROP_UNROLL_CASE1(p,(i)+1) RROP_UNROLL_CASE1(p,i)
|
||||
#define RROP_UNROLL_CASE4(p,i) RROP_UNROLL_CASE2(p,(i)+2) RROP_UNROLL_CASE2(p,i)
|
||||
#define RROP_UNROLL_CASE8(p,i) RROP_UNROLL_CASE4(p,(i)+4) RROP_UNROLL_CASE4(p,i)
|
||||
#define RROP_UNROLL_CASE16(p,i) RROP_UNROLL_CASE8(p,(i)+8) RROP_UNROLL_CASE8(p,i)
|
||||
#define RROP_UNROLL_CASE32(p,i) RROP_UNROLL_CASE16(p,(i)+16) RROP_UNROLL_CASE16(p,i)
|
||||
#define RROP_UNROLL_CASE3(p) RROP_UNROLL_CASE2(p,2) RROP_UNROLL_CASE1(p,1)
|
||||
#define RROP_UNROLL_CASE7(p) RROP_UNROLL_CASE4(p,4) RROP_UNROLL_CASE3(p)
|
||||
#define RROP_UNROLL_CASE15(p) RROP_UNROLL_CASE8(p,8) RROP_UNROLL_CASE7(p)
|
||||
#define RROP_UNROLL_CASE31(p) RROP_UNROLL_CASE16(p,16) RROP_UNROLL_CASE15(p)
|
||||
#ifdef LONG64
|
||||
#define RROP_UNROLL_CASE63(p) RROP_UNROLL_CASE32(p,32) RROP_UNROLL_CASE31(p)
|
||||
#endif /* LONG64 */
|
||||
|
||||
#define RROP_UNROLL_LOOP1(p,i) RROP_SOLID((p) + (i));
|
||||
#define RROP_UNROLL_LOOP2(p,i) RROP_UNROLL_LOOP1(p,(i)) RROP_UNROLL_LOOP1(p,(i)+1)
|
||||
#define RROP_UNROLL_LOOP4(p,i) RROP_UNROLL_LOOP2(p,(i)) RROP_UNROLL_LOOP2(p,(i)+2)
|
||||
#define RROP_UNROLL_LOOP8(p,i) RROP_UNROLL_LOOP4(p,(i)) RROP_UNROLL_LOOP4(p,(i)+4)
|
||||
#define RROP_UNROLL_LOOP16(p,i) RROP_UNROLL_LOOP8(p,(i)) RROP_UNROLL_LOOP8(p,(i)+8)
|
||||
#define RROP_UNROLL_LOOP32(p,i) RROP_UNROLL_LOOP16(p,(i)) RROP_UNROLL_LOOP16(p,(i)+16)
|
||||
#ifdef LONG64
|
||||
#define RROP_UNROLL_LOOP64(p,i) RROP_UNROLL_LOOP32(p,(i)) RROP_UNROLL_LOOP32(p,(i)+32)
|
||||
#endif /* LONG64 */
|
||||
|
||||
#if defined (FAST_CONSTANT_OFFSET_MODE) && defined (SHARED_IDCACHE) && (RROP == GXcopy)
|
||||
|
||||
#ifdef LONG64
|
||||
#define RROP_UNROLL_SHIFT 6
|
||||
#define RROP_UNROLL_CASE(p) RROP_UNROLL_CASE63(p)
|
||||
#define RROP_UNROLL_LOOP(p) RROP_UNROLL_LOOP64(p,-64)
|
||||
#else /* not LONG64 */
|
||||
#define RROP_UNROLL_SHIFT 5
|
||||
#define RROP_UNROLL_CASE(p) RROP_UNROLL_CASE31(p)
|
||||
#define RROP_UNROLL_LOOP(p) RROP_UNROLL_LOOP32(p,-32)
|
||||
#endif /* LONG64 */
|
||||
#define RROP_UNROLL (1<<RROP_UNROLL_SHIFT)
|
||||
#define RROP_UNROLL_MASK (RROP_UNROLL-1)
|
||||
|
||||
#define RROP_SPAN(pdst,nmiddle) {\
|
||||
int part = (nmiddle) & RROP_UNROLL_MASK; \
|
||||
(nmiddle) >>= RROP_UNROLL_SHIFT; \
|
||||
(pdst) += part * (sizeof (CfbBits) / sizeof (*pdst)); \
|
||||
switch (part) {\
|
||||
RROP_UNROLL_CASE((CfbBits *) (pdst)) \
|
||||
} \
|
||||
while (--(nmiddle) >= 0) { \
|
||||
(pdst) += RROP_UNROLL * (sizeof (CfbBits) / sizeof (*pdst)); \
|
||||
RROP_UNROLL_LOOP((CfbBits *) (pdst)) \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define RROP_SPAN(pdst,nmiddle) \
|
||||
while (--(nmiddle) >= 0) { \
|
||||
RROP_SOLID((CfbBits *) (pdst)); \
|
||||
(pdst) += sizeof (CfbBits) / sizeof (*pdst); \
|
||||
}
|
||||
#endif
|
||||
|
||||
#if !defined(UNIXCPP) || defined(ANSICPP)
|
||||
#define RROP_NAME_CAT(prefix,suffix) prefix##suffix
|
||||
#else
|
||||
#define RROP_NAME_CAT(prefix,suffix) prefix/**/suffix
|
||||
#endif
|
223
cfb/cfbscrinit.c
223
cfb/cfbscrinit.c
|
@ -1,223 +0,0 @@
|
|||
/************************************************************
|
||||
Copyright 1987 by Sun Microsystems, Inc. Mountain View, CA.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this
|
||||
software and its documentation for any purpose and without
|
||||
fee is hereby granted, provided that the above copyright no-
|
||||
tice appear in all copies and that both that copyright no-
|
||||
tice and this permission notice appear in supporting docu-
|
||||
mentation, and that the names of Sun or The Open Group
|
||||
not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific prior
|
||||
written permission. Sun and The Open Group make no
|
||||
representations about the suitability of this software for
|
||||
any purpose. It is provided "as is" without any express or
|
||||
implied warranty.
|
||||
|
||||
SUN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
||||
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FIT-
|
||||
NESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SUN BE LI-
|
||||
ABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
||||
PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
|
||||
THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
********************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "resource.h"
|
||||
#include "colormap.h"
|
||||
#include "colormapst.h"
|
||||
#include "cfb.h"
|
||||
#include "mi.h"
|
||||
#include "mistruct.h"
|
||||
#include "dix.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mibstore.h"
|
||||
|
||||
Bool
|
||||
cfbCloseScreen (index, pScreen)
|
||||
int index;
|
||||
ScreenPtr pScreen;
|
||||
{
|
||||
int d;
|
||||
DepthPtr depths = pScreen->allowedDepths;
|
||||
|
||||
for (d = 0; d < pScreen->numDepths; d++)
|
||||
xfree (depths[d].vids);
|
||||
xfree (depths);
|
||||
xfree (pScreen->visuals);
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
xfree (dixLookupPrivate(&pScreen->devPrivates, cfbScreenPrivateKey));
|
||||
#else
|
||||
xfree (pScreen->devPrivate);
|
||||
#endif
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void DestroyColormapNoop(
|
||||
ColormapPtr pColormap)
|
||||
{
|
||||
/* NOOP */
|
||||
}
|
||||
|
||||
static void StoreColorsNoop(
|
||||
ColormapPtr pColormap,
|
||||
int ndef,
|
||||
xColorItem * pdef)
|
||||
{
|
||||
/* NOOP */
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
||||
register ScreenPtr pScreen;
|
||||
pointer pbits; /* pointer to screen bitmap */
|
||||
int xsize, ysize; /* in pixels */
|
||||
int dpix, dpiy; /* dots per inch */
|
||||
int width; /* pixel width of frame buffer */
|
||||
{
|
||||
if (!cfbAllocatePrivates(pScreen, NULL))
|
||||
return FALSE;
|
||||
pScreen->defColormap = FakeClientID(0);
|
||||
/* let CreateDefColormap do whatever it wants for pixels */
|
||||
pScreen->blackPixel = pScreen->whitePixel = (Pixel) 0;
|
||||
pScreen->QueryBestSize = mfbQueryBestSizeWeak();
|
||||
/* SaveScreen */
|
||||
pScreen->GetImage = cfbGetImage;
|
||||
pScreen->GetSpans = cfbGetSpans;
|
||||
pScreen->CreateWindow = cfbCreateWindow;
|
||||
pScreen->DestroyWindow = cfbDestroyWindow;
|
||||
pScreen->PositionWindow = cfbPositionWindow;
|
||||
pScreen->ChangeWindowAttributes = cfbChangeWindowAttributes;
|
||||
pScreen->RealizeWindow = cfbMapWindow;
|
||||
pScreen->UnrealizeWindow = cfbUnmapWindow;
|
||||
pScreen->CopyWindow = cfbCopyWindow;
|
||||
pScreen->CreatePixmap = cfbCreatePixmap;
|
||||
pScreen->DestroyPixmap = cfbDestroyPixmap;
|
||||
pScreen->RealizeFont = mfbRealizeFontWeak();
|
||||
pScreen->UnrealizeFont = mfbUnrealizeFontWeak();
|
||||
pScreen->CreateGC = cfbCreateGC;
|
||||
pScreen->CreateColormap = cfbInitializeColormap;
|
||||
pScreen->DestroyColormap = DestroyColormapNoop;
|
||||
pScreen->InstallColormap = cfbInstallColormap;
|
||||
pScreen->UninstallColormap = cfbUninstallColormap;
|
||||
pScreen->ListInstalledColormaps = cfbListInstalledColormaps;
|
||||
pScreen->StoreColors = StoreColorsNoop;
|
||||
pScreen->ResolveColor = cfbResolveColor;
|
||||
pScreen->BitmapToRegion = mfbPixmapToRegionWeak();
|
||||
|
||||
mfbRegisterCopyPlaneProc (pScreen, cfbCopyPlane);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
Bool
|
||||
cfbCreateScreenResources(pScreen)
|
||||
ScreenPtr pScreen;
|
||||
{
|
||||
Bool retval;
|
||||
|
||||
pointer oldDevPrivate = pScreen->devPrivate;
|
||||
pScreen->devPrivate = dixLookupPrivate(&pScreen->devPrivates,
|
||||
cfbScreenPrivateKey);
|
||||
retval = miCreateScreenResources(pScreen);
|
||||
dixSetPrivate(&pScreen->devPrivates, cfbScreenPrivateKey,
|
||||
pScreen->devPrivate);
|
||||
pScreen->devPrivate = oldDevPrivate;
|
||||
return retval;
|
||||
}
|
||||
#endif
|
||||
|
||||
Bool
|
||||
cfbFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
||||
register ScreenPtr pScreen;
|
||||
pointer pbits; /* pointer to screen bitmap */
|
||||
int xsize, ysize; /* in pixels */
|
||||
int dpix, dpiy; /* dots per inch */
|
||||
int width; /* pixel width of frame buffer */
|
||||
{
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
pointer oldDevPrivate;
|
||||
#endif
|
||||
VisualPtr visuals;
|
||||
DepthPtr depths;
|
||||
int nvisuals;
|
||||
int ndepths;
|
||||
int rootdepth;
|
||||
VisualID defaultVisual;
|
||||
|
||||
rootdepth = 0;
|
||||
if (!cfbInitVisuals (&visuals, &depths, &nvisuals, &ndepths, &rootdepth,
|
||||
&defaultVisual,((unsigned long)1<<(PSZ-1)), 8))
|
||||
return FALSE;
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
oldDevPrivate = pScreen->devPrivate;
|
||||
#endif
|
||||
if (! miScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width,
|
||||
rootdepth, ndepths, depths,
|
||||
defaultVisual, nvisuals, visuals))
|
||||
return FALSE;
|
||||
/* overwrite miCloseScreen with our own */
|
||||
pScreen->CloseScreen = cfbCloseScreen;
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
pScreen->CreateScreenResources = cfbCreateScreenResources;
|
||||
dixSetPrivate(&pScreen->devPrivates, cfbScreenPrivateKey,
|
||||
pScreen->devPrivate);
|
||||
pScreen->devPrivate = oldDevPrivate;
|
||||
#endif
|
||||
pScreen->GetScreenPixmap = cfbGetScreenPixmap;
|
||||
pScreen->SetScreenPixmap = cfbSetScreenPixmap;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/* dts * (inch/dot) * (25.4 mm / inch) = mm */
|
||||
Bool
|
||||
cfbScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width)
|
||||
register ScreenPtr pScreen;
|
||||
pointer pbits; /* pointer to screen bitmap */
|
||||
int xsize, ysize; /* in pixels */
|
||||
int dpix, dpiy; /* dots per inch */
|
||||
int width; /* pixel width of frame buffer */
|
||||
{
|
||||
if (!cfbSetupScreen(pScreen, pbits, xsize, ysize, dpix, dpiy, width))
|
||||
return FALSE;
|
||||
return cfbFinishScreenInit(pScreen, pbits, xsize, ysize, dpix, dpiy, width);
|
||||
}
|
||||
|
||||
PixmapPtr
|
||||
cfbGetScreenPixmap(pScreen)
|
||||
ScreenPtr pScreen;
|
||||
{
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
return (PixmapPtr)dixLookupPrivate(&pScreen->devPrivates,
|
||||
cfbScreenPrivateKey);
|
||||
#else
|
||||
return (PixmapPtr)pScreen->devPrivate;
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
cfbSetScreenPixmap(pPix)
|
||||
PixmapPtr pPix;
|
||||
{
|
||||
#ifdef CFB_NEED_SCREEN_PRIVATE
|
||||
if (pPix)
|
||||
dixSetPrivate(&pPix->drawable.pScreen->devPrivates,
|
||||
cfbScreenPrivateKey, pPix);
|
||||
#else
|
||||
if (pPix)
|
||||
pPix->drawable.pScreen->devPrivate = (pointer)pPix;
|
||||
#endif
|
||||
}
|
316
cfb/cfbsetsp.c
316
cfb/cfbsetsp.c
|
@ -1,316 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
|
||||
#include "misc.h"
|
||||
#include "regionstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include <mergerop.h>
|
||||
|
||||
/* cfbSetScanline -- copies the bits from psrc to the drawable starting at
|
||||
* (xStart, y) and continuing to (xEnd, y). xOrigin tells us where psrc
|
||||
* starts on the scanline. (I.e., if this scanline passes through multiple
|
||||
* boxes, we may not want to start grabbing bits at psrc but at some offset
|
||||
* further on.)
|
||||
*/
|
||||
void
|
||||
cfbSetScanline(y, xOrigin, xStart, xEnd, psrc, alu, pdstBase, widthDst, planemask)
|
||||
int y;
|
||||
int xOrigin; /* where this scanline starts */
|
||||
int xStart; /* first bit to use from scanline */
|
||||
int xEnd; /* last bit to use from scanline + 1 */
|
||||
register unsigned int *psrc;
|
||||
register int alu; /* raster op */
|
||||
int *pdstBase; /* start of the drawable */
|
||||
int widthDst; /* width of drawable in words */
|
||||
unsigned long planemask;
|
||||
{
|
||||
int w; /* width of scanline in bits */
|
||||
register int *pdst; /* where to put the bits */
|
||||
register int tmpSrc; /* scratch buffer to collect bits in */
|
||||
int offSrc;
|
||||
int nl;
|
||||
#if PSZ == 24
|
||||
register char *psrcb, *pdstb;
|
||||
register int xIndex;
|
||||
#else
|
||||
int dstBit; /* offset in bits from beginning of
|
||||
* word */
|
||||
register int nstart; /* number of bits from first partial */
|
||||
#if PSZ != 32 || PPW != 1
|
||||
register int nend; /* " " last partial word */
|
||||
#endif
|
||||
int startmask, endmask, nlMiddle;
|
||||
#endif
|
||||
DeclareMergeRop()
|
||||
|
||||
InitializeMergeRop(alu,planemask);
|
||||
#if PSZ == 24
|
||||
pdst = pdstBase + (y * widthDst);
|
||||
xIndex = xStart;
|
||||
pdstb = (char *)pdst + (xStart * 3);
|
||||
offSrc = xStart - xOrigin;
|
||||
psrcb = (char *)psrc + (offSrc * 3);
|
||||
#else
|
||||
pdst = pdstBase + (y * widthDst) + (xStart >> PWSH);
|
||||
psrc += (xStart - xOrigin) >> PWSH;
|
||||
offSrc = (xStart - xOrigin) & PIM;
|
||||
#endif
|
||||
w = xEnd - xStart;
|
||||
|
||||
#if PSZ == 24
|
||||
nl = w;
|
||||
while (nl--){
|
||||
psrc = (unsigned int *)((unsigned long)psrcb & ~0x03);
|
||||
getbits24(psrc, tmpSrc, offSrc);
|
||||
pdst = (int *)((unsigned long)pdstb & ~0x03);
|
||||
DoMergeRop24(tmpSrc, pdst, xIndex);
|
||||
offSrc++;
|
||||
psrcb += 3;
|
||||
xIndex++;
|
||||
pdstb += 3;
|
||||
}
|
||||
#else /* PSZ == 24 */
|
||||
dstBit = xStart & PIM;
|
||||
if (dstBit + w <= PPW)
|
||||
{
|
||||
maskpartialbits(dstBit, w, startmask);
|
||||
endmask = 0;
|
||||
nlMiddle = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(xStart, w, startmask, endmask, nlMiddle);
|
||||
}
|
||||
if (startmask)
|
||||
nstart = PPW - dstBit;
|
||||
else
|
||||
nstart = 0;
|
||||
#if PSZ != 32 || PPW != 1
|
||||
if (endmask)
|
||||
nend = xEnd & PIM;
|
||||
else
|
||||
nend = 0;
|
||||
#endif
|
||||
if (startmask)
|
||||
{
|
||||
getbits(psrc, offSrc, nstart, tmpSrc);
|
||||
putbitsmropshort(tmpSrc, dstBit, nstart, pdst);
|
||||
pdst++;
|
||||
offSrc += nstart;
|
||||
if (offSrc > PLST)
|
||||
{
|
||||
psrc++;
|
||||
offSrc -= PPW;
|
||||
}
|
||||
}
|
||||
nl = nlMiddle;
|
||||
while (nl--)
|
||||
{
|
||||
getbits(psrc, offSrc, PPW, tmpSrc);
|
||||
*pdst = DoMergeRop(tmpSrc, *pdst);
|
||||
pdst++;
|
||||
psrc++;
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
getbits(psrc, offSrc, nend, tmpSrc);
|
||||
putbitsmropshort(tmpSrc, 0, nend, pdst);
|
||||
}
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* SetSpans -- for each span copy pwidth[i] bits from psrc to pDrawable at
|
||||
* ppt[i] using the raster op from the GC. If fSorted is TRUE, the scanlines
|
||||
* are in increasing Y order.
|
||||
* Source bit lines are server scanline padded so that they always begin
|
||||
* on a word boundary.
|
||||
*/
|
||||
void
|
||||
cfbSetSpans(pDrawable, pGC, pcharsrc, ppt, pwidth, nspans, fSorted)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
char *pcharsrc;
|
||||
register DDXPointPtr ppt;
|
||||
int *pwidth;
|
||||
int nspans;
|
||||
int fSorted;
|
||||
{
|
||||
unsigned int *psrc = (unsigned int *)pcharsrc;
|
||||
CfbBits *pdstBase; /* start of dst bitmap */
|
||||
int widthDst; /* width of bitmap in words */
|
||||
register BoxPtr pbox, pboxLast, pboxTest;
|
||||
register DDXPointPtr pptLast;
|
||||
int alu;
|
||||
RegionPtr prgnDst;
|
||||
int xStart, xEnd;
|
||||
int yMax;
|
||||
|
||||
alu = pGC->alu;
|
||||
prgnDst = cfbGetCompositeClip(pGC);
|
||||
pptLast = ppt + nspans;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
|
||||
|
||||
yMax = (int) pDrawable->y + (int) pDrawable->height;
|
||||
|
||||
pbox = REGION_RECTS(prgnDst);
|
||||
pboxLast = pbox + REGION_NUM_RECTS(prgnDst);
|
||||
|
||||
if(fSorted)
|
||||
{
|
||||
/* scan lines sorted in ascending order. Because they are sorted, we
|
||||
* don't have to check each scanline against each clip box. We can be
|
||||
* sure that this scanline only has to be clipped to boxes at or after the
|
||||
* beginning of this y-band
|
||||
*/
|
||||
pboxTest = pbox;
|
||||
while(ppt < pptLast)
|
||||
{
|
||||
pbox = pboxTest;
|
||||
if(ppt->y >= yMax)
|
||||
break;
|
||||
while(pbox < pboxLast)
|
||||
{
|
||||
if(pbox->y1 > ppt->y)
|
||||
{
|
||||
/* scanline is before clip box */
|
||||
break;
|
||||
}
|
||||
else if(pbox->y2 <= ppt->y)
|
||||
{
|
||||
/* clip box is before scanline */
|
||||
pboxTest = ++pbox;
|
||||
continue;
|
||||
}
|
||||
else if(pbox->x1 > ppt->x + *pwidth)
|
||||
{
|
||||
/* clip box is to right of scanline */
|
||||
break;
|
||||
}
|
||||
else if(pbox->x2 <= ppt->x)
|
||||
{
|
||||
/* scanline is to right of clip box */
|
||||
pbox++;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* at least some of the scanline is in the current clip box */
|
||||
xStart = max(pbox->x1, ppt->x);
|
||||
xEnd = min(ppt->x + *pwidth, pbox->x2);
|
||||
cfbSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu,
|
||||
(int *)pdstBase, widthDst, pGC->planemask);
|
||||
if(ppt->x + *pwidth <= pbox->x2)
|
||||
{
|
||||
/* End of the line, as it were */
|
||||
break;
|
||||
}
|
||||
else
|
||||
pbox++;
|
||||
}
|
||||
/* We've tried this line against every box; it must be outside them
|
||||
* all. move on to the next point */
|
||||
ppt++;
|
||||
psrc += PixmapWidthInPadUnits(*pwidth, pDrawable->depth);
|
||||
pwidth++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* scan lines not sorted. We must clip each line against all the boxes */
|
||||
while(ppt < pptLast)
|
||||
{
|
||||
if(ppt->y >= 0 && ppt->y < yMax)
|
||||
{
|
||||
|
||||
for(pbox = REGION_RECTS(prgnDst); pbox< pboxLast; pbox++)
|
||||
{
|
||||
if(pbox->y1 > ppt->y)
|
||||
{
|
||||
/* rest of clip region is above this scanline,
|
||||
* skip it */
|
||||
break;
|
||||
}
|
||||
if(pbox->y2 <= ppt->y)
|
||||
{
|
||||
/* clip box is below scanline */
|
||||
pbox++;
|
||||
break;
|
||||
}
|
||||
if(pbox->x1 <= ppt->x + *pwidth &&
|
||||
pbox->x2 > ppt->x)
|
||||
{
|
||||
xStart = max(pbox->x1, ppt->x);
|
||||
xEnd = min(pbox->x2, ppt->x + *pwidth);
|
||||
cfbSetScanline(ppt->y, ppt->x, xStart, xEnd, psrc, alu,
|
||||
(int *)pdstBase, widthDst, pGC->planemask);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
psrc += PixmapWidthInPadUnits(*pwidth, pDrawable->depth);
|
||||
ppt++;
|
||||
pwidth++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
1365
cfb/cfbsolid.c
1365
cfb/cfbsolid.c
File diff suppressed because it is too large
Load Diff
589
cfb/cfbteblt8.c
589
cfb/cfbteblt8.c
|
@ -1,589 +0,0 @@
|
|||
/*
|
||||
* TEGblt - ImageText expanded glyph fonts only. For
|
||||
* 8 bit displays, in Copy mode with no clipping.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#if PSZ == 8
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
/*
|
||||
* this code supports up to 5 characters at a time. The performance
|
||||
* differences between 4 and 5 is usually small (~7% on PMAX) and
|
||||
* frequently negative (SPARC and Sun3), so this file is compiled
|
||||
* only once for now. If you want to use the other options, you'll
|
||||
* need to hack cfbgc.c as well.
|
||||
*/
|
||||
|
||||
#ifndef NGLYPHS
|
||||
#define NGLYPHS 4
|
||||
#define DO_COMMON
|
||||
#endif
|
||||
|
||||
#ifdef DO_COMMON
|
||||
#define CFBTEGBLT8 cfbTEGlyphBlt8
|
||||
#endif
|
||||
|
||||
/*
|
||||
* On little-endian machines (or where fonts are padded to 32-bit
|
||||
* boundaries) we can use some magic to avoid the expense of getleftbits
|
||||
*/
|
||||
|
||||
#if ((BITMAP_BIT_ORDER == LSBFirst && NGLYPHS >= 4) || GLYPHPADBYTES == 4)
|
||||
|
||||
#if GLYPHPADBYTES == 1
|
||||
typedef unsigned char *glyphPointer;
|
||||
#define USE_LEFTBITS
|
||||
#endif
|
||||
|
||||
#if GLYPHPADBYTES == 2
|
||||
typedef unsigned short *glyphPointer;
|
||||
#define USE_LEFTBITS
|
||||
#endif
|
||||
|
||||
#if GLYPHPADBYTES == 4
|
||||
typedef unsigned int *glyphPointer;
|
||||
#endif
|
||||
|
||||
#define GetBitsL c = BitLeft (*leftChar++, lshift)
|
||||
#define NGetBits1S(r) c = BitRight(*char1++ r, xoff1)
|
||||
#define NGetBits1L(r) GetBitsL | BitRight(*char1++ r, xoff1)
|
||||
#define NGetBits1U(r) c = *char1++ r
|
||||
#define NGetBits2S(r) NGetBits1S(| BitRight(*char2++ r, widthGlyph))
|
||||
#define NGetBits2L(r) NGetBits1L(| BitRight(*char2++ r, widthGlyph))
|
||||
#define NGetBits2U(r) NGetBits1U(| BitRight(*char2++ r, widthGlyph))
|
||||
#define NGetBits3S(r) NGetBits2S(| BitRight(*char3++ r, widthGlyph))
|
||||
#define NGetBits3L(r) NGetBits2L(| BitRight(*char3++ r, widthGlyph))
|
||||
#define NGetBits3U(r) NGetBits2U(| BitRight(*char3++ r, widthGlyph))
|
||||
#define NGetBits4S(r) NGetBits3S(| BitRight(*char4++ r, widthGlyph))
|
||||
#define NGetBits4L(r) NGetBits3L(| BitRight(*char4++ r, widthGlyph))
|
||||
#define NGetBits4U(r) NGetBits3U(| BitRight(*char4++ r, widthGlyph))
|
||||
#define NGetBits5S(r) NGetBits4S(| BitRight(*char5++ r, widthGlyph))
|
||||
#define NGetBits5L(r) NGetBits4L(| BitRight(*char5++ r, widthGlyph))
|
||||
#define NGetBits5U(r) NGetBits4U(| BitRight(*char5++ r, widthGlyph))
|
||||
#define GetBits1S c = BitRight(*char1++, xoff1)
|
||||
#define GetBits1L GetBitsL | BitRight(*char1++, xoff1)
|
||||
#define GetBits1U c = *char1++
|
||||
#define GetBits2S NGetBits1S(| BitRight(*char2++, widthGlyph))
|
||||
#define GetBits2L NGetBits1L(| BitRight(*char2++, widthGlyph))
|
||||
#define GetBits2U NGetBits1U(| BitRight(*char2++, widthGlyph))
|
||||
#define GetBits3S NGetBits2S(| BitRight(*char3++, widthGlyph))
|
||||
#define GetBits3L NGetBits2L(| BitRight(*char3++, widthGlyph))
|
||||
#define GetBits3U NGetBits2U(| BitRight(*char3++, widthGlyph))
|
||||
#define GetBits4S NGetBits3S(| BitRight(*char4++, widthGlyph))
|
||||
#define GetBits4L NGetBits3L(| BitRight(*char4++, widthGlyph))
|
||||
#define GetBits4U NGetBits3U(| BitRight(*char4++, widthGlyph))
|
||||
#define GetBits5S NGetBits4S(| BitRight(*char5++, widthGlyph))
|
||||
#define GetBits5L NGetBits4L(| BitRight(*char5++, widthGlyph))
|
||||
#define GetBits5U NGetBits4U(| BitRight(*char5++, widthGlyph))
|
||||
|
||||
#else
|
||||
|
||||
typedef unsigned int *glyphPointer;
|
||||
|
||||
#define USE_LEFTBITS
|
||||
#define ALL_LEFTBITS
|
||||
|
||||
#define GetBitsL WGetBitsL
|
||||
#define GetBits1S WGetBits1S
|
||||
#define GetBits1L WGetBits1L
|
||||
#define GetBits1U WGetBits1U
|
||||
|
||||
#define GetBits2S GetBits1S Get1Bits (char2, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff2);
|
||||
#define GetBits2L GetBits1L Get1Bits (char2, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff2);
|
||||
#define GetBits2U GetBits1U Get1Bits (char2, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff2);
|
||||
|
||||
#define GetBits3S GetBits2S Get1Bits (char3, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff3);
|
||||
#define GetBits3L GetBits2L Get1Bits (char3, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff3);
|
||||
#define GetBits3U GetBits2U Get1Bits (char3, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff3);
|
||||
|
||||
#define GetBits4S GetBits3S Get1Bits (char4, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff4);
|
||||
#define GetBits4L GetBits3L Get1Bits (char4, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff4);
|
||||
#define GetBits4U GetBits3U Get1Bits (char4, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff4);
|
||||
|
||||
#define GetBits5S GetBits4S Get1Bits (char5, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff5);
|
||||
#define GetBits5L GetBits4L Get1Bits (char5, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff5);
|
||||
#define GetBits5U GetBits4U Get1Bits (char5, tmpSrc) \
|
||||
c |= BitRight(tmpSrc, xoff5);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef USE_LEFTBITS
|
||||
|
||||
#define IncChar(c) (c = (glyphPointer) (((char *) c) + glyphBytes))
|
||||
|
||||
#define Get1Bits(ch,dst) glyphbits (ch, widthGlyph, glyphMask, dst); \
|
||||
IncChar (ch);
|
||||
|
||||
#define glyphbits(bits,width,mask,dst) getleftbits(bits,width,dst); \
|
||||
dst &= mask;
|
||||
|
||||
#define WGetBitsL Get1Bits(leftChar,c); \
|
||||
c = BitLeft (c, lshift);
|
||||
#define WGetBits1S Get1Bits (char1, c) \
|
||||
c = BitRight (c, xoff1);
|
||||
#define WGetBits1L WGetBitsL Get1Bits (char1, tmpSrc) \
|
||||
c |= BitRight (tmpSrc, xoff1);
|
||||
#define WGetBits1U Get1Bits (char1, c)
|
||||
|
||||
#else
|
||||
#define WGetBitsL GetBitsL
|
||||
#define WGetBits1S GetBits1S
|
||||
#define WGetBits1L GetBits1L
|
||||
#define WGetBits1U GetBits1U
|
||||
#endif
|
||||
|
||||
#if NGLYPHS == 2
|
||||
# define GetBitsNS GetBits2S
|
||||
# define GetBitsNL GetBits2L
|
||||
# define GetBitsNU GetBits2U
|
||||
# define LastChar char2
|
||||
#ifndef CFBTEGBLT8
|
||||
# define CFBTEGBLT8 cfbTEGlyphBlt8x2
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS == 3
|
||||
# define GetBitsNS GetBits3S
|
||||
# define GetBitsNL GetBits3L
|
||||
# define GetBitsNU GetBits3U
|
||||
# define LastChar char3
|
||||
#ifndef CFBTEGBLT8
|
||||
# define CFBTEGBLT8 cfbTEGlyphBlt8x3
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS == 4
|
||||
# define GetBitsNS GetBits4S
|
||||
# define GetBitsNL GetBits4L
|
||||
# define GetBitsNU GetBits4U
|
||||
# define LastChar char4
|
||||
#ifndef CFBTEGBLT8
|
||||
# define CFBTEGBLT8 cfbTEGlyphBlt8x4
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS == 5
|
||||
# define GetBitsNS GetBits5S
|
||||
# define GetBitsNL GetBits5L
|
||||
# define GetBitsNU GetBits5U
|
||||
# define LastChar char5
|
||||
#ifndef CFBTEGBLT8
|
||||
# define CFBTEGBLT8 cfbTEGlyphBlt8x5
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* another ugly giant macro */
|
||||
#define SwitchEm switch (ew) \
|
||||
{ \
|
||||
case 0: \
|
||||
break; \
|
||||
case 1: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 2: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 3: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step StoreBits(2) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 4: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 5: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) Step \
|
||||
StoreBits(4) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 6: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) Step \
|
||||
StoreBits(4) Step StoreBits(5) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 7: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) Step \
|
||||
StoreBits(4) Step StoreBits(5) Step \
|
||||
StoreBits(6) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
case 8: \
|
||||
while (hTmp--) { \
|
||||
GetBits; \
|
||||
StoreBits0 FirstStep StoreBits(1) Step \
|
||||
StoreBits(2) Step StoreBits(3) Step \
|
||||
StoreBits(4) Step StoreBits(5) Step \
|
||||
StoreBits(6) Step StoreBits(7) \
|
||||
Loop \
|
||||
} \
|
||||
break; \
|
||||
}
|
||||
|
||||
#ifdef FAST_CONSTANT_OFFSET_MODE
|
||||
#define StorePixels(o,p) dst[o] = p
|
||||
#define Loop dst += widthDst;
|
||||
#else
|
||||
#define StorePixels(o,p) do { *dst = (p); dst++; } while (0)
|
||||
#define Loop dst += widthLeft;
|
||||
#endif
|
||||
|
||||
#define Step NextBitGroup(c);
|
||||
|
||||
#if (BITMAP_BIT_ORDER == MSBFirst)
|
||||
#define StoreBits(o) StorePixels(o,GetPixelGroup(c));
|
||||
#define FirstStep Step
|
||||
#else
|
||||
#if PGSZ == 64
|
||||
#define StoreBits(o) StorePixels(o,cfb8Pixels[(c) & PGSZBMSK]);
|
||||
#define FirstStep Step
|
||||
#else /* PGSZ == 32 */
|
||||
#define StoreBits(o) StorePixels(o,*((CfbBits *) (((char *) cfb8Pixels) + (c & 0x3c))));
|
||||
#define FirstStep c = BitLeft (c, 2);
|
||||
#endif /* PGSZ */
|
||||
#endif /* BITMAP_BIT_ORDER */
|
||||
|
||||
|
||||
void
|
||||
CFBTEGBLT8 (pDrawable, pGC, xInit, yInit, nglyph, ppci, pglyphBase)
|
||||
DrawablePtr pDrawable;
|
||||
GC *pGC;
|
||||
int xInit, yInit;
|
||||
unsigned int nglyph;
|
||||
CharInfoPtr *ppci; /* array of character info */
|
||||
pointer pglyphBase; /* start of array of glyphs */
|
||||
{
|
||||
register CfbBits c;
|
||||
register CfbBits *dst;
|
||||
register CfbBits leftMask, rightMask;
|
||||
register int hTmp;
|
||||
register int xoff1;
|
||||
register glyphPointer char1;
|
||||
register glyphPointer char2;
|
||||
#if NGLYPHS >= 3
|
||||
register glyphPointer char3;
|
||||
#endif
|
||||
#if NGLYPHS >= 4
|
||||
register glyphPointer char4;
|
||||
#endif
|
||||
#if NGLYPHS >= 5
|
||||
register glyphPointer char5;
|
||||
#endif
|
||||
#ifdef ALL_LEFTBITS
|
||||
int xoff2, xoff3, xoff4, xoff5;
|
||||
#endif
|
||||
|
||||
FontPtr pfont = pGC->font;
|
||||
CfbBits *dstLine;
|
||||
glyphPointer oldRightChar;
|
||||
CfbBits *pdstBase;
|
||||
glyphPointer leftChar;
|
||||
int widthDst;
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
int widthLeft;
|
||||
#endif
|
||||
int widthGlyph;
|
||||
int h;
|
||||
int ew;
|
||||
int x, y;
|
||||
BoxRec bbox; /* for clipping */
|
||||
int lshift;
|
||||
int widthGlyphs;
|
||||
#ifdef USE_LEFTBITS
|
||||
register CfbBits glyphMask;
|
||||
register CfbBits tmpSrc;
|
||||
register int glyphBytes;
|
||||
#endif
|
||||
|
||||
widthGlyph = FONTMAXBOUNDS(pfont,characterWidth);
|
||||
h = FONTASCENT(pfont) + FONTDESCENT(pfont);
|
||||
if (!h)
|
||||
return;
|
||||
x = xInit + FONTMAXBOUNDS(pfont,leftSideBearing) + pDrawable->x;
|
||||
y = yInit - FONTASCENT(pfont) + pDrawable->y;
|
||||
bbox.x1 = x;
|
||||
bbox.x2 = x + (widthGlyph * nglyph);
|
||||
bbox.y1 = y;
|
||||
bbox.y2 = y + h;
|
||||
|
||||
switch (RECT_IN_REGION(pGC->pScreen, cfbGetCompositeClip(pGC), &bbox))
|
||||
{
|
||||
case rgnPART:
|
||||
cfbImageGlyphBlt8(pDrawable, pGC, xInit, yInit, nglyph, ppci, pglyphBase);
|
||||
case rgnOUT:
|
||||
return;
|
||||
}
|
||||
|
||||
if (!cfb8CheckPixels (pGC->fgPixel, pGC->bgPixel))
|
||||
cfb8SetPixels (pGC->fgPixel, pGC->bgPixel);
|
||||
|
||||
leftChar = 0;
|
||||
|
||||
cfbGetLongWidthAndPointer(pDrawable, widthDst, pdstBase)
|
||||
|
||||
#if NGLYPHS == 2
|
||||
widthGlyphs = widthGlyph << 1;
|
||||
#else
|
||||
#if NGLYPHS == 4
|
||||
widthGlyphs = widthGlyph << 2;
|
||||
#else
|
||||
widthGlyphs = widthGlyph * NGLYPHS;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef USE_LEFTBITS
|
||||
glyphMask = mfbGetendtab(widthGlyph);
|
||||
glyphBytes = GLYPHWIDTHBYTESPADDED(*ppci);
|
||||
#endif
|
||||
|
||||
pdstBase += y * widthDst;
|
||||
#ifdef DO_COMMON
|
||||
if (widthGlyphs <= 32)
|
||||
#endif
|
||||
while (nglyph >= NGLYPHS)
|
||||
{
|
||||
nglyph -= NGLYPHS;
|
||||
hTmp = h;
|
||||
dstLine = pdstBase + (x >> PWSH);
|
||||
xoff1 = x & PIM;
|
||||
char1 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
char2 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
#ifdef ALL_LEFTBITS
|
||||
xoff2 = xoff1 + widthGlyph;
|
||||
#endif
|
||||
#if NGLYPHS >= 3
|
||||
char3 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
#ifdef ALL_LEFTBITS
|
||||
xoff3 = xoff2 + widthGlyph;
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS >= 4
|
||||
char4 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
#ifdef ALL_LEFTBITS
|
||||
xoff4 = xoff3 + widthGlyph;
|
||||
#endif
|
||||
#endif
|
||||
#if NGLYPHS >= 5
|
||||
char5 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
#ifdef ALL_LEFTBITS
|
||||
xoff5 = xoff4 + widthGlyph;
|
||||
#endif
|
||||
#endif
|
||||
oldRightChar = LastChar;
|
||||
dst = dstLine;
|
||||
if (xoff1)
|
||||
{
|
||||
ew = ((widthGlyphs - (PGSZB - xoff1)) >> PWSH) + 1;
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
widthLeft = widthDst - ew;
|
||||
#endif
|
||||
if (!leftChar)
|
||||
{
|
||||
leftMask = cfbendtab[xoff1];
|
||||
rightMask = cfbstarttab[xoff1];
|
||||
|
||||
#define StoreBits0 StorePixels (0, (dst[0] & leftMask) | \
|
||||
(GetPixelGroup(c) & rightMask));
|
||||
#define GetBits GetBitsNS
|
||||
|
||||
SwitchEm
|
||||
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
lshift = widthGlyph - xoff1;
|
||||
|
||||
#define StoreBits0 StorePixels (0,GetPixelGroup(c));
|
||||
#define GetBits GetBitsNL
|
||||
|
||||
SwitchEm
|
||||
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
#if NGLYPHS == 4 && PGSZ == 32
|
||||
ew = widthGlyph; /* widthGlyphs >> 2 */
|
||||
#else
|
||||
ew = widthGlyphs >> PWSH;
|
||||
#endif
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
widthLeft = widthDst - ew;
|
||||
#endif
|
||||
|
||||
#define StoreBits0 StorePixels (0,GetPixelGroup(c));
|
||||
#define GetBits GetBitsNU
|
||||
|
||||
SwitchEm
|
||||
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
x += widthGlyphs;
|
||||
leftChar = oldRightChar;
|
||||
}
|
||||
while (nglyph--)
|
||||
{
|
||||
xoff1 = x & PIM;
|
||||
char1 = (glyphPointer) FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
hTmp = h;
|
||||
dstLine = pdstBase + (x >> PWSH);
|
||||
oldRightChar = char1;
|
||||
dst = dstLine;
|
||||
if (xoff1)
|
||||
{
|
||||
ew = ((widthGlyph - (PGSZB - xoff1)) >> PWSH) + 1;
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
widthLeft = widthDst - ew;
|
||||
#endif
|
||||
if (!leftChar)
|
||||
{
|
||||
leftMask = cfbendtab[xoff1];
|
||||
rightMask = cfbstarttab[xoff1];
|
||||
|
||||
#define StoreBits0 StorePixels (0, (dst[0] & leftMask) | \
|
||||
(GetPixelGroup(c) & rightMask));
|
||||
#define GetBits WGetBits1S
|
||||
|
||||
SwitchEm
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
lshift = widthGlyph - xoff1;
|
||||
|
||||
#define StoreBits0 StorePixels (0,GetPixelGroup(c));
|
||||
#define GetBits WGetBits1L
|
||||
|
||||
SwitchEm
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ew = widthGlyph >> PWSH;
|
||||
|
||||
#ifndef FAST_CONSTANT_OFFSET_MODE
|
||||
widthLeft = widthDst - ew;
|
||||
#endif
|
||||
|
||||
#define StoreBits0 StorePixels (0,GetPixelGroup(c));
|
||||
#define GetBits WGetBits1U
|
||||
|
||||
SwitchEm
|
||||
|
||||
#undef GetBits
|
||||
#undef StoreBits0
|
||||
|
||||
}
|
||||
x += widthGlyph;
|
||||
leftChar = oldRightChar;
|
||||
}
|
||||
/*
|
||||
* draw the tail of the last character
|
||||
*/
|
||||
xoff1 = x & PIM;
|
||||
if (xoff1)
|
||||
{
|
||||
rightMask = cfbstarttab[xoff1];
|
||||
leftMask = cfbendtab[xoff1];
|
||||
lshift = widthGlyph - xoff1;
|
||||
dst = pdstBase + (x >> PWSH);
|
||||
hTmp = h;
|
||||
while (hTmp--)
|
||||
{
|
||||
GetBitsL;
|
||||
*dst = (*dst & rightMask) | (GetPixelGroup(c) & leftMask);
|
||||
dst += widthDst;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* PSZ == 8 */
|
218
cfb/cfbtegblt.c
218
cfb/cfbtegblt.c
|
@ -1,218 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include <X11/Xproto.h>
|
||||
#include "cfb.h"
|
||||
#include <X11/fonts/fontstruct.h>
|
||||
#include "dixfontstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "windowstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mi.h"
|
||||
#define MFB_CONSTS_ONLY
|
||||
#include "maskbits.h"
|
||||
|
||||
/*
|
||||
this works for fonts with glyphs <= 32 bits wide, on an
|
||||
arbitrarily deep display. Use cfbTEGlyphBlt8 for 8 bit displays.
|
||||
|
||||
This should be called only with a terminal-emulator font;
|
||||
this means that the FIXED_METRICS flag is set, and that
|
||||
glyphbounds == charbounds.
|
||||
|
||||
in theory, this goes faster; even if it doesn't, it reduces the
|
||||
flicker caused by writing a string over itself with image text (since
|
||||
the background gets repainted per character instead of per string.)
|
||||
this seems to be important for some converted X10 applications.
|
||||
|
||||
Image text looks at the bits in the glyph and the fg and bg in the
|
||||
GC. it paints a rectangle, as defined in the protocol dcoument,
|
||||
and the paints the characters.
|
||||
|
||||
*/
|
||||
|
||||
void
|
||||
cfbTEGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase)
|
||||
DrawablePtr pDrawable;
|
||||
GC *pGC;
|
||||
int x, y;
|
||||
unsigned int nglyph;
|
||||
CharInfoPtr *ppci; /* array of character info */
|
||||
pointer pglyphBase; /* start of array of glyphs */
|
||||
{
|
||||
FontPtr pfont = pGC->font;
|
||||
int widthDst;
|
||||
CfbBits *pdstBase; /* pointer to longword with top row
|
||||
of current glyph */
|
||||
|
||||
int w; /* width of glyph and char */
|
||||
int h; /* height of glyph and char */
|
||||
register int xpos=x; /* current x%32 */
|
||||
int ypos=y; /* current y%32 */
|
||||
register unsigned char *pglyph;
|
||||
int widthGlyph;
|
||||
|
||||
register CfbBits *pdst;/* pointer to current longword in dst */
|
||||
int hTmp; /* counter for height */
|
||||
BoxRec bbox; /* for clipping */
|
||||
|
||||
register int wtmp,xtemp,width;
|
||||
CfbBits bgfill,fgfill,*ptemp,tmpDst1,tmpDst2,*pdtmp;
|
||||
#if PSZ != 24
|
||||
int tmpx;
|
||||
#endif
|
||||
|
||||
xpos += pDrawable->x;
|
||||
ypos += pDrawable->y;
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, widthDst, pdstBase)
|
||||
|
||||
wtmp = FONTMAXBOUNDS(pfont,characterWidth);
|
||||
h = FONTASCENT(pfont) + FONTDESCENT(pfont);
|
||||
widthGlyph = GLYPHWIDTHBYTESPADDED(*ppci);
|
||||
|
||||
xpos += FONTMAXBOUNDS(pfont,leftSideBearing);
|
||||
ypos -= FONTASCENT(pfont);
|
||||
|
||||
bbox.x1 = xpos;
|
||||
bbox.x2 = xpos + (wtmp * nglyph);
|
||||
bbox.y1 = ypos;
|
||||
bbox.y2 = ypos + h;
|
||||
|
||||
fgfill = PFILL(pGC->fgPixel);
|
||||
bgfill = PFILL(pGC->bgPixel);
|
||||
|
||||
switch (RECT_IN_REGION(pGC->pScreen, cfbGetCompositeClip(pGC), &bbox))
|
||||
{
|
||||
case rgnOUT:
|
||||
break;
|
||||
case rgnPART:
|
||||
/* this is the WRONG thing to do, but it works.
|
||||
calling the non-terminal text is easy, but slow, given
|
||||
what we know about the font.
|
||||
|
||||
the right thing to do is something like:
|
||||
for each clip rectangle
|
||||
compute at which row the glyph starts to be in it,
|
||||
and at which row the glyph ceases to be in it
|
||||
compute which is the first glyph inside the left
|
||||
edge, and the last one inside the right edge
|
||||
draw a fractional first glyph, using only
|
||||
the rows we know are in
|
||||
draw all the whole glyphs, using the appropriate rows
|
||||
draw any pieces of the last glyph, using the right rows
|
||||
|
||||
this way, the code would take advantage of knowing that
|
||||
all glyphs are the same height and don't overlap.
|
||||
|
||||
one day...
|
||||
*/
|
||||
cfbImageGlyphBlt8(pDrawable, pGC, x, y, nglyph, ppci, pglyphBase);
|
||||
break;
|
||||
case rgnIN:
|
||||
|
||||
pdtmp = pdstBase + (widthDst * ypos);
|
||||
while(nglyph--)
|
||||
{
|
||||
|
||||
pglyph = FONTGLYPHBITS(pglyphBase, *ppci++);
|
||||
pdst = pdtmp;
|
||||
hTmp = h;
|
||||
|
||||
while (hTmp--)
|
||||
{
|
||||
x = xpos;
|
||||
width = wtmp;
|
||||
xtemp = 0;
|
||||
|
||||
while (width > 0)
|
||||
{
|
||||
#if PSZ == 24
|
||||
w = 1;
|
||||
ptemp = (CfbBits *)(pglyph + ((xtemp *3)>> 2));
|
||||
getstipplepixels24(ptemp,xtemp,0,&bgfill,&tmpDst1, xtemp);
|
||||
getstipplepixels24(ptemp,xtemp,1,&fgfill,&tmpDst2, xtemp);
|
||||
#else
|
||||
tmpx = x & PIM;
|
||||
w = min(width, PPW - tmpx);
|
||||
w = min(w, (PGSZ - xtemp));
|
||||
ptemp = (CfbBits *)(pglyph + (xtemp >> MFB_PWSH));
|
||||
getstipplepixels(ptemp,xtemp,w,0,&bgfill,&tmpDst1);
|
||||
getstipplepixels(ptemp,xtemp,w,1,&fgfill,&tmpDst2);
|
||||
#endif
|
||||
|
||||
{
|
||||
CfbBits tmpDst = tmpDst1 | tmpDst2;
|
||||
#if PSZ == 24
|
||||
CfbBits *pdsttmp = pdst + ((x*3) >> 2);
|
||||
putbits24(tmpDst,w,pdsttmp,pGC->planemask,x);
|
||||
#else
|
||||
CfbBits *pdsttmp = pdst + (x >> PWSH);
|
||||
putbits(tmpDst,tmpx,w,pdsttmp,pGC->planemask);
|
||||
#endif
|
||||
}
|
||||
x += w;
|
||||
xtemp += w;
|
||||
width -= w;
|
||||
}
|
||||
pglyph += widthGlyph;
|
||||
pdst += widthDst;
|
||||
}
|
||||
xpos += wtmp;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
517
cfb/cfbtile32.c
517
cfb/cfbtile32.c
|
@ -1,517 +0,0 @@
|
|||
/*
|
||||
* Fill 32 bit tiled rectangles. Used by PolyFillRect.
|
||||
* no depth dependencies.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xmd.h>
|
||||
#include "servermd.h"
|
||||
#include "gcstruct.h"
|
||||
#include "window.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "cfb8bit.h"
|
||||
|
||||
#include "mergerop.h"
|
||||
|
||||
#include "mi.h"
|
||||
#include "mispans.h"
|
||||
|
||||
#ifdef sparc
|
||||
#define SHARED_IDCACHE
|
||||
#endif
|
||||
|
||||
#if PSZ == 24
|
||||
#define STORE(p) (*(p) = MROP_PREBUILT_SOLID(srcpix,*(p)))
|
||||
/*#define STORE24(p,index) {\
|
||||
register int idx = ((index) & 3)<< 1; \
|
||||
*(p) = (((MROP_PREBUILT_SOLID(srcpix,*(p))<<cfb24Shift[idx])&cfbmask[idx])| \
|
||||
(*(p)&cfbrmask[idx])); \
|
||||
idx++; \
|
||||
(p)++; \
|
||||
*(p) = (((MROP_PREBUILT_SOLID(srcpix,*(p))>>cfb24Shift[idx])&cfbmask[idx])| \
|
||||
(*(p)&cfbrmask[idx])); \
|
||||
(p)--; \
|
||||
}*/
|
||||
#define STORE24(p,index) MROP_PREBUILT_SOLID24(srcpix, (p), index)
|
||||
|
||||
#define STORE_MASK(p,mask) (*(p) = MROP_PREBUILT_MASK(srcpix,*(p),(mask)))
|
||||
#define QSTORE(p) ((*(p) = MROP_PREBUILT_SOLID(((srcpix<<24)|srcpix),*(p))), \
|
||||
(p)++,(*(p) = MROP_PREBUILT_SOLID(((srcpix<<16)|(srcpix>>8)),*(p))), \
|
||||
(p)++,(*(p) = MROP_PREBUILT_SOLID(((srcpix<<8)|(srcpix>>16)),*(p))))
|
||||
|
||||
#if (MROP == Mcopy) && defined(FAST_CONSTANT_OFFSET_MODE) && defined(SHARED_IDCACHE)
|
||||
# define Expand(left,right) {\
|
||||
int part = nlwMiddle & ((PGSZB*2)-1); \
|
||||
nlwMiddle *= 3; \
|
||||
nlwMiddle >>= PWSH + 3; \
|
||||
while (h--) { \
|
||||
srcpix = psrc[srcy]; \
|
||||
MROP_PREBUILD(srcpix); \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0; \
|
||||
left \
|
||||
p += part; \
|
||||
switch (part) { \
|
||||
case 7: \
|
||||
STORE24(p - 7, xtmp - 7); \
|
||||
case 6: \
|
||||
STORE24(p - 6, xtmp - 6); \
|
||||
case 5: \
|
||||
STORE24(p - 5, xtmp - 5); \
|
||||
case 4: \
|
||||
STORE24(p - 4, xtmp - 4); \
|
||||
case 3: \
|
||||
STORE24(p - 3, xtmp - 3); \
|
||||
case 2: \
|
||||
STORE24(p - 2, xtmp - 2); \
|
||||
case 1: \
|
||||
STORE24(p - 1, xtmp - 1); \
|
||||
} \
|
||||
nlw = nlwMiddle; \
|
||||
while (nlw) { \
|
||||
STORE24 (p + 0, xtmp + 0); \
|
||||
STORE24 (p + 1, xtmp + 1); \
|
||||
STORE24 (p + 2, xtmp + 2); \
|
||||
STORE24 (p + 3, xtmp + 3); \
|
||||
STORE24 (p + 4, xtmp + 4); \
|
||||
STORE24 (p + 5, xtmp + 5); \
|
||||
STORE24 (p + 6, xtmp + 6); \
|
||||
STORE24 (p + 7, xtmp + 7); \
|
||||
p += 8; \
|
||||
xtmp += 8; \
|
||||
nlw--; \
|
||||
} \
|
||||
right \
|
||||
p += nlwExtra; \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define Expand(left,right) {\
|
||||
while (h--) { \
|
||||
srcpix = psrc[srcy]; \
|
||||
MROP_PREBUILD(srcpix); \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0; \
|
||||
left \
|
||||
while (nlw--) \
|
||||
{ \
|
||||
STORE24(p,xtmp); \
|
||||
if(xtmp&3) p++; \
|
||||
xtmp++; \
|
||||
} \
|
||||
right \
|
||||
p += nlwExtra; \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
#else /*PSZ != 24*/
|
||||
#define STORE(p) (*(p) = MROP_PREBUILT_SOLID(srcpix,*(p)))
|
||||
|
||||
#if (MROP == Mcopy) && defined(FAST_CONSTANT_OFFSET_MODE) && defined(SHARED_IDCACHE)
|
||||
# define Expand(left,right) {\
|
||||
int part = nlwMiddle & ((PGSZB*2)-1); \
|
||||
nlwMiddle >>= PWSH + 1; \
|
||||
while (h--) { \
|
||||
srcpix = psrc[srcy]; \
|
||||
MROP_PREBUILD(srcpix); \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0; \
|
||||
left \
|
||||
p += part; \
|
||||
switch (part) { \
|
||||
case 7: \
|
||||
STORE(p - 7); \
|
||||
case 6: \
|
||||
STORE(p - 6); \
|
||||
case 5: \
|
||||
STORE(p - 5); \
|
||||
case 4: \
|
||||
STORE(p - 4); \
|
||||
case 3: \
|
||||
STORE(p - 3); \
|
||||
case 2: \
|
||||
STORE(p - 2); \
|
||||
case 1: \
|
||||
STORE(p - 1); \
|
||||
} \
|
||||
nlw = nlwMiddle; \
|
||||
while (nlw) { \
|
||||
STORE (p + 0); \
|
||||
STORE (p + 1); \
|
||||
STORE (p + 2); \
|
||||
STORE (p + 3); \
|
||||
STORE (p + 4); \
|
||||
STORE (p + 5); \
|
||||
STORE (p + 6); \
|
||||
STORE (p + 7); \
|
||||
p += 8; \
|
||||
nlw--; \
|
||||
} \
|
||||
right \
|
||||
p += nlwExtra; \
|
||||
} \
|
||||
}
|
||||
#else
|
||||
#define Expand(left,right) {\
|
||||
while (h--) { \
|
||||
srcpix = psrc[srcy]; \
|
||||
MROP_PREBUILD(srcpix); \
|
||||
++srcy; \
|
||||
if (srcy == tileHeight) \
|
||||
srcy = 0; \
|
||||
left \
|
||||
nlw = nlwMiddle; \
|
||||
while (nlw--) \
|
||||
{ \
|
||||
STORE(p); \
|
||||
p++; \
|
||||
} \
|
||||
right \
|
||||
p += nlwExtra; \
|
||||
} \
|
||||
}
|
||||
#endif
|
||||
#endif /*PSZ == 24*/
|
||||
|
||||
void
|
||||
MROP_NAME(cfbFillRectTile32) (pDrawable, pGC, nBox, pBox)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nBox; /* number of boxes to fill */
|
||||
BoxPtr pBox; /* pointer to list of boxes to fill */
|
||||
{
|
||||
register CfbBits srcpix;
|
||||
CfbBits *psrc; /* pointer to bits in tile, if needed */
|
||||
int tileHeight; /* height of the tile */
|
||||
|
||||
int nlwDst; /* width in longwords of the dest pixmap */
|
||||
int w; /* width of current box */
|
||||
register int h; /* height of current box */
|
||||
register CfbBits startmask;
|
||||
register CfbBits endmask; /* masks for reggedy bits at either end of line */
|
||||
int nlwMiddle; /* number of longwords between sides of boxes */
|
||||
int nlwExtra; /* to get from right of box to left of next span */
|
||||
register int nlw = 0; /* loop version of nlwMiddle */
|
||||
register CfbBits *p; /* pointer to bits we're writing */
|
||||
int y; /* current scan line */
|
||||
int srcy; /* current tile position */
|
||||
|
||||
CfbBits *pbits;/* pointer to start of pixmap */
|
||||
PixmapPtr tile; /* rotated, expanded tile */
|
||||
#if MROP == 0 && PSZ == 24
|
||||
DeclareMergeRop()
|
||||
#else
|
||||
MROP_DECLARE_REG()
|
||||
#endif
|
||||
MROP_PREBUILT_DECLARE()
|
||||
#if PSZ == 24
|
||||
CfbBits xtmp;
|
||||
#endif
|
||||
|
||||
tile = pGC->pRotatedPixmap;
|
||||
tileHeight = tile->drawable.height;
|
||||
psrc = (CfbBits *)tile->devPrivate.ptr;
|
||||
|
||||
#if MROP == 0 && PSZ == 24
|
||||
InitializeMergeRop(pGC->alu, pGC->planemask);
|
||||
#else
|
||||
MROP_INITIALIZE(pGC->alu, pGC->planemask);
|
||||
#endif
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pbits)
|
||||
|
||||
while (nBox--)
|
||||
{
|
||||
w = pBox->x2 - pBox->x1;
|
||||
h = pBox->y2 - pBox->y1;
|
||||
y = pBox->y1;
|
||||
#if PSZ == 24
|
||||
xtmp = pBox->x1;
|
||||
p = pbits + (y * nlwDst) + ((pBox->x1*3) >> 2);
|
||||
/* p = pbits + (y * nlwDst) + ((pBox->x1>> 2)*3);*/
|
||||
#else
|
||||
p = pbits + (y * nlwDst) + (pBox->x1 >> PWSH);
|
||||
#endif
|
||||
srcy = y % tileHeight;
|
||||
|
||||
#if PSZ == 24
|
||||
if (w == 1 && ((pBox->x1 & 3) == 0 || (pBox->x1 & 3) == 3))
|
||||
#else
|
||||
if ( ((pBox->x1 & PIM) + w) <= PPW)
|
||||
#endif
|
||||
{
|
||||
maskpartialbits(pBox->x1, w, startmask);
|
||||
nlwExtra = nlwDst;
|
||||
while (h--)
|
||||
{
|
||||
srcpix = psrc[srcy];
|
||||
MROP_PREBUILD(srcpix);
|
||||
++srcy;
|
||||
if (srcy == tileHeight)
|
||||
srcy = 0;
|
||||
*p = MROP_PREBUILT_MASK (srcpix, *p, startmask);
|
||||
p += nlwExtra;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(pBox->x1, w, startmask, endmask, nlwMiddle);
|
||||
nlwExtra = nlwDst - nlwMiddle;
|
||||
|
||||
if (startmask)
|
||||
{
|
||||
nlwExtra -= 1;
|
||||
if (endmask)
|
||||
{
|
||||
Expand(*p = MROP_PREBUILT_MASK(srcpix, *p, startmask); p++;,
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, endmask);)
|
||||
}
|
||||
else
|
||||
{
|
||||
Expand(*p = MROP_PREBUILT_MASK(srcpix, *p, startmask); p++;,
|
||||
;)
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (endmask)
|
||||
{
|
||||
Expand(;,
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, endmask);)
|
||||
}
|
||||
else
|
||||
{
|
||||
Expand(;,
|
||||
;)
|
||||
}
|
||||
}
|
||||
}
|
||||
pBox++;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
MROP_NAME(cfbTile32FS)(pDrawable, pGC, nInit, pptInit, pwidthInit, fSorted)
|
||||
DrawablePtr pDrawable;
|
||||
GCPtr pGC;
|
||||
int nInit; /* number of spans to fill */
|
||||
DDXPointPtr pptInit; /* pointer to list of start points */
|
||||
int *pwidthInit; /* pointer to list of n widths */
|
||||
int fSorted;
|
||||
{
|
||||
/* next three parameters are post-clip */
|
||||
int n; /* number of spans to fill */
|
||||
DDXPointPtr ppt; /* pointer to list of start points */
|
||||
int *pwidth;/* pointer to list of n widths */
|
||||
CfbBits *pbits; /* pointer to start of bitmap */
|
||||
int nlwDst; /* width in longwords of bitmap */
|
||||
register CfbBits *p; /* pointer to current longword in bitmap */
|
||||
register int w; /* current span width */
|
||||
register int nlw;
|
||||
register int x;
|
||||
register CfbBits startmask;
|
||||
register CfbBits endmask;
|
||||
register CfbBits srcpix;
|
||||
int y;
|
||||
int *pwidthFree;/* copies of the pointers to free */
|
||||
DDXPointPtr pptFree;
|
||||
PixmapPtr tile;
|
||||
CfbBits *psrc; /* pointer to bits in tile */
|
||||
int tileHeight;/* height of the tile */
|
||||
#if MROP == 0 && PSZ == 24
|
||||
DeclareMergeRop()
|
||||
#else
|
||||
MROP_DECLARE_REG()
|
||||
#endif
|
||||
MROP_PREBUILT_DECLARE()
|
||||
#if PSZ == 24
|
||||
CfbBits xtmp;
|
||||
#endif
|
||||
|
||||
n = nInit * miFindMaxBand( cfbGetCompositeClip(pGC) );
|
||||
pwidthFree = (int *)xalloc(n * sizeof(int));
|
||||
pptFree = (DDXPointRec *)xalloc(n * sizeof(DDXPointRec));
|
||||
if(!pptFree || !pwidthFree)
|
||||
{
|
||||
if (pptFree) xfree(pptFree);
|
||||
if (pwidthFree) xfree(pwidthFree);
|
||||
return;
|
||||
}
|
||||
pwidth = pwidthFree;
|
||||
ppt = pptFree;
|
||||
n = miClipSpans( cfbGetCompositeClip(pGC),
|
||||
pptInit, pwidthInit, nInit,
|
||||
ppt, pwidth, fSorted);
|
||||
|
||||
tile = pGC->pRotatedPixmap;
|
||||
tileHeight = tile->drawable.height;
|
||||
psrc = (CfbBits *)tile->devPrivate.ptr;
|
||||
|
||||
#if MROP == 0 && PSZ == 24
|
||||
InitializeMergeRop(pGC->alu, pGC->planemask);
|
||||
#else
|
||||
MROP_INITIALIZE(pGC->alu, pGC->planemask);
|
||||
#endif
|
||||
|
||||
cfbGetLongWidthAndPointer (pDrawable, nlwDst, pbits)
|
||||
|
||||
#if MROP == Mcopy
|
||||
if (!(tileHeight & (tileHeight-1)))
|
||||
{
|
||||
tileHeight--;
|
||||
while (n--)
|
||||
{
|
||||
x = ppt->x;
|
||||
y = ppt->y;
|
||||
++ppt;
|
||||
w = *pwidth++;
|
||||
#if PSZ == 24
|
||||
/* p = pbits + (y * nlwDst) + ((x*3) >> 2);*/
|
||||
xtmp = x;
|
||||
p = pbits + (y * nlwDst) + ((x >> 2)*3);
|
||||
#else
|
||||
p = pbits + (y * nlwDst) + (x >> PWSH);
|
||||
#endif
|
||||
srcpix = psrc[y & tileHeight];
|
||||
MROP_PREBUILD(srcpix);
|
||||
|
||||
#if PSZ == 24
|
||||
if ((x & 3) + w < 5)
|
||||
#else
|
||||
if ((x & PIM) + w < PPW)
|
||||
#endif
|
||||
{
|
||||
maskpartialbits(x, w, startmask);
|
||||
*p = MROP_PREBUILT_MASK (srcpix, *p, startmask);
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(x, w, startmask, endmask, nlw);
|
||||
if (startmask)
|
||||
{
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, startmask);
|
||||
#if PSZ == 24
|
||||
if(xtmp&3) p++;
|
||||
xtmp++;
|
||||
#else
|
||||
p++;
|
||||
#endif
|
||||
}
|
||||
while (nlw--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
STORE24(p,xtmp);
|
||||
if(xtmp&3) p++;
|
||||
++xtmp;
|
||||
#else
|
||||
STORE(p);
|
||||
++p;
|
||||
#endif
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
while (n--)
|
||||
{
|
||||
x = ppt->x;
|
||||
y = ppt->y;
|
||||
++ppt;
|
||||
w = *pwidth++;
|
||||
#if PSZ == 24
|
||||
/* p = pbits + (y * nlwDst) + ((x *3)>> 2);*/
|
||||
p = pbits + (y * nlwDst) + ((x >> 2)*3);
|
||||
xtmp = x;
|
||||
#else
|
||||
p = pbits + (y * nlwDst) + (x >> PWSH);
|
||||
#endif
|
||||
srcpix = psrc[y % tileHeight];
|
||||
MROP_PREBUILD(srcpix);
|
||||
|
||||
#if PSZ == 24
|
||||
if ((x & 3) + w < 5)
|
||||
#else
|
||||
if ((x & PIM) + w < PPW)
|
||||
#endif
|
||||
{
|
||||
maskpartialbits(x, w, startmask);
|
||||
*p = MROP_PREBUILT_MASK (srcpix, *p, startmask);
|
||||
}
|
||||
else
|
||||
{
|
||||
maskbits(x, w, startmask, endmask, nlw);
|
||||
if (startmask)
|
||||
{
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, startmask);
|
||||
#if PSZ == 24
|
||||
if(xtmp&3)p++;
|
||||
xtmp++;
|
||||
#else
|
||||
p++;
|
||||
#endif
|
||||
}
|
||||
while (nlw--)
|
||||
{
|
||||
#if PSZ == 24
|
||||
STORE24(p,xtmp);
|
||||
if(xtmp&3)p++;
|
||||
xtmp++;
|
||||
#else
|
||||
STORE(p);
|
||||
++p;
|
||||
#endif
|
||||
}
|
||||
if (endmask)
|
||||
{
|
||||
*p = MROP_PREBUILT_MASK(srcpix, *p, endmask);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
xfree(pptFree);
|
||||
xfree(pwidthFree);
|
||||
}
|
1245
cfb/cfbtileodd.c
1245
cfb/cfbtileodd.c
File diff suppressed because it is too large
Load Diff
161
cfb/cfbunmap.h
161
cfb/cfbunmap.h
|
@ -1,161 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1994-1998 The XFree86 Project, Inc. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Unmap names
|
||||
*/
|
||||
|
||||
#undef CFBNAME
|
||||
#undef CATNAME
|
||||
|
||||
#undef QuartetBitsTable
|
||||
#undef QuartetPixelMaskTable
|
||||
#undef cfb8ClippedLineCopy
|
||||
#undef cfb8ClippedLineGeneral
|
||||
#undef cfb8ClippedLineXor
|
||||
#undef cfb8LineSS1Rect
|
||||
#undef cfb8LineSS1RectCopy
|
||||
#undef cfb8LineSS1RectGeneral
|
||||
#undef cfb8LineSS1RectPreviousCopy
|
||||
#undef cfb8LineSS1RectXor
|
||||
#undef cfb8SegmentSS1Rect
|
||||
#undef cfb8SegmentSS1RectCopy
|
||||
#undef cfb8SegmentSS1RectGeneral
|
||||
#undef cfb8SegmentSS1RectShiftCopy
|
||||
#undef cfb8SegmentSS1RectXor
|
||||
#undef cfbAllocatePrivates
|
||||
#undef cfbBSFuncRec
|
||||
#undef cfbBitBlt
|
||||
#undef cfbBresD
|
||||
#undef cfbBresS
|
||||
#undef cfbChangeWindowAttributes
|
||||
#undef cfbClearVisualTypes
|
||||
#undef cfbCloseScreen
|
||||
#undef cfbCreateDefColormap
|
||||
#undef cfbCopyArea
|
||||
#undef cfbCopyImagePlane
|
||||
#undef cfbCopyPixmap
|
||||
#undef cfbCopyPlane
|
||||
#undef cfbCopyPlaneReduce
|
||||
#undef cfbCopyRotatePixmap
|
||||
#undef cfbCopyWindow
|
||||
#undef cfbCreateGC
|
||||
#undef cfbCreatePixmap
|
||||
#undef cfbCreateScreenResources
|
||||
#undef cfbCreateWindow
|
||||
#undef cfbDestroyPixmap
|
||||
#undef cfbDestroyWindow
|
||||
#undef cfbDoBitblt
|
||||
#undef cfbDoBitbltCopy
|
||||
#undef cfbDoBitbltGeneral
|
||||
#undef cfbDoBitbltOr
|
||||
#undef cfbDoBitbltXor
|
||||
#undef cfbExpandDirectColors
|
||||
#undef cfbFillBoxTile32sCopy
|
||||
#undef cfbFillBoxTile32sGeneral
|
||||
#undef cfbFillBoxTileOdd
|
||||
#undef cfbFillBoxTileOddCopy
|
||||
#undef cfbFillBoxTileOddGeneral
|
||||
#undef cfbFillPoly1RectCopy
|
||||
#undef cfbFillPoly1RectGeneral
|
||||
#undef cfbFillRectSolidCopy
|
||||
#undef cfbFillRectSolidGeneral
|
||||
#undef cfbFillRectSolidXor
|
||||
#undef cfbFillRectTile32Copy
|
||||
#undef cfbFillRectTile32General
|
||||
#undef cfbFillRectTileOdd
|
||||
#undef cfbFillSpanTile32sCopy
|
||||
#undef cfbFillSpanTile32sGeneral
|
||||
#undef cfbFillSpanTileOddCopy
|
||||
#undef cfbFillSpanTileOddGeneral
|
||||
#undef cfbFinishScreenInit
|
||||
#undef cfbGCFuncs
|
||||
#undef cfbGCPrivateKey
|
||||
#undef cfbGetImage
|
||||
#undef cfbGetScreenPixmap
|
||||
#undef cfbGetSpans
|
||||
#undef cfbHorzS
|
||||
#undef cfbImageGlyphBlt8
|
||||
#undef cfbInitializeColormap
|
||||
#undef cfbInitVisuals
|
||||
#undef cfbInstallColormap
|
||||
#undef cfbLineSD
|
||||
#undef cfbLineSS
|
||||
#undef cfbListInstalledColormaps
|
||||
#undef cfbMapWindow
|
||||
#undef cfbMatchCommon
|
||||
#undef cfbNonTEOps
|
||||
#undef cfbNonTEOps1Rect
|
||||
#undef cfbPadPixmap
|
||||
#undef cfbPolyFillArcSolidCopy
|
||||
#undef cfbPolyFillArcSolidGeneral
|
||||
#undef cfbPolyFillRect
|
||||
#undef cfbPolyGlyphBlt8
|
||||
#undef cfbPolyGlyphRop8
|
||||
#undef cfbPolyPoint
|
||||
#undef cfbPositionWindow
|
||||
#undef cfbPutImage
|
||||
#undef cfbReduceRasterOp
|
||||
#undef cfbResolveColor
|
||||
#undef cfbRestoreAreas
|
||||
#undef cfbSaveAreas
|
||||
#undef cfbScreenInit
|
||||
#undef cfbScreenPrivateKey
|
||||
#undef cfbSegmentSD
|
||||
#undef cfbSegmentSS
|
||||
#undef cfbSetScanline
|
||||
#undef cfbSetScreenPixmap
|
||||
#undef cfbSetSpans
|
||||
#undef cfbSetVisualTypes
|
||||
#undef cfbSetupScreen
|
||||
#undef cfbSolidSpansCopy
|
||||
#undef cfbSolidSpansGeneral
|
||||
#undef cfbSolidSpansXor
|
||||
#undef cfbStippleStack
|
||||
#undef cfbStippleStackTE
|
||||
#undef cfbTEGlyphBlt
|
||||
#undef cfbTEOps
|
||||
#undef cfbTEOps1Rect
|
||||
#undef cfbTile32FSCopy
|
||||
#undef cfbTile32FSGeneral
|
||||
#undef cfbUninstallColormap
|
||||
#undef cfbUnmapWindow
|
||||
#undef cfbUnnaturalStippleFS
|
||||
#undef cfbUnnaturalTileFS
|
||||
#undef cfbValidateGC
|
||||
#undef cfbVertS
|
||||
#undef cfbWindowPrivateKey
|
||||
#undef cfbXRotatePixmap
|
||||
#undef cfbYRotatePixmap
|
||||
#undef cfbZeroPolyArcSS8Copy
|
||||
#undef cfbZeroPolyArcSS8General
|
||||
#undef cfbZeroPolyArcSS8Xor
|
||||
#undef cfbendpartial
|
||||
#undef cfbendtab
|
||||
#undef cfbmask
|
||||
#undef cfbrmask
|
||||
#undef cfbstartpartial
|
||||
#undef cfbstarttab
|
160
cfb/cfbwindow.c
160
cfb/cfbwindow.c
|
@ -1,160 +0,0 @@
|
|||
/***********************************************************
|
||||
|
||||
Copyright 1987, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
|
||||
Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
|
||||
|
||||
All Rights Reserved
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Digital not be
|
||||
used in advertising or publicity pertaining to distribution of the
|
||||
software without specific, written prior permission.
|
||||
|
||||
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
||||
DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
||||
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
||||
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
||||
SOFTWARE.
|
||||
|
||||
******************************************************************/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include "scrnintstr.h"
|
||||
#include "windowstr.h"
|
||||
#include "cfb.h"
|
||||
#include "mistruct.h"
|
||||
#include "regionstr.h"
|
||||
#include "cfbmskbits.h"
|
||||
|
||||
Bool
|
||||
cfbCreateWindow(WindowPtr pWin)
|
||||
{
|
||||
#ifdef PIXMAP_PER_WINDOW
|
||||
/* Setup pointer to Screen pixmap */
|
||||
dixSetPrivate(&pWin->devPrivates, frameWindowPrivateKey,
|
||||
cfbGetScreenPixmap(pWin->drawable.pScreen));
|
||||
#endif
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbDestroyWindow(WindowPtr pWin)
|
||||
{
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
Bool
|
||||
cfbMapWindow(pWindow)
|
||||
WindowPtr pWindow;
|
||||
{
|
||||
return(TRUE);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
Bool
|
||||
cfbPositionWindow(WindowPtr pWin, int x, int y)
|
||||
{
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
Bool
|
||||
cfbUnmapWindow(pWindow)
|
||||
WindowPtr pWindow;
|
||||
{
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/* UNCLEAN!
|
||||
this code calls the bitblt helper code directly.
|
||||
|
||||
cfbCopyWindow copies only the parts of the destination that are
|
||||
visible in the source.
|
||||
*/
|
||||
|
||||
|
||||
void
|
||||
cfbCopyWindow(pWin, ptOldOrg, prgnSrc)
|
||||
WindowPtr pWin;
|
||||
DDXPointRec ptOldOrg;
|
||||
RegionPtr prgnSrc;
|
||||
{
|
||||
DDXPointPtr pptSrc;
|
||||
register DDXPointPtr ppt;
|
||||
RegionRec rgnDst;
|
||||
register BoxPtr pbox;
|
||||
register int dx, dy;
|
||||
register int i, nbox;
|
||||
WindowPtr pwinRoot;
|
||||
|
||||
pwinRoot = WindowTable[pWin->drawable.pScreen->myNum];
|
||||
|
||||
REGION_NULL(pWin->drawable.pScreen, &rgnDst);
|
||||
|
||||
dx = ptOldOrg.x - pWin->drawable.x;
|
||||
dy = ptOldOrg.y - pWin->drawable.y;
|
||||
REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy);
|
||||
REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc);
|
||||
|
||||
pbox = REGION_RECTS(&rgnDst);
|
||||
nbox = REGION_NUM_RECTS(&rgnDst);
|
||||
if(!nbox || !(pptSrc = (DDXPointPtr )xalloc(nbox * sizeof(DDXPointRec))))
|
||||
{
|
||||
REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);
|
||||
return;
|
||||
}
|
||||
ppt = pptSrc;
|
||||
|
||||
for (i = nbox; --i >= 0; ppt++, pbox++)
|
||||
{
|
||||
ppt->x = pbox->x1 + dx;
|
||||
ppt->y = pbox->y1 + dy;
|
||||
}
|
||||
|
||||
cfbDoBitbltCopy((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
|
||||
GXcopy, &rgnDst, pptSrc, ~0L);
|
||||
xfree(pptSrc);
|
||||
REGION_UNINIT(pWin->drawable.pScreen, &rgnDst);
|
||||
}
|
||||
|
||||
Bool
|
||||
cfbChangeWindowAttributes(WindowPtr pWin, unsigned long mask)
|
||||
{
|
||||
return (TRUE);
|
||||
}
|
||||
|
322
cfb/cfbzerarc.c
322
cfb/cfbzerarc.c
|
@ -1,322 +0,0 @@
|
|||
/************************************************************
|
||||
|
||||
Copyright 1989, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
|
||||
********************************************************/
|
||||
|
||||
|
||||
/* Derived from:
|
||||
* "Algorithm for drawing ellipses or hyperbolae with a digital plotter"
|
||||
* by M. L. V. Pitteway
|
||||
* The Computer Journal, November 1967, Volume 10, Number 3, pp. 282-289
|
||||
*/
|
||||
|
||||
#ifdef HAVE_DIX_CONFIG_H
|
||||
#include <dix-config.h>
|
||||
#endif
|
||||
|
||||
#include <limits.h>
|
||||
|
||||
#include <X11/X.h>
|
||||
#include <X11/Xprotostr.h>
|
||||
#include "regionstr.h"
|
||||
#include "gcstruct.h"
|
||||
#include "pixmapstr.h"
|
||||
#include "scrnintstr.h"
|
||||
#include "cfb.h"
|
||||
#include "cfbmskbits.h"
|
||||
#include "mizerarc.h"
|
||||
#include "cfbrrop.h"
|
||||
#include "mi.h"
|
||||
|
||||
#ifdef PIXEL_ADDR
|
||||
|
||||
static void
|
||||
RROP_NAME(cfbZeroArcSS8)(
|
||||
DrawablePtr pDraw,
|
||||
GCPtr pGC,
|
||||
xArc *arc)
|
||||
{
|
||||
miZeroArcRec info;
|
||||
Bool do360;
|
||||
register int x;
|
||||
PixelType *addrp;
|
||||
register PixelType *yorgp, *yorgop;
|
||||
#if PSZ == 24
|
||||
int xorg, xorg3, xorgo, xorgo3;
|
||||
register int xtmp;
|
||||
#endif
|
||||
RROP_DECLARE
|
||||
register int yoffset;
|
||||
int npwidth, dyoffset;
|
||||
register int y, a, b, d, mask;
|
||||
register int k1, k3, dx, dy;
|
||||
|
||||
cfbGetPixelWidthAndPointer(pDraw,npwidth, addrp)
|
||||
|
||||
RROP_FETCH_GC (pGC);
|
||||
do360 = miZeroArcSetup(arc, &info, TRUE);
|
||||
yorgp = addrp + ((info.yorg + pDraw->y) * npwidth);
|
||||
yorgop = addrp + ((info.yorgo + pDraw->y) * npwidth);
|
||||
info.xorg += pDraw->x;
|
||||
info.xorgo += pDraw->x;
|
||||
#if PSZ == 24
|
||||
xorg = info.xorg;
|
||||
xorg3 = xorg * 3;
|
||||
info.xorg = (info.xorg * 3) >> 2;
|
||||
xorgo = info.xorgo;
|
||||
xorgo3 = xorgo * 3;
|
||||
info.xorgo = (info.xorgo * 3) >> 2;
|
||||
#endif
|
||||
MIARCSETUP();
|
||||
yoffset = y ? npwidth : 0;
|
||||
dyoffset = 0;
|
||||
mask = info.initialMask;
|
||||
if (!(arc->width & 1))
|
||||
{
|
||||
#if PSZ == 24
|
||||
if (mask & 2)
|
||||
RROP_SOLID24((yorgp + info.xorgo), xorgo);
|
||||
if (mask & 8)
|
||||
RROP_SOLID24((yorgop + info.xorgo), xorgo);
|
||||
#else
|
||||
if (mask & 2)
|
||||
RROP_SOLID((yorgp + info.xorgo));
|
||||
if (mask & 8)
|
||||
RROP_SOLID((yorgop + info.xorgo));
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
if (!info.end.x || !info.end.y)
|
||||
{
|
||||
mask = info.end.mask;
|
||||
info.end = info.altend;
|
||||
}
|
||||
if (do360 && (arc->width == arc->height) && !(arc->width & 1))
|
||||
{
|
||||
register int xoffset = npwidth;
|
||||
#if PSZ == 24
|
||||
PixelType *yorghb = yorgp + (info.h * npwidth);
|
||||
register int tmp1, tmp2, tmp1_3, tmp2_3;
|
||||
|
||||
tmp1 = xorg + info.h;
|
||||
tmp1_3 = tmp1 * 3;
|
||||
tmp2 = xorg - info.h;
|
||||
tmp2_3 = tmp2 * 3;
|
||||
while (1)
|
||||
{
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg + x);
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg + x);
|
||||
xtmp = (xorg3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg - x);
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg - x);
|
||||
if (a < 0)
|
||||
break;
|
||||
xtmp = (tmp1_3 - y * 3) >> 2;
|
||||
RROP_SOLID24(yorghb - xoffset + xtmp, tmp1 - y);
|
||||
RROP_SOLID24(yorghb + xoffset + xtmp, tmp1 - y);
|
||||
xtmp = (tmp2_3 + y * 3) >> 2;
|
||||
RROP_SOLID24(yorghb - xoffset + xtmp, tmp2 + y);
|
||||
RROP_SOLID24(yorghb + xoffset + xtmp, tmp2 + y);
|
||||
xoffset += npwidth;
|
||||
MIARCCIRCLESTEP(yoffset += npwidth;);
|
||||
}
|
||||
#else
|
||||
PixelType *yorghb = yorgp + (info.h * npwidth) + info.xorg;
|
||||
PixelType *yorgohb = yorghb - info.h;
|
||||
|
||||
yorgp += info.xorg;
|
||||
yorgop += info.xorg;
|
||||
yorghb += info.h;
|
||||
while (1)
|
||||
{
|
||||
RROP_SOLID(yorgp + yoffset + x);
|
||||
RROP_SOLID(yorgp + yoffset - x);
|
||||
RROP_SOLID(yorgop - yoffset - x);
|
||||
RROP_SOLID(yorgop - yoffset + x);
|
||||
if (a < 0)
|
||||
break;
|
||||
RROP_SOLID(yorghb - xoffset - y);
|
||||
RROP_SOLID(yorgohb - xoffset + y);
|
||||
RROP_SOLID(yorgohb + xoffset + y);
|
||||
RROP_SOLID(yorghb + xoffset - y);
|
||||
xoffset += npwidth;
|
||||
MIARCCIRCLESTEP(yoffset += npwidth;);
|
||||
}
|
||||
yorgp -= info.xorg;
|
||||
yorgop -= info.xorg;
|
||||
#endif /* PSZ == 24 */
|
||||
x = info.w;
|
||||
yoffset = info.h * npwidth;
|
||||
}
|
||||
else if (do360)
|
||||
{
|
||||
while (y < info.h || x < info.w)
|
||||
{
|
||||
MIARCOCTANTSHIFT(dyoffset = npwidth;);
|
||||
#if PSZ == 24
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg + x);
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg + x);
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorgo - x);
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorgo - x);
|
||||
#else
|
||||
RROP_SOLID(yorgp + yoffset + info.xorg + x);
|
||||
RROP_SOLID(yorgp + yoffset + info.xorgo - x);
|
||||
RROP_SOLID(yorgop - yoffset + info.xorgo - x);
|
||||
RROP_SOLID(yorgop - yoffset + info.xorg + x);
|
||||
#endif
|
||||
MIARCSTEP(yoffset += dyoffset;, yoffset += npwidth;);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (y < info.h || x < info.w)
|
||||
{
|
||||
MIARCOCTANTSHIFT(dyoffset = npwidth;);
|
||||
if ((x == info.start.x) || (y == info.start.y))
|
||||
{
|
||||
mask = info.start.mask;
|
||||
info.start = info.altstart;
|
||||
}
|
||||
#if PSZ == 24
|
||||
if (mask & 1){
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg + x);
|
||||
}
|
||||
if (mask & 2){
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorgo - x);
|
||||
}
|
||||
if (mask & 4){
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorgo - x);
|
||||
}
|
||||
if (mask & 8){
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg + x);
|
||||
}
|
||||
#else
|
||||
if (mask & 1)
|
||||
RROP_SOLID(yorgp + yoffset + info.xorg + x);
|
||||
if (mask & 2)
|
||||
RROP_SOLID(yorgp + yoffset + info.xorgo - x);
|
||||
if (mask & 4)
|
||||
RROP_SOLID(yorgop - yoffset + info.xorgo - x);
|
||||
if (mask & 8)
|
||||
RROP_SOLID(yorgop - yoffset + info.xorg + x);
|
||||
#endif /* PSZ == 24 */
|
||||
if ((x == info.end.x) || (y == info.end.y))
|
||||
{
|
||||
mask = info.end.mask;
|
||||
info.end = info.altend;
|
||||
}
|
||||
MIARCSTEP(yoffset += dyoffset;, yoffset += npwidth;);
|
||||
}
|
||||
}
|
||||
if ((x == info.start.x) || (y == info.start.y))
|
||||
mask = info.start.mask;
|
||||
#if PSZ == 24
|
||||
if (mask & 1){
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorg + x);
|
||||
}
|
||||
if (mask & 4){
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorgo - x);
|
||||
}
|
||||
#else
|
||||
if (mask & 1)
|
||||
RROP_SOLID(yorgp + yoffset + info.xorg + x);
|
||||
if (mask & 4)
|
||||
RROP_SOLID(yorgop - yoffset + info.xorgo - x);
|
||||
#endif /* PSZ == 24 */
|
||||
if (arc->height & 1)
|
||||
{
|
||||
#if PSZ == 24
|
||||
if (mask & 2){
|
||||
xtmp = (xorgo3 - x * 3) >> 2;
|
||||
RROP_SOLID24(yorgp + yoffset + xtmp, xorgo - x);
|
||||
}
|
||||
if (mask & 8){
|
||||
xtmp = (xorg3 + x * 3) >> 2;
|
||||
RROP_SOLID24(yorgop - yoffset + xtmp, xorg + x);
|
||||
}
|
||||
#else
|
||||
if (mask & 2)
|
||||
RROP_SOLID(yorgp + yoffset + info.xorgo - x);
|
||||
if (mask & 8)
|
||||
RROP_SOLID(yorgop - yoffset + info.xorg + x);
|
||||
#endif /* PSZ == 24 */
|
||||
}
|
||||
RROP_UNDECLARE
|
||||
}
|
||||
|
||||
void
|
||||
RROP_NAME (cfbZeroPolyArcSS8) (pDraw, pGC, narcs, parcs)
|
||||
register DrawablePtr pDraw;
|
||||
GCPtr pGC;
|
||||
int narcs;
|
||||
xArc *parcs;
|
||||
{
|
||||
register xArc *arc;
|
||||
register int i;
|
||||
BoxRec box;
|
||||
int x2, y2;
|
||||
RegionPtr cclip;
|
||||
|
||||
cclip = cfbGetCompositeClip(pGC);
|
||||
for (arc = parcs, i = narcs; --i >= 0; arc++)
|
||||
{
|
||||
if (miCanZeroArc(arc))
|
||||
{
|
||||
box.x1 = arc->x + pDraw->x;
|
||||
box.y1 = arc->y + pDraw->y;
|
||||
/*
|
||||
* Because box.x2 and box.y2 get truncated to 16 bits, and the
|
||||
* RECT_IN_REGION test treats the resulting number as a signed
|
||||
* integer, the RECT_IN_REGION test alone can go the wrong way.
|
||||
* This can result in a server crash because the rendering
|
||||
* routines in this file deal directly with cpu addresses
|
||||
* of pixels to be stored, and do not clip or otherwise check
|
||||
* that all such addresses are within their respective pixmaps.
|
||||
* So we only allow the RECT_IN_REGION test to be used for
|
||||
* values that can be expressed correctly in a signed short.
|
||||
*/
|
||||
x2 = box.x1 + (int)arc->width + 1;
|
||||
box.x2 = x2;
|
||||
y2 = box.y1 + (int)arc->height + 1;
|
||||
box.y2 = y2;
|
||||
if ( (x2 <= SHRT_MAX) && (y2 <= SHRT_MAX) &&
|
||||
(RECT_IN_REGION(pDraw->pScreen, cclip, &box) == rgnIN) )
|
||||
RROP_NAME (cfbZeroArcSS8) (pDraw, pGC, arc);
|
||||
else
|
||||
miZeroPolyArc(pDraw, pGC, 1, arc);
|
||||
}
|
||||
else
|
||||
miPolyArc(pDraw, pGC, 1, arc);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
121
cfb/stip68kgnu.h
121
cfb/stip68kgnu.h
|
@ -1,121 +0,0 @@
|
|||
/*
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
/*
|
||||
* Stipple stack macro for 68k GCC
|
||||
*/
|
||||
|
||||
#define STIPPLE(addr,stipple,value,width,count,shift) \
|
||||
__asm volatile ( \
|
||||
"lea 5f,%/a1\n\
|
||||
moveq #28,%/d2\n\
|
||||
addl %2,%/d2\n\
|
||||
moveq #28,%/d3\n\
|
||||
subql #4,%2\n\
|
||||
negl %2\n\
|
||||
1:\n\
|
||||
movel %0,%/a0\n\
|
||||
addl %6,%0\n\
|
||||
movel %3@+,%/d1\n\
|
||||
jeq 3f\n\
|
||||
movel %/d1,%/d0\n\
|
||||
lsrl %/d2,%/d0\n\
|
||||
lsll #5,%/d0\n\
|
||||
lsll %2,%/d1\n\
|
||||
jmp %/a1@(%/d0:l)\n\
|
||||
2:\n\
|
||||
addl #4,%/a0\n\
|
||||
movel %/d1,%/d0\n\
|
||||
lsrl %/d3,%/d0\n\
|
||||
lsll #5,%/d0\n\
|
||||
lsll #4,%/d1\n\
|
||||
jmp %/a1@(%/d0:l)\n\
|
||||
5:\n\
|
||||
jne 2b ; dbra %1,1b ; jra 4f\n\
|
||||
. = 5b + 0x20\n\
|
||||
moveb %5,%/a0@(3)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f\n\
|
||||
. = 5b + 0x40\n\
|
||||
moveb %5,%/a0@(2)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f\n\
|
||||
. = 5b + 0x60\n\
|
||||
movew %5,%/a0@(2)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f\n\
|
||||
. = 5b + 0x80\n\
|
||||
moveb %5,%/a0@(1)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0xa0\n\
|
||||
moveb %5,%/a0@(3) ; moveb %5,%/a0@(1)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0xc0\n\
|
||||
movew %5,%/a0@(1)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0xe0\n\
|
||||
movew %5,%/a0@(2) ; moveb %5,%/a0@(1)\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x100\n\
|
||||
moveb %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x120\n\
|
||||
moveb %5,%/a0@(3) ; moveb %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x140\n\
|
||||
moveb %5,%/a0@(2) ; moveb %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x160\n\
|
||||
movew %5,%/a0@(2) ; moveb %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x180\n\
|
||||
movew %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x1a0\n\
|
||||
moveb %5,%/a0@(3) ; movew %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x1c0\n\
|
||||
moveb %5,%/a0@(2) ; movew %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; dbra %1,1b ; jra 4f ;\n\
|
||||
. = 5b + 0x1e0\n\
|
||||
movel %5,%/a0@\n\
|
||||
andl %/d1,%/d1 ; jne 2b ; \n\
|
||||
3: dbra %1,1b ; \n\
|
||||
4:\n"\
|
||||
: "=a" (addr), /* %0 */ \
|
||||
"=d" (count), /* %1 */ \
|
||||
"=d" (shift), /* %2 */ \
|
||||
"=a" (stipple) /* %3 */ \
|
||||
: "0" (addr), /* %4 */ \
|
||||
"d" (value), /* %5 */ \
|
||||
"a" (width), /* %6 */ \
|
||||
"1" (count-1), /* %7 */ \
|
||||
"2" (shift), /* %8 */ \
|
||||
"3" (stipple) /* %9 */ \
|
||||
: /* ctemp */ "d0", \
|
||||
/* c */ "d1", \
|
||||
/* lshift */ "d2", \
|
||||
/* rshift */ "d3", \
|
||||
/* atemp */ "a0", \
|
||||
/* case */ "a1")
|
281
cfb/stipmips.s
281
cfb/stipmips.s
|
@ -1,281 +0,0 @@
|
|||
/*
|
||||
* $Xorg: stipmips.s,v 1.4 2001/02/09 02:04:39 xorgcvs Exp $
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
|
||||
/*
|
||||
* MIPS assembly code for optimized text rendering.
|
||||
*
|
||||
* Other stippling could be done in assembly, but the payoff is
|
||||
* not nearly as large. Mostly because large areas are heavily
|
||||
* optimized already.
|
||||
*/
|
||||
|
||||
#ifdef MIPSEL
|
||||
# define BitsR sll
|
||||
# define BitsL srl
|
||||
# define BO(o) o
|
||||
# define HO(o) o
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) and dest, bits, 0xf
|
||||
#else
|
||||
# define BitsR srl
|
||||
# define BitsL sll
|
||||
# define BO(o) 3-o
|
||||
# define HO(o) 2-o
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) srl dest, bits, 28
|
||||
#endif
|
||||
|
||||
/* reordering instructions would be fatal here */
|
||||
.set noreorder
|
||||
|
||||
|
||||
/*
|
||||
* cfbStippleStack(addr, stipple, value, stride, Count, Shift)
|
||||
* 4 5 6 7 16(sp) 20(sp)
|
||||
*
|
||||
* Apply successive 32-bit stipples starting at addr, addr+stride, ...
|
||||
*
|
||||
* Used for text rendering, but only when no data could be lost
|
||||
* when the stipple is shifted left by Shift bits
|
||||
*/
|
||||
/* arguments */
|
||||
#define addr $4
|
||||
#define stipple $5
|
||||
#define value $6
|
||||
#define stride $7
|
||||
#define Count 16($sp)
|
||||
#define Shift 20($sp)
|
||||
|
||||
/* local variables */
|
||||
#define count $14
|
||||
#define shift $13
|
||||
#define atemp $12
|
||||
#define bits $11
|
||||
#define lshift $9
|
||||
#define sbase $8
|
||||
#define stemp $2
|
||||
|
||||
#define CASE_SIZE 5 /* case blocks are 2^5 bytes each */
|
||||
#define CASE_MASK 0x1e0 /* first case mask */
|
||||
|
||||
#define ForEachLine $200
|
||||
#define NextLine $201
|
||||
#define NextLine1 $202
|
||||
#define CaseBegin $203
|
||||
#define ForEachBits $204
|
||||
#define ForEachBits1 $205
|
||||
#define NextBits $206
|
||||
|
||||
#ifdef TETEXT
|
||||
#define cfbStippleStack cfbStippleStackTE
|
||||
#endif
|
||||
|
||||
.globl cfbStippleStack
|
||||
.ent cfbStippleStack 2
|
||||
cfbStippleStack:
|
||||
.frame $sp, 0, $31
|
||||
lw count, Count /* fetch stack params */
|
||||
la sbase,CaseBegin /* load up switch table */
|
||||
lw shift, Shift
|
||||
li lshift, 4 /* compute offset within */
|
||||
subu lshift, lshift, shift /* stipple of remaining bits */
|
||||
#ifdef MIPSEL
|
||||
addu shift, shift, CASE_SIZE /* first shift for LSB */
|
||||
#else
|
||||
addu shift, shift, 28-CASE_SIZE /* first shift for MSB */
|
||||
#endif
|
||||
/* do ... while (--count > 0); */
|
||||
ForEachLine:
|
||||
lw bits, 0(stipple) /* get stipple bits */
|
||||
move atemp, addr /* set up for this line */
|
||||
#ifdef TETEXT
|
||||
/* Terminal emulator fonts are expanded and have many 0 rows */
|
||||
beqz bits, NextLine /* skip out early on 0 */
|
||||
#endif
|
||||
addu addr, addr, stride /* step for the loop */
|
||||
BitsR stemp, bits, shift /* get first bits */
|
||||
and stemp, stemp, CASE_MASK /* compute first branch */
|
||||
addu stemp, stemp, sbase /* ... */
|
||||
j stemp /* ... */
|
||||
BitsL bits, bits, lshift /* set remaining bits */
|
||||
|
||||
ForEachBits:
|
||||
addu atemp, atemp, 4
|
||||
ForEachBits1:
|
||||
FourBits(stemp, bits) /* compute jump for */
|
||||
sll stemp, stemp, CASE_SIZE /* next four bits */
|
||||
addu stemp, stemp, sbase /* ... */
|
||||
j stemp /* ... */
|
||||
BitsL bits, bits, 4 /* step for remaining bits */
|
||||
CaseBegin:
|
||||
bnez bits, ForEachBits1 /* 0 */
|
||||
addu atemp, atemp, 4
|
||||
NextLine:
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 1 */
|
||||
sb value, BO(0)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 2 */
|
||||
sb value, BO(1)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 3 */
|
||||
sh value, HO(0)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 4 */
|
||||
sb value, BO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
sb value, BO(0)(atemp) /* 5 */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
sb value, BO(1)(atemp) /* 6 */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 7 */
|
||||
swl value, BO(2)(atemp) /* untested on MSB */
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* 8 */
|
||||
sb value, BO(3)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
sb value, BO(0)(atemp) /* 9 */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(3)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
sb value, BO(1)(atemp) /* a */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(3)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
sh value, HO(0)(atemp) /* b */
|
||||
bnez bits, ForEachBits
|
||||
sb value, BO(3)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* c */
|
||||
sh value, HO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
sb value, BO(0)(atemp) /* d */
|
||||
bnez bits, ForEachBits
|
||||
sh value, HO(2)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* e */
|
||||
swr value, BO(1)(atemp) /* untested on MSB */
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
bnez bits, ForEachBits /* f */
|
||||
sw value, WO(0)(atemp)
|
||||
addu count, count, -1
|
||||
bnez count, ForEachLine
|
||||
addu stipple, stipple, 4
|
||||
j $31
|
||||
nop
|
||||
nop
|
||||
|
||||
.end cfbStippleStack
|
290
cfb/stipsparc.s
290
cfb/stipsparc.s
|
@ -1,290 +0,0 @@
|
|||
/*
|
||||
* $Xorg: stipsparc.s,v 1.4 2001/02/09 02:04:39 xorgcvs Exp $
|
||||
* $XdotOrg: $
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
/* $XFree86: xc/programs/Xserver/cfb/stipsparc.s,v 1.4 2001/01/17 22:36:38 dawes Exp $ */
|
||||
|
||||
/*
|
||||
* SPARC assembly code for optimized text rendering.
|
||||
*
|
||||
* Other stippling could be done in assembly, but the payoff is
|
||||
* not nearly as large. Mostly because large areas are heavily
|
||||
* optimized already.
|
||||
*/
|
||||
|
||||
/* not that I expect to ever see an LSB SPARC, but ... */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
# define BitsR sll
|
||||
# define BitsL srl
|
||||
# define BO(o) o
|
||||
# define HO(o) o
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) and bits, 0xf, dest
|
||||
#else
|
||||
# define BitsR srl
|
||||
# define BitsL sll
|
||||
# define BO(o) 3-o
|
||||
# define HO(o) 2-o
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) srl bits, 28, dest
|
||||
#endif
|
||||
|
||||
/*
|
||||
* cfbStippleStack(addr, stipple, value, stride, Count, Shift)
|
||||
* 4 5 6 7 16(sp) 20(sp)
|
||||
*
|
||||
* Apply successive 32-bit stipples starting at addr, addr+stride, ...
|
||||
*
|
||||
* Used for text rendering, but only when no data could be lost
|
||||
* when the stipple is shifted left by Shift bits
|
||||
*/
|
||||
/* arguments */
|
||||
#define addr %i0
|
||||
#define stipple %i1
|
||||
#define value %i2
|
||||
#define stride %i3
|
||||
#define count %i4
|
||||
#define shift %i5
|
||||
|
||||
/* local variables */
|
||||
#define atemp %l0
|
||||
#define bits %l1
|
||||
#define lshift %l2
|
||||
#define sbase %l3
|
||||
#define stemp %l4
|
||||
|
||||
#define CASE_SIZE 5 /* case blocks are 2^5 bytes each */
|
||||
#define CASE_MASK 0x1e0 /* first case mask */
|
||||
|
||||
#define ForEachLine LY1
|
||||
#define NextLine LY2
|
||||
#define CaseBegin LY3
|
||||
#define ForEachBits LY4
|
||||
#define NextBits LY5
|
||||
|
||||
#if defined(SVR4) || defined(__ELF__)
|
||||
#ifdef TETEXT
|
||||
#define _cfbStippleStack cfbStippleStackTE
|
||||
#else
|
||||
#define _cfbStippleStack cfbStippleStack
|
||||
#endif
|
||||
#else
|
||||
#ifdef TETEXT
|
||||
#define _cfbStippleStack _cfbStippleStackTE
|
||||
#endif
|
||||
#endif
|
||||
.seg "text"
|
||||
.proc 16
|
||||
.globl _cfbStippleStack
|
||||
_cfbStippleStack:
|
||||
save %sp,-64,%sp
|
||||
#ifdef SHAREDCODE
|
||||
1:
|
||||
call 2f
|
||||
nop
|
||||
2:
|
||||
mov %o7,sbase /* sbase = 1b(1:) */
|
||||
add sbase, CaseBegin-1b, sbase
|
||||
#else /* !SHAREDCODE */
|
||||
sethi %hi(CaseBegin),sbase /* load up switch table */
|
||||
or sbase,%lo(CaseBegin),sbase
|
||||
#endif /* SHAREDCODE */
|
||||
mov 4,lshift /* compute offset within */
|
||||
sub lshift, shift, lshift /* stipple of remaining bits */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
inc CASE_SIZE, shift /* first shift for LSB */
|
||||
#else
|
||||
inc 28-CASE_SIZE, shift /* first shift for MSB */
|
||||
#endif
|
||||
/* do ... while (--count > 0); */
|
||||
ForEachLine:
|
||||
ld [stipple],bits /* get stipple bits */
|
||||
mov addr,atemp /* set up for this line */
|
||||
#ifdef TETEXT
|
||||
/* Terminal emulator fonts are expanded and have many 0 rows */
|
||||
tst bits
|
||||
bz NextLine /* skip out early on 0 */
|
||||
#endif
|
||||
add addr, stride, addr /* step for the loop */
|
||||
BitsR bits, shift, stemp /* get first bits */
|
||||
and stemp, CASE_MASK, stemp /* compute first jump */
|
||||
BitsL bits, lshift, bits /* set remaining bits */
|
||||
jmp sbase+stemp /* ... */
|
||||
tst bits
|
||||
|
||||
ForEachBits:
|
||||
inc 4, atemp
|
||||
ForEachBits1:
|
||||
FourBits(stemp, bits) /* compute jump for */
|
||||
sll stemp, CASE_SIZE, stemp /* these four bits */
|
||||
BitsL bits, 4, bits /* step for remaining bits */
|
||||
jmp sbase+stemp /* jump */
|
||||
tst bits
|
||||
CaseBegin:
|
||||
bnz,a ForEachBits1 /* 0 */
|
||||
inc 4, atemp
|
||||
NextLine:
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 1 */
|
||||
stb value, [atemp+BO(0)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 2 */
|
||||
stb value, [atemp+BO(1)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 3 */
|
||||
sth value, [atemp+HO(0)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 4 */
|
||||
stb value, [atemp+BO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
stb value, [atemp+BO(0)] /* 5 */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
stb value, [atemp+BO(1)] /* 6 */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
sth value, [atemp+HO(0)] /* 7 */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
bnz ForEachBits /* 8 */
|
||||
stb value, [atemp+BO(3)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
stb value, [atemp+BO(0)] /* 9 */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(3)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
stb value, [atemp+BO(1)] /* a */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(3)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
sth value, [atemp+HO(0)] /* b */
|
||||
bnz ForEachBits
|
||||
stb value, [atemp+BO(3)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
bnz ForEachBits /* c */
|
||||
sth value, [atemp+HO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
stb value, [atemp+BO(0)] /* d */
|
||||
bnz ForEachBits
|
||||
sth value, [atemp+HO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
stb value, [atemp+BO(1)] /* e */
|
||||
bnz ForEachBits
|
||||
sth value, [atemp+HO(2)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
bnz ForEachBits /* f */
|
||||
st value, [atemp+WO(0)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
291
cfb/stipsprc32.s
291
cfb/stipsprc32.s
|
@ -1,291 +0,0 @@
|
|||
/*
|
||||
* $Xorg: stipsprc32.s,v 1.4 2001/02/09 02:04:39 xorgcvs Exp $
|
||||
* $XdotOrg: $
|
||||
*
|
||||
Copyright 1990, 1998 The Open Group
|
||||
|
||||
Permission to use, copy, modify, distribute, and sell this software and its
|
||||
documentation for any purpose is hereby granted without fee, provided that
|
||||
the above copyright notice appear in all copies and that both that
|
||||
copyright notice and this permission notice appear in supporting
|
||||
documentation.
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
|
||||
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
Except as contained in this notice, the name of The Open Group shall not be
|
||||
used in advertising or otherwise to promote the sale, use or other dealings
|
||||
in this Software without prior written authorization from The Open Group.
|
||||
*
|
||||
* Author: Keith Packard, MIT X Consortium
|
||||
*/
|
||||
/* $XFree86: xc/programs/Xserver/cfb/stipsprc32.s,v 1.4 2001/01/17 22:36:38 dawes Exp $ */
|
||||
|
||||
/*
|
||||
* SPARC assembly code for optimized text rendering.
|
||||
*
|
||||
* Other stippling could be done in assembly, but the payoff is
|
||||
* not nearly as large. Mostly because large areas are heavily
|
||||
* optimized already.
|
||||
*/
|
||||
|
||||
/* not that I expect to ever see an LSB SPARC, but ... */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
# define BitsR sll
|
||||
# define BitsL srl
|
||||
# define WO(o) 3-o
|
||||
# define FourBits(dest,bits) and bits, 0xf, dest
|
||||
#else
|
||||
# define BitsR srl
|
||||
# define BitsL sll
|
||||
# define WO(o) o
|
||||
# define FourBits(dest,bits) srl bits, 28, dest
|
||||
#endif
|
||||
|
||||
/*
|
||||
* cfb32StippleStack(addr, stipple, value, stride, Count, Shift)
|
||||
* 4 5 6 7 16(sp) 20(sp)
|
||||
*
|
||||
* Apply successive 32-bit stipples starting at addr, addr+stride, ...
|
||||
*
|
||||
* Used for text rendering, but only when no data could be lost
|
||||
* when the stipple is shifted left by Shift bits
|
||||
*/
|
||||
/* arguments */
|
||||
#define addr %i0
|
||||
#define stipple %i1
|
||||
#define value %i2
|
||||
#define stride %i3
|
||||
#define count %i4
|
||||
#define shift %i5
|
||||
|
||||
/* local variables */
|
||||
#define atemp %l0
|
||||
#define bits %l1
|
||||
#define lshift %l2
|
||||
#define sbase %l3
|
||||
#define stemp %l4
|
||||
|
||||
#define CASE_SIZE 5 /* case blocks are 2^5 bytes each */
|
||||
#define CASE_MASK 0x1e0 /* first case mask */
|
||||
|
||||
#define ForEachLine LY1
|
||||
#define NextLine LY2
|
||||
#define CaseBegin LY3
|
||||
#define ForEachBits LY4
|
||||
#define NextBits LY5
|
||||
|
||||
#if defined(SVR4) || defined(__ELF__)
|
||||
#ifdef TETEXT
|
||||
#define _cfb32StippleStack cfb32StippleStackTE
|
||||
#else
|
||||
#define _cfb32StippleStack cfb32StippleStack
|
||||
#endif
|
||||
#else
|
||||
#ifdef TETEXT
|
||||
#define _cfb32StippleStack _cfb32StippleStackTE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
.seg "text"
|
||||
.proc 16
|
||||
.globl _cfb32StippleStack
|
||||
_cfb32StippleStack:
|
||||
save %sp,-64,%sp
|
||||
#ifdef SHAREDCODE
|
||||
1:
|
||||
call 2f
|
||||
nop
|
||||
2:
|
||||
mov %o7,sbase /* sbase = 1b(1:) */
|
||||
add sbase, CaseBegin-1b, sbase
|
||||
#else /* !SHAREDCODE */
|
||||
sethi %hi(CaseBegin),sbase /* load up switch table */
|
||||
or sbase,%lo(CaseBegin),sbase
|
||||
#endif /* !SHAREDCODE */
|
||||
mov 4,lshift /* compute offset within */
|
||||
sub lshift, shift, lshift /* stipple of remaining bits */
|
||||
#ifdef LITTLE_ENDIAN
|
||||
inc CASE_SIZE, shift /* first shift for LSB */
|
||||
#else
|
||||
inc 28-CASE_SIZE, shift /* first shift for MSB */
|
||||
#endif
|
||||
/* do ... while (--count > 0); */
|
||||
ForEachLine:
|
||||
ld [stipple],bits /* get stipple bits */
|
||||
mov addr,atemp /* set up for this line */
|
||||
#ifdef TETEXT
|
||||
/* Terminal emulator fonts are expanded and have many 0 rows */
|
||||
tst bits
|
||||
bz NextLine /* skip out early on 0 */
|
||||
#endif
|
||||
add addr, stride, addr /* step for the loop */
|
||||
BitsR bits, shift, stemp /* get first bits */
|
||||
and stemp, CASE_MASK, stemp /* compute first jump */
|
||||
BitsL bits, lshift, bits /* set remaining bits */
|
||||
jmp sbase+stemp /* ... */
|
||||
tst bits
|
||||
|
||||
ForEachBits:
|
||||
inc 16, atemp
|
||||
ForEachBits1:
|
||||
FourBits(stemp, bits) /* compute jump for */
|
||||
sll stemp, CASE_SIZE, stemp /* these four bits */
|
||||
BitsL bits, 4, bits /* step for remaining bits */
|
||||
jmp sbase+stemp /* jump */
|
||||
tst bits
|
||||
CaseBegin:
|
||||
bnz,a ForEachBits1 /* 0 */
|
||||
inc 16, atemp
|
||||
NextLine:
|
||||
deccc 1, count
|
||||
NextLine1:
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 1 */
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 2 */
|
||||
st value, [atemp+WO(8)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(8)] /* 3 */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
bnz ForEachBits /* 4 */
|
||||
st value, [atemp+WO(4)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(4)] /* 5 */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(4)] /* 6 */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(8)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(4)] /* 7 */
|
||||
st value, [atemp+WO(8)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
b NextLine1
|
||||
deccc 1, count
|
||||
nop
|
||||
nop
|
||||
|
||||
bnz ForEachBits /* 8 */
|
||||
st value, [atemp+WO(0)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(0)] /* 9 */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(0)] /* a */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(8)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(0)] /* b */
|
||||
st value, [atemp+WO(8)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
b NextLine1
|
||||
deccc 1, count
|
||||
nop
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(0)] /* c */
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(4)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
||||
|
||||
st value, [atemp+WO(0)] /* d */
|
||||
st value, [atemp+WO(4)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
b NextLine1
|
||||
deccc 1, count
|
||||
nop
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(0)] /* e */
|
||||
st value, [atemp+WO(4)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(8)]
|
||||
b NextLine1
|
||||
deccc 1, count
|
||||
nop
|
||||
nop
|
||||
|
||||
st value, [atemp+WO(0)] /* f */
|
||||
st value, [atemp+WO(4)]
|
||||
st value, [atemp+WO(8)]
|
||||
bnz ForEachBits
|
||||
st value, [atemp+WO(12)]
|
||||
deccc 1, count
|
||||
bnz,a ForEachLine
|
||||
inc 4, stipple
|
||||
ret
|
||||
restore
|
|
@ -1,9 +0,0 @@
|
|||
noinst_LTLIBRARIES = libcfb32.la
|
||||
|
||||
include $(top_srcdir)/cfb/Makefile.am.inc
|
||||
|
||||
libcfb32_la_SOURCES = $(libcfb_common_sources) $(libcfb_gen_sources)
|
||||
|
||||
INCLUDES = $(CFB_INCLUDES) $(DIX_CFLAGS) -I$(top_srcdir)/hw/xfree86/os-support -I$(top_srcdir)/hw/xfree86/common
|
||||
|
||||
AM_CFLAGS = -DPSZ=32 $(PLATFORMDEFS)
|
|
@ -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])
|
||||
dnl legacy fb support
|
||||
AC_ARG_ENABLE(mfb, AS_HELP_STRING([--enable-mfb], [Build legacy mono framebuffer support (default: enabled)]), [MFB=$enableval], [MFB=$XORG])
|
||||
AC_ARG_ENABLE(cfb, AS_HELP_STRING([--enable-cfb], [Build legacy color framebuffer support (default: enabled)]), [CFB=$enableval], [CFB=$XORG])
|
||||
AC_ARG_ENABLE(afb, AS_HELP_STRING([--enable-afb], [Build legacy advanced framebuffer support (default: enabled)]), [AFB=$enableval], [AFB=$XORG])
|
||||
dnl kdrive and its subsystems
|
||||
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
|
||||
test "x$MFB" = xauto && MFB="$XORG"
|
||||
test "x$CFB" = xauto && CFB="$XORG"
|
||||
test "x$AFB" = xauto && AFB="$XORG"
|
||||
AM_CONDITIONAL(MFB, [test "x$MFB" = xyes])
|
||||
AM_CONDITIONAL(CFB, [test "x$CFB" = xyes])
|
||||
AM_CONDITIONAL(AFB, [test "x$AFB" = xyes])
|
||||
if test "x$MFB" = xyes -o "x$CFB" = xyes -o "x$AFB" = xyes; then
|
||||
if test "x$MFB" = xyes -o "x$AFB" = xyes; then
|
||||
if test "x$XORG" != xyes; then
|
||||
AC_MSG_ERROR([legacy fb support requires the Xorg server])
|
||||
fi
|
||||
|
@ -2135,8 +2132,6 @@ fb/Makefile
|
|||
record/Makefile
|
||||
XTrap/Makefile
|
||||
mfb/Makefile
|
||||
cfb/Makefile
|
||||
cfb32/Makefile
|
||||
config/Makefile
|
||||
mi/Makefile
|
||||
miext/Makefile
|
||||
|
@ -2195,7 +2190,6 @@ hw/xfree86/xaa/Makefile
|
|||
hw/xfree86/xf1bpp/Makefile
|
||||
hw/xfree86/xf4bpp/Makefile
|
||||
hw/xfree86/xf8_16bpp/Makefile
|
||||
hw/xfree86/xf8_32bpp/Makefile
|
||||
hw/xfree86/utils/Makefile
|
||||
hw/xfree86/utils/cvt/Makefile
|
||||
hw/xfree86/utils/gtf/Makefile
|
||||
|
|
|
@ -16,20 +16,16 @@ if MFB
|
|||
MFB_SUBDIR = xf1bpp xf4bpp
|
||||
endif
|
||||
|
||||
if CFB
|
||||
CFB_SUBDIR = xf8_32bpp
|
||||
endif
|
||||
|
||||
DOC_SUBDIR = doc
|
||||
|
||||
SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support parser rac \
|
||||
ramdac shadowfb vbe vgahw xaa $(MFB_SUBDIR) $(CFB_SUBDIR) \
|
||||
ramdac shadowfb vbe vgahw xaa $(MFB_SUBDIR) \
|
||||
xf8_16bpp loader dixmods exa modes \
|
||||
$(DRI_SUBDIR) $(DRI2_SUBDIR) $(XF86UTILS_SUBDIR) $(DOC_SUBDIR)
|
||||
|
||||
DIST_SUBDIRS = common ddc dummylib i2c x86emu int10 fbdevhw os-support \
|
||||
parser rac ramdac shadowfb vbe vgahw xaa xf1bpp xf4bpp \
|
||||
xf8_16bpp xf8_32bpp loader dixmods dri dri2 exa modes \
|
||||
xf8_16bpp loader dixmods dri dri2 exa modes \
|
||||
utils doc
|
||||
|
||||
bin_PROGRAMS = Xorg
|
||||
|
|
|
@ -18,10 +18,6 @@ if AFB
|
|||
AFBMOD = libafb.la
|
||||
endif
|
||||
|
||||
if CFB
|
||||
CFBMOD = libcfb.la libcfb32.la
|
||||
endif
|
||||
|
||||
if MFB
|
||||
MFBMOD = libmfb.la
|
||||
endif
|
||||
|
@ -31,7 +27,6 @@ RECORDMOD = librecord.la
|
|||
endif
|
||||
|
||||
module_LTLIBRARIES = $(AFBMOD) \
|
||||
$(CFBMOD) \
|
||||
libfb.la \
|
||||
libwfb.la \
|
||||
$(MFBMOD) \
|
||||
|
@ -61,14 +56,6 @@ libafb_la_LDFLAGS = -avoid-version
|
|||
libafb_la_LIBADD = $(top_builddir)/afb/libafb.la
|
||||
libafb_la_SOURCES = afbmodule.c
|
||||
|
||||
libcfb_la_LDFLAGS = -avoid-version
|
||||
libcfb_la_LIBADD = $(top_builddir)/cfb/libcfb.la
|
||||
libcfb_la_SOURCES = cfbmodule.c
|
||||
|
||||
libcfb32_la_LDFLAGS = -avoid-version
|
||||
libcfb32_la_LIBADD = $(top_builddir)/cfb32/libcfb32.la
|
||||
libcfb32_la_SOURCES = cfb32module.c
|
||||
|
||||
libdbe_la_LDFLAGS = -avoid-version
|
||||
libdbe_la_LIBADD = $(top_builddir)/dbe/libdbe.la
|
||||
libdbe_la_SOURCES = dbemodule.c
|
||||
|
|
|
@ -1,57 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1998 The XFree86 Project, Inc. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_XORG_CONFIG_H
|
||||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#include "xf86Module.h"
|
||||
|
||||
static MODULESETUPPROTO(cfb32Setup);
|
||||
|
||||
static XF86ModuleVersionInfo VersRec =
|
||||
{
|
||||
"cfb32",
|
||||
MODULEVENDORSTRING,
|
||||
MODINFOSTRING1,
|
||||
MODINFOSTRING2,
|
||||
XORG_VERSION_CURRENT,
|
||||
1, 0, 0,
|
||||
ABI_CLASS_ANSIC, /* Only need the ansic layer */
|
||||
ABI_ANSIC_VERSION,
|
||||
MOD_CLASS_NONE,
|
||||
{0,0,0,0} /* signature, to be patched into the file by a tool */
|
||||
};
|
||||
|
||||
_X_EXPORT XF86ModuleData cfb32ModuleData = { &VersRec, cfb32Setup, NULL };
|
||||
|
||||
static pointer
|
||||
cfb32Setup(pointer module, pointer opts, int *errmaj, int *errmin)
|
||||
{
|
||||
/* This modules requires cfb, so load it */
|
||||
return LoadSubModule(module, "cfb", NULL, NULL, NULL, NULL,
|
||||
errmaj, errmin);
|
||||
}
|
|
@ -1,57 +0,0 @@
|
|||
/*
|
||||
* Copyright (C) 1998 The XFree86 Project, Inc. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
* of this software and associated documentation files (the "Software"), to
|
||||
* deal in the Software without restriction, including without limitation the
|
||||
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
||||
* sell copies of the Software, and to permit persons to whom the Software is
|
||||
* furnished to do so, subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in
|
||||
* all copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
* XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* Except as contained in this notice, the name of the XFree86 Project shall
|
||||
* not be used in advertising or otherwise to promote the sale, use or other
|
||||
* dealings in this Software without prior written authorization from the
|
||||
* XFree86 Project.
|
||||
*/
|
||||
|
||||
#ifdef HAVE_XORG_CONFIG_H
|
||||
#include <xorg-config.h>
|
||||
#endif
|
||||
|
||||
#include "xf86Module.h"
|
||||
|
||||
static MODULESETUPPROTO(cfbSetup);
|
||||
|
||||
static XF86ModuleVersionInfo VersRec =
|
||||
{
|
||||
"cfb",
|
||||
MODULEVENDORSTRING,
|
||||
MODINFOSTRING1,
|
||||
MODINFOSTRING2,
|
||||
XORG_VERSION_CURRENT,
|
||||
1, 0, 0,
|
||||
ABI_CLASS_ANSIC, /* Only need the ansic layer */
|
||||
ABI_ANSIC_VERSION,
|
||||
MOD_CLASS_NONE,
|
||||
{0,0,0,0} /* signature, to be patched into the file by a tool */
|
||||
};
|
||||
|
||||
_X_EXPORT XF86ModuleData cfbModuleData = { &VersRec, cfbSetup, NULL };
|
||||
|
||||
static pointer
|
||||
cfbSetup(pointer module, pointer opts, int *errmaj, int *errmin)
|
||||
{
|
||||
/* This modules requires mfb, so load it */
|
||||
return LoadSubModule(module, "mfb", NULL, NULL, NULL, NULL,
|
||||
errmaj, errmin);
|
||||
}
|
|
@ -23,7 +23,6 @@ AM_CFLAGS = @DIX_CFLAGS@ @XORG_CFLAGS@
|
|||
INCLUDES = @XORG_INCS@ \
|
||||
-I$(top_srcdir)/afb \
|
||||
-I$(top_srcdir)/mfb \
|
||||
-I$(top_srcdir)/cfb \
|
||||
-I$(top_srcdir)/dbe \
|
||||
-I$(top_srcdir)/hw/xfree86/loader \
|
||||
-I$(top_srcdir)/miext/shadow
|
||||
|
|
|
@ -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
|
|
@ -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 */
|
|
@ -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 */
|
||||
}
|
|
@ -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);
|
||||
}
|
|
@ -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));
|
||||
}
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
|
@ -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++;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -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++;
|
||||
}
|
||||
}
|
|
@ -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;
|
||||
}
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue