Back to index

lightning-sunbird  0.9+nobinonly
Defines | Typedefs | Functions | Variables
fbcompose.c File Reference
#include "pixman-xserver-compat.h"
#include "fbpict.h"
#include "pixregionint.h"

Go to the source code of this file.

Defines

#define mod(a, b)   ((b) == 1 ? 0 : (a) >= 0 ? (a) % (b) : (b) - (-a) % (b))
#define SCANLINE_BUFFER_LENGTH   2048
#define Fetch8(l, o)   (((CARD8 *) (l))[(o) >> 2])
#define Fetch4(l, o)   ((o) & 2 ? Fetch8(l,o) >> 4 : Fetch8(l,o) & 0xf)
#define Fetch8(l, o)   (((CARD8 *) (l))[(o) >> 2])
#define Fetch4(l, o)   ((o) & 2 ? Fetch8(l,o) >> 4 : Fetch8(l,o) & 0xf)
#define Splita(v)   CARD32 a = ((v) >> 24), r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff
#define Split(v)   CARD32 r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff
#define Store8(l, o, v)   (((CARD8 *) l)[(o) >> 3] = (v))
#define Store4(l, o, v)
#define CombineAOut   1
#define CombineAIn   2
#define CombineBOut   4
#define CombineBIn   8
#define CombineClear   0
#define CombineA   (CombineAOut|CombineAIn)
#define CombineB   (CombineBOut|CombineBIn)
#define CombineAOver   (CombineAOut|CombineBOut|CombineAIn)
#define CombineBOver   (CombineAOut|CombineBOut|CombineBIn)
#define CombineAAtop   (CombineBOut|CombineAIn)
#define CombineBAtop   (CombineAOut|CombineBIn)
#define CombineXor   (CombineAOut|CombineBOut)
#define DIV(a, b)

Typedefs

typedef FASTCALL void(* fetchProc )(const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
typedef FASTCALL CARD32(* fetchPixelProc )(const FbBits *bits, int offset, miIndexedPtr indexed)
typedef FASTCALL void(* storeProc )(FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
typedef void(* scanStoreProc )(PicturePtr, int, int, int, CARD32 *)
typedef void(* scanFetchProc )(PicturePtr, int, int, int, CARD32 *)

Functions

static Bool PictureTransformPoint3d (pixman_transform_t *transform, PictVector *vector)
static FASTCALL void fbFetch_a8r8g8b8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_x8r8g8b8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a8b8g8r8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_x8b8g8r8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_r8g8b8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_b8g8r8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_r5g6b5 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_b5g6r5 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a1r5g5b5 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_x1r5g5b5 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a1b5g5r5 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_x1b5g5r5 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a4r4g4b4 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_x4r4g4b4 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a4b4g4r4 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_x4b4g4r4 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_r3g3b2 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_b2g3r3 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a2r2g2b2 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a2b2g2r2 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_c8 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a4 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_r1g2b1 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_b1g2r1 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a1r1g1b1 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a1b1g1r1 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_c4 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_a1 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static FASTCALL void fbFetch_g1 (const FbBits *bits, int x, int width, CARD32 *buffer, miIndexedPtr indexed)
static fetchProc fetchProcForPicture (PicturePtr pict)
static FASTCALL CARD32 fbFetchPixel_a8r8g8b8 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_x8r8g8b8 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a8b8g8r8 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_x8b8g8r8 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_r8g8b8 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_b8g8r8 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_r5g6b5 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_b5g6r5 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a1r5g5b5 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_x1r5g5b5 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a1b5g5r5 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_x1b5g5r5 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a4r4g4b4 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_x4r4g4b4 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a4b4g4r4 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_x4b4g4r4 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a8 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_r3g3b2 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_b2g3r3 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a2r2g2b2 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a2b2g2r2 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_c8 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a4 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_r1g2b1 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_b1g2r1 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a1r1g1b1 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a1b1g1r1 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_c4 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_a1 (const FbBits *bits, int offset, miIndexedPtr indexed)
static FASTCALL CARD32 fbFetchPixel_g1 (const FbBits *bits, int offset, miIndexedPtr indexed)
static fetchPixelProc fetchPixelProcForPicture (PicturePtr pict)
static FASTCALL void fbStore_a8r8g8b8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_x8r8g8b8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a8b8g8r8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_x8b8g8r8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_r8g8b8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_b8g8r8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_r5g6b5 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_b5g6r5 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a1r5g5b5 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_x1r5g5b5 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a1b5g5r5 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_x1b5g5r5 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a4r4g4b4 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_x4r4g4b4 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a4b4g4r4 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_x4b4g4r4 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_r3g3b2 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_b2g3r3 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a2r2g2b2 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_c8 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a4 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_r1g2b1 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_b1g2r1 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a1r1g1b1 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a1b1g1r1 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_c4 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_a1 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static FASTCALL void fbStore_g1 (FbBits *bits, const CARD32 *values, int x, int width, miIndexedPtr indexed)
static storeProc storeProcForPicture (PicturePtr pict)
static FASTCALL void fbCombineMaskU (CARD32 *src, const CARD32 *mask, int width)
static FASTCALL void fbCombineClear (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineSrcU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineOverU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineOverReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineInU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineInReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineOutU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineOutReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineAtopU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineAtopReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineXorU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineAddU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineSaturateU (CARD32 *dest, const CARD32 *src, int width)
static INLINE CARD8 fbCombineDisjointOutPart (CARD8 a, CARD8 b)
static INLINE CARD8 fbCombineDisjointInPart (CARD8 a, CARD8 b)
static FASTCALL void fbCombineDisjointGeneralU (CARD32 *dest, const CARD32 *src, int width, CARD8 combine)
static FASTCALL void fbCombineDisjointOverU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineDisjointInU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineDisjointInReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineDisjointOutU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineDisjointOutReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineDisjointAtopU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineDisjointAtopReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineDisjointXorU (CARD32 *dest, const CARD32 *src, int width)
static INLINE CARD8 fbCombineConjointOutPart (CARD8 a, CARD8 b)
static INLINE CARD8 fbCombineConjointInPart (CARD8 a, CARD8 b)
static FASTCALL void fbCombineConjointGeneralU (CARD32 *dest, const CARD32 *src, int width, CARD8 combine)
static FASTCALL void fbCombineConjointOverU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineConjointOverReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineConjointInU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineConjointInReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineConjointOutU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineConjointOutReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineConjointAtopU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineConjointAtopReverseU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineConjointXorU (CARD32 *dest, const CARD32 *src, int width)
static FASTCALL void fbCombineMaskC (CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineMaskValueC (CARD32 *src, const CARD32 *mask, int width)
static FASTCALL void fbCombineMaskAlphaC (const CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineClearC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineSrcC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineOverC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineOverReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineInC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineInReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineOutC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineOutReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineAtopC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineAtopReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineXorC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineAddC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineSaturateC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineDisjointGeneralC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width, CARD8 combine)
static FASTCALL void fbCombineDisjointOverC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineDisjointInC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineDisjointInReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineDisjointOutC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineDisjointOutReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineDisjointAtopC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineDisjointAtopReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineDisjointXorC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointGeneralC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width, CARD8 combine)
static FASTCALL void fbCombineConjointOverC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointOverReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointInC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointInReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointOutC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointOutReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointAtopC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointAtopReverseC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static FASTCALL void fbCombineConjointXorC (CARD32 *dest, CARD32 *src, CARD32 *mask, int width)
static void fbFetchSolid (PicturePtr pict, int x, int y, int width, CARD32 *buffer)
static void fbFetch (PicturePtr pict, int x, int y, int width, CARD32 *buffer)
static void fbFetchTransformed (PicturePtr pict, int x, int y, int width, CARD32 *buffer)
static void fbFetchExternalAlpha (PicturePtr pict, int x, int y, int width, CARD32 *buffer)
static void fbStore (PicturePtr pict, int x, int y, int width, CARD32 *buffer)
static void fbStoreExternalAlpha (PicturePtr pict, int x, int y, int width, CARD32 *buffer)
static void fbCompositeRect (const FbComposeData *data, CARD32 *scanline_buffer)
void pixman_compositeGeneral (pixman_operator_t op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height)

Variables

static CombineFuncU fbCombineFuncU []
static CombineFuncC fbCombineFuncC []
FbComposeFunctions composeFunctions

Define Documentation

Definition at line 1673 of file fbcompose.c.

Definition at line 1677 of file fbcompose.c.

#define CombineAIn   2

Definition at line 1668 of file fbcompose.c.

Definition at line 1667 of file fbcompose.c.

Definition at line 1675 of file fbcompose.c.

Definition at line 1674 of file fbcompose.c.

Definition at line 1678 of file fbcompose.c.

#define CombineBIn   8

Definition at line 1670 of file fbcompose.c.

Definition at line 1669 of file fbcompose.c.

Definition at line 1676 of file fbcompose.c.

Definition at line 1672 of file fbcompose.c.

Definition at line 1679 of file fbcompose.c.

#define DIV (   a,
  b 
)
Value:
((((a) < 0) == ((b) < 0)) ? (a) / (b) :\
        ((a) - (b) + 1 - (((b) < 0) << 1)) / (b))

Definition at line 2676 of file fbcompose.c.

#define Fetch4 (   l,
  o 
)    ((o) & 2 ? Fetch8(l,o) >> 4 : Fetch8(l,o) & 0xf)

Definition at line 867 of file fbcompose.c.

#define Fetch4 (   l,
  o 
)    ((o) & 2 ? Fetch8(l,o) >> 4 : Fetch8(l,o) & 0xf)

Definition at line 867 of file fbcompose.c.

#define Fetch8 (   l,
  o 
)    (((CARD8 *) (l))[(o) >> 2])

Definition at line 863 of file fbcompose.c.

#define Fetch8 (   l,
  o 
)    (((CARD8 *) (l))[(o) >> 2])

Definition at line 863 of file fbcompose.c.

#define mod (   a,
  b 
)    ((b) == 1 ? 0 : (a) >= 0 ? (a) % (b) : (b) - (-a) % (b))

Definition at line 68 of file fbcompose.c.

Definition at line 70 of file fbcompose.c.

#define Split (   v)    CARD32 r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff

Definition at line 1029 of file fbcompose.c.

#define Splita (   v)    CARD32 a = ((v) >> 24), r = ((v) >> 16) & 0xff, g = ((v) >> 8) & 0xff, b = (v) & 0xff

Definition at line 1028 of file fbcompose.c.

#define Store4 (   l,
  o,
  v 
)
Value:
Store8(l,o,((o) & 4 ? \
                               (Fetch8(l,o) & 0x0f) | ((v) << 4) : \
                               (Fetch8(l,o) & 0xf0) | (v)))

Definition at line 1293 of file fbcompose.c.

#define Store8 (   l,
  o,
  v 
)    (((CARD8 *) l)[(o) >> 3] = (v))

