1431ee95fe
upsteam code. Backporting keeping UMS changes by me, some bugfixes from kettenis@. Has been in snapshots for a while, committed on request so we can be sure what people are running. This is a prerequesite for sandybridge support but has those chipsets disabled for now until the correct code has been added.
585 lines
21 KiB
C
585 lines
21 KiB
C
/*
|
|
* Copyright © 2000, 2008 Keith Packard
|
|
* 2004 Eric Anholt
|
|
* 2005 Zack Rusin
|
|
*
|
|
* 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 copyright holders not be used in
|
|
* advertising or publicity pertaining to distribution of the software without
|
|
* specific, written prior permission. Copyright holders make no
|
|
* representations about the suitability of this software for any purpose. It
|
|
* is provided "as is" without express or implied warranty.
|
|
*
|
|
* THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
|
|
* SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
* FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS 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.
|
|
*/
|
|
|
|
/** @file
|
|
* UXA - the unified memory acceleration architecture.
|
|
*
|
|
* This is the header containing the public API of UXA for uxa drivers.
|
|
*/
|
|
|
|
#ifndef UXA_H
|
|
#define UXA_H
|
|
|
|
#include "scrnintstr.h"
|
|
#include "pixmapstr.h"
|
|
#include "windowstr.h"
|
|
#include "gcstruct.h"
|
|
#include "picturestr.h"
|
|
#include "fb.h"
|
|
|
|
#define UXA_VERSION_MAJOR 1
|
|
#define UXA_VERSION_MINOR 0
|
|
#define UXA_VERSION_RELEASE 0
|
|
|
|
typedef enum {
|
|
UXA_ACCESS_RO,
|
|
UXA_ACCESS_RW
|
|
} uxa_access_t;
|
|
|
|
/**
|
|
* The UxaDriver structure is allocated through uxa_driver_alloc(), and then
|
|
* fllled in by drivers.
|
|
*/
|
|
typedef struct _UxaDriver {
|
|
/**
|
|
* uxa_major and uxa_minor should be set by the driver to the version of
|
|
* UXA which the driver was compiled for (or configures itself at
|
|
* runtime to support). This allows UXA to extend the structure for
|
|
* new features without breaking ABI for drivers compiled against
|
|
* older versions.
|
|
*/
|
|
int uxa_major, uxa_minor;
|
|
|
|
/**
|
|
* The flags field is bitfield of boolean values controlling UXA's
|
|
* behavior.
|
|
*
|
|
* The flags include UXA_TWO_BITBLT_DIRECTIONS.
|
|
*/
|
|
int flags;
|
|
|
|
/** @name solid
|
|
* @{
|
|
*/
|
|
/**
|
|
* check_solid() checks whether the driver can do a solid fill to this drawable.
|
|
* @param pDrawable Destination drawable
|
|
* @param alu raster operation
|
|
* @param planemask write mask for the fill
|
|
*
|
|
* The check_solid() call is recommended if prepare_solid() is
|
|
* implemented, but is not required.
|
|
*/
|
|
Bool(*check_solid) (DrawablePtr pDrawable, int alu, Pixel planemask);
|
|
|
|
/**
|
|
* prepare_solid() sets up the driver for doing a solid fill.
|
|
* @param pPixmap Destination pixmap
|
|
* @param alu raster operation
|
|
* @param planemask write mask for the fill
|
|
* @param fg "foreground" color for the fill
|
|
*
|
|
* This call should set up the driver for doing a series of solid fills
|
|
* through the solid() call. The alu raster op is one of the GX*
|
|
* graphics functions listed in X.h, and typically maps to a similar
|
|
* single-byte "ROP" setting in all hardware. The planemask controls
|
|
* which bits of the destination should be affected, and will only
|
|
* represent the bits up to the depth of pPixmap. The fg is the pixel
|
|
* value of the foreground color referred to in ROP descriptions.
|
|
*
|
|
* Note that many drivers will need to store some of the data in the
|
|
* driver private record, for sending to the hardware with each
|
|
* drawing command.
|
|
*
|
|
* The prepare_solid() call is required of all drivers, but it may fail
|
|
* for any reason. Failure results in a fallback to software rendering.
|
|
*/
|
|
Bool(*prepare_solid) (PixmapPtr pPixmap,
|
|
int alu, Pixel planemask, Pixel fg);
|
|
|
|
/**
|
|
* solid() performs a solid fill set up in the last prepare_solid()
|
|
* call.
|
|
*
|
|
* @param pPixmap destination pixmap
|
|
* @param x1 left coordinate
|
|
* @param y1 top coordinate
|
|
* @param x2 right coordinate
|
|
* @param y2 bottom coordinate
|
|
*
|
|
* Performs the fill set up by the last prepare_solid() call,
|
|
* covering the area from (x1,y1) to (x2,y2) in pPixmap. Note that
|
|
* the coordinates are in the coordinate space of the destination
|
|
* pixmap, so the driver will need to set up the hardware's offset
|
|
* and pitch for the destination coordinates according to the pixmap's
|
|
* offset and pitch within framebuffer.
|
|
*
|
|
* This call is required if prepare_solid() ever succeeds.
|
|
*/
|
|
void (*solid) (PixmapPtr pPixmap, int x1, int y1, int x2, int y2);
|
|
|
|
/**
|
|
* done_solid() finishes a set of solid fills.
|
|
*
|
|
* @param pPixmap destination pixmap.
|
|
*
|
|
* The done_solid() call is called at the end of a series of consecutive
|
|
* solid() calls following a successful prepare_solid(). This allows
|
|
* drivers to finish up emitting drawing commands that were buffered, or
|
|
* clean up state from prepare_solid().
|
|
*
|
|
* This call is required if prepare_solid() ever succeeds.
|
|
*/
|
|
void (*done_solid) (PixmapPtr pPixmap);
|
|
/** @} */
|
|
|
|
/** @name copy
|
|
* @{
|
|
*/
|
|
/**
|
|
* check_copy() checks whether the driver can blit between the two Pictures
|
|
*/
|
|
Bool(*check_copy) (PixmapPtr pSrc, PixmapPtr pDst, int alu, Pixel planemask);
|
|
/**
|
|
* prepare_copy() sets up the driver for doing a copy within video
|
|
* memory.
|
|
- *
|
|
* @param pSrcPixmap source pixmap
|
|
* @param pDstPixmap destination pixmap
|
|
* @param dx X copy direction
|
|
* @param dy Y copy direction
|
|
* @param alu raster operation
|
|
* @param planemask write mask for the fill
|
|
*
|
|
* This call should set up the driver for doing a series of copies
|
|
* from the pSrcPixmap to the pDstPixmap. The dx flag will be
|
|
* positive if the
|
|
* hardware should do the copy from the left to the right, and dy will
|
|
* be positive if the copy should be done from the top to the bottom.
|
|
* This is to deal with self-overlapping copies when
|
|
* pSrcPixmap == pDstPixmap.
|
|
*
|
|
* If your hardware can only support blits that are (left to right,
|
|
* top to bottom) or (right to left, bottom to top), then you should
|
|
* set #UXA_TWO_BITBLT_DIRECTIONS, and UXA will break down copy
|
|
* operations to ones that meet those requirements. The alu raster
|
|
* op is one of the GX* graphics functions listed in X.h, and
|
|
* typically maps to a similar single-byte "ROP" setting in all
|
|
* hardware. The planemask controls which bits of the destination
|
|
* should be affected, and will only represent the bits up to the
|
|
* depth of pPixmap.
|
|
*
|
|
* Note that many drivers will need to store some of the data in the
|
|
* driver private record, for sending to the hardware with each
|
|
* drawing command.
|
|
*
|
|
* The prepare_copy() call is required of all drivers, but it may fail
|
|
* for any reason. Failure results in a fallback to software rendering.
|
|
*/
|
|
Bool(*prepare_copy) (PixmapPtr pSrcPixmap,
|
|
PixmapPtr pDstPixmap,
|
|
int dx, int dy, int alu, Pixel planemask);
|
|
|
|
/**
|
|
* copy() performs a copy set up in the last prepare_copy call.
|
|
*
|
|
* @param pDstPixmap destination pixmap
|
|
* @param srcX source X coordinate
|
|
* @param srcY source Y coordinate
|
|
* @param dstX destination X coordinate
|
|
* @param dstY destination Y coordinate
|
|
* @param width width of the rectangle to be copied
|
|
* @param height height of the rectangle to be copied.
|
|
*
|
|
* Performs the copy set up by the last prepare_copy() call, copying the
|
|
* rectangle from (srcX, srcY) to (srcX + width, srcY + width) in the
|
|
* source pixmap to the same-sized rectangle at (dstX, dstY) in the
|
|
* destination pixmap. Those rectangles may overlap in memory, if
|
|
* pSrcPixmap == pDstPixmap. Note that this call does not receive the
|
|
* pSrcPixmap as an argument -- if it's needed in this function, it
|
|
* should be stored in the driver private during prepare_copy(). As
|
|
* with solid(), the coordinates are in the coordinate space of each
|
|
* pixmap, so the driver will need to set up source and destination
|
|
* pitches and offsets from those pixmaps, probably using
|
|
* uxaGetPixmapOffset() and uxa_get_pixmap_pitch().
|
|
*
|
|
* This call is required if prepare_copy ever succeeds.
|
|
*/
|
|
void (*copy) (PixmapPtr pDstPixmap,
|
|
int srcX,
|
|
int srcY, int dstX, int dstY, int width, int height);
|
|
|
|
/**
|
|
* done_copy() finishes a set of copies.
|
|
*
|
|
* @param pPixmap destination pixmap.
|
|
*
|
|
* The done_copy() call is called at the end of a series of consecutive
|
|
* copy() calls following a successful prepare_copy(). This allows
|
|
* drivers to finish up emitting drawing commands that were buffered,
|
|
* or clean up state from prepare_copy().
|
|
*
|
|
* This call is required if prepare_copy() ever succeeds.
|
|
*/
|
|
void (*done_copy) (PixmapPtr pDstPixmap);
|
|
/** @} */
|
|
|
|
/** @name composite
|
|
* @{
|
|
*/
|
|
/**
|
|
* check_composite() checks to see if a composite operation could be
|
|
* accelerated.
|
|
*
|
|
* @param op Render operation
|
|
* @param pSrcPicture source Picture
|
|
* @param pMaskPicture mask picture
|
|
* @param pDstPicture destination Picture
|
|
* @param width The width of the composite operation
|
|
* @param height The height of the composite operation
|
|
*
|
|
* The check_composite() call checks if the driver could handle
|
|
* acceleration of op with the given source, mask, and destination
|
|
* pictures. This allows drivers to check source and destination
|
|
* formats, supported operations, transformations, and component
|
|
* alpha state, and send operations it can't support to software
|
|
* rendering early on.
|
|
*
|
|
* See prepare_composite() for more details on likely issues that
|
|
* drivers will have in accelerating composite operations.
|
|
*
|
|
* The check_composite() call is recommended if prepare_composite() is
|
|
* implemented, but is not required.
|
|
*/
|
|
Bool(*check_composite) (int op,
|
|
PicturePtr pSrcPicture,
|
|
PicturePtr pMaskPicture,
|
|
PicturePtr pDstPicture,
|
|
int width, int height);
|
|
|
|
/**
|
|
* check_composite_target() checks to see if the destination of the composite
|
|
* operation can be used without midification.
|
|
*
|
|
* @param pixmap Destination Pixmap
|
|
*
|
|
* The check_composite_target() call is recommended if prepare_composite() is
|
|
* implemented, but is not required.
|
|
*/
|
|
Bool(*check_composite_target) (PixmapPtr pixmap);
|
|
|
|
/**
|
|
* check_composite_texture() checks to see if a source to the composite
|
|
* operation can be used without midification.
|
|
*
|
|
* @param pScreen Screen
|
|
* @param pPicture Picture
|
|
*
|
|
* The check_composite_texture() call is recommended if prepare_composite() is
|
|
* implemented, but is not required.
|
|
*/
|
|
Bool(*check_composite_texture) (ScreenPtr pScreen,
|
|
PicturePtr pPicture);
|
|
|
|
/**
|
|
* prepare_composite() sets up the driver for doing a composite
|
|
* operation described in the Render extension protocol spec.
|
|
*
|
|
* @param op Render operation
|
|
* @param pSrcPicture source Picture
|
|
* @param pMaskPicture mask picture
|
|
* @param pDstPicture destination Picture
|
|
* @param pSrc source pixmap
|
|
* @param pMask mask pixmap
|
|
* @param pDst destination pixmap
|
|
*
|
|
* This call should set up the driver for doing a series of composite
|
|
* operations, as described in the Render protocol spec, with the given
|
|
* pSrcPicture, pMaskPicture, and pDstPicture. The pSrc, pMask, and
|
|
* pDst are the pixmaps containing the pixel data, and should be used
|
|
* for setting the offset and pitch used for the coordinate spaces for
|
|
* each of the Pictures.
|
|
*
|
|
* Notes on interpreting Picture structures:
|
|
* - The Picture structures will always have a valid pDrawable.
|
|
* - The Picture structures will never have alphaMap set.
|
|
* - The mask Picture (and therefore pMask) may be NULL, in which case
|
|
* the operation is simply src OP dst instead of src IN mask OP dst,
|
|
* and mask coordinates should be ignored.
|
|
* - pMarkPicture may have componentAlpha set, which greatly changes
|
|
* the behavior of the composite operation. componentAlpha has no
|
|
* effect when set on pSrcPicture or pDstPicture.
|
|
* - The source and mask Pictures may have a transformation set
|
|
* (Picture->transform != NULL), which means that the source
|
|
* coordinates should be transformed by that transformation,
|
|
* resulting in scaling, rotation, etc. The PictureTransformPoint()
|
|
* call can transform coordinates for you. Transforms have no
|
|
* effect on Pictures when used as a destination.
|
|
* - The source and mask pictures may have a filter set.
|
|
* PictFilterNearest and PictFilterBilinear are defined in the
|
|
* Render protocol, but others may be encountered, and must be
|
|
* handled correctly (usually by prepare_composite failing, and
|
|
* falling back to software). Filters have
|
|
* no effect on Pictures when used as a destination.
|
|
* - The source and mask Pictures may have repeating set, which must be
|
|
* respected. Many chipsets will be unable to support repeating on
|
|
* pixmaps that have a width or height that is not a power of two.
|
|
*
|
|
* If your hardware can't support source pictures (textures) with
|
|
* non-power-of-two pitches, you should set #UXA_OFFSCREEN_ALIGN_POT.
|
|
*
|
|
* Note that many drivers will need to store some of the data in the
|
|
* driver private record, for sending to the hardware with each
|
|
* drawing command.
|
|
*
|
|
* The prepare_composite() call is not required. However, it is highly
|
|
* recommended for performance of antialiased font rendering and
|
|
* performance of cairo applications. Failure results in a fallback
|
|
* to software rendering.
|
|
*/
|
|
Bool(*prepare_composite) (int op,
|
|
PicturePtr pSrcPicture,
|
|
PicturePtr pMaskPicture,
|
|
PicturePtr pDstPicture,
|
|
PixmapPtr pSrc,
|
|
PixmapPtr pMask, PixmapPtr pDst);
|
|
|
|
/**
|
|
* composite() performs a composite operation set up in the last
|
|
* prepare_composite() call.
|
|
*
|
|
* @param pDstPixmap destination pixmap
|
|
* @param srcX source X coordinate
|
|
* @param srcY source Y coordinate
|
|
* @param maskX source X coordinate
|
|
* @param maskY source Y coordinate
|
|
* @param dstX destination X coordinate
|
|
* @param dstY destination Y coordinate
|
|
* @param width destination rectangle width
|
|
* @param height destination rectangle height
|
|
*
|
|
* Performs the composite operation set up by the last
|
|
* prepare_composite() call, to the rectangle from (dstX, dstY) to
|
|
* (dstX + width, dstY + height) in the destination Pixmap. Note that
|
|
* if a transformation was set on the source or mask Pictures, the
|
|
* source rectangles may not be the same size as the destination
|
|
* rectangles and filtering. Getting the coordinate transformation
|
|
* right at the subpixel level can be tricky, and rendercheck
|
|
* can test this for you.
|
|
*
|
|
* This call is required if prepare_composite() ever succeeds.
|
|
*/
|
|
void (*composite) (PixmapPtr pDst,
|
|
int srcX,
|
|
int srcY,
|
|
int maskX,
|
|
int maskY,
|
|
int dstX, int dstY, int width, int height);
|
|
|
|
/**
|
|
* done_composite() finishes a set of composite operations.
|
|
*
|
|
* @param pPixmap destination pixmap.
|
|
*
|
|
* The done_composite() call is called at the end of a series of
|
|
* consecutive composite() calls following a successful
|
|
* prepare_composite(). This allows drivers to finish up emitting
|
|
* drawing commands that were buffered, or clean up state from
|
|
* prepare_composite().
|
|
*
|
|
* This call is required if prepare_composite() ever succeeds.
|
|
*/
|
|
void (*done_composite) (PixmapPtr pDst);
|
|
/** @} */
|
|
|
|
/**
|
|
* put_image() loads a rectangle of data from src into pDst.
|
|
*
|
|
* @param pDst destination pixmap
|
|
* @param x destination X coordinate.
|
|
* @param y destination Y coordinate
|
|
* @param width width of the rectangle to be copied
|
|
* @param height height of the rectangle to be copied
|
|
* @param src pointer to the beginning of the source data
|
|
* @param src_pitch pitch (in bytes) of the lines of source data.
|
|
*
|
|
* put_image() copies data in system memory beginning at src (with
|
|
* pitch src_pitch) into the destination pixmap from (x, y) to
|
|
* (x + width, y + height). This is typically done with hostdata
|
|
* uploads, where the CPU sets up a blit command on the hardware with
|
|
* instructions that the blit data will be fed through some sort of
|
|
* aperture on the card.
|
|
*
|
|
* put_image() is most important for the performance of uxa_glyphs()
|
|
* (antialiased font drawing) by allowing pipelining of data uploads,
|
|
* avoiding a sync of the card after each glyph.
|
|
*
|
|
* @return TRUE if the driver successfully uploaded the data. FALSE
|
|
* indicates that UXA should fall back to doing the upload in software.
|
|
*
|
|
* put_image() is not required, but is recommended if composite
|
|
* acceleration is supported.
|
|
*/
|
|
Bool(*put_image) (PixmapPtr pDst,
|
|
int x,
|
|
int y, int w, int h, char *src, int src_pitch);
|
|
|
|
/**
|
|
* get_image() loads a rectangle of data from pSrc into dst
|
|
*
|
|
* @param pSrc source pixmap
|
|
* @param x source X coordinate.
|
|
* @param y source Y coordinate
|
|
* @param width width of the rectangle to be copied
|
|
* @param height height of the rectangle to be copied
|
|
* @param dst pointer to the beginning of the destination data
|
|
* @param dst_pitch pitch (in bytes) of the lines of destination data.
|
|
*
|
|
* get_image() copies data from offscreen memory in pSrc from
|
|
* (x, y) to (x + width, y + height), to system memory starting at
|
|
* dst (with pitch dst_pitch). This would usually be done
|
|
* using scatter-gather DMA, supported by a DRM call, or by blitting
|
|
* to AGP and then synchronously reading from AGP.
|
|
*
|
|
* @return TRUE if the driver successfully downloaded the data. FALSE
|
|
* indicates that UXA should fall back to doing the download in
|
|
* software.
|
|
*
|
|
* get_image() is not required, but is highly recommended.
|
|
*/
|
|
Bool(*get_image) (PixmapPtr pSrc,
|
|
int x, int y,
|
|
int w, int h, char *dst, int dst_pitch);
|
|
|
|
/** @{ */
|
|
/**
|
|
* prepare_access() is called before CPU access to an offscreen pixmap.
|
|
*
|
|
* @param pPix the pixmap being accessed
|
|
* @param index the index of the pixmap being accessed.
|
|
*
|
|
* prepare_access() will be called before CPU access to an offscreen
|
|
* pixmap.
|
|
*
|
|
* This can be used to set up hardware surfaces for byteswapping or
|
|
* untiling, or to adjust the pixmap's devPrivate.ptr for the purpose of
|
|
* making CPU access use a different aperture.
|
|
*
|
|
* The index is one of #UXA_PREPARE_DEST, #UXA_PREPARE_SRC, or
|
|
* #UXA_PREPARE_MASK, indicating which pixmap is in question. Since
|
|
* only up to three pixmaps will have prepare_access() called on them
|
|
* per operation, drivers can have a small, statically-allocated space
|
|
* to maintain state for prepare_access() and finish_access() in.
|
|
* Note that the same pixmap may have prepare_access() called on it
|
|
* more than once, for uxample when doing a copy within the same
|
|
* pixmap (so it gets prepare_access as
|
|
* #UXA_PREPARE_DEST and then as #UXA_PREPARE_SRC).
|
|
*
|
|
* prepare_access() may fail. An example might be the case of
|
|
* hardware that can set up 1 or 2 surfaces for CPU access, but not
|
|
* 3. If prepare_access()
|
|
* fails, UXA will migrate the pixmap to system memory.
|
|
* get_image() must be implemented and must not fail if a driver
|
|
* wishes to fail in prepare_access(). prepare_access() must not
|
|
* fail when pPix is the visible screen, because the visible screen
|
|
* can not be migrated.
|
|
*
|
|
* @return TRUE if prepare_access() successfully prepared the pixmap
|
|
* for CPU drawing.
|
|
* @return FALSE if prepare_access() is unsuccessful and UXA should use
|
|
* get_image() to migate the pixmap out.
|
|
*/
|
|
Bool(*prepare_access) (PixmapPtr pPix, uxa_access_t access);
|
|
|
|
/**
|
|
* finish_access() is called after CPU access to an offscreen pixmap.
|
|
*
|
|
* @param pPix the pixmap being accessed
|
|
* @param index the index of the pixmap being accessed.
|
|
*
|
|
* finish_access() will be called after finishing CPU access of an
|
|
* offscreen pixmap set up by prepare_access(). Note that the
|
|
* finish_access() will not be called if prepare_access() failed.
|
|
*/
|
|
void (*finish_access) (PixmapPtr pPix);
|
|
|
|
/**
|
|
* PixmapIsOffscreen() is an optional driver replacement to
|
|
* uxa_pixmap_is_offscreen(). Set to NULL if you want the standard
|
|
* behaviour of uxa_pixmap_is_offscreen().
|
|
*
|
|
* @param pPix the pixmap
|
|
* @return TRUE if the given drawable is in framebuffer memory.
|
|
*
|
|
* uxa_pixmap_is_offscreen() is used to determine if a pixmap is in
|
|
* offscreen memory, meaning that acceleration could probably be done
|
|
* to it, and that it will need to be wrapped by
|
|
* prepare_access()/finish_access() when accessing it with the CPU.
|
|
*/
|
|
Bool(*pixmap_is_offscreen) (PixmapPtr pPix);
|
|
|
|
/** @} */
|
|
} uxa_driver_t;
|
|
|
|
/** @name UXA driver flags
|
|
* @{
|
|
*/
|
|
/**
|
|
* UXA_TWO_BITBLT_DIRECTIONS indicates to UXA that the driver can only
|
|
* support copies that are (left-to-right, top-to-bottom) or
|
|
* (right-to-left, bottom-to-top).
|
|
*/
|
|
#define UXA_TWO_BITBLT_DIRECTIONS (1 << 2)
|
|
|
|
/** @} */
|
|
|
|
/** @name UXA CreatePixmap hint flags
|
|
* @{
|
|
*/
|
|
/**
|
|
* Flag to hint that the first operation on the pixmap will be a
|
|
* prepare_access.
|
|
*/
|
|
#define UXA_CREATE_PIXMAP_FOR_MAP 0x20000000
|
|
/** @} */
|
|
|
|
uxa_driver_t *uxa_driver_alloc(void);
|
|
|
|
Bool uxa_driver_init(ScreenPtr screen, uxa_driver_t * uxa_driver);
|
|
Bool uxa_resources_init(ScreenPtr screen);
|
|
|
|
void uxa_driver_fini(ScreenPtr pScreen);
|
|
|
|
CARD32 uxa_get_pixmap_first_pixel(PixmapPtr pPixmap);
|
|
|
|
Bool
|
|
uxa_get_color_for_pixmap (PixmapPtr pixmap,
|
|
CARD32 src_format,
|
|
CARD32 dst_format,
|
|
CARD32 *pixel);
|
|
|
|
void uxa_set_fallback_debug(ScreenPtr screen, Bool enable);
|
|
void uxa_set_force_fallback(ScreenPtr screen, Bool enable);
|
|
|
|
/**
|
|
* Returns TRUE if the given planemask covers all the significant bits in the
|
|
* pixel values for pDrawable.
|
|
*/
|
|
#define UXA_PM_IS_SOLID(_pDrawable, _pm) \
|
|
(((_pm) & FbFullMask((_pDrawable)->depth)) == \
|
|
FbFullMask((_pDrawable)->depth))
|
|
|
|
#endif /* UXA_H */
|