fdo-mirrors/cairo
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/cairo/cairo.git synced 2026-05-05 07:38:22 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Removed reliance on server headers. Reowrked IcFormat

Browse source
This commit is contained in:
Carl Worth 2003-04-17 08:48:22 +00:00
parent 2d8dfcec1b
commit b61b9ffc23
13 changed files with 800 additions and 398 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
pixman/ChangeLog.libic
View file

@ -1,3 +1,53 @@
2003-04-17 Carl Worth <cworth@isi.edu>
* src/icint.h: Removed reliance on some server include files,
(this included copy and paste of Xserver/render/picture.h into
icint.h)
* src/icformat.c (IcFormatInit): Replaced public
IcFormatCreate/IcFormatDestroy with IcFormatInit and an exposed
IcFormat structure.
(_IcFormatCreate): Tracked changes now that IcFormat no longer has
direct and indexed sub-structure.
* src/iccompose.c: Commented out all code supporting indexed
formats.
* src/ic.h: Expose IcFormat structure, (with no support for
indexed formats).
* src/ic.c (IcComposite): Track changes in IcImage structure
(format vs. format_name)
2003-03-10 Carl Worth <cworth@isi.edu>
* src/Makefile.am (INCLUDES): Cleaned up to no longer require
includes from X server source tree.
2003-03-05 Carl Worth <cworth@isi.edu>
* src/ictri.c (IcTriangles):
(IcTriStrip):
(IcTriFan): fixed argument order to match XRender
* src/icrect.c (IcRectangle): Add IcRectangle convenience function.
(IcRectangles): fixed argument order to match XRender
* src/ictri.c (IcTriangles):
(IcTriStrip):
(IcTriFan): Removed format argument from IcTri* functions.
* src/ictrap.c (IcTrapezoids): Removed format argument from
IcTrapezoids.
* src/icrect.c (IcRectangles): Initial (painfully slow)
implementation of IcRectangles.
* src/icimage.c (IcImageCreate): Simplified IcImageCreate, (no
longer requires mask/vlist/error/error_value)
(IcImageSetRepeat): Added IcImageSetRepeat
(IcImageSetClipRegion): Implemented simple IcImageSetClipRegion.
2003-02-25 Carl Worth <cworth@isi.edu>
* src/icimage.c (IcImageInit):

40
pixman/src/ic.c
View file

