/* * Copyright © 2004 David Reveman * * Permission to use, copy, modify, distribute, and sell this software * and its documentation for any purpose is hereby granted without * fee, provided that the above copyright notice appear in all copies * and that both that copyright notice and this permission notice * appear in supporting documentation, and that the name of * David Reveman not be used in advertising or publicity pertaining to * distribution of the software without specific, written prior permission. * David Reveman makes no representations about the suitability of this * software for any purpose. It is provided "as is" without express or * implied warranty. * * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * Author: David Reveman */ #ifndef _XGL_H_ #define _XGL_H_ #include #include #define NEED_EVENTS #include #include #include #include "scrnintstr.h" #include "pixmapstr.h" #include "windowstr.h" #include "servermd.h" #include "mi.h" #include "dix.h" #include "damage.h" #include "gc.h" #include "micmap.h" /* I'd like gc.h to provide this */ typedef struct _GCFuncs *GCFuncsPtr; #ifdef RENDER #include "mipict.h" #else #ifdef XV #undef XV /* Xv implementation require RENDER */ #endif #endif #ifdef XV #define XGL_XV_FORMAT_YUY2 0 #define XGL_XV_FORMAT_YV12 1 #define XGL_XV_FORMAT_RGB 2 #define XGL_XV_FORMAT_NUM 3 #endif /* For the modules. We should decide what the actual version numbering should * be. */ #define VERSION "0.0.1" extern WindowPtr *WindowTable; #define XGL_DEFAULT_PBO_MASK 0 typedef struct _xglSizeConstraint { int minWidth; int minHeight; int aboveWidth; int aboveHeight; } xglSizeConstraintRec, *xglSizeConstraintPtr; typedef struct _xglAccelInfo { Bool enabled; Bool pbuffer; xglSizeConstraintRec size; } xglAccelInfoRec, *xglAccelInfoPtr; typedef struct _xglScreenAccelInfo { xglAccelInfoRec pixmap; xglAccelInfoRec window; xglAccelInfoRec glx; xglAccelInfoRec xv; } xglScreenAccelInfoRec, *xglScreenAccelInfoPtr; typedef struct _xglScreenInfo { glitz_drawable_t *drawable; unsigned int depth; unsigned int width; unsigned int height; unsigned int widthMm; unsigned int heightMm; int geometryDataType; int geometryUsage; Bool yInverted; int pboMask; Bool lines; xglScreenAccelInfoRec accel; } xglScreenInfoRec, *xglScreenInfoPtr; extern xglScreenInfoRec xglScreenInfo; typedef struct _xglPixelFormat { CARD8 depth, bitsPerRGB; glitz_pixel_masks_t masks; } xglPixelFormatRec, *xglPixelFormatPtr; typedef struct _xglVisual { struct _xglVisual *next; VisualID vid; xglPixelFormatPtr pPixel; Bool pbuffer; struct { glitz_drawable_format_t *drawable; glitz_format_t *surface; } format; } xglVisualRec, *xglVisualPtr; extern xglVisualPtr xglVisuals; #define xglAreaAvailable 0 #define xglAreaDivided 1 #define xglAreaOccupied 2 typedef struct _xglRootArea *xglRootAreaPtr; typedef struct _xglArea { int state; int level; int x, y; int width, height; struct _xglArea *pArea[4]; xglRootAreaPtr pRoot; pointer closure; DevUnion devPrivate; } xglAreaRec, *xglAreaPtr; typedef struct _xglAreaFuncs { Bool (*Create) (xglAreaPtr pArea); Bool (*MoveIn) (xglAreaPtr pArea, pointer closure); void (*MoveOut) (xglAreaPtr pArea, pointer closure); int (*CompareScore) (xglAreaPtr pArea, pointer closure1, pointer closure2); } xglAreaFuncsRec, *xglAreaFuncsPtr; typedef struct _xglRootArea { int maxLevel; int width, height; xglAreaPtr pArea; xglAreaFuncsPtr funcs; int devPrivateSize; pointer closure; } xglRootAreaRec; typedef struct xglGeometry { glitz_buffer_t *buffer; pointer *data; Bool broken; glitz_fixed16_16_t xOff, yOff; int dataType; int usage; int size, endOffset; glitz_geometry_type_t type; glitz_geometry_format_t f; int first, width, count; glitz_multi_array_t *array; } xglGeometryRec, *xglGeometryPtr; #ifdef RENDER typedef struct _xglFBox { glitz_float_t x1, y1, x2, y2; } xglFBoxRec; typedef union _xglBox { BoxRec sBox; xglFBoxRec fBox; } xglBoxRec, *xglBoxPtr; typedef struct _xglRange { int first; unsigned int count; } xglRangeRec, *xglRangePtr; typedef struct _xglGlyphTexture { PicturePtr pMask; glitz_pixel_format_t pixel; glitz_geometry_format_t format; int geometryDataType; } xglGlyphTextureRec, *xglGlyphTexturePtr; typedef struct _xglGlyphArea { unsigned long serial; union { xglBoxRec box; xglRangeRec range; } u; } xglGlyphAreaRec, *xglGlyphAreaPtr; typedef struct _xglGlyphCache { ScreenPtr pScreen; int depth; xglRootAreaRec rootArea; union { xglGlyphTextureRec texture; xglGeometryRec geometry; } u; } xglGlyphCacheRec, *xglGlyphCachePtr; typedef struct _xglGlyph { xglAreaPtr pArea; } xglGlyphRec, *xglGlyphPtr; extern int xglGlyphPrivateIndex; #define XGL_GET_GLYPH_PRIV(pScreen, pGlyph) ((xglGlyphPtr) \ (GetGlyphPrivatesForScreen (pGlyph, pScreen))[xglGlyphPrivateIndex].ptr) #define XGL_GLYPH_PRIV(pScreen, pGlyph) \ xglGlyphPtr pGlyphPriv = XGL_GET_GLYPH_PRIV (pScreen, pGlyph) #endif typedef struct _xglScreen { xglVisualPtr pVisual; #ifdef GLXEXT xglVisualPtr pGlxVisual; #endif #ifdef XV xglVisualRec pXvVisual[XGL_XV_FORMAT_NUM]; #endif xglVisualPtr rootVisual; glitz_drawable_t *drawable; glitz_surface_t *surface; PixmapPtr pScreenPixmap; unsigned long features; int geometryUsage; int geometryDataType; Bool yInverted; int pboMask; Bool lines; xglGeometryRec scratchGeometry; xglScreenAccelInfoRec accel; #ifdef RENDER xglGlyphCacheRec glyphCache[33]; PicturePtr pSolidAlpha; struct _trapInfo { PicturePtr pMask; glitz_geometry_format_t format; } trapInfo; #endif GetImageProcPtr GetImage; GetSpansProcPtr GetSpans; CreateWindowProcPtr CreateWindow; DestroyWindowProcPtr DestroyWindow; ChangeWindowAttributesProcPtr ChangeWindowAttributes; CopyWindowProcPtr CopyWindow; CreateGCProcPtr CreateGC; CloseScreenProcPtr CloseScreen; SetWindowPixmapProcPtr SetWindowPixmap; BitmapToRegionProcPtr BitmapToRegion; #ifdef RENDER CompositeProcPtr Composite; GlyphsProcPtr Glyphs; TrapezoidsProcPtr Trapezoids; AddTrapsProcPtr AddTraps; AddTrianglesProcPtr AddTriangles; ChangePictureProcPtr ChangePicture; ChangePictureTransformProcPtr ChangePictureTransform; ChangePictureFilterProcPtr ChangePictureFilter; RealizeGlyphProcPtr RealizeGlyph; UnrealizeGlyphProcPtr UnrealizeGlyph; #endif } xglScreenRec, *xglScreenPtr; extern int xglScreenPrivateIndex; #define XGL_GET_SCREEN_PRIV(pScreen) \ ((xglScreenPtr) (pScreen)->devPrivates[xglScreenPrivateIndex].ptr) #define XGL_SET_SCREEN_PRIV(pScreen, v) \ ((pScreen)->devPrivates[xglScreenPrivateIndex].ptr = (pointer) v) #define XGL_SCREEN_PRIV(pScreen) \ xglScreenPtr pScreenPriv = XGL_GET_SCREEN_PRIV (pScreen) #define XGL_SCREEN_WRAP(field, wrapper) \ pScreenPriv->field = pScreen->field; \ pScreen->field = wrapper #define XGL_SCREEN_UNWRAP(field) \ pScreen->field = pScreenPriv->field #ifdef RENDER #define XGL_PICTURE_SCREEN_WRAP(field, wrapper) \ pScreenPriv->field = pPictureScreen->field; \ pPictureScreen->field = wrapper #define XGL_PICTURE_SCREEN_UNWRAP(field) \ pPictureScreen->field = pScreenPriv->field #endif #define xglGCSoftwareDrawableFlag (1L << 0) #define xglGCBadFunctionFlag (1L << 1) #define xglGCPlaneMaskFlag (1L << 2) typedef struct _xglGC { glitz_surface_t *fg; glitz_surface_t *bg; glitz_format_id_t id; glitz_operator_t op; unsigned long flags; GCFuncsPtr funcs; GCOpsPtr ops; } xglGCRec, *xglGCPtr; extern int xglGCPrivateIndex; #define XGL_GET_GC_PRIV(pGC) \ ((xglGCPtr) (pGC)->devPrivates[xglGCPrivateIndex].ptr) #define XGL_GC_PRIV(pGC) \ xglGCPtr pGCPriv = XGL_GET_GC_PRIV (pGC) #define XGL_GC_WRAP(field, wrapper) \ pGCPriv->field = pGC->field; \ pGC->field = wrapper #define XGL_GC_UNWRAP(field) \ pGC->field = pGCPriv->field #define xglPCFillMask (1L << 0) #define xglPCFilterMask (1L << 1) #define xglPCTransformMask (1L << 2) #define xglPCComponentAlphaMask (1L << 3) #define xglPCDitherMask (1L << 4) #define xglPFFilterMask (1L << 8) #define xglPixmapTargetNo 0 #define xglPixmapTargetOut 1 #define xglPixmapTargetIn 2 #ifdef XV typedef struct _xglXvPort { PixmapPtr pPixmap; PicturePtr pSrc; PicturePtr pDst; } xglXvPortRec, *xglXvPortPtr; #endif typedef struct _xglPixmap { xglVisualPtr pVisual; glitz_surface_t *surface; glitz_drawable_t *drawable; glitz_buffer_t *buffer; int target; Bool acceleratedTile; pointer bits; int stride; DamagePtr pDamage; BoxRec damageBox; RegionRec bitRegion; Bool allBits; unsigned long pictureMask; xglGeometryPtr pGeometry; #ifdef XV xglXvPortPtr pPortPriv; #endif } xglPixmapRec, *xglPixmapPtr; extern int xglPixmapPrivateIndex; #define XGL_GET_PIXMAP_PRIV(pPixmap) \ ((xglPixmapPtr) (pPixmap)->devPrivates[xglPixmapPrivateIndex].ptr) #define XGL_PIXMAP_PRIV(pPixmap) \ xglPixmapPtr pPixmapPriv = XGL_GET_PIXMAP_PRIV (pPixmap) #define XGL_PICTURE_CHANGES(pictureMask) (pictureMask & 0x0000ffff) #define XGL_PICTURE_FAILURES(pictureMask) (pictureMask & 0xffff0000) typedef struct _xglWin { PixmapPtr pPixmap; } xglWinRec, *xglWinPtr; extern int xglWinPrivateIndex; #define XGL_GET_WINDOW_PRIV(pWin) \ ((xglWinPtr) (pWin)->devPrivates[xglWinPrivateIndex].ptr) #define XGL_WINDOW_PRIV(pWin) \ xglWinPtr pWinPriv = XGL_GET_WINDOW_PRIV (pWin) #define XGL_GET_WINDOW_PIXMAP(pWin) \ (XGL_GET_WINDOW_PRIV((WindowPtr) (pWin))->pPixmap) #define XGL_GET_DRAWABLE_PIXMAP(pDrawable) \ (((pDrawable)->type == DRAWABLE_WINDOW)? \ XGL_GET_WINDOW_PIXMAP (pDrawable): \ (PixmapPtr) (pDrawable)) #define XGL_DRAWABLE_PIXMAP(pDrawable) \ PixmapPtr pPixmap = XGL_GET_DRAWABLE_PIXMAP (pDrawable) #define XGL_GET_DRAWABLE_PIXMAP_PRIV(pDrawable) \ XGL_GET_PIXMAP_PRIV (XGL_GET_DRAWABLE_PIXMAP (pDrawable)) #define XGL_DRAWABLE_PIXMAP_PRIV(pDrawable) \ xglPixmapPtr pPixmapPriv = XGL_GET_DRAWABLE_PIXMAP_PRIV (pDrawable) #ifdef COMPOSITE #define __XGL_OFF_X_WIN(pPix) (-(pPix)->screen_x) #define __XGL_OFF_Y_WIN(pPix) (-(pPix)->screen_y) #else #define __XGL_OFF_X_WIN(pPix) (0) #define __XGL_OFF_Y_WIN(pPix) (0) #endif #define XGL_GET_DRAWABLE(pDrawable, pSurface, xOff, yOff) \ { \ PixmapPtr _pPix; \ if ((pDrawable)->type != DRAWABLE_PIXMAP) { \ _pPix = XGL_GET_WINDOW_PIXMAP (pDrawable); \ (xOff) = __XGL_OFF_X_WIN (_pPix); \ (yOff) = __XGL_OFF_Y_WIN (_pPix); \ } else { \ _pPix = (PixmapPtr) (pDrawable); \ (yOff) = (xOff) = 0; \ } \ (pSurface) = XGL_GET_PIXMAP_PRIV (_pPix)->surface; \ } #define XGL_DEFAULT_DPI 96 #define XGL_SW_FAILURE_STRING "software fall-back failure" #define MIN(a,b) ((a) < (b) ? (a) : (b)) #define MAX(a,b) ((a) > (b) ? (a) : (b)) #define POWER_OF_TWO(v) ((v & (v - 1)) == 0) #define MOD(a,b) ((a) < 0 ? ((b) - ((-(a) - 1) % (b))) - 1 : (a) % (b)) #define FIXED_TO_FLOAT(f) (((glitz_float_t) (f)) / 65536) #define FLOAT_TO_FIXED(f) ((int) ((f) * 65536)) #define BOX_NOTEMPTY(pBox) \ (((pBox)->x2 - (pBox)->x1) > 0 && \ ((pBox)->y2 - (pBox)->y1) > 0) /* xglinput.c */ int xglMouseProc (DeviceIntPtr pDevice, int onoff); int xglKeybdProc (DeviceIntPtr pDevice, int onoff); void xglBell (int volume, DeviceIntPtr pDev, pointer ctrl, int something); void xglKbdCtrl (DeviceIntPtr pDevice, KeybdCtrl *ctrl); void xglInitInput (int argc, char **argv); /* xgloutput.c */ void xglSetPixmapFormats (ScreenInfo *pScreenInfo); void xglSetRootClip (ScreenPtr pScreen, Bool enable); /* xglcmap.c */ void xglSetVisualTypes (int depth, int visuals, int redSize, int greenSize, int blueSize); Bool xglHasVisualTypes (xglVisualPtr pVisual, int depth); glitz_format_t * xglFindBestSurfaceFormat (ScreenPtr pScreen, xglPixelFormatPtr pPixel); void xglInitVisuals (ScreenPtr pScreen); xglVisualPtr xglFindVisualWithDepth (ScreenPtr pScreen, int depth); xglVisualPtr xglFindVisualWithId (ScreenPtr pScreen, int vid); void xglClearVisualTypes (void); /* xglparse.c */ char * xglParseFindNext (char *cur, char *delim, char *save, char *last); void xglParseScreen (char *arg); void xglUseMsg (void); int xglProcessArgument (int argc, char **argv, int i); /* xglscreen.c */ Bool xglScreenInit (ScreenPtr pScreen); Bool xglFinishScreenInit (ScreenPtr pScreen); Bool xglCloseScreen (int index, ScreenPtr pScreen); void xglCreateSolidAlphaPicture (ScreenPtr pScreen); /* xglarea.c */ Bool xglRootAreaInit (xglRootAreaPtr pRoot, int maxLevel, int width, int height, int devPrivateSize, xglAreaFuncsPtr funcs, pointer closure); void xglRootAreaFini (xglRootAreaPtr pRoot); void xglLeaveArea (xglAreaPtr pArea); void xglWithdrawArea (xglAreaPtr pArea); Bool xglFindArea (xglAreaPtr pArea, int width, int height, Bool kickOut, pointer closure); /* xglgeometry.c */ #define GEOMETRY_DATA_TYPE_SHORT 0 #define GEOMETRY_DATA_TYPE_FLOAT 1 typedef struct _xglDataTypeInfo { glitz_data_type_t type; int size; } xglDataTypeInfoRec, *xglDataTypeInfoPtr; extern xglDataTypeInfoRec xglGeometryDataTypes[2]; #define DEFAULT_GEOMETRY_DATA_TYPE GEOMETRY_DATA_TYPE_FLOAT #define GEOMETRY_USAGE_STREAM 0 #define GEOMETRY_USAGE_STATIC 1 #define GEOMETRY_USAGE_DYNAMIC 2 #define GEOMETRY_USAGE_SYSMEM 3 #define DEFAULT_GEOMETRY_USAGE GEOMETRY_USAGE_SYSMEM #define GEOMETRY_INIT(pScreen, pGeometry, _type, _usage, _size) \ { \ (pGeometry)->type = _type; \ (pGeometry)->usage = _usage; \ (pGeometry)->dataType = DEFAULT_GEOMETRY_DATA_TYPE; \ (pGeometry)->usage = _usage; \ (pGeometry)->size = 0; \ (pGeometry)->endOffset = 0; \ (pGeometry)->data = (pointer) 0; \ (pGeometry)->buffer = NULL; \ (pGeometry)->broken = FALSE; \ (pGeometry)->xOff = 0; \ (pGeometry)->yOff = 0; \ (pGeometry)->array = NULL; \ (pGeometry)->first = 0; \ (pGeometry)->count = 0; \ if (_type == GLITZ_GEOMETRY_TYPE_VERTEX) \ { \ (pGeometry)->width = 2; \ (pGeometry)->f.vertex.type = \ xglGeometryDataTypes[(pGeometry)->dataType].type; \ (pGeometry)->f.vertex.bytes_per_vertex = (pGeometry)->width * \ xglGeometryDataTypes[(pGeometry)->dataType].size; \ (pGeometry)->f.vertex.primitive = GLITZ_PRIMITIVE_QUADS; \ (pGeometry)->f.vertex.attributes = 0; \ (pGeometry)->f.vertex.src.type = GLITZ_DATA_TYPE_FLOAT; \ (pGeometry)->f.vertex.src.size = GLITZ_COORDINATE_SIZE_X; \ (pGeometry)->f.vertex.src.offset = 0; \ (pGeometry)->f.vertex.mask.type = GLITZ_DATA_TYPE_FLOAT; \ (pGeometry)->f.vertex.mask.size = GLITZ_COORDINATE_SIZE_X; \ (pGeometry)->f.vertex.mask.offset = 0; \ } \ else \ { \ (pGeometry)->width = 0; \ (pGeometry)->f.bitmap.scanline_order = \ GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN; \ (pGeometry)->f.bitmap.bytes_per_line = 0; \ (pGeometry)->f.bitmap.pad = GLYPHPADBYTES; \ } \ if (_size) \ xglGeometryResize (pScreen, pGeometry, _size); \ } #define GEOMETRY_UNINIT(pGeometry) \ { \ if ((pGeometry)->array) \ glitz_multi_array_destroy ((pGeometry)->array); \ if ((pGeometry)->buffer) \ glitz_buffer_destroy ((pGeometry)->buffer); \ if ((pGeometry)->data) \ xfree ((pGeometry)->data); \ } #define GEOMETRY_SET_BUFFER(pGeometry, _buffer) \ { \ glitz_buffer_reference (_buffer); \ if ((pGeometry)->buffer) \ glitz_buffer_destroy ((pGeometry)->buffer); \ (pGeometry)->buffer = _buffer; \ } #define GEOMETRY_SET_MULTI_ARRAY(pGeometry, _array) \ { \ glitz_multi_array_reference (_array); \ if ((pGeometry)->array) \ glitz_multi_array_destroy ((pGeometry)->array); \ (pGeometry)->array = _array; \ } #define GEOMETRY_RESIZE(pScreen, pGeometry, size) \ xglGeometryResize (pScreen, pGeometry, size) #define GEOMETRY_SET_TRANSLATE(pGeometry, _x, _y) \ { \ (pGeometry)->xOff = (_x) << 16; \ (pGeometry)->yOff = (_y) << 16; \ } #define GEOMETRY_TRANSLATE(pGeometry, tx, ty) \ { \ (pGeometry)->xOff += (tx) << 16; \ (pGeometry)->yOff += (ty) << 16; \ } #define GEOMETRY_TRANSLATE_FIXED(pGeometry, ftx, fty) \ { \ (pGeometry)->xOff += (ftx); \ (pGeometry)->yOff += (fty); \ } #define GEOMETRY_SET_VERTEX_PRIMITIVE(pGeometry, _primitive) \ (pGeometry)->f.vertex.primitive = _primitive #define GEOMETRY_SET_VERTEX_DATA_TYPE(pGeometry, _type) \ { \ (pGeometry)->dataType = _type; \ (pGeometry)->f.vertex.type = xglGeometryDataTypes[_type].type; \ (pGeometry)->f.vertex.bytes_per_vertex = (pGeometry)->width * \ xglGeometryDataTypes[_type].size; \ } #define GEOMETRY_ADD_BOX(pScreen, pGeometry, pBox, nBox) \ xglGeometryAddBox (pScreen, pGeometry, pBox, nBox, \ (pGeometry)->endOffset) #define GEOMETRY_ADD_REGION_AT(pScreen, pGeometry, pRegion, offset) \ xglGeometryAddBox (pScreen, pGeometry, \ REGION_RECTS (pRegion), \ REGION_NUM_RECTS (pRegion), \ offset) #define GEOMETRY_ADD_REGION(pScreen, pGeometry, pRegion) \ xglGeometryAddBox (pScreen, pGeometry, \ REGION_RECTS (pRegion), \ REGION_NUM_RECTS (pRegion), \ (pGeometry)->endOffset) #define GEOMETRY_ADD_SPAN(pScreen, pGeometry, ppt, pwidth, n) \ xglGeometryAddSpan (pScreen, pGeometry, ppt, pwidth, n, \ (pGeometry)->endOffset) #define GEOMETRY_ADD_LINE(pScreen, pGeometry, loop, mode, npt, ppt) \ xglGeometryAddLine (pScreen, pGeometry, loop, mode, npt, ppt, \ (pGeometry)->endOffset) #define GEOMETRY_ADD_SEGMENT(pScreen, pGeometry, nsegInit, pSegInit) \ xglGeometryAddSegment (pScreen, pGeometry, nsegInit, pSegInit, \ (pGeometry)->endOffset) #define GEOMETRY_FOR_GLYPH(pScreen, pGeometry, nGlyph, ppciInit, pglyphBase) \ xglGeometryForGlyph (pScreen, pGeometry, nGlyph, ppciInit, pglyphBase); #define GEOMETRY_ADD_TRAPEZOID(pScreen, pGeometry, pTrap, nTrap) \ xglGeometryAddTrapezoid (pScreen, pGeometry, pTrap, nTrap, \ (pGeometry)->endOffset) #define GEOMETRY_ADD_TRAP(pScreen, pGeometry, pTrap, nTrap) \ xglGeometryAddTrap (pScreen, pGeometry, pTrap, nTrap, \ (pGeometry)->endOffset) #define GEOMETRY_GET_FORMAT(pGeometry, format) \ xglGeometryGetFormat (pGeometry, format) #define GEOMETRY_ENABLE(pGeometry, surface) \ xglSetGeometry (pGeometry, surface) #define GEOMETRY_DISABLE(surface) \ glitz_set_geometry (surface, GLITZ_GEOMETRY_TYPE_NONE, NULL, NULL) void xglGeometryResize (ScreenPtr pScreen, xglGeometryPtr pGeometry, int size); void xglGeometryAddBox (ScreenPtr pScreen, xglGeometryPtr pGeometry, BoxPtr pBox, int nBox, int offset); void xglGeometryAddSpan (ScreenPtr pScreen, xglGeometryPtr pGeometry, DDXPointPtr ppt, int *pwidth, int n, int offset); void xglGeometryAddLine (ScreenPtr pScreen, xglGeometryPtr pGeometry, int loop, int mode, int npt, DDXPointPtr ppt, int offset); void xglGeometryAddSegment (ScreenPtr pScreen, xglGeometryPtr pGeometry, int nsegInit, xSegment *pSegInit, int offset); void xglGeometryForGlyph (ScreenPtr pScreen, xglGeometryPtr pGeometry, unsigned int nGlyph, CharInfoPtr *ppciInit, pointer pglyphBase); void xglGeometryAddTrapezoid (ScreenPtr pScreen, xglGeometryPtr pGeometry, xTrapezoid *pTrap, int nTrap, int offset); void xglGeometryAddTrap (ScreenPtr pScreen, xglGeometryPtr pGeometry, xTrap *pTrap, int nTrap, int offset); xglGeometryPtr xglGetScratchGeometryWithSize (ScreenPtr pScreen, int size); xglGeometryPtr xglGetScratchVertexGeometryWithType (ScreenPtr pScreen, int type, int count); xglGeometryPtr xglGetScratchVertexGeometry (ScreenPtr pScreen, int count); Bool xglSetGeometry (xglGeometryPtr pGeometry, glitz_surface_t *surface); /* xglpixmap.c */ #define XGL_PIXMAP_USAGE_HINT_STREAM_DRAW 1 #define XGL_PIXMAP_USAGE_HINT_STREAM_READ 2 #define XGL_PIXMAP_USAGE_HINT_STREAM_COPY 3 #define XGL_PIXMAP_USAGE_HINT_STATIC_DRAW 4 #define XGL_PIXMAP_USAGE_HINT_STATIC_READ 5 #define XGL_PIXMAP_USAGE_HINT_STATIC_COPY 6 #define XGL_PIXMAP_USAGE_HINT_DYNAMIC_DRAW 7 #define XGL_PIXMAP_USAGE_HINT_DYNAMIC_READ 8 #define XGL_PIXMAP_USAGE_HINT_DYNAMIC_COPY 9 #define XGL_PIXMAP_USAGE_HINT_DEFAULT XGL_PIXMAP_USAGE_HINT_STREAM_DRAW PixmapPtr xglCreatePixmap (ScreenPtr pScreen, int width, int height, int depth, unsigned usage_hint); void xglFiniPixmap (PixmapPtr pPixmap); Bool xglDestroyPixmap (PixmapPtr pPixmap); Bool xglModifyPixmapHeader (PixmapPtr pPixmap, int width, int height, int depth, int bitsPerPixel, int devKind, pointer pPixData); void xglSetPixmapVisual (PixmapPtr pPixmap, xglVisualPtr pVisual); RegionPtr xglPixmapToRegion (PixmapPtr pPixmap); xglGeometryPtr xglPixmapToGeometry (PixmapPtr pPixmap, int xOff, int yOff); Bool xglCreatePixmapSurface (PixmapPtr pPixmap); Bool xglAllocatePixmapBits (PixmapPtr pPixmap, int hint); Bool xglMapPixmapBits (PixmapPtr pPixmap); Bool xglUnmapPixmapBits (PixmapPtr pPixmap); Bool xglCheckPixmapSize (PixmapPtr pPixmap, xglSizeConstraintPtr pSize); void xglEnablePixmapAccel (PixmapPtr pPixmap, xglAccelInfoPtr pAccel); /* xglsync.c */ Bool xglSyncBits (DrawablePtr pDrawable, BoxPtr pExtents); void xglSyncDamageBoxBits (DrawablePtr pDrawable); Bool xglSyncSurface (DrawablePtr pDrawable); Bool xglPrepareTarget (DrawablePtr pDrawable); void xglAddSurfaceDamage (DrawablePtr pDrawable, RegionPtr pRegion); void xglAddCurrentSurfaceDamage (DrawablePtr pDrawable); void xglAddBitDamage (DrawablePtr pDrawable, RegionPtr pRegion); void xglAddCurrentBitDamage (DrawablePtr pDrawable); /* xglsolid.c */ Bool xglSolid (DrawablePtr pDrawable, glitz_operator_t op, glitz_surface_t *solid, xglGeometryPtr pGeometry, int x, int y, int width, int height, BoxPtr pBox, int nBox); Bool xglSolidGlyph (DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nGlyph, CharInfoPtr *ppci, pointer pglyphBase); /* xgltile.c */ xglGeometryPtr xglTiledBoxGeometry (PixmapPtr pTile, int tileX, int tileY, BoxPtr pBox, int nBox); Bool xglTile (DrawablePtr pDrawable, glitz_operator_t op, PixmapPtr pTile, int tileX, int tileY, xglGeometryPtr pGeometry, int x, int y, int width, int height, BoxPtr pBox, int nBox); /* xglcopy.c */ Bool xglCopy (DrawablePtr pSrc, DrawablePtr pDst, int dx, int dy, BoxPtr pBox, int nBox); void xglCopyProc (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, BoxPtr pBox, int nBox, int dx, int dy, Bool reverse, Bool upsidedown, Pixel bitplane, void *closure); /* xglfill.c */ Bool xglFill (DrawablePtr pDrawable, GCPtr pGC, xglGeometryPtr pGeometry, int x, int y, int width, int height, BoxPtr pBox, int nBox); void xglFillSpan (DrawablePtr pDrawable, GCPtr pGC, int n, DDXPointPtr ppt, int *pwidth); void xglFillRect (DrawablePtr pDrawable, GCPtr pGC, int nrect, xRectangle *prect); Bool xglFillLine (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, DDXPointPtr ppt); Bool xglFillSegment (DrawablePtr pDrawable, GCPtr pGC, int nsegInit, xSegment *pSegInit); Bool xglFillGlyph (DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nglyph, CharInfoPtr *ppciInit, pointer pglyphBase); /* xglwindow.c */ Bool xglCreateWindow (WindowPtr pWin); Bool xglDestroyWindow (WindowPtr pWin); Bool xglChangeWindowAttributes (WindowPtr pWin, unsigned long mask); void xglCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc); PixmapPtr xglGetWindowPixmap (WindowPtr pWin); void xglSetWindowPixmap (WindowPtr pWin, PixmapPtr pPixmap); /* xglget.c */ void xglGetImage (DrawablePtr pDrawable, int x, int y, int w, int h, unsigned int format, unsigned long planeMask, char *d); void xglGetSpans (DrawablePtr pDrawable, int wMax, DDXPointPtr ppt, int *pwidth, int nspans, char *pchardstStart); /* xglgc.c */ Bool xglCreateGC (GCPtr pGC); void xglDestroyGC (GCPtr pGC); void xglValidateGC (GCPtr pGC, unsigned long changes, DrawablePtr pDrawable); void xglFillSpans (DrawablePtr pDrawable, GCPtr pGC, int nspans, DDXPointPtr ppt, int *pwidth, int fSorted); void xglSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc, DDXPointPtr ppt, int *pwidth, int nspans, int fSorted); void xglPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, int x, int y, int w, int h, int leftPad, int format, char *bits); RegionPtr xglCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcX, int srcY, int w, int h, int dstX, int dstY); RegionPtr xglCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, int srcX, int srcY, int w, int h, int dstX, int dstY, unsigned long bitPlane); void xglPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, DDXPointPtr pptInit); void xglPolylines (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, DDXPointPtr ppt); void xglPolySegment (DrawablePtr pDrawable, GCPtr pGC, int nsegInit, xSegment *pSegInit); void xglPolyArc (DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *pArcs); void xglPolyFillRect (DrawablePtr pDrawable, GCPtr pGC, int nrect, xRectangle *prect); void xglPolyFillArc (DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc *pArcs); void xglImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nglyph, CharInfoPtr *ppci, pointer pglyphBase); void xglPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, int x, int y, unsigned int nglyph, CharInfoPtr *ppci, pointer pglyphBase); void xglPushPixels (GCPtr pGC, PixmapPtr pBitmap, DrawablePtr pDrawable, int w, int h, int x, int y); #ifdef MITSHM /* xglshm.c */ void xglShmPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, unsigned int format, int w, int h, int sx, int sy, int sw, int sh, int dx, int dy, char *data); #endif #ifdef RENDER /* xglpict.c */ void xglComposite (CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height); void xglAddTriangles (PicturePtr pDst, INT16 xOff, INT16 yOff, int ntri, xTriangle *tris); void xglChangePicture (PicturePtr pPicture, Mask mask); int xglChangePictureTransform (PicturePtr pPicture, PictTransform *transform); int xglChangePictureFilter (PicturePtr pPicture, int filter, xFixed *params, int nparams); PicturePtr xglCreateDevicePicture (pointer data); Bool xglSyncPicture (ScreenPtr pScreen, PicturePtr pPicture, INT16 x, INT16 y, CARD16 width, CARD16 height, INT16 *xOff, INT16 *yOff); Bool xglPictureInit (ScreenPtr pScreen); void xglPictureClipExtents (PicturePtr pPicture, BoxPtr extents); /* xglcompose.c */ Bool xglCompositeGeneral (CARD8 op, PicturePtr pSrc, PicturePtr pMask, PicturePtr pDst, xglGeometryPtr pGeometry, INT16 xSrc, INT16 ySrc, INT16 xMask, INT16 yMask, INT16 xDst, INT16 yDst, CARD16 width, CARD16 height); /* xglglyph.c */ Bool xglRealizeGlyph (ScreenPtr pScreen, GlyphPtr pGlyph); void xglUnrealizeGlyph (ScreenPtr pScreen, GlyphPtr pGlyph); Bool xglInitGlyphCache (xglGlyphCachePtr pCache, ScreenPtr pScreen, PictFormatPtr format); void xglFiniGlyphCache (xglGlyphCachePtr pCache); void xglGlyphs (CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr *glyphs); /* xgltrap.c */ void xglTrapezoids (CARD8 op, PicturePtr pSrc, PicturePtr pDst, PictFormatPtr maskFormat, INT16 xSrc, INT16 ySrc, int nTrap, xTrapezoid *traps); void xglAddTraps (PicturePtr pDst, INT16 xOff, INT16 yOff, int nTrap, xTrap *traps); #endif #ifdef XGL_MODULAR /* xglloader.c */ typedef struct _xglSymbol { void **ptr; const char *name; } xglSymbolRec, *xglSymbolPtr; void * xglLoadModule (const char *name, int flag); void xglUnloadModule (void *handle); Bool xglLookupSymbols (void *handle, xglSymbolPtr sym, int nSym); #endif /* xglxv.c */ #ifdef XV Bool xglXvScreenInit (ScreenPtr pScreen); #endif /* xglhash.c */ typedef struct _xglHashTable *xglHashTablePtr; Bool xglLoadHashFuncs (void *handle); xglHashTablePtr xglNewHashTable (void); void xglDeleteHashTable (xglHashTablePtr pTable); void * xglHashLookup (const xglHashTablePtr pTable, unsigned int key); void xglHashInsert (xglHashTablePtr pTable, unsigned int key, void *data); void xglHashRemove (xglHashTablePtr pTable, unsigned int key); unsigned int xglHashFirstEntry (xglHashTablePtr pTable); unsigned int xglHashNextEntry (const xglHashTablePtr pTable, unsigned int key); unsigned int xglHashFindFreeKeyBlock (xglHashTablePtr pTable, unsigned int numKeys); #endif /* _XGL_H_ */