Definition at line 1287 of file fbcompose.c.


Typedef Documentation

Definition at line 596 of file fbcompose.c.

Definition at line 72 of file fbcompose.c.

Definition at line 3446 of file fbcompose.c.

Definition at line 3445 of file fbcompose.c.

Definition at line 1026 of file fbcompose.c.


Function Documentation

static FASTCALL void fbCombineAddC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2273 of file fbcompose.c.

{
    int i;
    fbCombineMaskValueC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 d = dest[i];
        FbByteAdd(d, s);
        dest[i] = d;
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineAddU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1610 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 d = dest[i];
        FbByteAdd(d, s);
        dest[i] = d;
    }
}
static FASTCALL void fbCombineAtopC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2227 of file fbcompose.c.

{
    int i;
    fbCombineMaskC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32 d = dest[i];
        CARD32 s = src[i];
        CARD32 ad = ~mask[i];
        CARD16 as = d >> 24;
        FbByteAddMulC(d, ad, s, as);
        dest[i] = d;
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineAtopReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2242 of file fbcompose.c.

{
    int i;
    fbCombineMaskC(src, mask, width);
    for (i = 0; i < width; ++i) {

        CARD32 d = dest[i];
        CARD32 s = src[i];
        CARD32 ad = mask[i];
        CARD16 as = ~d >> 24;
        FbByteAddMulC(d, ad, s, as);
        dest[i] = d;
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineAtopReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1580 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 d = dest[i];
        CARD32 src_a = Alpha(s);
        CARD32 dest_ia = Alpha(~d);

        FbByteAddMul(s, dest_ia, d, src_a);
        dest[i] = s;
    }
}
static FASTCALL void fbCombineAtopU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1565 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 d = dest[i];
        CARD32 dest_a = Alpha(d);
        CARD32 src_ia = Alpha(~s);

        FbByteAddMul(s, dest_a, d, src_ia);
        dest[i] = s;
    }
}
static FASTCALL void fbCombineClear ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1477 of file fbcompose.c.

{
    memset(dest, 0, width*sizeof(CARD32));
}

Here is the call graph for this function:

static FASTCALL void fbCombineClearC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2087 of file fbcompose.c.

{
    memset(dest, 0, width*sizeof(CARD32));
}

Here is the call graph for this function:

static FASTCALL void fbCombineConjointAtopC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2557 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointAtopReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2563 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointAtopReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1942 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointAtopU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1936 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointGeneralC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width,
CARD8  combine 
) [static]

Definition at line 2449 of file fbcompose.c.

{
    int i;
    fbCombineMaskC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32  s, d;
        CARD32  m,n,o,p;
        CARD32  Fa, Fb;
        CARD16  t, u, v;
        CARD32  sa;
        CARD8   da;

        s = src[i];
        sa = mask[i];
        d = dest[i];
        da = d >> 24;

        switch (combine & CombineA) {
        default:
            Fa = 0;
            break;
        case CombineAOut:
            m = fbCombineConjointOutPart ((CARD8) (sa >> 0), da);
            n = fbCombineConjointOutPart ((CARD8) (sa >> 8), da) << 8;
            o = fbCombineConjointOutPart ((CARD8) (sa >> 16), da) << 16;
            p = fbCombineConjointOutPart ((CARD8) (sa >> 24), da) << 24;
            Fa = m|n|o|p;
            break;
        case CombineAIn:
            m = fbCombineConjointInPart ((CARD8) (sa >> 0), da);
            n = fbCombineConjointInPart ((CARD8) (sa >> 8), da) << 8;
            o = fbCombineConjointInPart ((CARD8) (sa >> 16), da) << 16;
            p = fbCombineConjointInPart ((CARD8) (sa >> 24), da) << 24;
            Fa = m|n|o|p;
            break;
        case CombineA:
            Fa = 0xffffffff;
            break;
        }

        switch (combine & CombineB) {
        default:
            Fb = 0;
            break;
        case CombineBOut:
            m = fbCombineConjointOutPart (da, (CARD8) (sa >> 0));
            n = fbCombineConjointOutPart (da, (CARD8) (sa >> 8)) << 8;
            o = fbCombineConjointOutPart (da, (CARD8) (sa >> 16)) << 16;
            p = fbCombineConjointOutPart (da, (CARD8) (sa >> 24)) << 24;
            Fb = m|n|o|p;
            break;
        case CombineBIn:
            m = fbCombineConjointInPart (da, (CARD8) (sa >> 0));
            n = fbCombineConjointInPart (da, (CARD8) (sa >> 8)) << 8;
            o = fbCombineConjointInPart (da, (CARD8) (sa >> 16)) << 16;
            p = fbCombineConjointInPart (da, (CARD8) (sa >> 24)) << 24;
            Fb = m|n|o|p;
            break;
        case CombineB:
            Fb = 0xffffffff;
            break;
        }
        m = FbGen (s,d,0,FbGet8(Fa,0),FbGet8(Fb,0),t, u, v);
        n = FbGen (s,d,8,FbGet8(Fa,8),FbGet8(Fb,8),t, u, v);
        o = FbGen (s,d,16,FbGet8(Fa,16),FbGet8(Fb,16),t, u, v);
        p = FbGen (s,d,24,FbGet8(Fa,24),FbGet8(Fb,24),t, u, v);
        s = m|n|o|p;
        dest[i] = s;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL void fbCombineConjointGeneralU ( CARD32 dest,
const CARD32 src,
int  width,
CARD8  combine 
) [static]

Definition at line 1847 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  s = src[i];
        CARD32 d = dest[i];
        CARD32  m,n,o,p;
        CARD16  Fa, Fb, t, u, v;
        CARD8 sa = s >> 24;
        CARD8 da = d >> 24;

        switch (combine & CombineA) {
        default:
            Fa = 0;
            break;
        case CombineAOut:
            Fa = fbCombineConjointOutPart (sa, da);
            break;
        case CombineAIn:
            Fa = fbCombineConjointInPart (sa, da);
            break;
        case CombineA:
            Fa = 0xff;
            break;
        }

        switch (combine & CombineB) {
        default:
            Fb = 0;
            break;
        case CombineBOut:
            Fb = fbCombineConjointOutPart (da, sa);
            break;
        case CombineBIn:
            Fb = fbCombineConjointInPart (da, sa);
            break;
        case CombineB:
            Fb = 0xff;
            break;
        }
        m = FbGen (s,d,0,Fa,Fb,t, u, v);
        n = FbGen (s,d,8,Fa,Fb,t, u, v);
        o = FbGen (s,d,16,Fa,Fb,t, u, v);
        p = FbGen (s,d,24,Fa,Fb,t, u, v);
        s = m|n|o|p;
        dest[i] = s;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL void fbCombineConjointInC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2533 of file fbcompose.c.

Here is the call graph for this function:

static INLINE CARD8 fbCombineConjointInPart ( CARD8  a,
CARD8  b 
) [static]

Definition at line 1837 of file fbcompose.c.

{
    /* min (1,b/a) */

    if (b >= a)                 /* b >= a -> b/a >= 1 */
       return 0xff;      /* 1 */
    return FbIntDiv(b,a);   /* b/a */
}

Here is the caller graph for this function:

static FASTCALL void fbCombineConjointInReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2539 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointInReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1918 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointInU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1911 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointOutC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2545 of file fbcompose.c.

Here is the call graph for this function:

static INLINE CARD8 fbCombineConjointOutPart ( CARD8  a,
CARD8  b 
) [static]

Definition at line 1823 of file fbcompose.c.

{
    /* max (1-b/a,0) */
    /* = 1-min(b/a,1) */

    /* min (1, (1-b) / a) */

    if (b >= a)                 /* b >= a -> b/a >= 1 */
       return 0x00;      /* 0 */
    return ~FbIntDiv(b,a);   /* 1 - b/a */
}

Here is the caller graph for this function:

static FASTCALL void fbCombineConjointOutReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2551 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointOutReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1930 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointOutU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1924 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointOverC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2521 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointOverReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2527 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointOverReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1904 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointOverU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1897 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointXorC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2569 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineConjointXorU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1948 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointAtopC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2431 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointAtopReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2437 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointAtopReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1810 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointAtopU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1804 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointGeneralC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width,
CARD8  combine 
) [static]

Definition at line 2329 of file fbcompose.c.