@ -26,9 +26,8 @@
#include "icint.h"
#include "icimage.h"
#include "misc.h"
/*
#include "misc.h"
#include "scrnintstr.h"
#include "validate.h"
#include "windowstr.h"
@ -38,11 +37,10 @@
#include "dixstruct.h"
#include "gcstruct.h"
#include "picturestr.h"
*/
#include "os.h"
#include "resource.h"
#include "servermd.h"
*/
#ifndef __GNUC__
@ -140,7 +138,7 @@ IcIn (CARD32 x, CARD8 y)
return; \
} \
/* manage missing src alpha */ \
if ((image)->image_format->direct.alphaMask == 0) \
if ((image)->image_format->alphaMask == 0) \
(bits) |= 0xff000000; \
}
@ -948,10 +946,10 @@ IcComposite (char op,
iSrc->pixels->height == 1)
{
srcRepeat = FALSE;
if (PICT_FORMAT_COLOR(iSrc->format)) {
switch (iMask->format) {
if (PICT_FORMAT_COLOR(iSrc->format_name)) {
switch (iMask->format_name) {
case PICT_a8:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_r5g6b5:
case PICT_b5g6r5:
func = IcCompositeSolidMask_nx8x0565;
@ -970,7 +968,7 @@ IcComposite (char op,
break;
case PICT_a8r8g8b8:
if (iMask->componentAlpha) {
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_a8r8g8b8:
case PICT_x8r8g8b8:
func = IcCompositeSolidMask_nx8888x8888C;
@ -983,7 +981,7 @@ IcComposite (char op,
break;
case PICT_a8b8g8r8:
if (iMask->componentAlpha) {
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_a8b8g8r8:
case PICT_x8b8g8r8:
func = IcCompositeSolidMask_nx8888x8888C;
@ -995,7 +993,7 @@ IcComposite (char op,
}
break;
case PICT_a1:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_r5g6b5:
case PICT_b5g6r5:
case PICT_r8g8b8:
@ -1013,10 +1011,10 @@ IcComposite (char op,
}
else
{
switch (iSrc->format) {
switch (iSrc->format_name) {
case PICT_a8r8g8b8:
case PICT_x8r8g8b8:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_a8r8g8b8:
case PICT_x8r8g8b8:
func = IcCompositeSrc_8888x8888;
@ -1031,7 +1029,7 @@ IcComposite (char op,
break;
case PICT_a8b8g8r8:
case PICT_x8b8g8r8:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_a8b8g8r8:
case PICT_x8b8g8r8:
func = IcCompositeSrc_8888x8888;
@ -1045,14 +1043,14 @@ IcComposite (char op,
}
break;
case PICT_r5g6b5:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_r5g6b5:
func = IcCompositeSrc_0565x0565;
break;
}
break;
case PICT_b5g6r5:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_b5g6r5:
func = IcCompositeSrc_0565x0565;
break;
@ -1064,30 +1062,30 @@ IcComposite (char op,
case PictOpAdd:
if (iMask == 0)
{
switch (iSrc->format) {
switch (iSrc->format_name) {
case PICT_a8r8g8b8:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_a8r8g8b8:
func = IcCompositeSrcAdd_8888x8888;
break;
}
break;
case PICT_a8b8g8r8:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_a8b8g8r8:
func = IcCompositeSrcAdd_8888x8888;
break;
}
break;
case PICT_a8:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_a8:
func = IcCompositeSrcAdd_8000x8000;
break;
}
break;
case PICT_a1:
switch (iDst->format) {
switch (iDst->format_name) {
case PICT_a1:
func = IcCompositeSrcAdd_1000x1000;
break;

161
pixman/src/ic.h
View file

@ -31,23 +31,31 @@
/* icformat.c */
/* XXX: Perhaps we just want an enum for some standard formats? */
/* XXX: Change from int to enum for IcFormatName */
typedef int IcFormatName;
typedef struct _IcFormat IcFormat;
/* XXX: Not sure if this is at all the API we want for IcFormat */
IcFormat *
IcFormatCreate (IcFormatName name);
/* XXX: Is depth redundant here? */
typedef struct _IcFormat {
/* XXX: Should switch from int to an IcFormatName enum */
int format_name;
int depth;
int red, redMask;
int green, greenMask;
int blue, blueMask;
int alpha, alphaMask;
} IcFormat;
void
IcFormatDestroy (IcFormat *format);
IcFormatInit (IcFormat *format, IcFormatName name);
/* icpixels.c */
/* icimage.c */
typedef struct _IcPixels IcPixels;
typedef struct _IcImage IcImage;
IcPixels *
IcPixelsCreate (int width, int height, int depth);
IcImage *
IcImageCreate (IcFormat *format,
int width,
int height);
/*
* This single define controls the basic size of data manipulated
@ -68,78 +76,105 @@ typedef uint32_t IcBits;
# endif
#endif
IcPixels *
IcPixelsCreateForData (IcBits *data, int width, int height, int depth, int bpp, int stride);
IcImage *
IcImageCreateForData (IcBits *data, IcFormat *format, int width, int height, int bpp, int stride);
void
IcPixelsDestroy (IcPixels *pixels);
IcImageDestroy (IcImage *image);
/* icimage.c */
int
IcImageSetClipRegion (IcImage *image,
PixRegion *region);
typedef struct _IcImage IcImage;
typedef struct _IcTransform {
XFixed matrix[3][3];
} IcTransform;
/* XXX: I'd like to drop the mask/list interfaces here, (as well as two error codes) */
IcImage *
IcImageCreate (IcFormat *format,
int width,
int height,
Mask vmask,
XID *vlist,
int *error,
int *error_value);
int
IcImageSetTransform (IcImage *image,
IcTransform *transform);
IcImage *
IcImageCreateForPixels (IcPixels *pixels,
IcFormat *format,
Mask vmask,
XID *vlist,
int *error,
int *error_value);
void
IcImageSetRepeat (IcImage *image,
int repeat);
/* iccolor.c */
/* XXX: Do we really need a struct here? Only IcRectangles uses this. */
typedef struct {
unsigned short red;
unsigned short green;
unsigned short blue;
unsigned short alpha;
} IcColor;
void
IcColorToPixel (const IcFormat *format,
const IcColor *color,
IcBits *pixel);
void
IcPixelToColor (const IcFormat *format,
IcBits pixel,
IcColor *color);
/* icrect.c */
void IcFillRectangle (char op,
IcImage *dst,
const IcColor *color,
int x,
int y,
unsigned int width,
unsigned int height);
void
IcFillRectangles (char op,
IcImage *dst,
const IcColor *color,
const XRectangle *rects,
int nRects);
/* ictrap.c */
/* XXX: Switch to enum for op */
void
IcTrapezoids (char op,
IcImage *src,
IcImage *dst,
IcFormat *format,
int xSrc,
int ySrc,
int ntrap,
XTrapezoid *traps);
IcCompositeTrapezoids (char op,
IcImage *src,
IcImage *dst,
int xSrc,
int ySrc,
const XTrapezoid *traps,
int ntrap);
/* ictri.c */
void
IcTriangles (char op,
IcImage *src,
IcImage *dst,
IcFormat *format,
int xSrc,
int ySrc,
int ntri,
XTriangle *tris);
IcCompositeTriangles (char op,
IcImage *src,
IcImage *dst,
int xSrc,
int ySrc,
const XTriangle *tris,
int ntris);
void
IcTriStrip (char op,
IcImage *src,
IcImage *dst,
IcFormat *format,
int xSrc,
int ySrc,
int npoint,
XPointFixed *points);
IcCompositeTriStrip (char op,
IcImage *src,
IcImage *dst,
int xSrc,
int ySrc,
const XPointFixed *points,
int npoints);
void
IcTriFan (char op,
IcImage *src,
IcImage *dst,
IcFormat *format,
int xSrc,
int ySrc,
int npoint,
XPointFixed *points);
IcCompositeTriFan (char op,
IcImage *src,
IcImage *dst,
int xSrc,
int ySrc,
const XPointFixed *points,
int npoints);
/* ic.c */

85
pixman/src/iccolor.c Normal file
View file

@ -0,0 +1,85 @@
/*
* $XFree86: $
*
* Copyright © 2000 SuSE, Inc.
*
* 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, and that the name of SuSE not be used in advertising or
* publicity pertaining to distribution of the software without specific,
* written prior permission. SuSE makes no representations about the
* suitability of this software for any purpose. It is provided "as is"
* without express or implied warranty.
*
* SuSE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL SuSE
* 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.
*
* Author: Keith Packard, SuSE, Inc.
*/
#include "icint.h"
static int
Ones(unsigned long mask);
static int
Ones(unsigned long mask) /* HACKMEM 169 */
{
register unsigned long y;
y = (mask >> 1) &033333333333;
y = mask - y - ((y >>1) & 033333333333);
return (((y + (y >> 3)) & 030707070707) % 077);
}
void
IcColorToPixel (const IcFormat *format,
const IcColor *color,
IcBits *pixel)
{
CARD32 r, g, b, a;
r = color->red >> (16 - Ones (format->redMask));
g = color->green >> (16 - Ones (format->greenMask));
b = color->blue >> (16 - Ones (format->blueMask));
a = color->alpha >> (16 - Ones (format->alphaMask));
r = r << format->red;
g = g << format->green;
b = b << format->blue;
a = a << format->alpha;
*pixel = r|g|b|a;
}
static CARD16
IcFillColor (CARD32 pixel, int bits)
{
while (bits < 16)
{
pixel |= pixel << bits;
bits <<= 1;
}
return (CARD16) pixel;
}
void
IcPixelToColor (const IcFormat *format,
const IcBits pixel,
IcColor *color)
{
CARD32 r, g, b, a;
r = (pixel >> format->red) & format->redMask;
g = (pixel >> format->green) & format->greenMask;
b = (pixel >> format->blue) & format->blueMask;
a = (pixel >> format->alpha) & format->alphaMask;
color->red = IcFillColor (r, Ones (format->redMask));
color->green = IcFillColor (r, Ones (format->greenMask));
color->blue = IcFillColor (r, Ones (format->blueMask));
color->alpha = IcFillColor (r, Ones (format->alphaMask));
}

26
pixman/src/iccompose.c
View file

@ -1892,6 +1892,7 @@ IcFetch_a2b2g2r2 (IcCompositeOperand *op)
return a|r|g|b;
}
/* XXX: We're not supporting indexed formats, right?
CARD32
IcFetch_c8 (IcCompositeOperand *op)
{
@ -1900,6 +1901,7 @@ IcFetch_c8 (IcCompositeOperand *op)
return op->indexed->rgba[pixel];
}
*/
#define Fetch8(l,o) (((CARD8 *) (l))[(o) >> 3])
#if IMAGE_BYTE_ORDER == MSBFirst
@ -1984,6 +1986,7 @@ IcFetch_a1b1g1r1 (IcCompositeOperand *op)
return a|r|g|b;
}
/* XXX: We're not supporting indexed formats, right?
CARD32
IcFetch_c4 (IcCompositeOperand *op)
{
@ -1992,6 +1995,7 @@ IcFetch_c4 (IcCompositeOperand *op)
return op->indexed->rgba[pixel];
}
*/
CARD32
IcFetcha_a1 (IcCompositeOperand *op)
@ -2031,6 +2035,7 @@ IcFetch_a1 (IcCompositeOperand *op)
return a << 24;
}
/* XXX: We're not supporting indexed formats, right?
CARD32
IcFetch_g1 (IcCompositeOperand *op)
{
@ -2045,6 +2050,7 @@ IcFetch_g1 (IcCompositeOperand *op)
a = a & 1;
return op->indexed->rgba[a];
}
*/
/*
* All the store functions
@ -2273,6 +2279,7 @@ IcStore_a2r2g2b2 (IcCompositeOperand *op, CARD32 value)
((b >> 6) ));
}
/* XXX: We're not supporting indexed formats, right?
void
IcStore_c8 (IcCompositeOperand *op, CARD32 value)
{
@ -2288,6 +2295,7 @@ IcStore_g8 (IcCompositeOperand *op, CARD32 value)
CARD8 *pixel = ((CARD8 *) line) + (offset >> 3);
*pixel = IcIndexToEntY24(op->indexed,value);
}
*/
#define Store8(l,o,v) (((CARD8 *) l)[(o) >> 3] = (v))
#if IMAGE_BYTE_ORDER == MSBFirst
@ -2359,6 +2367,7 @@ IcStore_a1b1g1r1 (IcCompositeOperand *op, CARD32 value)
Store4(line,offset,pixel);
}
/* XXX: We're not supporting indexed formats, right?
void
IcStore_c4 (IcCompositeOperand *op, CARD32 value)
{
@ -2378,6 +2387,7 @@ IcStore_g4 (IcCompositeOperand *op, CARD32 value)
pixel = IcIndexToEntY24(op->indexed,value);
Store4(line,offset,pixel);
}
*/
void
IcStore_a1 (IcCompositeOperand *op, CARD32 value)
@ -2390,6 +2400,7 @@ IcStore_a1 (IcCompositeOperand *op, CARD32 value)
*pixel = (*pixel & ~mask) | value;
}
/* XXX: We're not supporting indexed formats, right?
void
IcStore_g1 (IcCompositeOperand *op, CARD32 value)
{
@ -2400,6 +2411,7 @@ IcStore_g1 (IcCompositeOperand *op, CARD32 value)
value = IcIndexToEntY24(op->indexed,value) ? mask : 0;
*pixel = (*pixel & ~mask) | value;
}
*/
CARD32
IcFetch_external (IcCompositeOperand *op)
@ -2623,8 +2635,10 @@ IcAccessMap icAccessMap[] = {
{ PICT_r3g3b2, IcFetch_r3g3b2, IcFetch_r3g3b2, IcStore_r3g3b2 },
{ PICT_b2g3r3, IcFetch_b2g3r3, IcFetch_b2g3r3, IcStore_b2g3r3 },
{ PICT_a2r2g2b2, IcFetch_a2r2g2b2, IcFetch_a2r2g2b2, IcStore_a2r2g2b2 },
/* XXX: We're not supporting indexed formats, right?
{ PICT_c8, IcFetch_c8, IcFetch_c8, IcStore_c8 },
{ PICT_g8, IcFetch_c8, IcFetch_c8, IcStore_g8 },
*/
/* 4bpp formats */
{ PICT_a4, IcFetch_a4, IcFetcha_a4, IcStore_a4 },
@ -2632,12 +2646,16 @@ IcAccessMap icAccessMap[] = {
{ PICT_b1g2r1, IcFetch_b1g2r1, IcFetch_b1g2r1, IcStore_b1g2r1 },
{ PICT_a1r1g1b1, IcFetch_a1r1g1b1, IcFetch_a1r1g1b1, IcStore_a1r1g1b1 },
{ PICT_a1b1g1r1, IcFetch_a1b1g1r1, IcFetch_a1b1g1r1, IcStore_a1b1g1r1 },
/* XXX: We're not supporting indexed formats, right?
{ PICT_c4, IcFetch_c4, IcFetch_c4, IcStore_c4 },
{ PICT_g4, IcFetch_c4, IcFetch_c4, IcStore_g4 },
*/
/* 1bpp formats */
{ PICT_a1, IcFetch_a1, IcFetcha_a1, IcStore_a1 },
/* XXX: We're not supporting indexed formats, right?
{ PICT_g1, IcFetch_g1, IcFetch_g1, IcStore_g1 },
*/
};
#define NumAccessMap (sizeof icAccessMap / sizeof icAccessMap[0])
@ -2734,7 +2752,9 @@ IcBuildCompositeOperand (IcImage *image,
op->over = IcStepOver_transform;
op->down = IcStepDown_transform;
op->set = IcSet_transform;
/* XXX: We're not supporting indexed formats, right?
op->indexed = (IcIndexedPtr) image->image_format->index.devPrivate;
*/
op->clip = op[1].clip;
return TRUE;
@ -2758,7 +2778,9 @@ IcBuildCompositeOperand (IcImage *image,
op->over = IcStepOver_external;
op->down = IcStepDown_external;
op->set = IcSet_external;
/* XXX: We're not supporting indexed formats, right?
op->indexed = (IcIndexedPtr) image->image_format->index.devPrivate;
*/
op->clip = op[1].clip;
return TRUE;
@ -2770,7 +2792,7 @@ IcBuildCompositeOperand (IcImage *image,
int xoff, yoff;
for (i = 0; i < NumAccessMap; i++)
if (icAccessMap[i].format == image->format)
if (icAccessMap[i].format == image->format_name)
{
IcBits *bits;
IcStride stride;
@ -2782,7 +2804,9 @@ IcBuildCompositeOperand (IcImage *image,
op->over = IcStepOver;
op->down = IcStepDown;
op->set = IcSet;
/* XXX: We're not supporting indexed formats, right?
op->indexed = (IcIndexedPtr) image->image_format->index.devPrivate;
*/
op->clip = image->pCompositeClip;
IcGetPixels (image->pixels, bits, stride, bpp,

67
pixman/src/icformat.c
View file

@ -25,13 +25,10 @@
#include "icint.h"
void
IcFormatInit (IcFormat *format, IcFormatName name);
#define Mask(n) ((n) == 32 ? 0xffffffff : ((1 << (n))-1))
IcFormat *
IcFormatCreate (IcFormatName name)
_IcFormatCreate (IcFormatName name)
{
IcFormat *format;
@ -50,59 +47,57 @@ IcFormatInit (IcFormat *format, IcFormatName name)
/* XXX: What do we want to lodge in here?
format->id = FakeClientID (0);
*/
format->format_name = name;
format->depth = PICT_FORMAT_BPP(name);
format->format = name;
switch (PICT_FORMAT_TYPE(name)) {
case PICT_TYPE_ARGB:
format->type = PictTypeDirect;
format->direct.alphaMask = Mask(PICT_FORMAT_A(name));
if (format->direct.alphaMask)
format->direct.alpha = (PICT_FORMAT_R(name) +
PICT_FORMAT_G(name) +
PICT_FORMAT_B(name));
format->alphaMask = Mask(PICT_FORMAT_A(name));
if (format->alphaMask)
format->alpha = (PICT_FORMAT_R(name) +
PICT_FORMAT_G(name) +
PICT_FORMAT_B(name));
format->direct.redMask = Mask(PICT_FORMAT_R(name));
format->direct.red = (PICT_FORMAT_G(name) +
PICT_FORMAT_B(name));
format->redMask = Mask(PICT_FORMAT_R(name));
format->red = (PICT_FORMAT_G(name) +
PICT_FORMAT_B(name));
format->direct.greenMask = Mask(PICT_FORMAT_G(name));
format->direct.green = PICT_FORMAT_B(name);
format->greenMask = Mask(PICT_FORMAT_G(name));
format->green = PICT_FORMAT_B(name);
format->direct.blueMask = Mask(PICT_FORMAT_B(name));
format->direct.blue = 0;
format->blueMask = Mask(PICT_FORMAT_B(name));
format->blue = 0;
break;
case PICT_TYPE_ABGR:
format->type = PictTypeDirect;
format->direct.alphaMask = Mask(PICT_FORMAT_A(name));
if (format->direct.alphaMask)
format->direct.alpha = (PICT_FORMAT_B(name) +
PICT_FORMAT_G(name) +
PICT_FORMAT_R(name));
format->alphaMask = Mask(PICT_FORMAT_A(name));
if (format->alphaMask)
format->alpha = (PICT_FORMAT_B(name) +
PICT_FORMAT_G(name) +
PICT_FORMAT_R(name));
format->direct.blueMask = Mask(PICT_FORMAT_B(name));
format->direct.blue = (PICT_FORMAT_G(name) +
PICT_FORMAT_R(name));
format->blueMask = Mask(PICT_FORMAT_B(name));
format->blue = (PICT_FORMAT_G(name) +
PICT_FORMAT_R(name));
format->direct.greenMask = Mask(PICT_FORMAT_G(name));
format->direct.green = PICT_FORMAT_R(name);
format->greenMask = Mask(PICT_FORMAT_G(name));
format->green = PICT_FORMAT_R(name);
format->direct.redMask = Mask(PICT_FORMAT_R(name));
format->direct.red = 0;
format->redMask = Mask(PICT_FORMAT_R(name));
format->red = 0;
break;
case PICT_TYPE_A:
format->type = PictTypeDirect;
format->direct.alpha = 0;
format->direct.alphaMask = Mask(PICT_FORMAT_A(name));
format->alpha = 0;
format->alphaMask = Mask(PICT_FORMAT_A(name));
/* remaining fields already set to zero */
break;
/* XXX: Supporting indexed formats requires more, (just pass in the visual?)
/* XXX: We're not supporting indexed formats, right?
case PICT_TYPE_COLOR:
case PICT_TYPE_GRAY:
format->type = PictTypeIndexed;
@ -113,7 +108,7 @@ IcFormatInit (IcFormat *format, IcFormatName name)
}
void
IcFormatDestroy (IcFormat *format)
_IcFormatDestroy (IcFormat *format)
{
free (format);
}

115
pixman/src/icimage.c
View file

@ -28,23 +28,41 @@
IcImage *
IcImageCreate (IcFormat *format,
int width,
int height,
Mask vmask,
XID *vlist,
int *error,
int *error_value)
int height)
{
IcImage *image;
IcPixels *pixels;
pixels = IcPixelsCreate (width, height, format->depth);
if (pixels == NULL) {
*error = BadAlloc;
*error_value = 0; /* XXX: What should this be? */
if (pixels == NULL)
return NULL;
image = IcImageCreateForPixels (pixels, format);
if (image == NULL) {
IcPixelsDestroy (pixels);
return NULL;
}
image->owns_pixels = 1;
return image;
}
IcImage *
IcImageCreateForData (IcBits *data, IcFormat *format, int width, int height, int bpp, int stride)
{
IcImage *image;
IcPixels *pixels;
pixels = IcPixelsCreateForData (data, width, height, format->depth, bpp, stride);
if (pixels == NULL)
return NULL;
image = IcImageCreateForPixels (pixels, format);
if (image == NULL) {
IcPixelsDestroy (pixels);
return NULL;
}
image = IcImageCreateForPixels (pixels, format, vmask, vlist, error, error_value);
image->owns_pixels = 1;
@ -53,25 +71,19 @@ IcImageCreate (IcFormat *format,
IcImage *
IcImageCreateForPixels (IcPixels *pixels,
IcFormat *format,
Mask vmask,
XID *vlist,
int *error,
int *error_value)
IcFormat *format)
{
IcImage *image;
image = malloc (sizeof (IcImage));
if (!image)
{
*error = BadAlloc;
*error_value = 0; /* XXX: What should this be? */
return NULL;
}
image->pixels = pixels;
image->image_format = format;
image->format = format->format;
image->format_name = format->format_name;
/* XXX: What's all this about?
if (pDrawable->type == DRAWABLE_PIXMAP)
{
@ -86,19 +98,7 @@ IcImageCreateForPixels (IcPixels *pixels,
*/
IcImageInit (image);
if (vmask)
;
/* XXX: Need to finish porting this function
*error = IcImageChange (image, vmask, vlist, 0, error_value);
*/
else
*error = Success;
if (*error != Success)
{
IcImageDestroy (image);
image = 0;
}
return image;
}
@ -180,6 +180,14 @@ IcImageSetTransform (IcImage *image,
return Success;
}
void
IcImageSetRepeat (IcImage *image,
int repeat)
{
if (image)
image->repeat = repeat;
}
void
IcImageDestroy (IcImage *image)
{
@ -205,49 +213,12 @@ IcImageDestroyClip (IcImage *image)
}
int
IcImageChangeClip (IcImage *image,
int type,
pointer value,
int n)
IcImageSetClipRegion (IcImage *image,
PixRegion *region)
{
pointer clientClip;
int clientClipType;
switch (type) {
case CT_PIXMAP:
return Success;
/* XXX: Still need to figure out how to handle this case
clientClip = (pointer) BITMAP_TO_REGION(pScreen, (PixmapPtr) value);
if (!clientClip)
return BadAlloc;
clientClipType = CT_REGION;
(*pScreen->DestroyPixmap) ((PixmapPtr) value);
break;
*/
case CT_REGION:
clientClip = value;
clientClipType = CT_REGION;
break;
case CT_NONE:
clientClip = 0;
clientClipType = CT_NONE;
break;
default:
return Success;
/* XXX: I don't see an Xlib version of RECTS_TO_REGION
clientClip = (pointer) RECTS_TO_REGION(pScreen, n,
(xRectangle *) value,
type);
if (!clientClip)
return BadAlloc;
clientClipType = CT_REGION;
free(value);
break;
*/
}
IcImageDestroyClip (image);
image->clientClip = clientClip;
image->clientClipType = clientClipType;
image->clientClip = region;
image->clientClipType = CT_REGION;
image->stateChanges |= CPClipMask;
return Success;
}

88
pixman/src/icimage.h
View file

@ -30,12 +30,8 @@
#include "ic.h"
/* XXX: This is a hack since I don't want to include the server's
miscstruct with the BoxRec that conflict's with Xlib's. */
#ifndef MISCSTRUCT_H
#define MISCSTRUCT_H 1
#include <X11/Xdefs.h>
#include "misc.h"
#include "X11/Xprotostr.h"
typedef xPoint DDXPointRec;
@ -49,13 +45,15 @@ typedef union _DevUnion {
#endif
);
} DevUnion;
#endif
#include "glyphstr.h"
/* #include "glyphstr.h" */
/* #include "scrnintstr.h" */
#include "resource.h"
#include "Xutil.h"
/* XXX: Hmmm... what's needed from here?
#include "resource.h"
*/
#include <X11/Xutil.h>
#define IcIntMult(a,b,t) ( (t) = (a) * (b) + 0x80, ( ( ( (t)>>8 ) + (t) )>>8 ) )
#define IcIntDiv(a,b) (((CARD16) (a) * 255) / (b))
@ -88,42 +86,32 @@ typedef union _DevUnion {
#define IcAdd(x,y,i,t) ((t) = IcGet8(x,i) + IcGet8(y,i), \
(CARD32) ((CARD8) ((t) | (0 - ((t) >> 8)))) << (i))
/* XXX: I'm not sure about several things here:
Do we want data to be IcBits * or unsigned char *?
*/
typedef struct _DirectFormat {
CARD16 red, redMask;
CARD16 green, greenMask;
CARD16 blue, blueMask;
CARD16 alpha, alphaMask;
} DirectFormatRec;
/*
typedef struct _IndexFormat {
VisualPtr pVisual;
VisualPtr pVisual;
ColormapPtr pColormap;
int nvalues;
xIndexValue *pValues;
void *devPrivate;
} IndexFormatRec;
*/
/*
typedef struct _IcFormat {
CARD32 id;
CARD32 format; /* except bpp */
CARD32 format;
unsigned char type;
unsigned char depth;
DirectFormatRec direct;
IndexFormatRec index;
} IcFormatRec;
typedef struct _IcTransform {
xFixed matrix[3][3];
} IcTransform, *IcTransformPtr;
*/
struct _IcImage {
IcPixels *pixels;
IcFormat *image_format;
CARD32 format;
/* XXX: Should switch from int to an IcFormatName enum */
int format_name;
int refcnt;
unsigned int repeat : 1;
@ -152,7 +140,7 @@ struct _IcImage {
IcTransform *transform;
int filter;
xFixed *filter_params;
XFixed *filter_params;
int filter_nparams;
int owns_pixels;
@ -169,11 +157,13 @@ struct _IcImage {
typedef CARD8 IcIndexType;
#endif
/* XXX: We're not supporting indexed operations, right?
typedef struct _IcIndexed {
Bool color;
CARD32 rgba[IC_MAX_INDEXED];
IcIndexType ent[32768];
} IcIndexedRec, *IcIndexedPtr;
*/
#define IcCvtR8G8B8to15(s) ((((s) >> 3) & 0x001f) | \
(((s) >> 6) & 0x03e0) | \
@ -183,11 +173,10 @@ typedef struct _IcIndexed {
#define IcIndexToEntY24(icf,rgb24) ((icf)->ent[CvtR8G8B8toY15(rgb24)])
/*
int
IcCreatePicture (PicturePtr pPicture);
void
IcImageDestroy (IcImage *image);
*/
void
IcImageInit (IcImage *image);
@ -199,18 +188,14 @@ IcImageChange (IcImage *image,
DevUnion *ulist,
int *error_value);
int
IcImageChangeClip (IcImage *image,
int type,
pointer value,
int n);
void
IcImageDestroyClip (IcImage *image);
/*
void
IcValidatePicture (PicturePtr pPicture,
Mask mask);
*/
/* XXX: What should this be?
@ -237,9 +222,12 @@ IcComputeCompositeRegion (PixRegion *region,
CARD16 width,
CARD16 height);
/*
Bool
IcPictureInit (ScreenPtr pScreen, PictFormatPtr formats, int nformats);
*/
/*
void
IcGlyphs (CARD8 op,
PicturePtr pSrc,
@ -250,23 +238,16 @@ IcGlyphs (CARD8 op,
int nlist,
GlyphListPtr list,
GlyphPtr *glyphs);
*/
void
IcRenderColorToPixel (PictFormatPtr pPict,
xRenderColor *color,
CARD32 *pixel);
void
IcRenderPixelToColor (PictFormatPtr pPict,
CARD32 pixel,
xRenderColor *color);
/*
void
IcCompositeRects (CARD8 op,
PicturePtr pDst,
xRenderColor *color,
int nRect,
xRectangle *rects);
*/
IcImage *
IcCreateAlphaPicture (IcImage *dst,
@ -317,7 +298,7 @@ struct _IcCompositeOperand {
int start_x;
int x;
int y;
IcTransformPtr transform;
IcTransform *transform;
int filter;
} transform;
} u;
@ -327,7 +308,9 @@ struct _IcCompositeOperand {
IcCompositeStep over;
IcCompositeStep down;
IcCompositeSet set;
/* XXX: We're not supporting indexed operations, right?
IcIndexedPtr indexed;
*/
PixRegion *clip;
};
@ -949,11 +932,14 @@ IcFetcha_external (IcCompositeOperand *op);
void
IcStore_external (IcCompositeOperand *op, CARD32 value);
/*
Bool
IcBuildOneCompositeOperand (PicturePtr pPict,
IcCompositeOperand *op,
INT16 x,
INT16 y);
*/
Bool
IcBuildCompositeOperand (IcImage *image,
IcCompositeOperand op[4],
@ -1168,10 +1154,4 @@ IcCompositeSolidMask_nx1xn (CARD8 op,
CARD16 width,
CARD16 height);
/* over in ic.c */
int
IcImageSetTransform (IcImage *image,
IcTransform *transform);
#endif /* _IC_MIPICT_H_ */

285
pixman/src/icint.h
View file

@ -24,19 +24,33 @@
#ifndef _ICINT_H_
#define _ICINT_H_
#include <stdlib.h>
#include <string.h>
#include <limits.h>
/* Need definitions for XFixed, etc. */
#include "X11/extensions/Xrender.h"
/* XXX: Hack: It would be nice to figure out a cleaner way to
successfully include both Xlib/server header files without having
major clashes over the definition of BoxRec and BoxPtr. */
#define EXCLUDE_SERVER_BOXPTR 1
#include <X11/X.h>
#include "servermd.h"
#include <X11/Xmd.h>
#include "misc.h"
/* These few definitions avoid me needing to include servermd.h and misc.h from Xserver/include */
#ifndef BITMAP_SCANLINE_PAD
#define BITMAP_SCANLINE_PAD 32
#define LOG2_BITMAP_PAD 5
#define LOG2_BYTES_PER_SCANLINE_PAD 2
#endif
#define FALSE 0
#define TRUE 1
#define MAXSHORT SHRT_MAX
#define MINSHORT SHRT_MIN
/* XXX: What do we need from here?
#include "picture.h"
*/
#include "X11/Xprotostr.h"
#include "X11/extensions/Xrender.h"
@ -51,12 +65,6 @@
#define IC_MASK (IC_UNIT - 1)
#define IC_ALLONES ((IcBits) -1)
#if GLYPHPADBYTES != 4
#error "GLYPHPADBYTES must be 4"
#endif
#if GETLEFTBITS_ALIGNMENT != 1
#error "GETLEFTBITS_ALIGNMENT must be 1"
#endif
/* whether to bother to include 24bpp support */
#ifndef ICNO24BIT
#define IC_24BIT
@ -86,15 +94,8 @@
#define IcFullMask(n) ((n) == IC_UNIT ? IC_ALLONES : ((((IcBits) 1) << n) - 1))
/* XXX: What's the significance of this distinction for IcStip? */
#if LOG2_BITMAP_PAD == IC_SHIFT
typedef IcBits IcStip;
#else
# if LOG2_BITMAP_PAD == 5
typedef CARD32 IcStip;
# endif
#endif
typedef uint32_t IcStip;
typedef int IcStride;
@ -697,7 +698,7 @@ IcStipple (IcBits *dst,
int xRot,
int yRot);
struct _IcPixels {
typedef struct _IcPixels {
IcBits *data;
unsigned int width;
unsigned int height;
@ -707,7 +708,7 @@ struct _IcPixels {
int x;
int y;
unsigned int refcnt;
};
} IcPixels;
/* XXX: This is to avoid including colormap.h from the server includes */
typedef CARD32 Pixel;
@ -728,15 +729,245 @@ IcReplicatePixel (Pixel p, int bpp);
#include "icimage.h"
/* icformat.c */
IcFormat *
_IcFormatCreate (IcFormatName name);
void
_IcFormatDestroy (IcFormat *format);
/* icimage.c */
IcImage *
IcImageCreateForPixels (IcPixels *pixels,
IcFormat *format);
/* icpixels.c */
IcPixels *
IcPixelsCreate (int width, int height, int depth);
IcPixels *
IcPixelsCreateForData (IcBits *data, int width, int height, int depth, int bpp, int stride);
void
IcPixelsDestroy (IcPixels *pixels);
/* ictrap.c */
void
IcRasterizeTrapezoid (IcImage *pMask,
XTrapezoid *pTrap,
int x_off,
int y_off);
IcRasterizeTrapezoid (IcImage *pMask,
const XTrapezoid *pTrap,
int x_off,
int y_off);
#include "icrop.h"
/* XXX: For now, I'm just wholesale pasting Xserver/render/picture.h here: */
#ifndef _PICTURE_H_
#define _PICTURE_H_
typedef struct _DirectFormat *DirectFormatPtr;
typedef struct _PictFormat *PictFormatPtr;
typedef struct _Picture *PicturePtr;
/*
* While the protocol is generous in format support, the
* sample implementation allows only packed RGB and GBR
* representations for data to simplify software rendering,
*/
#define PICT_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \
((type) << 16) | \
((a) << 12) | \
((r) << 8) | \
((g) << 4) | \
((b)))
/*
* gray/color formats use a visual index instead of argb
*/
#define PICT_VISFORMAT(bpp,type,vi) (((bpp) << 24) | \
((type) << 16) | \
((vi)))
#define PICT_FORMAT_BPP(f) (((f) >> 24) )
#define PICT_FORMAT_TYPE(f) (((f) >> 16) & 0xff)
#define PICT_FORMAT_A(f) (((f) >> 12) & 0x0f)
#define PICT_FORMAT_R(f) (((f) >> 8) & 0x0f)
#define PICT_FORMAT_G(f) (((f) >> 4) & 0x0f)
#define PICT_FORMAT_B(f) (((f) ) & 0x0f)
#define PICT_FORMAT_RGB(f) (((f) ) & 0xfff)
#define PICT_FORMAT_VIS(f) (((f) ) & 0xffff)
#define PICT_TYPE_OTHER 0
#define PICT_TYPE_A 1
#define PICT_TYPE_ARGB 2
#define PICT_TYPE_ABGR 3
#define PICT_TYPE_COLOR 4
#define PICT_TYPE_GRAY 5
#define PICT_FORMAT_COLOR(f) (PICT_FORMAT_TYPE(f) & 2)
/* 32bpp formats */
#define PICT_a8r8g8b8 PICT_FORMAT(32,PICT_TYPE_ARGB,8,8,8,8)
#define PICT_x8r8g8b8 PICT_FORMAT(32,PICT_TYPE_ARGB,0,8,8,8)
#define PICT_a8b8g8r8 PICT_FORMAT(32,PICT_TYPE_ABGR,8,8,8,8)
#define PICT_x8b8g8r8 PICT_FORMAT(32,PICT_TYPE_ABGR,0,8,8,8)
/* 24bpp formats */
#define PICT_r8g8b8 PICT_FORMAT(24,PICT_TYPE_ARGB,0,8,8,8)
#define PICT_b8g8r8 PICT_FORMAT(24,PICT_TYPE_ABGR,0,8,8,8)
/* 16bpp formats */
#define PICT_r5g6b5 PICT_FORMAT(16,PICT_TYPE_ARGB,0,5,6,5)
#define PICT_b5g6r5 PICT_FORMAT(16,PICT_TYPE_ABGR,0,5,6,5)
#define PICT_a1r5g5b5 PICT_FORMAT(16,PICT_TYPE_ARGB,1,5,5,5)
#define PICT_x1r5g5b5 PICT_FORMAT(16,PICT_TYPE_ARGB,0,5,5,5)
#define PICT_a1b5g5r5 PICT_FORMAT(16,PICT_TYPE_ABGR,1,5,5,5)
#define PICT_x1b5g5r5 PICT_FORMAT(16,PICT_TYPE_ABGR,0,5,5,5)
#define PICT_a4r4g4b4 PICT_FORMAT(16,PICT_TYPE_ARGB,4,4,4,4)
#define PICT_x4r4g4b4 PICT_FORMAT(16,PICT_TYPE_ARGB,4,4,4,4)
#define PICT_a4b4g4r4 PICT_FORMAT(16,PICT_TYPE_ARGB,4,4,4,4)
#define PICT_x4b4g4r4 PICT_FORMAT(16,PICT_TYPE_ARGB,4,4,4,4)
/* 8bpp formats */
#define PICT_a8 PICT_FORMAT(8,PICT_TYPE_A,8,0,0,0)
#define PICT_r3g3b2 PICT_FORMAT(8,PICT_TYPE_ARGB,0,3,3,2)
#define PICT_b2g3r3 PICT_FORMAT(8,PICT_TYPE_ABGR,0,3,3,2)
#define PICT_a2r2g2b2 PICT_FORMAT(8,PICT_TYPE_ARGB,2,2,2,2)
#define PICT_a2b2g2r2 PICT_FORMAT(8,PICT_TYPE_ABGR,2,2,2,2)
#define PICT_c8 PICT_FORMAT(8,PICT_TYPE_COLOR,0,0,0,0)
#define PICT_g8 PICT_FORMAT(8,PICT_TYPE_GRAY,0,0,0,0)
/* 4bpp formats */
#define PICT_a4 PICT_FORMAT(4,PICT_TYPE_A,4,0,0,0)
#define PICT_r1g2b1 PICT_FORMAT(4,PICT_TYPE_ARGB,0,1,2,1)
#define PICT_b1g2r1 PICT_FORMAT(4,PICT_TYPE_ABGR,0,1,2,1)
#define PICT_a1r1g1b1 PICT_FORMAT(4,PICT_TYPE_ARGB,1,1,1,1)
#define PICT_a1b1g1r1 PICT_FORMAT(4,PICT_TYPE_ABGR,1,1,1,1)
#define PICT_c4 PICT_FORMAT(4,PICT_TYPE_COLOR,0,0,0,0)
#define PICT_g4 PICT_FORMAT(4,PICT_TYPE_GRAY,0,0,0,0)
/* 1bpp formats */
#define PICT_a1 PICT_FORMAT(1,PICT_TYPE_A,1,0,0,0)
#define PICT_g1 PICT_FORMAT(1,PICT_TYPE_GRAY,0,0,0,0)
/*
* For dynamic indexed visuals (GrayScale and PseudoColor), these control the
* selection of colors allocated for drawing to Pictures. The default
* policy depends on the size of the colormap:
*
* Size Default Policy
* ----------------------------
* < 64 PolicyMono
* < 256 PolicyGray
* 256 PolicyColor (only on PseudoColor)
*
* The actual allocation code lives in miindex.c, and so is
* austensibly server dependent, but that code does:
*
* PolicyMono Allocate no additional colors, use black and white
* PolicyGray Allocate 13 gray levels (11 cells used)
* PolicyColor Allocate a 4x4x4 cube and 13 gray levels (71 cells used)
* PolicyAll Allocate as big a cube as possible, fill with gray (all)
*
* Here's a picture to help understand how many colors are
* actually allocated (this is just the gray ramp):
*
* gray level
* all 0000 1555 2aaa 4000 5555 6aaa 8000 9555 aaaa bfff d555 eaaa ffff
* b/w 0000 ffff
* 4x4x4 5555 aaaa
* extra 1555 2aaa 4000 6aaa 8000 9555 bfff d555 eaaa
*
* The default colormap supplies two gray levels (black/white), the
* 4x4x4 cube allocates another two and nine more are allocated to fill
* in the 13 levels. When the 4x4x4 cube is not allocated, a total of
* 11 cells are allocated.
*/
#define PictureCmapPolicyInvalid -1
#define PictureCmapPolicyDefault 0
#define PictureCmapPolicyMono 1
#define PictureCmapPolicyGray 2
#define PictureCmapPolicyColor 3
#define PictureCmapPolicyAll 4
extern int PictureCmapPolicy;
int PictureParseCmapPolicy (const char *name);
/* Fixed point updates from Carl Worth, USC, Information Sciences Institute */
#ifdef WIN32
typedef __int64 xFixed_32_32;
#else
# if defined(__alpha__) || defined(__alpha) || \
defined(ia64) || defined(__ia64__) || \
defined(__sparc64__) || \
defined(__s390x__) || \
defined(x86_64) || defined (__x86_64__)
typedef long xFixed_32_32;
# else
# if defined(__GNUC__) && \
((__GNUC__ > 2) || \
((__GNUC__ == 2) && defined(__GNUC_MINOR__) && (__GNUC_MINOR__ > 7)))
__extension__
# endif
typedef long long int xFixed_32_32;
# endif
#endif
typedef CARD32 xFixed_1_31;
typedef CARD32 xFixed_1_16;
typedef INT32 xFixed_16_16;
/*
* An unadorned "xFixed" is the same as xFixed_16_16,
* (since it's quite common in the code)
*/
typedef xFixed_16_16 xFixed;
#define XFIXED_BITS 16
#define xFixedToInt(f) (int) ((f) >> XFIXED_BITS)
#define IntToxFixed(i) ((xFixed) (i) << XFIXED_BITS)
#define xFixedE ((xFixed) 1)
#define xFixed1 (IntToxFixed(1))
#define xFixed1MinusE (xFixed1 - xFixedE)
#define xFixedFrac(f) ((f) & xFixed1MinusE)
#define xFixedFloor(f) ((f) & ~xFixed1MinusE)
#define xFixedCeil(f) xFixedFloor((f) + xFixed1MinusE)
#define xFixedFraction(f) ((f) & xFixed1MinusE)
#define xFixedMod2(f) ((f) & (xFixed1 | xFixed1MinusE))
/* whether 't' is a well defined not obviously empty trapezoid */
#define xTrapezoidValid(t) ((t)->left.p1.y != (t)->left.p2.y && \
(t)->right.p1.y != (t)->right.p2.y && \
(int) ((t)->bottom - (t)->top) > 0)
/*
* Standard NTSC luminance conversions:
*
* y = r * 0.299 + g * 0.587 + b * 0.114
*
* Approximate this for a bit more speed:
*
* y = (r * 153 + g * 301 + b * 58) / 512
*
* This gives 17 bits of luminance; to get 15 bits, lop the low two
*/
#define CvtR8G8B8toY15(s) (((((s) >> 16) & 0xff) * 153 + \
(((s) >> 8) & 0xff) * 301 + \
(((s) ) & 0xff) * 58) >> 2)
#endif /* _PICTURE_H_ */
#endif

22
pixman/src/icpixels.c
View file

@ -1,5 +1,5 @@
/*
* $Id: icpixels.c,v 1.2 2003-02-21 18:07:17 cworth Exp $
* $Id: icpixels.c,v 1.3 2003-04-17 15:48:22 cworth Exp $
*
* Copyright © 1998 Keith Packard
*
@ -26,7 +26,7 @@
#include "icint.h"
static void
IcPixelsInit (IcPixels *pixels, IcBits *data, int width, int height, int depth, int bpp, int stride);
IcPixelsInit (IcPixels *pixels, IcBits *buf, int width, int height, int depth, int bpp, int stride);
static unsigned int
IcBitsPerPixel (unsigned int depth);
@ -52,8 +52,8 @@ IcPixels *
IcPixelsCreate (int width, int height, int depth)
{
IcPixels *pixels;
IcBits *data;
unsigned int datasize;
IcBits *buf;
unsigned int buf_size;
unsigned int bpp;
unsigned int stride;
unsigned int adjust;
@ -61,20 +61,20 @@ IcPixelsCreate (int width, int height, int depth)
bpp = IcBitsPerPixel (depth);
stride = ((width * bpp + IC_MASK) >> IC_SHIFT) * sizeof (IcBits);
datasize = height * stride;
buf_size = height * stride;
base = sizeof (IcPixels);
adjust = 0;
if (base & 7)
adjust = 8 - (base & 7);
datasize += adjust;
buf_size += adjust;
pixels = malloc(base + datasize);
pixels = malloc(base + buf_size);
if (!pixels)
return NULL;
data = (IcBits *) ((char *)pixels + base + adjust);
buf = (IcBits *) ((char *)pixels + base + adjust);
IcPixelsInit (pixels, data, width, height, depth, bpp, stride);
IcPixelsInit (pixels, buf, width, height, depth, bpp, stride);
return pixels;
}
@ -94,9 +94,9 @@ IcPixelsCreateForData (IcBits *data, int width, int height, int depth, int bpp,
}
static void
IcPixelsInit (IcPixels *pixels, IcBits *data, int width, int height, int depth, int bpp, int stride)
IcPixelsInit (IcPixels *pixels, IcBits *buf, int width, int height, int depth, int bpp, int stride)
{
pixels->data = data;
pixels->data = buf;
pixels->width = width;
pixels->height = height;
pixels->depth = depth;

109
pixman/src/icrect.c
View file

@ -24,6 +24,7 @@
#include "icint.h"
/* XXX: I haven't ported this yet
static void
IcColorRects (IcImage *dst,
IcImage *clipPict,
@ -46,9 +47,8 @@ IcColorRects (IcImage *dst,
tmpval[3] = dst->clipOrigin.y - yoff;
mask |= CPClipXOrigin|CPClipYOrigin;
clip = REGION_CREATE (pScreen, NULL, 1);
REGION_COPY (pScreen, pClip,
(RegionPtr) pClipPict->clientClip);
clip = PixRegionCreate ();
PixRegionCopy (clip, pClipPict->clientClip);
(*pGC->funcs->ChangeClip) (pGC, CT_REGION, pClip, 0);
}
@ -72,80 +72,97 @@ IcColorRects (IcImage *dst,
}
}
}
*/
void IcFillRectangle (char op,
IcImage *dst,
const IcColor *color,
int x,
int y,
unsigned int width,
unsigned int height)
{
XRectangle rect;
rect.x = x;
rect.y = y;
rect.width = width;
rect.height = height;
IcFillRectangles (op, dst, color, &rect, 1);
}
void
IcCompositeRects (CARD8 op,
IcImage *dst,
IcColor *color,
int nRect,
xRectangle *rects)
IcFillRectangles (char op,
IcImage *dst,
const IcColor *color,
const XRectangle *rects,
int nRects)
{
if (color->alpha == 0xffff)
IcColor color_s = *color;
if (color_s.alpha == 0xffff)
{
if (op == PictOpOver)
op = PictOpSrc;
}
if (op == PictOpClear)
color->red = color->green = color->blue = color->alpha = 0;
color_s.red = color_s.green = color_s.blue = color_s.alpha = 0;
/* XXX: Really need this to optimize solid rectangles
if (op == PictOpSrc || op == PictOpClear)
{
IcColorRects (dst, dst, color, nRect, rects, 0, 0);
IcColorRects (dst, dst, &color_s, nRects, rects, 0, 0);
if (dst->alphaMap)
IcColorRects (dst->alphaMap, dst,
color, nRect, rects,
&color_s, nRects, rects,
dst->alphaOrigin.x,
dst->alphaOrigin.y);
}
else
*/
{
IcFormat *rgbaFormat;
IcFormat rgbaFormat;
IcPixels *pixels;
IcImage *src;
xRectangle one;
int error;
Pixel pixel;
CARD32 tmpval[2];
IcBits pixel;
rgbaFormat = IcFormatCreate (PICT_a8r8g8b8);
if (!rgbaFormat)
IcFormatInit (&rgbaFormat, PICT_a8r8g8b8);
pixels = IcPixelsCreate (1, 1, rgbaFormat.depth);
if (!pixels)
goto bail1;
pixels = IcPixelsCreate (1, 1, rgbaFormat->depth);
if (!pixels)
goto bail2;
IcRenderColorToPixel (rgbaFormat, color, &pixel);
IcColorToPixel (&rgbaFormat, &color_s, &pixel);
/* XXX: how to do this?
one.x = 0;
one.y = 0;
one.width = 1;
one.height = 1;
(*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &one);
/* XXX: Originally, fb had the following:
(*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &one);
I haven't checked to see what I might be breaking with a
trivial assignment instead.
*/
tmpval[0] = xTrue;
src = IcImageCreateForPixels (pixels, rgbaFormat,
CPRepeat, tmpval, &error, &error_value);
if (!src)
goto bail4;
pixels->data[0] = pixel;
while (nRect--)
src = IcImageCreateForPixels (pixels, &rgbaFormat);
if (!src)
goto bail2;
IcImageSetRepeat (src, 1);
while (nRects--)
{
CompositePicture (op, pSrc, 0, pDst, 0, 0, 0, 0,
rects->x,
rects->y,
rects->width,
rects->height);
IcComposite (op, src, 0, dst, 0, 0, 0, 0,
rects->x,
rects->y,
rects->width,
rects->height);
rects++;
}
IcImageDestroy (src);
bail4:
bail3:
IcPixelsDestroy (pixels);
bail2:
IcPixelsDestroy (pixels);
bail1:
;
}

48
pixman/src/ictrap.c
View file

@ -37,7 +37,6 @@ IcCreateAlphaPicture (IcImage *dst,
CARD16 width,
CARD16 height)
{
int error, error_value;
IcImage *image;
if (width > 32767 || height > 32767)
@ -45,15 +44,16 @@ IcCreateAlphaPicture (IcImage *dst,
if (!format)
{
/* XXX: Is the memory from this IcFormatCreate leaking? */
if (dst->polyEdge == PolyEdgeSharp)
format = IcFormatCreate (PICT_a1);
format = _IcFormatCreate (PICT_a1);
else
format = IcFormatCreate (PICT_a8);
format = _IcFormatCreate (PICT_a8);
if (!format)
return 0;
}
image = IcImageCreate (format, width, height, 0, 0, &error, &error_value);
image = IcImageCreate (format, width, height);
/* XXX: Is this a reasonable way to clear the image? Would
probably be preferable to use IcImageFillRectangle once such a
@ -64,7 +64,7 @@ IcCreateAlphaPicture (IcImage *dst,
}
static XFixed
IcLineFixedX (XLineFixed *l, XFixed y, Bool ceil)
IcLineFixedX (const XLineFixed *l, XFixed y, Bool ceil)
{
XFixed dx = l->p2.x - l->p1.x;
xFixed_32_32 ex = (xFixed_32_32) (y - l->p1.y) * dx;
@ -75,7 +75,7 @@ IcLineFixedX (XLineFixed *l, XFixed y, Bool ceil)
}
static void
IcTrapezoidBounds (int ntrap, XTrapezoid *traps, PixRegionBox *box)
IcTrapezoidBounds (int ntrap, const XTrapezoid *traps, PixRegionBox *box)
{
box->y1 = MAXSHORT;
box->y2 = MINSHORT;
@ -95,12 +95,12 @@ IcTrapezoidBounds (int ntrap, XTrapezoid *traps, PixRegionBox *box)
if (y2 > box->y2)
box->y2 = y2;
x1 = xFixedToInt (min (IcLineFixedX (&traps->left, traps->top, FALSE),
x1 = xFixedToInt (MIN (IcLineFixedX (&traps->left, traps->top, FALSE),
IcLineFixedX (&traps->left, traps->bottom, FALSE)));
if (x1 < box->x1)
box->x1 = x1;
x2 = xFixedToInt (xFixedCeil (max (IcLineFixedX (&traps->right, traps->top, TRUE),
x2 = xFixedToInt (xFixedCeil (MAX (IcLineFixedX (&traps->right, traps->top, TRUE),
IcLineFixedX (&traps->right, traps->bottom, TRUE))));
if (x2 > box->x2)
box->x2 = x2;
@ -108,26 +108,28 @@ IcTrapezoidBounds (int ntrap, XTrapezoid *traps, PixRegionBox *box)
}
void
IcTrapezoids (char op,
IcImage *src,
IcImage *dst,
IcFormat *format,
int xSrc,
int ySrc,
int ntrap,
XTrapezoid *traps)
IcCompositeTrapezoids (char op,
IcImage *src,
IcImage *dst,
int xSrc,
int ySrc,
const XTrapezoid *traps,
int ntraps)
{
IcImage *image = NULL;
PixRegionBox bounds;
INT16 xDst, yDst;
INT16 xRel, yRel;
IcFormat *format;
xDst = traps[0].left.p1.x >> 16;
yDst = traps[0].left.p1.y >> 16;
format = _IcFormatCreate (PICT_a8);
if (format)
{
IcTrapezoidBounds (ntrap, traps, &bounds);
IcTrapezoidBounds (ntraps, traps, &bounds);
if (bounds.y1 >= bounds.y2 || bounds.x1 >= bounds.x2)
return;
image = IcCreateAlphaPicture (dst, format,
@ -136,7 +138,7 @@ IcTrapezoids (char op,
if (!image)
return;
}
for (; ntrap; ntrap--, traps++)
for (; ntraps; ntraps--, traps++)
{
if (!xTrapezoidValid(traps))
continue;
@ -174,6 +176,8 @@ IcTrapezoids (char op,
bounds.y2 - bounds.y1);
IcImageDestroy (image);
}
_IcFormatDestroy (format);
}
#ifdef DEBUG
@ -1133,10 +1137,10 @@ PixelAlpha(xFixed pixel_x,
)
void
IcRasterizeTrapezoid (IcImage *pMask,
XTrapezoid *pTrap,
int x_off,
int y_off)
IcRasterizeTrapezoid (IcImage *pMask,
const XTrapezoid *pTrap,
int x_off,
int y_off)
{
XTrapezoid trap = *pTrap;
int alpha, temp;

102
pixman/src/ictri.c
View file

@ -25,13 +25,13 @@
#include "icint.h"
void
IcRasterizeTriangle (IcImage *image,
XTriangle *tri,
int x_off,
int y_off);
IcRasterizeTriangle (IcImage *image,
const XTriangle *tri,
int x_off,
int y_off);
static void
IcPointFixedBounds (int npoint, XPointFixed *points, PixRegionBox *bounds)
IcPointFixedBounds (int npoint, const XPointFixed *points, PixRegionBox *bounds)
{
bounds->x1 = xFixedToInt (points->x);
bounds->x2 = xFixedToInt (xFixedCeil (points->x));
@ -59,18 +59,18 @@ IcPointFixedBounds (int npoint, XPointFixed *points, PixRegionBox *bounds)
}
static void
IcTriangleBounds (int ntri, XTriangle *tris, PixRegionBox *bounds)
IcTriangleBounds (int ntri, const XTriangle *tris, PixRegionBox *bounds)
{
IcPointFixedBounds (ntri * 3, (XPointFixed *) tris, bounds);
}
void
IcRasterizeTriangle (IcImage *image,
XTriangle *tri,
int x_off,
int y_off)
IcRasterizeTriangle (IcImage *image,
const XTriangle *tri,
int x_off,
int y_off)
{
XPointFixed *top, *left, *right, *t;
const XPointFixed *top, *left, *right, *t;
XTrapezoid trap[2];
top = &tri->p1;
@ -143,26 +143,28 @@ IcRasterizeTriangle (IcImage *image,
}
void
IcTriangles (char op,
IcImage *src,
IcImage *dst,
IcFormat *format,
int xSrc,
int ySrc,
int ntri,
XTriangle *tris)
IcCompositeTriangles (char op,
IcImage *src,
IcImage *dst,
int xSrc,
int ySrc,
const XTriangle *tris,
int ntris)
{
PixRegionBox bounds;
IcImage *image = NULL;
int xDst, yDst;
int xRel, yRel;
IcFormat *format;
xDst = tris[0].p1.x >> 16;
yDst = tris[0].p1.y >> 16;
format = _IcFormatCreate (PICT_a8);
if (format)
{
IcTriangleBounds (ntri, tris, &bounds);
IcTriangleBounds (ntris, tris, &bounds);
if (bounds.x2 <= bounds.x1 || bounds.y2 <= bounds.y1)
return;
image = IcCreateAlphaPicture (dst,
@ -172,7 +174,7 @@ IcTriangles (char op,
if (!image)
return;
}
for (; ntri; ntri--, tris++)
for (; ntris; ntris--, tris++)
{
if (!format)
{
@ -207,32 +209,36 @@ IcTriangles (char op,
bounds.x2 - bounds.x1, bounds.y2 - bounds.y1);
IcImageDestroy (image);
}
_IcFormatDestroy (format);
}
void
IcTriStrip (char op,
IcImage *src,
IcImage *dst,
IcFormat *format,
int xSrc,
int ySrc,
int npoint,
XPointFixed *points)
IcCompositeTriStrip (char op,
IcImage *src,
IcImage *dst,
int xSrc,
int ySrc,
const XPointFixed *points,
int npoints)
{
XTriangle tri;
PixRegionBox bounds;
IcImage *image = NULL;
int xDst, yDst;
int xRel, yRel;
IcFormat *format;
xDst = points[0].x >> 16;
yDst = points[0].y >> 16;
format = _IcFormatCreate (PICT_a8);
if (npoint < 3)
if (npoints < 3)
return;
if (format)
{
IcPointFixedBounds (npoint, points, &bounds);
IcPointFixedBounds (npoints, points, &bounds);
if (bounds.x2 <= bounds.x1 || bounds.y2 <= bounds.y1)
return;
image = IcCreateAlphaPicture (dst,
@ -242,7 +248,7 @@ IcTriStrip (char op,
if (!image)
return;
}
for (; npoint >= 3; npoint--, points++)
for (; npoints >= 3; npoints--, points++)
{
tri.p1 = points[0];
tri.p2 = points[1];
@ -279,33 +285,37 @@ IcTriStrip (char op,
bounds.x2 - bounds.x1, bounds.y2 - bounds.y1);
IcImageDestroy (image);
}
_IcFormatDestroy (format);
}
void
IcTriFan (char op,
IcImage *src,
IcImage *dst,
IcFormat *format,
int xSrc,
int ySrc,
int npoint,
XPointFixed *points)
IcCompositeTriFan (char op,
IcImage *src,
IcImage *dst,
int xSrc,
int ySrc,
const XPointFixed *points,
int npoints)
{
XTriangle tri;
PixRegionBox bounds;
IcImage *image = NULL;
XPointFixed *first;
const XPointFixed *first;
int xDst, yDst;
int xRel, yRel;
IcFormat *format;
xDst = points[0].x >> 16;
yDst = points[0].y >> 16;
format = _IcFormatCreate (PICT_a8);
if (npoint < 3)
if (npoints < 3)
return;
if (format)
{
IcPointFixedBounds (npoint, points, &bounds);
IcPointFixedBounds (npoints, points, &bounds);
if (bounds.x2 <= bounds.x1 || bounds.y2 <= bounds.y1)
return;
image = IcCreateAlphaPicture (dst,
@ -316,8 +326,8 @@ IcTriFan (char op,
return;
}
first = points++;
npoint--;
for (; npoint >= 2; npoint--, points++)
npoints--;
for (; npoints >= 2; npoints--, points++)
{
tri.p1 = *first;
tri.p2 = points[0];
@ -354,5 +364,7 @@ IcTriFan (char op,
bounds.x2 - bounds.x1, bounds.y2 - bounds.y1);
IcImageDestroy (image);
}
_IcFormatDestroy (format);
}