{
    int i;
    fbCombineMaskC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32  s, d;
        CARD32  m,n,o,p;
        CARD32  Fa, Fb;
        CARD16  t, u, v;
        CARD32  sa;
        CARD8   da;

        s = src[i];
        sa = mask[i];
        d = dest[i];
        da = d >> 24;

        switch (combine & CombineA) {
        default:
            Fa = 0;
            break;
        case CombineAOut:
            m = fbCombineDisjointOutPart ((CARD8) (sa >> 0), da);
            n = fbCombineDisjointOutPart ((CARD8) (sa >> 8), da) << 8;
            o = fbCombineDisjointOutPart ((CARD8) (sa >> 16), da) << 16;
            p = fbCombineDisjointOutPart ((CARD8) (sa >> 24), da) << 24;
            Fa = m|n|o|p;
            break;
        case CombineAIn:
            m = fbCombineDisjointInPart ((CARD8) (sa >> 0), da);
            n = fbCombineDisjointInPart ((CARD8) (sa >> 8), da) << 8;
            o = fbCombineDisjointInPart ((CARD8) (sa >> 16), da) << 16;
            p = fbCombineDisjointInPart ((CARD8) (sa >> 24), da) << 24;
            Fa = m|n|o|p;
            break;
        case CombineA:
            Fa = 0xffffffff;
            break;
        }

        switch (combine & CombineB) {
        default:
            Fb = 0;
            break;
        case CombineBOut:
            m = fbCombineDisjointOutPart (da, (CARD8) (sa >> 0));
            n = fbCombineDisjointOutPart (da, (CARD8) (sa >> 8)) << 8;
            o = fbCombineDisjointOutPart (da, (CARD8) (sa >> 16)) << 16;
            p = fbCombineDisjointOutPart (da, (CARD8) (sa >> 24)) << 24;
            Fb = m|n|o|p;
            break;
        case CombineBIn:
            m = fbCombineDisjointInPart (da, (CARD8) (sa >> 0));
            n = fbCombineDisjointInPart (da, (CARD8) (sa >> 8)) << 8;
            o = fbCombineDisjointInPart (da, (CARD8) (sa >> 16)) << 16;
            p = fbCombineDisjointInPart (da, (CARD8) (sa >> 24)) << 24;
            Fb = m|n|o|p;
            break;
        case CombineB:
            Fb = 0xffffffff;
            break;
        }
        m = FbGen (s,d,0,FbGet8(Fa,0),FbGet8(Fb,0),t, u, v);
        n = FbGen (s,d,8,FbGet8(Fa,8),FbGet8(Fb,8),t, u, v);
        o = FbGen (s,d,16,FbGet8(Fa,16),FbGet8(Fb,16),t, u, v);
        p = FbGen (s,d,24,FbGet8(Fa,24),FbGet8(Fb,24),t, u, v);
        s = m|n|o|p;
        dest[i] = s;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL void fbCombineDisjointGeneralU ( CARD32 dest,
const CARD32 src,
int  width,
CARD8  combine 
) [static]

Definition at line 1708 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 d = dest[i];
        CARD32 m,n,o,p;
        CARD16 Fa, Fb, t, u, v;
        CARD8 sa = s >> 24;
        CARD8 da = d >> 24;

        switch (combine & CombineA) {
        default:
            Fa = 0;
            break;
        case CombineAOut:
            Fa = fbCombineDisjointOutPart (sa, da);
            break;
        case CombineAIn:
            Fa = fbCombineDisjointInPart (sa, da);
            break;
        case CombineA:
            Fa = 0xff;
            break;
        }

        switch (combine & CombineB) {
        default:
            Fb = 0;
            break;
        case CombineBOut:
            Fb = fbCombineDisjointOutPart (da, sa);
            break;
        case CombineBIn:
            Fb = fbCombineDisjointInPart (da, sa);
            break;
        case CombineB:
            Fb = 0xff;
            break;
        }
        m = FbGen (s,d,0,Fa,Fb,t, u, v);
        n = FbGen (s,d,8,Fa,Fb,t, u, v);
        o = FbGen (s,d,16,Fa,Fb,t, u, v);
        p = FbGen (s,d,24,Fa,Fb,t, u, v);
        s = m|n|o|p;
        dest[i] = s;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL void fbCombineDisjointInC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2407 of file fbcompose.c.

Here is the call graph for this function:

static INLINE CARD8 fbCombineDisjointInPart ( CARD8  a,
CARD8  b 
) [static]

Definition at line 1695 of file fbcompose.c.

{
    /* max (1-(1-b)/a,0) */
    /*  = - min ((1-b)/a - 1, 0) */
    /*  = 1 - min (1, (1-b)/a) */

    b = ~b;              /* 1 - b */
    if (b >= a)                 /* 1 - b >= a -> (1-b)/a >= 1 */
       return 0;         /* 1 - 1 */
    return ~FbIntDiv(b,a);  /* 1 - (1-b) / a */
}

Here is the caller graph for this function:

static FASTCALL void fbCombineDisjointInReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2413 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointInReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1786 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointInU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1780 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointOutC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2419 of file fbcompose.c.

Here is the call graph for this function:

static INLINE CARD8 fbCombineDisjointOutPart ( CARD8  a,
CARD8  b 
) [static]

Definition at line 1683 of file fbcompose.c.

{
    /* min (1, (1-b) / a) */

    b = ~b;              /* 1 - b */
    if (b >= a)                 /* 1 - b >= a -> (1-b)/a >= 1 */
       return 0xff;      /* 1 */
    return FbIntDiv(b,a);   /* (1-b) / a */
}

Here is the caller graph for this function:

static FASTCALL void fbCombineDisjointOutReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2425 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointOutReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1798 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointOutU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1792 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointOverC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2401 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointOverU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1758 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  s = src[i];
        CARD16  a = s >> 24;

        if (a != 0x00)
        {
            if (a != 0xff)
            {
                CARD32 d = dest[i];
                a = fbCombineDisjointOutPart (d >> 24, a);
                FbByteMulAdd(d, a, s);
                s = d;
            }
            dest[i] = s;
        }
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointXorC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2443 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineDisjointXorU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1816 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineInC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2143 of file fbcompose.c.

{
    int i;
    fbCombineMaskValueC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32 d = dest[i];
        CARD16 a = d >> 24;
        CARD32 s = 0;
        if (a)
        {
            s = src[i];
            if (a != 0xff)
            {
                FbByteMul(s, a);
            }
        }
        dest[i] = s;
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineInReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2164 of file fbcompose.c.

{
    int i;
    fbCombineMaskAlphaC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32 a = mask[i];

        if (a != 0xffffffff)
        {
            CARD32 d = 0;
            if (a)
            {
                d = dest[i];
                FbByteMulC(d, a);
            }
            dest[i] = d;
        }
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineInReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1529 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 d = dest[i];
        CARD32 a = Alpha(src[i]);
        FbByteMul(d, a);
        dest[i] = d;
    }
}
static FASTCALL void fbCombineInU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1517 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 a = Alpha(dest[i]);
        FbByteMul(s, a);
        dest[i] = s;
    }
}
static FASTCALL void fbCombineMaskAlphaC ( const CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2059 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 a = mask[i];
        CARD32       x;

        if (!a)
            continue;

        x = src[i] >> 24;
        if (x == 0xff)
            continue;
        if (a == 0xffffffff)
        {
            x = x >> 24;
            x |= x << 8;
            x |= x << 16;
            mask[i] = x;
            continue;
        }

        FbByteMul(a, x);
        mask[i] = a;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbCombineMaskC ( CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2001 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 a = mask[i];

        CARD32       x;
        CARD16       xa;

        if (!a)
        {
            src[i] = 0;
            continue;
        }

        x = src[i];
        if (a == 0xffffffff)
        {
            x = x >> 24;
            x |= x << 8;
            x |= x << 16;
            mask[i] = x;
            continue;
        }

        xa = x >> 24;
        FbByteMulC(x, a);
        src[i] = x;
        FbByteMul(a, xa);
        mask[i] = a;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbCombineMaskU ( CARD32 src,
const CARD32 mask,
int  width 
) [static]

Definition at line 1461 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 a = mask[i] >> 24;
        CARD32 s = src[i];
        FbByteMul(s, a);
        src[i] = s;
    }
}
static FASTCALL void fbCombineMaskValueC ( CARD32 src,
const CARD32 mask,
int  width 
) [static]

Definition at line 2035 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 a = mask[i];
        CARD32       x;

        if (!a)
        {
            src[i] = 0;
            continue;
        }

        if (a == 0xffffffff)
            continue;

        x = src[i];
        FbByteMulC(x, a);
        src[i] = x;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbCombineOutC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2185 of file fbcompose.c.

{
    int i;
    fbCombineMaskValueC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32 d = dest[i];
        CARD16 a = ~d >> 24;
        CARD32 s = 0;
        if (a)
        {
            s = src[i];
            if (a != 0xff)
            {
                FbByteMul(s, a);
            }
        }
        dest[i] = s;
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineOutReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2206 of file fbcompose.c.

{
    int i;
    fbCombineMaskAlphaC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32 a = ~mask[i];

        if (a != 0xffffffff)
        {
            CARD32 d = 0;
            if (a)
            {
                d = dest[i];
                FbByteMulC(d, a);
            }
            dest[i] = d;
        }
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineOutReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1553 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 d = dest[i];
        CARD32 a = Alpha(~src[i]);
        FbByteMul(d, a);
        dest[i] = d;
    }
}
static FASTCALL void fbCombineOutU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1541 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 a = Alpha(~dest[i]);
        FbByteMul(s, a);
        dest[i] = s;
    }
}
static FASTCALL void fbCombineOverC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2100 of file fbcompose.c.

{
    int i;
    fbCombineMaskC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32  s = src[i];
        CARD32  a = ~mask[i];

        if (a != 0xffffffff)
        {
            if (a)
            {
                CARD32 d = dest[i];
                FbByteMulAddC(d, a, s);
                s = d;
            }
            dest[i] = s;
        }
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineOverReverseC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2122 of file fbcompose.c.

{
    int i;
    fbCombineMaskValueC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32 d = dest[i];
        CARD32 a = ~d >> 24;

        if (a)
        {
            CARD32 s = src[i];
            if (a != 0xff)
            {
                FbByteMulAdd(s, a, d);
            }
            dest[i] = s;
        }
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineOverReverseU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1504 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 d = dest[i];
        CARD32 ia = Alpha(~dest[i]);
        FbByteMulAdd(s, ia, d);
        dest[i] = s;
    }
}
static FASTCALL void fbCombineOverU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1490 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 d = dest[i];
        CARD32 ia = Alpha(~s);

        FbByteMulAdd(d, ia, s);
        dest[i] = d;
    }
}
static FASTCALL void fbCombineSaturateC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2286 of file fbcompose.c.

{
    int i;
    fbCombineMaskC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32  s, d;
        CARD16  sa, sr, sg, sb, da;
        CARD16  t, u, v;
        CARD32  m,n,o,p;

        d = dest[i];
        s = src[i];
        sa = (mask[i] >> 24);
        sr = (mask[i] >> 16) & 0xff;
        sg = (mask[i] >>  8) & 0xff;
        sb = (mask[i]      ) & 0xff;
        da = ~d >> 24;

        if (sb <= da)
            m = FbAdd(s,d,0,t);
        else
            m = FbGen (s, d, 0, (da << 8) / sb, 0xff, t, u, v);

        if (sg <= da)
            n = FbAdd(s,d,8,t);
        else
            n = FbGen (s, d, 8, (da << 8) / sg, 0xff, t, u, v);

        if (sr <= da)
            o = FbAdd(s,d,16,t);
        else
            o = FbGen (s, d, 16, (da << 8) / sr, 0xff, t, u, v);

        if (sa <= da)
            p = FbAdd(s,d,24,t);
        else
            p = FbGen (s, d, 24, (da << 8) / sa, 0xff, t, u, v);

        dest[i] = m|n|o|p;
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineSaturateU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1622 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  s = src[i];
        CARD32 d = dest[i];
        CARD16  sa, da;

        sa = s >> 24;
        da = ~d >> 24;
        if (sa > da)
        {
            sa = FbIntDiv(da, sa);
            FbByteMul(s, sa);
        }
        FbByteAdd(d, s);
        dest[i] = d;
    }
}
static FASTCALL void fbCombineSrcC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2093 of file fbcompose.c.

Here is the call graph for this function:

static FASTCALL void fbCombineSrcU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1483 of file fbcompose.c.

{
    memcpy(dest, src, width*sizeof(CARD32));
}

Here is the call graph for this function:

static FASTCALL void fbCombineXorC ( CARD32 dest,
CARD32 src,
CARD32 mask,
int  width 
) [static]

Definition at line 2258 of file fbcompose.c.

{
    int i;
    fbCombineMaskC(src, mask, width);
    for (i = 0; i < width; ++i) {
        CARD32 d = dest[i];
        CARD32 s = src[i];
        CARD32 ad = ~mask[i];
        CARD16 as = ~d >> 24;
        FbByteAddMulC(d, ad, s, as);
        dest[i] = d;
    }
}

Here is the call graph for this function:

static FASTCALL void fbCombineXorU ( CARD32 dest,
const CARD32 src,
int  width 
) [static]

Definition at line 1595 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32 s = src[i];
        CARD32 d = dest[i];
        CARD32 src_ia = Alpha(~s);
        CARD32 dest_ia = Alpha(~d);

        FbByteAddMul(s, dest_ia, d, src_ia);
        dest[i] = s;
    }
}
static void fbCompositeRect ( const FbComposeData data,
CARD32 scanline_buffer 
) [static]

Definition at line 3449 of file fbcompose.c.

{
    CARD32 *src_buffer = scanline_buffer;
    CARD32 *dest_buffer = src_buffer + data->width;
    int i;
    scanStoreProc store;
    scanFetchProc fetchSrc = NULL, fetchMask = NULL, fetchDest = NULL;

    if (data->op == PIXMAN_OPERATOR_CLEAR)
        fetchSrc = NULL;
    else if (!data->src->pDrawable) {
#ifdef PIXMAN_GRADIENTS
        if (data->src->pSourcePict)
            fetchSrc = fbFetchSourcePict;
#endif
    } else if (data->src->alphaMap)
        fetchSrc = fbFetchExternalAlpha;
    else if (data->src->repeat == RepeatNormal &&
             data->src->pDrawable->width == 1 && data->src->pDrawable->height == 1)
        fetchSrc = fbFetchSolid;
#ifdef PIXMAN_CONVOLUTION
    else if (!data->src->transform && data->src->filter != PictFilterConvolution)
        fetchSrc = fbFetch;
#else
    else if (!data->src->transform)
        fetchSrc = fbFetch;
#endif
    else
        fetchSrc = fbFetchTransformed;

    if (data->mask && data->op != PIXMAN_OPERATOR_CLEAR) {
        if (!data->mask->pDrawable) {
#ifdef PIXMAN_GRADIENTS
            if (data->mask->pSourcePict)
                fetchMask = fbFetchSourcePict;
#endif
        } else if (data->mask->alphaMap)
            fetchMask = fbFetchExternalAlpha;
        else if (data->mask->repeat == RepeatNormal
                 && data->mask->pDrawable->width == 1 && data->mask->pDrawable->height == 1)
            fetchMask = fbFetchSolid;
#ifdef PIXMAN_CONVOLUTION
        else if (!data->mask->transform && data->mask->filter != PictFilterConvolution)
            fetchMask = fbFetch;
#else
        else if (!data->mask->transform)
            fetchMask = fbFetch;
#endif
        else
            fetchMask = fbFetchTransformed;
    } else {
        fetchMask = NULL;
    }

    if (data->dest->alphaMap) {
        fetchDest = fbFetchExternalAlpha;
        store = fbStoreExternalAlpha;
    } else {
        fetchDest = fbFetch;
        store = fbStore;
    }
    if (data->op == PIXMAN_OPERATOR_CLEAR || data->op == PIXMAN_OPERATOR_SRC)
        fetchDest = NULL;

    if (fetchSrc && fetchMask && data->mask && data->mask->componentAlpha && PICT_FORMAT_RGB(data->mask->format_code)) {
        CARD32 *mask_buffer = dest_buffer + data->width;
        CombineFuncC compose = composeFunctions.combineC[data->op];
        if (!compose)
            return;

        for (i = 0; i < data->height; ++i)
        {
            /* fill first half of scanline with source */
            fetchSrc(data->src, data->xSrc, data->ySrc + i, data->width, src_buffer);
            fetchMask(data->mask, data->xMask, data->yMask + i, data->width, mask_buffer);

            /* fill dest into second half of scanline */
            if (fetchDest)
                fetchDest(data->dest, data->xDest, data->yDest + i, data->width, dest_buffer);

            /* blend */
            compose(dest_buffer, src_buffer, mask_buffer, data->width);

            /* write back */
            store(data->dest, data->xDest, data->yDest + i, data->width, dest_buffer);
        }
    } else {

        CombineFuncU compose = composeFunctions.combineU[data->op];
        if (!compose)
            return;

        if (fetchSrc == fbFetchSolid && (!fetchMask || fetchMask == fbFetchSolid)) {
            fetchSrc(data->src, data->xSrc, data->ySrc, data->width, src_buffer);
            if (fetchMask) {
                fetchMask(data->mask, data->xMask, data->yMask, data->width, dest_buffer);
                composeFunctions.combineMaskU(src_buffer, dest_buffer, data->width);
            }
            fetchSrc = NULL;
            fetchMask = NULL;
        }

        for (i = 0; i < data->height; ++i) {
            /* fill first half of scanline with source */
            if (fetchSrc) {
                fetchSrc(data->src, data->xSrc, data->ySrc + i, data->width, src_buffer);

                /* add in mask */
                if (fetchMask) {
                    fetchMask(data->mask, data->xMask, data->yMask + i, data->width, dest_buffer);
                    composeFunctions.combineMaskU(src_buffer, dest_buffer, data->width);
                }
            }

            /* fill dest into second half of scanline */
            if (fetchDest)
                fetchDest(data->dest, data->xDest, data->yDest + i, data->width, dest_buffer);

            /* blend */
            compose(dest_buffer, src_buffer, data->width);

            /* write back */
            store(data->dest, data->xDest, data->yDest + i, data->width, dest_buffer);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void fbFetch ( PicturePtr  pict,
int  x,
int  y,
int  width,
CARD32 buffer 
) [static]

Definition at line 2654 of file fbcompose.c.

{
    FbBits *bits;
    FbStride stride;
    int bpp;
    int xoff, yoff;
    fetchProc fetch = fetchProcForPicture(pict);
#ifdef PIXMAN_INDEXED_FORMATS
    miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
#else
    miIndexedPtr indexed = NULL;
#endif

    fbGetDrawable (pict->pDrawable, bits, stride, bpp, xoff, yoff);
    x += xoff;
    y += yoff;

    bits += y*stride;

    fetch(bits, x, width, buffer, indexed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL void fbFetch_a1 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 505 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  p = ((CARD32 *)bits)[(i + x) >> 5];
        CARD32  a;
#if BITMAP_BIT_ORDER == MSBFirst
        a = p >> (0x1f - ((i+x) & 0x1f));
#else
        a = p >> ((i+x) & 0x1f);
#endif
        a = a & 1;
        a |= a << 1;
        a |= a << 2;
        a |= a << 4;
        *buffer++ = a << 24;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a1b1g1r1 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 477 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  p = Fetch4(bits, i + x);
        CARD32  a,r,g,b;

        a = ((p & 0x8) * 0xff) << 21;
        r = ((p & 0x4) * 0xff) >> 3;
        g = ((p & 0x2) * 0xff) << 7;
        b = ((p & 0x1) * 0xff) << 16;
        *buffer++ = a|r|g|b;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a1b5g5r5 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 218 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b, a;

        a = (CARD32) ((CARD8) (0 - ((p & 0x8000) >> 15))) << 24;
        b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
        g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
        r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
        *buffer++ = (a | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a1r1g1b1 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 461 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  p = Fetch4(bits, i + x);
        CARD32  a,r,g,b;

        a = ((p & 0x8) * 0xff) << 21;
        r = ((p & 0x4) * 0xff) << 14;
        g = ((p & 0x2) * 0xff) << 7;
        b = ((p & 0x1) * 0xff);
        *buffer++ = a|r|g|b;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a1r5g5b5 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 185 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b, a;

        a = (CARD32) ((CARD8) (0 - ((p & 0x8000) >> 15))) << 24;
        r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
        g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
        b = ((p & 0x001c) | ((p & 0x001f) << 5)) >> 2;
        *buffer++ = (a | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a2b2g2r2 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 384 of file fbcompose.c.

{
    const CARD8 *pixel = (const CARD8 *)bits + x;
    const CARD8 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32   a,r,g,b;

        a = ((p & 0xc0) * 0x55) << 18;
        b = ((p & 0x30) * 0x55) >> 6;
        g = ((p & 0x0c) * 0x55) << 6;
        r = ((p & 0x03) * 0x55) << 16;
        *buffer++ = a|r|g|b;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a2r2g2b2 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 367 of file fbcompose.c.

{
    const CARD8 *pixel = (const CARD8 *)bits + x;
    const CARD8 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32   a,r,g,b;

        a = ((p & 0xc0) * 0x55) << 18;
        r = ((p & 0x30) * 0x55) << 12;
        g = ((p & 0x0c) * 0x55) << 6;
        b = ((p & 0x03) * 0x55);
        *buffer++ = a|r|g|b;
       }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a4 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 419 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  p = Fetch4(bits, i + x);

        p |= p << 4;
        *buffer++ = p << 24;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a4b4g4r4 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 284 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b, a;

        a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
        b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
        g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
        r = ((p & 0x000f) | ((p & 0x000f) << 4));
        *buffer++ = (a | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a4r4g4b4 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 251 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b, a;

        a = ((p & 0xf000) | ((p & 0xf000) >> 4)) << 16;
        r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
        g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
        b = ((p & 0x000f) | ((p & 0x000f) << 4));
        *buffer++ = (a | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a8 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 317 of file fbcompose.c.

{
    const CARD8 *pixel = (const CARD8 *)bits + x;
    const CARD8 *end = pixel + width;
    while (pixel < end) {
        *buffer++ = (*pixel++) << 24;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a8b8g8r8 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 95 of file fbcompose.c.

{
    const CARD32 *pixel = (CARD32 *)bits + x;
    const CARD32 *end = pixel + width;
    while (pixel < end) {
        *buffer++ =  ((*pixel & 0xff00ff00) |
                      ((*pixel >> 16) & 0xff) |
                      ((*pixel & 0xff) << 16));
        ++pixel;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_a8r8g8b8 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 79 of file fbcompose.c.

{
    memcpy(buffer, (const CARD32 *)bits + x, width*sizeof(CARD32));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL void fbFetch_b1g2r1 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 446 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  p = Fetch4(bits, i + x);
        CARD32  r,g,b;

        b = ((p & 0x8) * 0xff) >> 3;
        g = ((p & 0x6) * 0x55) << 7;
        r = ((p & 0x1) * 0xff) << 16;
        *buffer++ = 0xff000000|r|g|b;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_b2g3r3 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 346 of file fbcompose.c.

{
    const CARD8 *pixel = (const CARD8 *)bits + x;
    const CARD8 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b;

        b = (((p & 0xc0)     ) |
             ((p & 0xc0) >> 2) |
             ((p & 0xc0) >> 4) |
             ((p & 0xc0) >> 6));
        g = ((p & 0x38) | ((p & 0x38) >> 3) | ((p & 0x30) << 2)) << 8;
        r = (((p & 0x07)     ) |
             ((p & 0x07) << 3) |
             ((p & 0x06) << 6)) << 16;
        *buffer++ = (0xff000000 | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_b5g6r5 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 169 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b;

        b = ((p & 0xf800) | ((p & 0xe000) >> 5)) >> 8;
        g = ((p & 0x07e0) | ((p & 0x0600) >> 6)) << 5;
        r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
        *buffer++ = (0xff000000 | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_b8g8r8 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 134 of file fbcompose.c.

{
    const CARD8 *pixel = (const CARD8 *)bits + 3*x;
    const CARD8 *end = pixel + 3*width;
    while (pixel < end) {
        CARD32 b = 0xff000000;
#if IMAGE_BYTE_ORDER == MSBFirst
        b |= (*pixel++);
        b |= (*pixel++ << 8);
        b |= (*pixel++ << 16);
#else
        b |= (*pixel++ << 16);
        b |= (*pixel++ << 8);
        b |= (*pixel++);
#endif
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_c4 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 493 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  p = Fetch4(bits, i + x);

        *buffer++ = indexed->rgba[p];
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_c8 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 401 of file fbcompose.c.

{
    const CARD8 *pixel = (const CARD8 *)bits + x;
    const CARD8 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        *buffer++ = indexed->rgba[p];
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_g1 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 525 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  p = ((CARD32 *)bits)[(i+x) >> 5];
        CARD32 a;
#if BITMAP_BIT_ORDER == MSBFirst
        a = p >> (0x1f - ((i+x) & 0x1f));
#else
        a = p >> ((i+x) & 0x1f);
#endif
        a = a & 1;
        *buffer++ = indexed->rgba[a];
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_r1g2b1 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 431 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  p = Fetch4(bits, i + x);
        CARD32  r,g,b;

        r = ((p & 0x8) * 0xff) << 13;
        g = ((p & 0x6) * 0x55) << 7;
        b = ((p & 0x1) * 0xff);
        *buffer++ = 0xff000000|r|g|b;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_r3g3b2 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 327 of file fbcompose.c.

{
    const CARD8 *pixel = (const CARD8 *)bits + x;
    const CARD8 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b;

        r = ((p & 0xe0) | ((p & 0xe0) >> 3) | ((p & 0xc0) >> 6)) << 16;
        g = ((p & 0x1c) | ((p & 0x18) >> 3) | ((p & 0x1c) << 3)) << 8;
        b = (((p & 0x03)     ) |
             ((p & 0x03) << 2) |
             ((p & 0x03) << 4) |
             ((p & 0x03) << 6));
        *buffer++ = (0xff000000 | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_r5g6b5 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 153 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32 r = (((p) << 3) & 0xf8) | 
                   (((p) << 5) & 0xfc00) |
                   (((p) << 8) & 0xf80000);
        r |= (r >> 5) & 0x70007;
        r |= (r >> 6) & 0x300;
        *buffer++ = 0xff000000 | r;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_r8g8b8 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 122 of file fbcompose.c.

{
    const CARD8 *pixel = (const CARD8 *)bits + 3*x;
    const CARD8 *end = pixel + 3*width;
    while (pixel < end) {
        CARD32 b = Fetch24(pixel) | 0xff000000;
        pixel += 3;
        *buffer++ = b;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_x1b5g5r5 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 235 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b;

        b = ((p & 0x7c00) | ((p & 0x7000) >> 5)) >> 7;
        g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
        r = ((p & 0x001c) | ((p & 0x001f) << 5)) << 14;
        *buffer++ = (0xff000000 | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_x1r5g5b5 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 202 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b;

        r = ((p & 0x7c00) | ((p & 0x7000) >> 5)) << 9;
        g = ((p & 0x03e0) | ((p & 0x0380) >> 5)) << 6;
        b = ((p & 0x001c) | ((p & 0x001f) << 5)) >> 2;
        *buffer++ = (0xff000000 | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_x4b4g4r4 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 301 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b;

        b = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
        g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
        r = ((p & 0x000f) | ((p & 0x000f) << 4));
        *buffer++ = (0xff000000 | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_x4r4g4b4 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 268 of file fbcompose.c.

{
    const CARD16 *pixel = (const CARD16 *)bits + x;
    const CARD16 *end = pixel + width;
    while (pixel < end) {
        CARD32  p = *pixel++;
        CARD32  r,g,b;

        r = ((p & 0x0f00) | ((p & 0x0f00) >> 4)) << 12;
        g = ((p & 0x00f0) | ((p & 0x00f0) >> 4)) << 8;
        b = ((p & 0x000f) | ((p & 0x000f) << 4));
        *buffer++ = (0xff000000 | r | g | b);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_x8b8g8r8 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 108 of file fbcompose.c.

{
    const CARD32 *pixel = (CARD32 *)bits + x;
    const CARD32 *end = pixel + width;
    while (pixel < end) {
        *buffer++ =  0xff000000 |
                     ((*pixel & 0x0000ff00) |
                      ((*pixel >> 16) & 0xff) |
                      ((*pixel & 0xff) << 16));
        ++pixel;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbFetch_x8r8g8b8 ( const FbBits bits,
int  x,
int  width,
CARD32 buffer,
miIndexedPtr  indexed 
) [static]

Definition at line 85 of file fbcompose.c.

{
    const CARD32 *pixel = (const CARD32 *)bits + x;
    const CARD32 *end = pixel + width;
    while (pixel < end) {
        *buffer++ = *pixel++ | 0xff000000;
    }
}

Here is the caller graph for this function:

static void fbFetchExternalAlpha ( PicturePtr  pict,
int  x,
int  y,
int  width,
CARD32 buffer 
) [static]

Definition at line 3349 of file fbcompose.c.

{
    int i;
    CARD32 _alpha_buffer[SCANLINE_BUFFER_LENGTH];
    CARD32 *alpha_buffer = _alpha_buffer;

    if (!pict->alphaMap) {
        fbFetchTransformed(pict, x, y, width, buffer);
        return;
    }
    
    if (width > SCANLINE_BUFFER_LENGTH)
        alpha_buffer = (CARD32 *) malloc(width*sizeof(CARD32));
    
    fbFetchTransformed(pict, x, y, width, buffer);
    fbFetchTransformed(pict->alphaMap, x - pict->alphaOrigin.x, y - pict->alphaOrigin.y, width, alpha_buffer);
    for (i = 0; i < width; ++i) {
        int a = alpha_buffer[i]>>24;
        buffer[i] = (a << 24)
                 | (div_255(Red(buffer[i]) * a) << 16)
                 | (div_255(Green(buffer[i]) * a) << 8)
                 | (div_255(Blue(buffer[i]) * a));
    }

    if (alpha_buffer != _alpha_buffer)
        free(alpha_buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a1 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 939 of file fbcompose.c.

{
    CARD32  pixel = ((CARD32 *)bits)[offset >> 5];
    CARD32  a;
#if BITMAP_BIT_ORDER == MSBFirst
    a = pixel >> (0x1f - (offset & 0x1f));
#else
    a = pixel >> (offset & 0x1f);
#endif
    a = a & 1;
    a |= a << 1;
    a |= a << 2;
    a |= a << 4;
    return a << 24;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a1b1g1r1 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 917 of file fbcompose.c.

{
    CARD32  pixel = Fetch4(bits, offset);
    CARD32  a,r,g,b;

    a = ((pixel & 0x8) * 0xff) << 21;
    r = ((pixel & 0x4) * 0xff) >> 3;
    g = ((pixel & 0x2) * 0xff) << 7;
    b = ((pixel & 0x1) * 0xff) << 16;
    return a|r|g|b;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a1b5g5r5 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 716 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  a,r,g,b;

    a = (CARD32) ((CARD8) (0 - ((pixel & 0x8000) >> 15))) << 24;
    b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
    g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
    r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
    return (a | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a1r1g1b1 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 904 of file fbcompose.c.

{
    CARD32  pixel = Fetch4(bits, offset);
    CARD32  a,r,g,b;

    a = ((pixel & 0x8) * 0xff) << 21;
    r = ((pixel & 0x4) * 0xff) << 14;
    g = ((pixel & 0x2) * 0xff) << 7;
    b = ((pixel & 0x1) * 0xff);
    return a|r|g|b;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a1r5g5b5 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 691 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  a,r,g,b;

    a = (CARD32) ((CARD8) (0 - ((pixel & 0x8000) >> 15))) << 24;
    r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
    g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
    b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
    return (a | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a2b2g2r2 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 844 of file fbcompose.c.

{
    CARD32   pixel = ((CARD8 *) bits)[offset];
    CARD32   a,r,g,b;

    a = ((pixel & 0xc0) * 0x55) << 18;
    b = ((pixel & 0x30) * 0x55) >> 6;
    g = ((pixel & 0x0c) * 0x55) << 6;
    r = ((pixel & 0x03) * 0x55) << 16;
    return a|r|g|b;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a2r2g2b2 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 831 of file fbcompose.c.

{
    CARD32   pixel = ((CARD8 *) bits)[offset];
    CARD32   a,r,g,b;

    a = ((pixel & 0xc0) * 0x55) << 18;
    r = ((pixel & 0x30) * 0x55) << 12;
    g = ((pixel & 0x0c) * 0x55) << 6;
    b = ((pixel & 0x03) * 0x55);
    return a|r|g|b;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a4 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 871 of file fbcompose.c.

{
    CARD32  pixel = Fetch4(bits, offset);

    pixel |= pixel << 4;
    return pixel << 24;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a4b4g4r4 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 766 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  a,r,g,b;

    a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
    b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
    g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
    r = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
    return (a | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a4r4g4b4 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 741 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  a,r,g,b;

    a = ((pixel & 0xf000) | ((pixel & 0xf000) >> 4)) << 16;
    r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
    g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
    b = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
    return (a | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a8 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 791 of file fbcompose.c.

{
    CARD32   pixel = ((CARD8 *) bits)[offset];

    return pixel << 24;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a8b8g8r8 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 611 of file fbcompose.c.

{
    CARD32  pixel = ((CARD32 *)bits)[offset];

    return ((pixel & 0xff000000) |
           ((pixel >> 16) & 0xff) |
           (pixel & 0x0000ff00) |
           ((pixel & 0xff) << 16));
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_a8r8g8b8 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 599 of file fbcompose.c.

{
    return ((CARD32 *)bits)[offset];
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_b1g2r1 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 892 of file fbcompose.c.

{
    CARD32  pixel = Fetch4(bits, offset);
    CARD32  r,g,b;

    b = ((pixel & 0x8) * 0xff) >> 3;
    g = ((pixel & 0x6) * 0x55) << 7;
    r = ((pixel & 0x1) * 0xff) << 16;
    return 0xff000000|r|g|b;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_b2g3r3 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 814 of file fbcompose.c.

{
    CARD32   pixel = ((CARD8 *) bits)[offset];
    CARD32  r,g,b;

    b = (((pixel & 0xc0)     ) |
        ((pixel & 0xc0) >> 2) |
        ((pixel & 0xc0) >> 4) |
        ((pixel & 0xc0) >> 6));
    g = ((pixel & 0x38) | ((pixel & 0x38) >> 3) | ((pixel & 0x30) << 2)) << 8;
    r = (((pixel & 0x07)     ) |
        ((pixel & 0x07) << 3) |
        ((pixel & 0x06) << 6)) << 16;
    return (0xff000000 | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_b5g6r5 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 679 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  r,g,b;

    b = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) >> 8;
    g = ((pixel & 0x07e0) | ((pixel & 0x0600) >> 6)) << 5;
    r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
    return (0xff000000 | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_b8g8r8 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 650 of file fbcompose.c.

{
    CARD8   *pixel = ((CARD8 *) bits) + (offset*3);
#if IMAGE_BYTE_ORDER == MSBFirst
    return (0xff000000 |
           (pixel[2] << 16) |
           (pixel[1] << 8) |
           (pixel[0]));
#else
    return (0xff000000 |
           (pixel[0] << 16) |
           (pixel[1] << 8) |
           (pixel[2]));
#endif
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_c4 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 930 of file fbcompose.c.

{
    CARD32  pixel = Fetch4(bits, offset);

    return indexed->rgba[pixel];
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_c8 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 857 of file fbcompose.c.

{
    CARD32   pixel = ((CARD8 *) bits)[offset];
    return indexed->rgba[pixel];
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_g1 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 956 of file fbcompose.c.

{
    CARD32 pixel = ((CARD32 *)bits)[offset >> 5];
    CARD32 a;
#if BITMAP_BIT_ORDER == MSBFirst
    a = pixel >> (0x1f - (offset & 0x1f));
#else
    a = pixel >> (offset & 0x1f);
#endif
    a = a & 1;
    return indexed->rgba[a];
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_r1g2b1 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 880 of file fbcompose.c.

{
    CARD32  pixel = Fetch4(bits, offset);
    CARD32  r,g,b;

    r = ((pixel & 0x8) * 0xff) << 13;
    g = ((pixel & 0x6) * 0x55) << 7;
    b = ((pixel & 0x1) * 0xff);
    return 0xff000000|r|g|b;
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_r3g3b2 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 799 of file fbcompose.c.

{
    CARD32   pixel = ((CARD8 *) bits)[offset];
    CARD32  r,g,b;

    r = ((pixel & 0xe0) | ((pixel & 0xe0) >> 3) | ((pixel & 0xc0) >> 6)) << 16;
    g = ((pixel & 0x1c) | ((pixel & 0x18) >> 3) | ((pixel & 0x1c) << 3)) << 8;
    b = (((pixel & 0x03)     ) |
        ((pixel & 0x03) << 2) |
        ((pixel & 0x03) << 4) |
        ((pixel & 0x03) << 6));
    return (0xff000000 | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_r5g6b5 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 667 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  r,g,b;

    r = ((pixel & 0xf800) | ((pixel & 0xe000) >> 5)) << 8;
    g = ((pixel & 0x07e0) | ((pixel & 0x0600) >> 6)) << 5;
    b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
    return (0xff000000 | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_r8g8b8 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 633 of file fbcompose.c.

{
    CARD8   *pixel = ((CARD8 *) bits) + (offset*3);
#if IMAGE_BYTE_ORDER == MSBFirst
    return (0xff000000 |
           (pixel[0] << 16) |
           (pixel[1] << 8) |
           (pixel[2]));
#else
    return (0xff000000 |
            (pixel[2] << 16) |
            (pixel[1] << 8) |
            (pixel[0]));
#endif
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_x1b5g5r5 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 729 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  r,g,b;

    b = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) >> 7;
    g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
    r = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) << 14;
    return (0xff000000 | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_x1r5g5b5 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 704 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  r,g,b;

    r = ((pixel & 0x7c00) | ((pixel & 0x7000) >> 5)) << 9;
    g = ((pixel & 0x03e0) | ((pixel & 0x0380) >> 5)) << 6;
    b = ((pixel & 0x001c) | ((pixel & 0x001f) << 5)) >> 2;
    return (0xff000000 | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_x4b4g4r4 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 779 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  r,g,b;

    b = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
    g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
    r = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
    return (0xff000000 | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_x4r4g4b4 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 754 of file fbcompose.c.

{
    CARD32  pixel = ((CARD16 *) bits)[offset];
    CARD32  r,g,b;

    r = ((pixel & 0x0f00) | ((pixel & 0x0f00) >> 4)) << 12;
    g = ((pixel & 0x00f0) | ((pixel & 0x00f0) >> 4)) << 8;
    b = ((pixel & 0x000f) | ((pixel & 0x000f) << 4));
    return (0xff000000 | r | g | b);
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_x8b8g8r8 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 622 of file fbcompose.c.

{
    CARD32  pixel = ((CARD32 *)bits)[offset];

    return ((0xff000000) |
           ((pixel >> 16) & 0xff) |
           (pixel & 0x0000ff00) |
           ((pixel & 0xff) << 16));
}

Here is the caller graph for this function:

static FASTCALL CARD32 fbFetchPixel_x8r8g8b8 ( const FbBits bits,
int  offset,
miIndexedPtr  indexed 
) [static]

Definition at line 605 of file fbcompose.c.

{
    return ((CARD32 *)bits)[offset] | 0xff000000;
}

Here is the caller graph for this function:

static void fbFetchSolid ( PicturePtr  pict,
int  x,
int  y,
int  width,
CARD32 buffer 
) [static]

Definition at line 2629 of file fbcompose.c.

{
    FbBits *bits;
    FbStride stride;
    int bpp;
    int xoff, yoff;
    CARD32 color;
    CARD32 *end;
    fetchPixelProc fetch = fetchPixelProcForPicture(pict);
#ifdef PIXMAN_INDEXED_FORMATS
    miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
#else
    miIndexedPtr indexed = NULL;
#endif

    fbGetDrawable (pict->pDrawable, bits, stride, bpp, xoff, yoff);
    bits += yoff*stride + (xoff*bpp >> FB_SHIFT);

    color = fetch(bits, 0, indexed);

    end = buffer + width;
    while (buffer < end)
        *buffer++ = color;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void fbFetchTransformed ( PicturePtr  pict,
int  x,
int  y,
int  width,
CARD32 buffer 
) [static]

Definition at line 2892 of file fbcompose.c.

{
    FbBits     *bits;
    FbStride    stride;
    int         bpp;
    int         xoff, yoff;
    fetchPixelProc   fetch;
    PictVector       v;
    PictVector  unit;
    int         i;
    BoxRec    box;
#ifdef PIXMAN_INDEXED_FORMATS
    miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
#else
    miIndexedPtr indexed = NULL;
#endif
    Bool projective = FALSE;

    fetch = fetchPixelProcForPicture(pict);

    fbGetDrawable(pict->pDrawable, bits, stride, bpp, xoff, yoff);
    x += xoff;
    y += yoff;

    v.vector[0] = IntToxFixed(x);
    v.vector[1] = IntToxFixed(y);
    v.vector[2] = xFixed1;

    /* when using convolution filters one might get here without a transform */
    if (pict->transform) {
        if (!PictureTransformPoint3d (pict->transform, &v))
            return;
        unit.vector[0] = pict->transform->matrix[0][0];
        unit.vector[1] = pict->transform->matrix[1][0];
        unit.vector[2] = pict->transform->matrix[2][0];
    } else {
        unit.vector[0] = xFixed1;
        unit.vector[1] = 0;
        unit.vector[2] = 0;
    }
    projective = (unit.vector[2] != 0);

    if (pict->filter == PIXMAN_FILTER_NEAREST || pict->filter == PIXMAN_FILTER_FAST)
    {
        if (pict->repeat == RepeatNormal) {
            if (PIXREGION_NUM_RECTS(pict->pCompositeClip) == 1) {
                box = pict->pCompositeClip->extents;
                for (i = 0; i < width; ++i) {
                    if (!v.vector[2]) {
                        buffer[i] = 0;
                    } else {
                        if (projective) {
                            y = MOD(DIV(v.vector[1],v.vector[2]), pict->pDrawable->height);
                            x = MOD(DIV(v.vector[0],v.vector[2]), pict->pDrawable->width);
                        } else {
                            y = MOD(v.vector[1]>>16, pict->pDrawable->height);
                            x = MOD(v.vector[0]>>16, pict->pDrawable->width);
                        }
                        buffer[i] = fetch(bits + (y + pict->pDrawable->y)*stride, x + pict->pDrawable->x, indexed);
                    }
                    v.vector[0] += unit.vector[0];
                    v.vector[1] += unit.vector[1];
                    v.vector[2] += unit.vector[2];
                }
            } else {
                for (i = 0; i < width; ++i) {
                    if (!v.vector[2]) {
                        buffer[i] = 0;
                    } else {
                        if (projective) {
                            y = MOD(DIV(v.vector[1],v.vector[2]), pict->pDrawable->height);
                            x = MOD(DIV(v.vector[0],v.vector[2]), pict->pDrawable->width);
                        } else {
                            y = MOD(v.vector[1]>>16, pict->pDrawable->height);
                            x = MOD(v.vector[0]>>16, pict->pDrawable->width);
                        }
                        if (pixman_region_contains_point (pict->pCompositeClip, x, y, &box))
                            buffer[i] = fetch(bits + (y + pict->pDrawable->y)*stride, x + pict->pDrawable->x, indexed);
                        else
                            buffer[i] = 0;
                    }
                    v.vector[0] += unit.vector[0];
                    v.vector[1] += unit.vector[1];
                    v.vector[2] += unit.vector[2];
                }
            }
        } else {
            if (PIXREGION_NUM_RECTS(pict->pCompositeClip) == 1) {
                box = pict->pCompositeClip->extents;
                for (i = 0; i < width; ++i) {
                    if (!v.vector[2]) {
                        buffer[i] = 0;
                    } else {
                        if (projective) {
                            y = DIV(v.vector[1],v.vector[2]);
                            x = DIV(v.vector[0],v.vector[2]);
                        } else {
                            y = v.vector[1]>>16;
                            x = v.vector[0]>>16;
                        }
                        buffer[i] = ((x < box.x1) | (x >= box.x2) | (y < box.y1) | (y >= box.y2)) ?
                                    0 : fetch(bits + (y + pict->pDrawable->y)*stride, x + pict->pDrawable->x, indexed);
                    }
                    v.vector[0] += unit.vector[0];
                    v.vector[1] += unit.vector[1];
                    v.vector[2] += unit.vector[2];
                }
            } else {
                for (i = 0; i < width; ++i) {
                    if (!v.vector[2]) {
                        buffer[i] = 0;
                    } else {
                        if (projective) {
                            y = DIV(v.vector[1],v.vector[2]);
                            x = DIV(v.vector[0],v.vector[2]);
                        } else {
                            y = v.vector[1]>>16;
                            x = v.vector[0]>>16;
                        }
                        if (pixman_region_contains_point (pict->pCompositeClip, x, y, &box))
                            buffer[i] = fetch(bits + (y + pict->pDrawable->y)*stride, x + pict->pDrawable->x, indexed);
                        else
                            buffer[i] = 0;
                    }
                    v.vector[0] += unit.vector[0];
                    v.vector[1] += unit.vector[1];
                    v.vector[2] += unit.vector[2];
                }
            }
        }
    } else if (pict->filter == PIXMAN_FILTER_BILINEAR || pict->filter == PIXMAN_FILTER_GOOD || pict->filter == PIXMAN_FILTER_BEST) {
        if (pict->repeat == RepeatNormal) {
            if (PIXREGION_NUM_RECTS(pict->pCompositeClip) == 1) {
                box = pict->pCompositeClip->extents;
                for (i = 0; i < width; ++i) {
                    if (!v.vector[2]) {
                        buffer[i] = 0;
                    } else {
                        int x1, x2, y1, y2, distx, idistx, disty, idisty;
                        FbBits *b;
                        CARD32 tl, tr, bl, br, r;
                        CARD32 ft, fb;

                        if (projective) {
                            xFixed_48_16 div;
                            div = ((xFixed_48_16)v.vector[0] << 16)/v.vector[2];
                            x1 = div >> 16;
                            distx = ((xFixed)div >> 8) & 0xff;
                            div = ((xFixed_48_16)v.vector[1] << 16)/v.vector[2];
                            y1 = div >> 16;
                            disty = ((xFixed)div >> 8) & 0xff;
                        } else {
                            x1 = v.vector[0] >> 16;
                            distx = (v.vector[0] >> 8) & 0xff;
                            y1 = v.vector[1] >> 16;
                            disty = (v.vector[1] >> 8) & 0xff;
                        }
                        x2 = x1 + 1;
                        y2 = y1 + 1;

                        idistx = 256 - distx;
                        idisty = 256 - disty;

                        x1 = MOD (x1, pict->pDrawable->width);
                        x2 = MOD (x2, pict->pDrawable->width);
                        y1 = MOD (y1, pict->pDrawable->height);
                        y2 = MOD (y2, pict->pDrawable->height);

                        b = bits + (y1 + pict->pDrawable->y)*stride;

                        tl = fetch(b, x1 + pict->pDrawable->x, indexed);
                        tr = fetch(b, x2 + pict->pDrawable->x, indexed);
                        b = bits + (y2 + pict->pDrawable->y)*stride;
                        bl = fetch(b, x1 + pict->pDrawable->x, indexed);
                        br = fetch(b, x2 + pict->pDrawable->x, indexed);

                        ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
                        fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
                        r = (((ft * idisty + fb * disty) >> 16) & 0xff);
                        ft = FbGet8(tl,8) * idistx + FbGet8(tr,8) * distx;
                        fb = FbGet8(bl,8) * idistx + FbGet8(br,8) * distx;
                        r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
                        ft = FbGet8(tl,16) * idistx + FbGet8(tr,16) * distx;
                        fb = FbGet8(bl,16) * idistx + FbGet8(br,16) * distx;
                        r |= (((ft * idisty + fb * disty)) & 0xff0000);
                        ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
                        fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
                        r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
                        buffer[i] = r;
                    }
                    v.vector[0] += unit.vector[0];
                    v.vector[1] += unit.vector[1];
                    v.vector[2] += unit.vector[2];
                }
            } else {
                for (i = 0; i < width; ++i) {
                    if (!v.vector[2]) {
                        buffer[i] = 0;
                    } else {
                        int x1, x2, y1, y2, distx, idistx, disty, idisty;
                        FbBits *b;
                        CARD32 tl, tr, bl, br, r;
                        CARD32 ft, fb;

                        if (projective) {
                            xFixed_48_16 div;
                            div = ((xFixed_48_16)v.vector[0] << 16)/v.vector[2];
                            x1 = div >> 16;
                            distx = ((xFixed)div >> 8) & 0xff;
                            div = ((xFixed_48_16)v.vector[1] << 16)/v.vector[2];
                            y1 = div >> 16;
                            disty = ((xFixed)div >> 8) & 0xff;
                        } else {
                            x1 = v.vector[0] >> 16;
                            distx = (v.vector[0] >> 8) & 0xff;
                            y1 = v.vector[1] >> 16;
                            disty = (v.vector[1] >> 8) & 0xff;
                        }
                        x2 = x1 + 1;
                        y2 = y1 + 1;

                        idistx = 256 - distx;
                        idisty = 256 - disty;

                        x1 = MOD (x1, pict->pDrawable->width);
                        x2 = MOD (x2, pict->pDrawable->width);
                        y1 = MOD (y1, pict->pDrawable->height);
                        y2 = MOD (y2, pict->pDrawable->height);

                        b = bits + (y1 + pict->pDrawable->y)*stride;

                        tl = pixman_region_contains_point(pict->pCompositeClip, x1, y1, &box)
                             ? fetch(b, x1 + pict->pDrawable->x, indexed) : 0;
                        tr = pixman_region_contains_point(pict->pCompositeClip, x2, y1, &box)
                             ? fetch(b, x2 + pict->pDrawable->x, indexed) : 0;
                        b = bits + (y2 + pict->pDrawable->y)*stride;
                        bl = pixman_region_contains_point(pict->pCompositeClip, x1, y2, &box)
                             ? fetch(b, x1 + pict->pDrawable->x, indexed) : 0;
                        br = pixman_region_contains_point(pict->pCompositeClip, x2, y2, &box)
                             ? fetch(b, x2 + pict->pDrawable->x, indexed) : 0;

                        ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
                        fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
                        r = (((ft * idisty + fb * disty) >> 16) & 0xff);
                        ft = FbGet8(tl,8) * idistx + FbGet8(tr,8) * distx;
                        fb = FbGet8(bl,8) * idistx + FbGet8(br,8) * distx;
                        r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
                        ft = FbGet8(tl,16) * idistx + FbGet8(tr,16) * distx;
                        fb = FbGet8(bl,16) * idistx + FbGet8(br,16) * distx;
                        r |= (((ft * idisty + fb * disty)) & 0xff0000);
                        ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
                        fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
                        r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
                        buffer[i] = r;
                    }
                    v.vector[0] += unit.vector[0];
                    v.vector[1] += unit.vector[1];
                    v.vector[2] += unit.vector[2];
                }
            }
        } else {
            if (PIXREGION_NUM_RECTS(pict->pCompositeClip) == 1) {
                box = pict->pCompositeClip->extents;
                for (i = 0; i < width; ++i) {
                    if (!v.vector[2]) {
                        buffer[i] = 0;
                    } else {
                        int x1, x2, y1, y2, distx, idistx, disty, idisty, x_off;
                        FbBits *b;
                        CARD32 tl, tr, bl, br, r;
                        Bool x1_out, x2_out, y1_out, y2_out;
                        CARD32 ft, fb;

                        if (projective) {
                            xFixed_48_16 div;
                            div = ((xFixed_48_16)v.vector[0] << 16)/v.vector[2];
                            x1 = div >> 16;
                            distx = ((xFixed)div >> 8) & 0xff;
                            div = ((xFixed_48_16)v.vector[1] << 16)/v.vector[2];
                            y1 = div >> 16;
                            disty = ((xFixed)div >> 8) & 0xff;
                        } else {
                            x1 = v.vector[0] >> 16;
                            distx = (v.vector[0] >> 8) & 0xff;
                            y1 = v.vector[1] >> 16;
                            disty = (v.vector[1] >> 8) & 0xff;
                        }
                        x2 = x1 + 1;
                        y2 = y1 + 1;

                        idistx = 256 - distx;
                        idisty = 256 - disty;

                        b = bits + (y1 + pict->pDrawable->y)*stride;
                        x_off = x1 + pict->pDrawable->x;

                        x1_out = (x1 < box.x1) | (x1 >= box.x2);
                        x2_out = (x2 < box.x1) | (x2 >= box.x2);
                        y1_out = (y1 < box.y1) | (y1 >= box.y2);
                        y2_out = (y2 < box.y1) | (y2 >= box.y2);

                        tl = x1_out|y1_out ? 0 : fetch(b, x_off, indexed);
                        tr = x2_out|y1_out ? 0 : fetch(b, x_off + 1, indexed);
                        b += stride;
                        bl = x1_out|y2_out ? 0 : fetch(b, x_off, indexed);
                        br = x2_out|y2_out ? 0 : fetch(b, x_off + 1, indexed);

                        ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
                        fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
                        r = (((ft * idisty + fb * disty) >> 16) & 0xff);
                        ft = FbGet8(tl,8) * idistx + FbGet8(tr,8) * distx;
                        fb = FbGet8(bl,8) * idistx + FbGet8(br,8) * distx;
                        r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
                        ft = FbGet8(tl,16) * idistx + FbGet8(tr,16) * distx;
                        fb = FbGet8(bl,16) * idistx + FbGet8(br,16) * distx;
                        r |= (((ft * idisty + fb * disty)) & 0xff0000);
                        ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
                        fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
                        r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
                        buffer[i] = r;
                    }
                    v.vector[0] += unit.vector[0];
                    v.vector[1] += unit.vector[1];
                    v.vector[2] += unit.vector[2];
                }
            } else {
                for (i = 0; i < width; ++i) {
                    if (!v.vector[2]) {
                        buffer[i] = 0;
                    } else {
                        int x1, x2, y1, y2, distx, idistx, disty, idisty, x_off;
                        FbBits *b;
                        CARD32 tl, tr, bl, br, r;
                        CARD32 ft, fb;

                        if (projective) {
                            xFixed_48_16 div;
                            div = ((xFixed_48_16)v.vector[0] << 16)/v.vector[2];
                            x1 = div >> 16;
                            distx = ((xFixed)div >> 8) & 0xff;
                            div = ((xFixed_48_16)v.vector[1] << 16)/v.vector[2];
                            y1 = div >> 16;
                            disty = ((xFixed)div >> 8) & 0xff;
                        } else {
                            x1 = v.vector[0] >> 16;
                            distx = (v.vector[0] >> 8) & 0xff;
                            y1 = v.vector[1] >> 16;
                            disty = (v.vector[1] >> 8) & 0xff;
                        }
                        x2 = x1 + 1;
                        y2 = y1 + 1;

                        idistx = 256 - distx;
                        idisty = 256 - disty;

                        b = bits + (y1 + pict->pDrawable->y)*stride;
                        x_off = x1 + pict->pDrawable->x;

                        tl = pixman_region_contains_point(pict->pCompositeClip, x1, y1, &box)
                             ? fetch(b, x_off, indexed) : 0;
                        tr = pixman_region_contains_point(pict->pCompositeClip, x2, y1, &box)
                             ? fetch(b, x_off + 1, indexed) : 0;
                        b += stride;
                        bl = pixman_region_contains_point(pict->pCompositeClip, x1, y2, &box)
                             ? fetch(b, x_off, indexed) : 0;
                        br = pixman_region_contains_point(pict->pCompositeClip, x2, y2, &box)
                             ? fetch(b, x_off + 1, indexed) : 0;

                        ft = FbGet8(tl,0) * idistx + FbGet8(tr,0) * distx;
                        fb = FbGet8(bl,0) * idistx + FbGet8(br,0) * distx;
                        r = (((ft * idisty + fb * disty) >> 16) & 0xff);
                        ft = FbGet8(tl,8) * idistx + FbGet8(tr,8) * distx;
                        fb = FbGet8(bl,8) * idistx + FbGet8(br,8) * distx;
                        r |= (((ft * idisty + fb * disty) >> 8) & 0xff00);
                        ft = FbGet8(tl,16) * idistx + FbGet8(tr,16) * distx;
                        fb = FbGet8(bl,16) * idistx + FbGet8(br,16) * distx;
                        r |= (((ft * idisty + fb * disty)) & 0xff0000);
                        ft = FbGet8(tl,24) * idistx + FbGet8(tr,24) * distx;
                        fb = FbGet8(bl,24) * idistx + FbGet8(br,24) * distx;
                        r |= (((ft * idisty + fb * disty) << 8) & 0xff000000);
                        buffer[i] = r;
                    }
                    v.vector[0] += unit.vector[0];
                    v.vector[1] += unit.vector[1];
                    v.vector[2] += unit.vector[2];
                }
            }
        }
#ifdef PIXMAN_CONVOLUTION
    } else if (pict->filter == PictFilterConvolution) {
        xFixed *params = pict->filter_params;
        INT32 cwidth = xFixedToInt(params[0]);
        INT32 cheight = xFixedToInt(params[1]);
        int xoff = params[0] >> 1;
        int yoff = params[1] >> 1;
        params += 2;
        for (i = 0; i < width; ++i) {
            if (!v.vector[2]) {
                buffer[i] = 0;
            } else {
                int x1, x2, y1, y2, x, y;
                INT32 srtot, sgtot, sbtot, satot;
                xFixed *p = params;

                if (projective) {
                    xFixed_48_16 tmp;
                    tmp = ((xFixed_48_16)v.vector[0] << 16)/v.vector[2] - xoff;
                    x1 = xFixedToInt(tmp);
                    tmp = ((xFixed_48_16)v.vector[1] << 16)/v.vector[2] - yoff;
                    y1 = xFixedToInt(tmp);
                } else {
                    x1 = xFixedToInt(v.vector[0] - xoff);
                    y1 = xFixedToInt(v.vector[1] - yoff);
                }
                x2 = x1 + cwidth;
                y2 = y1 + cheight;

                srtot = sgtot = sbtot = satot = 0;

                for (y = y1; y < y2; y++) {
                    int ty = (pict->repeat == RepeatNormal) ? MOD (y, pict->pDrawable->height) : y;
                    for (x = x1; x < x2; x++) {
                        if (*p) {
                            int tx = (pict->repeat == RepeatNormal) ? MOD (x, pict->pDrawable->width) : x;
                            if (pixman_region_contains_point (pict->pCompositeClip, tx, ty, &box)) {
                                FbBits *b = bits + (ty + pict->pDrawable->y)*stride;
                                CARD32 c = fetch(b, tx + pict->pDrawable->x, indexed);

                                srtot += Red(c) * *p;
                                sgtot += Green(c) * *p;
                                sbtot += Blue(c) * *p;
                                satot += Alpha(c) * *p;
                            }
                        }
                        p++;
                    }
                }

                if (satot < 0) satot = 0; else if (satot > 0xff) satot = 0xff;
                if (srtot < 0) srtot = 0; else if (srtot > 0xff) srtot = 0xff;
                if (sgtot < 0) sgtot = 0; else if (sgtot > 0xff) sgtot = 0xff;
                if (sbtot < 0) sbtot = 0; else if (sbtot > 0xff) sbtot = 0xff;

                buffer[i] = ((satot << 24) |
                             (srtot << 16) |
                             (sgtot <<  8) |
                             (sbtot       ));
            }
            v.vector[0] += unit.vector[0];
            v.vector[1] += unit.vector[1];
            v.vector[2] += unit.vector[2];
        }
#endif
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void fbStore ( PicturePtr  pict,
int  x,
int  y,
int  width,
CARD32 buffer 
) [static]

Definition at line 3377 of file fbcompose.c.

{
    FbBits *bits;
    FbStride stride;
    int bpp;
    int xoff, yoff;
    storeProc store = storeProcForPicture(pict);
#ifdef PIXMAN_INDEXED_FORMATS
    miIndexedPtr indexed = (miIndexedPtr) pict->pFormat->index.devPrivate;
#else
    miIndexedPtr indexed = NULL;
#endif

    fbGetDrawable (pict->pDrawable, bits, stride, bpp, xoff, yoff);
    x += xoff;
    y += yoff;

    bits += y*stride;
    store(bits, buffer, x, width, indexed);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL void fbStore_a1 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1380 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  *pixel = ((CARD32 *) bits) + ((i+x) >> 5);
        CARD32  mask = FbStipMask((i+x) & 0x1f, 1);

        CARD32 v = values[i] & 0x80000000 ? mask : 0;
        *pixel = (*pixel & ~mask) | v;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a1b1g1r1 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1353 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  pixel;
        Splita(values[i]);
        pixel = (((a >> 4) & 0x8) |
                 ((b >> 5) & 0x4) |
                 ((g >> 6) & 0x2) |
                 ((r >> 7)      ));
        Store4(bits, i + x, pixel);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a1b5g5r5 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1147 of file fbcompose.c.

{
    int i;
    CARD16  *pixel = ((CARD16 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Splita(values[i]);
        *pixel++ = (((a << 8) & 0x8000) |
                    ((b << 7) & 0x7c00) |
                    ((g << 2) & 0x03e0) |
                    ((r >> 3)         ));
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a1r1g1b1 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1338 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  pixel;
        Splita(values[i]);
        pixel = (((a >> 4) & 0x8) |
                 ((r >> 5) & 0x4) |
                 ((g >> 6) & 0x2) |
                 ((b >> 7)      ));
        Store4(bits, i + x, pixel);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a1r5g5b5 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1120 of file fbcompose.c.

{
    int i;
    CARD16  *pixel = ((CARD16 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Splita(values[i]);
        *pixel++ = (((a << 8) & 0x8000) |
                    ((r << 7) & 0x7c00) |
                    ((g << 2) & 0x03e0) |
                    ((b >> 3)         ));
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a2r2g2b2 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1264 of file fbcompose.c.

{
    int i;
    CARD8   *pixel = ((CARD8 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Splita(values[i]);
        *pixel++ = (((a     ) & 0xc0) |
                    ((r >> 2) & 0x30) |
                    ((g >> 4) & 0x0c) |
                    ((b >> 6)       ));
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a4 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1299 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        Store4(bits, i + x, values[i]>>28);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a4b4g4r4 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1201 of file fbcompose.c.

{
    int i;
    CARD16  *pixel = ((CARD16 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Splita(values[i]);
        *pixel++ = (((a << 8) & 0xf000) |
                    ((b << 4) & 0x0f00) |
                    ((g     ) & 0x00f0) |
                    ((r >> 4)         ));
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a4r4g4b4 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1174 of file fbcompose.c.

{
    int i;
    CARD16  *pixel = ((CARD16 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Splita(values[i]);
        *pixel++ = (((a << 8) & 0xf000) |
                    ((r << 4) & 0x0f00) |
                    ((g     ) & 0x00f0) |
                    ((b >> 4)         ));
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a8 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1228 of file fbcompose.c.

{
    int i;
    CARD8   *pixel = ((CARD8 *) bits) + x;
    for (i = 0; i < width; ++i) {
        *pixel++ = values[i] >> 24;
       }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a8b8g8r8 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1047 of file fbcompose.c.

{
    int i;
    CARD32 *pixel = (CARD32 *)bits + x;
    for (i = 0; i < width; ++i)
        *pixel++ = (values[i] & 0xff00ff00) | ((values[i] >> 16) & 0xff) | ((values[i] & 0xff) << 16);
}

Here is the caller graph for this function:

static FASTCALL void fbStore_a8r8g8b8 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1032 of file fbcompose.c.

{
    memcpy(((CARD32 *)bits) + x, values, width*sizeof(CARD32));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static FASTCALL void fbStore_b1g2r1 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1323 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  pixel;

        Split(values[i]);
        pixel = (((b >> 4) & 0x8) |
                 ((g >> 5) & 0x6) |
                 ((r >> 7)      ));
        Store4(bits, i + x, pixel);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_b2g3r3 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1251 of file fbcompose.c.

{
    int i;
    CARD8   *pixel = ((CARD8 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Split(values[i]);
        *pixel++ = (((b     ) & 0xe0) |
                    ((g >> 3) & 0x1c) |
                    ((r >> 6)       ));
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_b5g6r5 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1107 of file fbcompose.c.

{
    int i;
    CARD16  *pixel = ((CARD16 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Split(values[i]);
        *pixel++ = (((b << 8) & 0xf800) |
                    ((g << 3) & 0x07e0) |
                    ((r >> 3)         ));
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_b8g8r8 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1076 of file fbcompose.c.

{
    int i;
    CARD8 *pixel = ((CARD8 *) bits) + x;
    for (i = 0; i < width; ++i) {
#if IMAGE_BYTE_ORDER == MSBFirst
        *pixel++ = Blue(values[i]);
        *pixel++ = Green(values[i]);
        *pixel++ = Red(values[i]);
#else
        *pixel++ = Red(values[i]);
        *pixel++ = Green(values[i]);
        *pixel++ = Blue(values[i]);
#endif
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_c4 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1368 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  pixel;

        pixel = miIndexToEnt24(indexed, values[i]);
        Store4(bits, i + x, pixel);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_c8 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1278 of file fbcompose.c.

{
    int i;
    CARD8   *pixel = ((CARD8 *) bits) + x;
    for (i = 0; i < width; ++i) {
        *pixel++ = miIndexToEnt24(indexed,values[i]);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_g1 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1393 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  *pixel = ((CARD32 *) bits) + ((i+x) >> 5);
        CARD32  mask = FbStipMask((i+x) & 0x1f, 1);

        CARD32 v = miIndexToEntY24(indexed,values[i]) ? mask : 0;
        *pixel = (*pixel & ~mask) | v;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_r1g2b1 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1308 of file fbcompose.c.

{
    int i;
    for (i = 0; i < width; ++i) {
        CARD32  pixel;

        Split(values[i]);
        pixel = (((r >> 4) & 0x8) |
                 ((g >> 5) & 0x6) |
                 ((b >> 7)      ));
        Store4(bits, i + x, pixel);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_r3g3b2 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1238 of file fbcompose.c.

{
    int i;
    CARD8   *pixel = ((CARD8 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Split(values[i]);
        *pixel++ = (((r     ) & 0xe0) |
                    ((g >> 3) & 0x1c) |
                    ((b >> 6)       ));
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_r5g6b5 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1094 of file fbcompose.c.

{
    int i;
    CARD16 *pixel = ((CARD16 *) bits) + x;
    for (i = 0; i < width; ++i) {
        CARD32 s = values[i];
        *pixel++ = ((s >> 3) & 0x001f) |
                   ((s >> 5) & 0x07e0) |
                   ((s >> 8) & 0xf800);
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_r8g8b8 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1065 of file fbcompose.c.

{
    int i;
    CARD8 *pixel = ((CARD8 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Store24(pixel, values[i]);
        pixel += 3;
    }
}

Here is the caller graph for this function:

static FASTCALL void fbStore_x1b5g5r5 ( FbBits bits,
const CARD32 values,
int  x,
int  width,
miIndexedPtr  indexed 
) [static]

Definition at line 1161 of file fbcompose.c.

{
    int i;
    CARD16  *pixel = ((CARD16 *) bits) + x;
    for (i = 0; i < width; ++i) {
        Split(values[i]);
        *pixel++ = (((b << 7) & 0x7c00) |
                    ((g << 2) & 0x03e0) |
                    ((r >> 3)         ));
    }
}

Here is the caller graph