XAA.HOWTO
This file describes how to add basic XAA support to a chipset driver.
0) What is XAA
1) XAA Initialization and Shutdown
2) The Primitives
2.0 Generic Flags
2.1 Screen to Screen Copies
2.2 Solid Fills
2.3 Solid Lines
2.4 Dashed Lines
2.5 Color Expand Fills
2.5.1 Screen to Screen Color Expansion
2.5.2 CPU to Screen Color Expansion
2.5.2.1 The Direct Method
2.5.2.2 The Indirect Method
2.6 8x8 Mono Pattern Fills
2.7 8x8 Color Pattern Fills
2.8 Image Writes
2.8.1 The Direct Method
2.8.2 The Indirect Method
2.9 Clipping
3) The Pixmap Cache
4) Offscreen Pixmaps
/********************************************************************/
0) WHAT IS XAA
XAA (the XFree86 Acceleration Architecture) is a device dependent
layer that encapsulates the unaccelerated framebuffer rendering layer,
intercepting rendering commands sent to it from higher levels of the
server. For rendering tasks where hardware acceleration is not
possible, XAA allows the requests to proceed to the software rendering
code. Otherwise, XAA breaks the sometimes complicated X primitives
into simpler primitives more suitable for hardware acceleration and
will use accelerated functions exported by the chipset driver to
render these.
XAA provides a simple, easy to use driver interface that allows
the driver to communicate its acceleration capabilities and restrictions
back to XAA. XAA will use the information provided by the driver
to determine whether or not acceleration will be possible for a
particular X primitive.
1) XAA INITIALIZATION AND SHUTDOWN
All relevant prototypes and defines are in xaa.h.
To Initialize the XAA layer, the driver should allocate an XAAInfoRec
via XAACreateInfoRec(), fill it out as described in this document
and pass it to XAAInit(). XAAInit() must be called _after_ the
framebuffer initialization (usually cfb?ScreenInit or similar) since
it is "wrapping" that layer. XAAInit() should be called _before_ the
cursor initialization (usually miDCInitialize) since the cursor
layer needs to "wrap" all the rendering code including XAA.
When shutting down, the driver should free the XAAInfoRec
structure in its CloseScreen function via XAADestroyInfoRec().
The prototypes for the functions mentioned above are as follows:
XAAInfoRecPtr XAACreateInfoRec(void);
Bool XAAInit(ScreenPtr, XAAInfoRecPtr);
void XAADestroyInfoRec(XAAInfoRec);
The driver informs XAA of it's acceleration capablities by
filling out an XAAInfoRec structure and passing it to XAAInit().
The XAAInfoRec structure contains many fields, most of which are
function pointers and flags. Each primitive will typically have
two functions and a set of flags associated with it, but it may
have more. These two functions are the "SetupFor" and "Subsequent"
functions. The "SetupFor" function tells the driver that the
hardware should be initialized for a particular type of graphics
operation. After the "SetupFor" function, one or more calls to the
"Subsequent" function will be made to indicate that an instance
of the particular primitive should be rendered by the hardware.
The details of each instance (width, height, etc...) are given
with each "Subsequent" function. The set of flags associated
with each primitive lets the driver tell XAA what its hardware
limitations are (eg. It doesn't support a planemask, it can only
do one of the raster-ops, etc...).
Of the XAAInfoRec fields, one is required. This is the
Sync function. XAA initialization will fail if this function
is not provided.
void Sync(ScrnInfoPtr pScrn) /* Required */
Sync will be called when XAA needs to be certain that all
graphics coprocessor operations are finished, such as when
the framebuffer must be written to or read from directly
and it must be certain that the accelerator will not be
overwriting the area of interest.
One needs to make certain that the Sync function not only
waits for the accelerator fifo to empty, but that it waits for
the rendering of that last operation to complete.
It is guaranteed that no direct framebuffer access will
occur after a "SetupFor" or "Subsequent" function without
the Sync function being called first.
2) THE PRIMITIVES
2.0 Generic Flags
Each primitive type has a set of flags associated with it which
allow the driver to tell XAA what the hardware limitations are.
The common ones are as follows:
/* Foreground, Background, rop and planemask restrictions */
GXCOPY_ONLY
This indicates that the accelerator only supports GXcopy
for the particular primitive.
ROP_NEEDS_SOURCE
This indicates that the accelerator doesn't supports a
particular primitive with rops that don't involve the source.
These rops are GXclear, GXnoop, GXinvert and GXset. If neither
this flag nor GXCOPY_ONLY is defined, it is assumed that the
accelerator supports all 16 raster operations (rops) for that
primitive.
NO_PLANEMASK
This indicates that the accelerator does not support a hardware
write planemask for the particular primitive.
RGB_EQUAL
This indicates that the particular primitive requires the red,
green and blue bytes of the foreground color (and background color,
if applicable) to be equal. This is useful for 24bpp when a graphics
coprocessor is used in 8bpp mode, which is not uncommon in older
hardware since some have no support for or only limited support for
acceleration at 24bpp. This way, many operations will be accelerated
for the common case of "grayscale" colors. This flag should only
be used in 24bpp.
In addition to the common ones listed above which are possible for
nearly all primitives, each primitive may have its own flags specific
to that primitive. If such flags exist they are documented in the
descriptions of those primitives below.
2.1 Screen to Screen Copies
The SetupFor and Subsequent ScreenToScreenCopy functions provide
an interface for copying rectangular areas from video memory to
video memory. To accelerate this primitive the driver should
provide both the SetupFor and Subsequent functions and indicate
the hardware restrictions via the ScreenToScreenCopyFlags. The
NO_PLANEMASK, GXCOPY_ONLY and ROP_NEEDS_SOURCE flags as described
in Section 2.0 are valid as well as the following:
NO_TRANSPARENCY
This indicates that the accelerator does not support skipping
of color keyed pixels when copying from the source to the destination.
TRANSPARENCY_GXCOPY_ONLY
This indicates that the accelerator supports skipping of color keyed
pixels only when the rop is GXcopy.
ONLY_LEFT_TO_RIGHT_BITBLT
This indicates that the hardware only accepts blitting when the
x direction is positive.
ONLY_TWO_BITBLT_DIRECTIONS
This indicates that the hardware can only cope with blitting when
the direction of x is the same as the direction in y.
void SetupForScreenToScreenCopy( ScrnInfoPtr pScrn,
int xdir, int ydir,
int rop,
unsigned int planemask,
int trans_color )
When this is called, SubsequentScreenToScreenCopy will be called
one or more times directly after. If ydir is 1, then the accelerator
should copy starting from the top (minimum y) of the source and
proceed downward. If ydir is -1, then the accelerator should copy
starting from the bottom of the source (maximum y) and proceed
upward. If xdir is 1, then the accelerator should copy each
y scanline starting from the leftmost pixel of the source. If
xdir is -1, it should start from the rightmost pixel.
If trans_color is not -1 then trans_color indicates that the
accelerator should not copy pixels with the color trans_color
from the source to the destination, but should skip them.
Trans_color is always -1 if the NO_TRANSPARENCY flag is set.
void SubsequentScreenToScreenCopy(ScrnInfoPtr pScrn,
int x1, int y1,
int x2, int y2,
int width, int height)
Copy a rectangle "width" x "height" from the source (x1,y1) to the
destination (x2,y2) using the parameters passed by the last
SetupForScreenToScreenCopy call. (x1,y1) and (x2,y2) always denote
the upper left hand corners of the source and destination regardless
of which xdir and ydir values are given by SetupForScreenToScreenCopy.
2.2 Solid Fills
The SetupFor and Subsequent SolidFill(Rect/Trap) functions provide
an interface for filling rectangular areas of the screen with a
foreground color. To accelerate this primitive the driver should
provide both the SetupForSolidFill and SubsequentSolidFillRect
functions and indicate the hardware restrictions via the SolidFillFlags.
The driver may optionally provide a SubsequentSolidFillTrap if
it is capable of rendering the primitive correctly.
The GXCOPY_ONLY, ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags
as described in Section 2.0 are valid.
void SetupForSolidFill(ScrnInfoPtr pScrn,
int color, int rop, unsigned int planemask)
SetupForSolidFill indicates that any combination of the following
may follow it.
SubsequentSolidFillRect
SubsequentSolidFillTrap
void SubsequentSolidFillRect(ScrnInfoPtr pScrn, int x, int y, int w, int h)
Fill a rectangle of dimensions "w" by "h" with origin at (x,y)
using the color, rop and planemask given by the last
SetupForSolidFill call.
void SubsequentSolidFillTrap(ScrnInfoPtr pScrn, int y, int h,
int left, int dxL, int dyL, int eL,
int right, int dxR, int dyR, int eR)
These parameters describe a trapezoid via a version of
Bresenham's parameters. "y" is the top line. "h" is the
number of spans to be filled in the positive Y direction.
"left" and "right" indicate the starting X values of the
left and right edges. dy/dx describes the edge slope.
These are not the deltas between the beginning and ending
points on an edge. They merely describe the slope. "e" is
the initial error term. It's the relationships between dx,
dy and e that define the edge.
If your engine does not do bresenham trapezoids or does
not allow the programmer to specify the error term then
you are not expected to be able to accelerate them.
2.3 Solid Lines
XAA provides an interface for drawing thin lines. In order to
draw X lines correctly a high degree of accuracy is required.
This usually limits line acceleration to hardware which has a
Bresenham line engine, though depending on the algorithm used,
other line engines may come close if they accept 16 bit line
deltas. XAA has both a Bresenham line interface and a two-point
line interface for drawing lines of arbitrary orientation.
Additionally there is a SubsequentSolidHorVertLine which will
be used for all horizontal and vertical lines. Horizontal and
vertical lines are handled separately since hardware that doesn't
have a line engine (or has one that is unusable due to precision
problems) can usually draw these lines by some other method such
as drawing them as thin rectangles. Even for hardware that can
draw arbitrary lines via the Bresenham or two-point interfaces,
the SubsequentSolidHorVertLine is used for horizontal and vertical
lines since most hardware is able to render the horizontal lines
and sometimes the vertical lines faster by other methods (Hint:
try rendering horizontal lines as flattened rectangles). If you have
not provided a SubsequentSolidHorVertLine but you have provided
Bresenham or two-point lines, a SubsequentSolidHorVertLine function
will be supplied for you.
The flags field associated with Solid Lines is SolidLineFlags and
the GXCOPY_ONLY, ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags as
described in Section 2.0 are valid restrictions.
Some line engines have line biases hardcoded to comply with
Microsoft line biasing rules. A tell-tale sign of this is the
hardware lines not matching the software lines in the zeroth and
fourth octants. The driver can set the flag:
MICROSOFT_ZERO_LINE_BIAS
in the AccelInfoRec.Flags field to adjust the software lines to
match the hardware lines. This is in the generic flags field
rather than the SolidLineFlags since this flag applies to all
software zero-width lines on the screen and not just the solid ones.
void SetupForSolidLine(ScrnInfoPtr pScrn,
int color, int rop, unsigned int planemask)
SetupForSolidLine indicates that any combination of the following
may follow it.
SubsequentSolidBresenhamLine
SubsequentSolidTwoPointLine
SubsequentSolidHorVertLine
void SubsequentSolidHorVertLine( ScrnInfoPtr pScrn,
int x, int y, int len, int dir )
All vertical and horizontal solid thin lines are rendered with
this function. The line starts at coordinate (x,y) and extends
"len" pixels inclusive. In the direction indicated by "dir."
The direction is either DEGREES_O or DEGREES_270. That is, it
always extends to the right or down.
void SubsequentSolidTwoPointLine(ScrnInfoPtr pScrn,
int x1, int y1, int x2, int y2, int flags)
Draw a line from (x1,y1) to (x2,y2). If the flags field contains
the flag OMIT_LAST, the last pixel should not be drawn. Otherwise,
the pixel at (x2,y2) should be drawn.
If you use the TwoPoint line interface there is a good possibility
that your line engine has hard-coded line biases that do not match
the default X zero-width lines. If so, you may need to set the
MICROSOFT_ZERO_LINE_BIAS flag described above. Note that since
any vertex in the 16-bit signed coordinate system is valid, your
line engine is expected to handle 16-bit values if you have hardware
line clipping enabled. If your engine cannot handle 16-bit values,
you should not use hardware line clipping.
void SubsequentSolidBresenhamLine(ScrnInfoPtr pScrn,
int x, int y, int major, int minor, int err, int len, int octant)
"X" and "y" are the starting point of the line. "Major" and "minor"
are the major and minor step constants. "Err" is the initial error
term. "Len" is the number of pixels to be drawn (inclusive). "Octant"
can be any combination of the following flags OR'd together:
Y_MAJOR Y is the major axis (X otherwise)
X_DECREASING The line is drawn from right to left
Y_DECREASING The line is drawn from bottom to top
The major, minor and err terms are the "raw" Bresenham parameters
consistent with a line engine that does:
e = err;
while(len--) {
DRAW_POINT(x,y);
e += minor;
if(e >= 0) {
e -= major;
TAKE_ONE_STEP_ALONG_MINOR_AXIS;
}
TAKE_ONE_STEP_ALONG_MAJOR_AXIS;
}
IBM 8514 style Bresenham line interfaces require their parameters
modified in the following way:
Axial = minor;
Diagonal = minor - major;
Error = minor + err;
SolidBresenhamLineErrorTermBits
This field allows the driver to tell XAA how many bits large its
Bresenham parameter registers are. Many engines have registers that
only accept 12 or 13 bit Bresenham parameters, and the parameters
for clipped lines may overflow these if they are not scaled down.
If this field is not set, XAA will assume the engine can accomodate
16 bit parameters, otherwise, it will scale the parameters to the
size specified.
2.4 Dashed Lines
The same degree of accuracy required by the solid lines is required
for drawing dashed lines as well. The dash pattern itself is a
buffer of binary data where ones are expanded into the foreground
color and zeros either correspond to the background color or
indicate transparency depending on whether or not DoubleDash or
OnOffDashes are being drawn.
The flags field associated with dashed Lines is DashedLineFlags and
the GXCOPY_ONLY, ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags as
described in Section 2.0 are valid restrictions. Additionally, the
following flags are valid:
NO_TRANSPARENCY
This indicates that the driver cannot support dashed lines
with transparent backgrounds (OnOffDashes).
TRANSPARENCY_ONLY
This indicates that the driver cannot support dashes with
both a foreground and background color (DoubleDashes).
LINE_PATTERN_POWER_OF_2_ONLY
This indicates that only patterns with a power of 2 length
can be accelerated.
LINE_PATTERN_LSBFIRST_MSBJUSTIFIED
LINE_PATTERN_LSBFIRST_LSBJUSTIFIED
LINE_PATTERN_MSBFIRST_MSBJUSTIFIED
LINE_PATTERN_MSBFIRST_LSBJUSTIFIED
These describe how the line pattern should be packed.
The pattern buffer is DWORD padded. LSBFIRST indicates
that the pattern runs from the LSB end to the MSB end.
MSBFIRST indicates that the pattern runs from the MSB end
to the LSB end. When the pattern does not completely fill
the DWORD padded buffer, the pattern will be justified
towards the MSB or LSB end based on the flags above.
The following field indicates the maximum length dash pattern that
should be accelerated.
int DashPatternMaxLength
void SetupForDashedLine(ScrnInfoPtr pScrn,
int fg, int bg, int rop, unsigned int planemask,
int length, unsigned char *pattern)
SetupForDashedLine indicates that any combination of the following
may follow it.
SubsequentDashedBresenhamLine
SubsequentDashedTwoPointLine
If "bg" is -1, then the background (pixels corresponding to clear
bits in the pattern) should remain unmodified. "Bg" indicates the
background color otherwise. "Length" indicates the length of
the pattern in bits and "pattern" points to the DWORD padded buffer
holding the pattern which has been packed according to the flags
set above.
void SubsequentDashedTwoPointLine( ScrnInfoPtr pScrn,
int x1, int y1, int x2, int y2, int flags, int phase)
void SubsequentDashedBresenhamLine(ScrnInfoPtr pScrn,
int x1, int y1, int major, int minor, int err, int len, int octant,
int phase)
These are the same as the SubsequentSolidTwoPointLine and
SubsequentBresenhamLine functions except for the addition
of the "phase" field which indicates the offset into the dash
pattern that the pixel at (x1,y1) corresponds to.
As with the SubsequentBresenhamLine, there is an
int DashedBresenhamLineErrorTermBits
field which indicates the size of the error term registers
used with dashed lines. This is usually the same value as
the field for the solid lines (because it's usually the same
register).
2.5 Color Expansion Fills
When filling a color expansion rectangle, the accelerator
paints each pixel depending on whether or not a bit in a
corresponding bitmap is set or clear. Opaque expansions are
when a set bit corresponds to the foreground color and a clear
bit corresponds to the background color. A transparent expansion
is when a set bit corresponds to the foreground color and a
clear bit indicates that the pixel should remain unmodified.
The graphics accelerator usually has access to the source
bitmap in one of two ways: 1) the bitmap data is sent serially
to the accelerator by the CPU through some memory mapped aperture
or 2) the accelerator reads the source bitmap out of offscreen
video memory. Some types of primitives are better suited towards
one method or the other. Type 2 is useful for reusable patterns
such as stipples which can be cached in offscreen memory. The
aperature method can be used for stippling but the CPU must pass
the data across the bus each time a stippled fill is to be performed.
For expanding 1bpp client pixmaps or text strings to the screen,
the aperature method is usually superior because the intermediate
copy in offscreen memory needed by the second method would only be
used once. Unfortunately, many accelerators can only do one of these
methods and not both.
XAA provides both ScreenToScreen and CPUToScreen color expansion
interfaces for doing color expansion fills. The ScreenToScreen
functions can only be used with hardware that supports reading
of source bitmaps from offscreen video memory, and these are only
used for cacheable patterns such as stipples. There are two
variants of the CPUToScreen routines - a direct method intended
for hardware that has a transfer aperature, and an indirect method
intended for hardware without transfer aperatures or hardware
with unusual transfer requirements. Hardware that can only expand
bitmaps from video memory should supply ScreenToScreen routines
but also ScanlineCPUToScreen (indirect) routines to optimize transfers
of non-cacheable data. Hardware that can only accept source bitmaps
through an aperature should supply CPUToScreen (or ScanlineCPUToScreen)
routines. Hardware that can do both should provide both ScreenToScreen
and CPUToScreen routines.
For both ScreenToScreen and CPUToScreen interfaces, the GXCOPY_ONLY,
ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags described in
Section 2.0 are valid as well as the following:
/* bit order requirements (one of these must be set) */
BIT_ORDER_IN_BYTE_LSBFIRST
This indicates that least significant bit in each byte of the source
data corresponds to the leftmost of that block of 8 pixels. This
is the prefered format.
BIT_ORDER_IN_BYTE_MSBFIRST
This indicates that most significant bit in each byte of the source
data corresponds to the leftmost of that block of 8 pixels.
/* transparency restrictions */
NO_TRANSPARENCY
This indicates that the accelerator cannot do a transparent expansion.
TRANSPARENCY_ONLY
This indicates that the accelerator cannot do an opaque expansion.
In cases where where the background needs to be filled, XAA will
render the primitive in two passes when using the CPUToScreen
interface, but will not do so with the ScreenToScreen interface
since that would require caching of two patterns. Some
ScreenToScreen hardware may be able to render two passes at the
driver level and remove the TRANSPARENCY_ONLY restriction if
it can render pixels corresponding to the zero bits.
2.5.1 Screen To Screen Color Expansion
The ScreenToScreenColorExpandFill routines provide an interface
for doing expansion blits from source patterns stored in offscreen
video memory.
void SetupForScreenToScreenColorExpandFill (ScrnInfoPtr pScrn,
int fg, int bg,
int rop, unsigned int planemask)
Ones in the source bitmap will correspond to the fg color.
Zeros in the source bitmap will correspond to the bg color
unless bg = -1. In that case the pixels corresponding to the
zeros in the bitmap shall be left unmodified by the accelerator.
For hardware that doesn't allow an easy implementation of skipleft, the
driver can replace CacheMonoStipple function with one that stores multiple
rotated copies of the stipple and select between them. In this case the
driver should set CacheColorExpandDensity to tell XAA how many copies of
the pattern are stored in the width of a cache slot. For instance if the
hardware can specify the starting address in bytes, then 8 rotated copies
of the stipple are needed and CacheColorExpandDensity should be set to 8.
void SubsequentScreenToScreenColorExpandFill( ScrnInfoPtr pScrn,
int x, int y, int w, int h,
int srcx, int srcy, int offset )
Fill a rectangle "w" x "h" at location (x,y). The source pitch
between scanlines is the framebuffer pitch (pScrn->displayWidth
pixels) and srcx and srcy indicate the start of the source pattern
in units of framebuffer pixels. "Offset" indicates the bit offset
into the pattern that corresponds to the pixel being painted at
"x" on the screen. Some hardware accepts source coordinates in
units of bits which makes implementation of the offset trivial.
In that case, the bit address of the source bit corresponding to
the pixel painted at (x,y) would be:
(srcy * pScrn->displayWidth + srcx) * pScrn->bitsPerPixel + offset
It should be noted that the offset assumes LSBFIRST hardware.
For MSBFIRST hardware, the driver may need to implement the
offset by bliting only from byte boundaries and hardware clipping.
2.5.2 CPU To Screen Color Expansion
The CPUToScreenColorExpandFill routines provide an interface for
doing expansion blits from source patterns stored in system memory.
There are two varieties of this primitive, a CPUToScreenColorExpandFill
and a ScanlineCPUToScreenColorExpandFill. With the
CPUToScreenColorExpandFill method, the source data is sent serially
through a memory mapped aperature. With the Scanline version, the
data is rendered scanline at a time into intermediate buffers with
a call to SubsequentColorExpandScanline following each scanline.
These two methods have separate flags fields, the
CPUToScreenColorExpandFillFlags and ScanlineCPUToScreenColorExpandFillFlags
respectively. Flags specific to one method or the other are described
in sections 2.5.2.1 and 2.5.2.2 but for both cases the bit order and
transparency restrictions listed at the beginning of section 2.5 are
valid as well as the following:
/* clipping (optional) */
LEFT_EDGE_CLIPPING
This indicates that the accelerator supports omission of up to
31 pixels on the left edge of the rectangle to be filled. This
is beneficial since it allows transfer of the source bitmap to
always occur from DWORD boundaries.
LEFT_EDGE_CLIPPING_NEGATIVE_X
This flag indicates that the accelerator can render color expansion
rectangles even if the value of x origin is negative (off of
the screen on the left edge).
/* misc */
TRIPLE_BITS_24BPP
When enabled (must be in 24bpp mode), color expansion functions
are expected to require three times the amount of bits to be
transferred so that 24bpp grayscale colors can be used with color
expansion in 8bpp coprocessor mode. Each bit is expanded to 3
bits when writing the monochrome data.
2.5.1 The Direct Method
Using the direct method of color expansion XAA will send all
bitmap data to the accelerator serially through an memory mapped
transfer window defined by the following two fields:
unsigned char *ColorExpandBase
This indicates the memory address of the beginning of the aperture.
int ColorExpandRange
This indicates the size in bytes of the aperture.
The driver should specify how the transfered data should be padded.
There are options for both the padding of each Y scanline and for the
total transfer to the aperature.
One of the following two flags must be set:
CPU_TRANSFER_PAD_DWORD
This indicates that the total transfer (sum of all scanlines) sent
to the aperature must be DWORD padded. This is the default behavior.
CPU_TRANSFER_PAD_QWORD
This indicates that the total transfer (sum of all scanlines) sent
to the aperature must be QWORD padded. With this set, XAA will send
an extra DWORD to the aperature when needed to ensure that only
an even number of DWORDs are sent.
And then there are the flags for padding of each scanline:
SCANLINE_PAD_DWORD
This indicates that each Y scanline should be DWORD padded.
This is the only option available and is the default.
Finally, there is the CPU_TRANSFER_BASE_FIXED flag which indicates
that the aperture is a single register rather than a range of
registers, and XAA should write all of the data to the first DWORD.
If the ColorExpandRange is not large enough to accomodate scanlines
the width of the screen, this option will be forced. That is, the
ColorExpandRange must be:
((virtualX + 31)/32) * 4 bytes or more.
((virtualX + 62)/32 * 4) if LEFT_EDGE_CLIPPING_NEGATIVE_X is set.
If the TRIPLE_BITS_24BPP flag is set, the required area should be
multiplied by three.
void SetupForCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
int fg, int bg,
int rop,
unsigned int planemask)
Ones in the source bitmap will correspond to the fg color.
Zeros in the source bitmap will correspond to the bg color
unless bg = -1. In that case the pixels corresponding to the
zeros in the bitmap shall be left unmodified by the accelerator.
void SubsequentCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
int x, int y, int w, int h,
int skipleft )
When this function is called, the accelerator should be setup
to fill a rectangle of dimension "w" by "h" with origin at (x,y)
in the fill style prescribed by the last call to
SetupForCPUToScreenColorExpandFill. XAA will pass the data to
the aperture immediately after this function is called. If the
skipleft is non-zero (and LEFT_EDGE_CLIPPING has been enabled), then
the accelerator _should_not_ render skipleft pixels on the leftmost
edge of the rectangle. Some engines have an alignment feature
like this built in, some others can do this using a clipping
window.
It can be arranged for XAA to call Sync() after it is through
calling the Subsequent function by setting SYNC_AFTER_COLOR_EXPAND
in the CPUToScreenColorExpandFillFlags. This can provide the driver
with an oportunity to reset a clipping window if needed.
2.5.2 The Indirect Method
Using the indirect method, XAA will render the bitmap data scanline
at a time to one or more buffers. These buffers may be memory
mapped apertures or just intermediate storage.
int NumScanlineColorExpandBuffers
This indicates the number of buffers available.
unsigned char **ScanlineColorExpandBuffers
This is an array of pointers to the memory locations of each buffer.
Each buffer is expected to be large enough to accommodate scanlines
the width of the screen. That is:
((virtualX + 31)/32) * 4 bytes or more.
((virtualX + 62)/32 * 4) if LEFT_EDGE_CLIPPING_NEGATIVE_X is set.
Scanlines are always DWORD padded.
If the TRIPLE_BITS_24BPP flag is set, the required area should be
multiplied by three.
void SetupForScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
int fg, int bg,
int rop,
unsigned int planemask)
Ones in the source bitmap will correspond to the fg color.
Zeros in the source bitmap will correspond to the bg color
unless bg = -1. In that case the pixels corresponding to the
zeros in the bitmap shall be left unmodified by the accelerator.
void SubsequentScanlineCPUToScreenColorExpandFill(ScrnInfoPtr pScrn,
int x, int y, int w, int h,
int skipleft )
void SubsequentColorExpandScanline(ScrnInfoPtr pScrn, int bufno)
When SubsequentScanlineCPUToScreenColorExpandFill is called, XAA
will begin transfering the source data scanline at a time, calling
SubsequentColorExpandScanline after each scanline. If more than
one buffer is available, XAA will cycle through the buffers.
Subsequent scanlines will use the next buffer and go back to the
buffer 0 again when the last buffer is reached. The index into
the ScanlineColorExpandBuffers array is presented as "bufno"
with each SubsequentColorExpandScanline call.
The skipleft field is the same as for the direct method.
The indirect method can be use to send the source data directly
to a memory mapped aperture represented by a single color expand
buffer, scanline at a time, but more commonly it is used to place
the data into offscreen video memory so that the accelerator can
blit it to the visible screen from there. In the case where the
accelerator permits rendering into offscreen video memory while
the accelerator is active, several buffers can be used so that
XAA can be placing source data into the next buffer while the
accelerator is blitting the current buffer. For cases where
the accelerator requires some special manipulation of the source
data first, the buffers can be in system memory. The CPU can
manipulate these buffers and then send the data to the accelerator.
2.6 8x8 Mono Pattern Fills
XAA provides support for two types of 8x8 hardware patterns -
"Mono" patterns and "Color" patterns. Mono pattern data is
64 bits of color expansion data with ones indicating the
foreground color and zeros indicating the background color.
The source bitmaps for the 8x8 mono patterns can be presented
to the graphics accelerator in one of two ways. They can be
passed as two DWORDS to the 8x8 mono pattern functions or
they can be cached in offscreen memory and their locations
passed to the 8x8 mono pattern functions. In addition to the
GXCOPY_ONLY, ROP_NEEDS_SOURCE, NO_PLANEMASK and RGB_EQUAL flags
defined in Section 2.0, the following are defined for the
Mono8x8PatternFillFlags:
HARDWARE_PATTERN_PROGRAMMED_BITS
This indicates that the 8x8 patterns should be packed into two
DWORDS and passed to the 8x8 mono pattern functions. The default
behavior is to cache the patterns in offscreen video memory and
pass the locations of these patterns to the functions instead.
The pixmap cache must be enabled for the default behavior (8x8
pattern caching) to work. See Section 3 for how to enable the
pixmap cache. The pixmap cache is not necessary for
HARDWARE_PATTERN_PROGRAMMED_BITS.
HARDWARE_PATTERN_PROGRAMMED_ORIGIN
If the hardware supports programmable pattern offsets then
this option should be set. See the table below for further
infomation.
HARDWARE_PATTERN_SCREEN_ORIGIN
Some hardware wants the pattern offset specified with respect to the
upper left-hand corner of the primitive being drawn. Other hardware
needs the option HARDWARE_PATTERN_SCREEN_ORIGIN set to indicate that
all pattern offsets should be referenced to the upper left-hand
corner of the screen. HARDWARE_PATTERN_SCREEN_ORIGIN is preferable
since this is more natural for the X-Window system and offsets will
have to be recalculated for each Subsequent function otherwise.
BIT_ORDER_IN_BYTE_MSBFIRST
BIT_ORDER_IN_BYTE_LSBFIRST
As with other color expansion routines this indicates whether the
most or the least significant bit in each byte from the pattern is
the leftmost on the screen.
TRANSPARENCY_ONLY
NO_TRANSPARENCY
This means the same thing as for the color expansion rect routines
except that for TRANSPARENCY_ONLY XAA will not render the primitive
in two passes since this is more easily handled by the driver.
It is recommended that TRANSPARENCY_ONLY hardware handle rendering
of opaque patterns in two passes (the background can be filled as
a rectangle in GXcopy) in the Subsequent function so that the
TRANSPARENCY_ONLY restriction can be removed.
Additional information about cached patterns...
For the case where HARDWARE_PATTERN_PROGRAMMED_BITS is not set and
the pattern must be cached in offscreen memory, the first pattern
starts at the cache slot boundary which is set by the
CachePixelGranularity field used to configure the pixmap cache.
One should ensure that the CachePixelGranularity reflects any
alignment restrictions that the accelerator may put on 8x8 pattern
storage locations. When HARDWARE_PATTERN_PROGRAMMED_ORIGIN is set
there is only one pattern stored. When this flag is not set,
all 64 pre-rotated copies of the pattern are cached in offscreen memory.
The MonoPatternPitch field can be used to specify the X position pixel
granularity that each of these patterns must align on. If the
MonoPatternPitch is not supplied, the patterns will be densely packed
within the cache slot. The behavior of the default XAA 8x8 pattern
caching mechanism to store all 8x8 patterns linearly in video memory.
If the accelerator needs the patterns stored in a more unusual fashion,
the driver will need to provide its own 8x8 mono pattern caching
routines for XAA to use.
The following table describes the meanings of the "patx" and "paty"
fields in both the SetupFor and Subsequent functions.
With HARDWARE_PATTERN_SCREEN_ORIGIN
-----------------------------------
HARDWARE_PATTERN_PROGRAMMED_BITS and HARDWARE_PATTERN_PROGRAMMED_ORIGIN
SetupFor: patx and paty are the first and second DWORDS of the
8x8 mono pattern.
Subsequent: patx and paty are the x,y offset into that pattern.
All Subsequent calls will have the same offset in
the case of HARDWARE_PATTERN_SCREEN_ORIGIN so only
the offset specified by the first Subsequent call
after a SetupFor call will need to be observed.
HARDWARE_PATTERN_PROGRAMMED_BITS only
SetupFor: patx and paty hold the first and second DWORDS of
the 8x8 mono pattern pre-rotated to match the desired
offset.
Subsequent: These just hold the same patterns and can be ignored.
HARDWARE_PATTERN_PROGRAMMED_ORIGIN only
SetupFor: patx and paty hold the x,y coordinates of the offscreen
memory location where the 8x8 pattern is stored. The
bits are stored linearly in memory at that location.
Subsequent: patx and paty hold the offset into the pattern.
All Subsequent calls will have the same offset in
the case of HARDWARE_PATTERN_SCREEN_ORIGIN so only
the offset specified by the first Subsequent call
after a SetupFor call will need to be observed.
Neither programmed bits or origin
SetupFor: patx and paty hold the x,y coordinates of the offscreen
memory location where the pre-rotated 8x8 pattern is
stored.
Subsequent: patx and paty are the same as in the SetupFor function
and can be ignored.
Without HARDWARE_PATTERN_SCREEN_ORIGIN
--------------------------------------
HARDWARE_PATTERN_PROGRAMMED_BITS and HARDWARE_PATTERN_PROGRAMMED_ORIGIN
SetupFor: patx and paty are the first and second DWORDS of the
8x8 mono pattern.
Subsequent: patx and paty are the x,y offset into that pattern.
HARDWARE_PATTERN_PROGRAMMED_BITS only
SetupFor: patx and paty holds the first and second DWORDS of
the unrotated 8x8 mono pattern. This can be ignored.
Subsequent: patx and paty hold the rotated 8x8 pattern to be
rendered.
HARDWARE_PATTERN_PROGRAMMED_ORIGIN only
SetupFor: patx and paty hold the x,y coordinates of the offscreen
memory location where the 8x8 pattern is stored. The
bits are stored linearly in memory at that location.
Subsequent: patx and paty hold the offset into the pattern.
Neither programmed bits or origin
SetupFor: patx and paty hold the x,y coordinates of the offscreen
memory location where the unrotated 8x8 pattern is
stored. This can be ignored.
Subsequent: patx and paty hold the x,y coordinates of the
rotated 8x8 pattern to be rendered.
void SetupForMono8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,
int fg, int bg, int rop, unsigned int planemask)
SetupForMono8x8PatternFill indicates that any combination of the
following may follow it.
SubsequentMono8x8PatternFillRect
SubsequentMono8x8PatternFillTrap
The fg, bg, rop and planemask fields have the same meaning as the
ones used for the other color expansion routines. Patx's and paty's
meaning can be determined from the table above.
void SubsequentMono8x8PatternFillRect( ScrnInfoPtr pScrn,
int patx, int paty, int x, int y, int w, int h)
Fill a rectangle of dimensions "w" by "h" with origin at (x,y)
using the parameters give by the last SetupForMono8x8PatternFill
call. The meanings of patx and paty can be determined by the
table above.
void SubsequentMono8x8PatternFillTrap( ScrnInfoPtr pScrn,
int patx, int paty, int y, int h,
int left, int dxL, int dyL, int eL,
int right, int dxR, int dyR, int eR )
The meanings of patx and paty can be determined by the table above.
The rest of the fields have the same meanings as those in the
SubsequentSolidFillTrap function.
2.7 8x8 Color Pattern Fills
8x8 color pattern data is 64 pixels of full color data that
is stored linearly in offscreen video memory. 8x8 color patterns
are useful as a substitute for 8x8 mono patterns when tiling,
doing opaque stipples, or in the case where transperency is
supported, regular stipples. 8x8 color pattern fills also have
the additional benefit of being able to tile full color 8x8
patterns instead of just 2 color ones like the mono patterns.
However, full color 8x8 patterns aren't used very often in the
X Window system so you might consider passing this primitive
by if you already can do mono patterns, especially if they
require alot of cache area. Color8x8PatternFillFlags is
the flags field for this primitive and the GXCOPY_ONLY,
ROP_NEEDS_SOURCE and NO_PLANEMASK flags as described in
Section 2.0 are valid as well as the following:
HARDWARE_PATTERN_PROGRAMMED_ORIGIN
If the hardware supports programmable pattern offsets then
this option should be set.
HARDWARE_PATTERN_SCREEN_ORIGIN
Some hardware wants the pattern offset specified with respect to the
upper left-hand corner of the primitive being drawn. Other hardware
needs the option HARDWARE_PATTERN_SCREEN_ORIGIN set to indicate that
all pattern offsets should be referenced to the upper left-hand
corner of the screen. HARDWARE_PATTERN_SCREEN_ORIGIN is preferable
since this is more natural for the X-Window system and offsets will
have to be recalculated for each Subsequent function otherwise.
NO_TRANSPARENCY
TRANSPARENCY_GXCOPY_ONLY
These mean the same as for the ScreenToScreenCopy functions.
The following table describes the meanings of patx and paty passed
to the SetupFor and Subsequent fields:
HARDWARE_PATTERN_PROGRAMMED_ORIGIN && HARDWARE_PATTERN_SCREEN_ORIGIN
SetupFor: patx and paty hold the x,y location of the unrotated
pattern.
Subsequent: patx and paty hold the pattern offset. For the case
of HARDWARE_PATTERN_SCREEN_ORIGIN all Subsequent calls
have the same offset so only the first call will need
to be observed.
HARDWARE_PATTERN_PROGRAMMED_ORIGIN only
SetupFor: patx and paty hold the x,y location of the unrotated
pattern.
Subsequent: patx and paty hold the pattern offset.
HARDWARE_PATTERN_SCREEN_ORIGIN
SetupFor: patx and paty hold the x,y location of the rotated pattern.
Subsequent: patx and paty hold the same location as the SetupFor
function so these can be ignored.
neither flag
SetupFor: patx and paty hold the x,y location of the unrotated
pattern. This can be ignored.
Subsequent: patx and paty hold the x,y location of the rotated
pattern.
Additional information about cached patterns...
All 8x8 color patterns are cached in offscreen video memory so
the pixmap cache must be enabled to use them. The first pattern
starts at the cache slot boundary which is set by the
CachePixelGranularity field used to configure the pixmap cache.
One should ensure that the CachePixelGranularity reflects any
alignment restrictions that the accelerator may put on 8x8 pattern
storage locations. When HARDWARE_PATTERN_PROGRAMMED_ORIGIN is set
there is only one pattern stored. When this flag is not set,
all 64 rotations off the pattern are accessible but it is assumed
that the accelerator is capable of accessing data stored on 8
pixel boundaries. If the accelerator has stricter alignment
requirements than this the dirver will need to provide its own
8x8 color pattern caching routines.
void SetupForColor8x8PatternFill(ScrnInfoPtr pScrn, int patx, int paty,
int rop, unsigned int planemask, int trans_color)
SetupForColor8x8PatternFill indicates that any combination of the
following may follow it.
SubsequentColor8x8PatternFillRect
SubsequentColor8x8PatternFillTrap (not implemented yet)
For the meanings of patx and paty, see the table above. Trans_color
means the same as for the ScreenToScreenCopy functions.
void SubsequentColor8x8PatternFillRect( ScrnInfoPtr pScrn,
int patx, int paty, int x, int y, int w, int h)
Fill a rectangle of dimensions "w" by "h" with origin at (x,y)
using the parameters give by the last SetupForColor8x8PatternFill
call. The meanings of patx and paty can be determined by the
table above.
void SubsequentColor8x8PatternFillTrap( ScrnInfoPtr pScrn,
int patx, int paty, int y, int h,
int left, int dxL, int dyL, int eL,
int right, int dxR, int dyR, int eR )
For the meanings of patx and paty, see the table above.
The rest of the fields have the same meanings as those in the
SubsequentSolidFillTrap function.
2.8 Image Writes
XAA provides a mechanism for transfering full color pixel data from
system memory to video memory through the accelerator. This is
useful for dealing with alignment issues and performing raster ops
on the data when writing it to the framebuffer. As with color
expansion rectangles, there is a direct and indirect method. The
direct method sends all data through a memory mapped aperature.
The indirect method sends the data to an intermediated buffer scanline
at a time.
The direct and indirect methods have separate flags fields, the
ImageWriteFlags and ScanlineImageWriteFlags respectively.
Flags specific to one method or the other are described in sections
2.8.1 and 2.8.2 but for both cases the GXCOPY_ONLY, ROP_NEEDS_SOURCE
and NO_PLANEMASK flags described in Section 2.0 are valid as well as
the following:
NO_GXCOPY
In order to have accelerated image transfers faster than the
software versions for GXcopy, the engine needs to support clipping,
be using the direct method and have a large enough image transfer
range so that CPU_TRANSFER_BASE_FIXED doesn't need to be set.
If these are not supported, then it is unlikely that transfering
the data through the accelerator will be of any advantage for the
simple case of GXcopy. In fact, it may be much slower. For such
cases it's probably best to set the NO_GXCOPY flag so that
Image writes will only be used for the more complicated rops.
/* transparency restrictions */
NO_TRANSPARENCY
This indicates that the accelerator does not support skipping
of color keyed pixels when copying from the source to the destination.
TRANSPARENCY_GXCOPY_ONLY
This indicates that the accelerator supports skipping of color keyed
pixels only when the rop is GXcopy.
/* clipping (optional) */
LEFT_EDGE_CLIPPING
This indicates that the accelerator supports omission of up to
3 pixels on the left edge of the rectangle to be filled. This
is beneficial since it allows transfer from the source pixmap to
always occur from DWORD boundaries.
LEFT_EDGE_CLIPPING_NEGATIVE_X
This flag indicates that the accelerator can fill areas with
image write data even if the value of x origin is negative (off of
the screen on the left edge).
2.8.1 The Direct Method
Using the direct method of ImageWrite XAA will send all
bitmap data to the accelerator serially through an memory mapped
transfer window defined by the following two fields:
unsigned char *ImageWriteBase
This indicates the memory address of the beginning of the aperture.
int ImageWriteRange
This indicates the size in bytes of the aperture.
The driver should specify how the transfered data should be padded.
There are options for both the padding of each Y scanline and for the
total transfer to the aperature.
One of the following two flags must be set:
CPU_TRANSFER_PAD_DWORD
This indicates that the total transfer (sum of all scanlines) sent
to the aperature must be DWORD padded. This is the default behavior.
CPU_TRANSFER_PAD_QWORD
This indicates that the total transfer (sum of all scanlines) sent
to the aperature must be QWORD padded. With this set, XAA will send
an extra DWORD to the aperature when needed to ensure that only
an even number of DWORDs are sent.
And then there are the flags for padding of each scanline:
SCANLINE_PAD_DWORD
This indicates that each Y scanline should be DWORD padded.
This is the only option available and is the default.
Finally, there is the CPU_TRANSFER_BASE_FIXED flag which indicates
that the aperture is a single register rather than a range of
registers, and XAA should write all of the data to the first DWORD.
XAA will automatically select CPU_TRANSFER_BASE_FIXED if the
ImageWriteRange is not large enough to accomodate an entire scanline.
void SetupForImageWrite(ScrnInfoPtr pScrn, int rop, unsigned int planemask,
int trans_color, int bpp, int depth)
If trans_color is not -1 then trans_color indicates the transparency
color key and pixels with color trans_color passed through the
aperature should not be transfered to the screen but should be
skipped. Bpp and depth indicate the bits per pixel and depth of
the source pixmap. Trans_color is always -1 if the NO_TRANSPARENCY
flag is set.
void SubsequentImageWriteRect(ScrnInfoPtr pScrn,
int x, int y, int w, int h, int skipleft)
Data passed through the aperature should be copied to a rectangle
of width "w" and height "h" with origin (x,y). If LEFT_EDGE_CLIPPING
has been enabled, skipleft will correspond to the number of pixels
on the left edge that should not be drawn. Skipleft is zero
otherwise.
It can be arranged for XAA to call Sync() after it is through
calling the Subsequent functions by setting SYNC_AFTER_IMAGE_WRITE
in the ImageWriteFlags. This can provide the driver with an
oportunity to reset a clipping window if needed.
2.8.2 The Indirect Method
Using the indirect method, XAA will render the pixel data scanline
at a time to one or more buffers. These buffers may be memory
mapped apertures or just intermediate storage.
int NumScanlineImageWriteBuffers
This indicates the number of buffers available.
unsigned char **ScanlineImageWriteBuffers
This is an array of pointers to the memory locations of each buffer.
Each buffer is expected to be large enough to accommodate scanlines
the width of the screen. That is:
pScrn->VirtualX * pScreen->bitsPerPixel/8 bytes or more.
If LEFT_EDGE_CLIPPING_NEGATIVE_X is set, add an additional 4
bytes to that requirement in 8 and 16bpp, 12 bytes in 24bpp.
Scanlines are always DWORD padded.
void SetupForScanlineImageWrite(ScrnInfoPtr pScrn, int rop,
unsigned int planemask, int trans_color,
int bpp, int depth)
If trans_color is not -1 then trans_color indicates the transparency
color key and pixels with color trans_color in the buffer should not
be transfered to the screen but should be skipped. Bpp and depth
indicate the bits per pixel and depth of the source bitmap.
Trans_color is always -1 if the NO_TRANSPARENCY flag is set.
void SubsequentImageWriteRect(ScrnInfoPtr pScrn,
int x, int y, int w, int h, int skipleft)
void SubsequentImageWriteScanline(ScrnInfoPtr pScrn, int bufno)
When SubsequentImageWriteRect is called, XAA will begin
transfering the source data scanline at a time, calling
SubsequentImageWriteScanline after each scanline. If more than
one buffer is available, XAA will cycle through the buffers.
Subsequent scanlines will use the next buffer and go back to the
buffer 0 again when the last buffer is reached. The index into
the ScanlineImageWriteBuffers array is presented as "bufno"
with each SubsequentImageWriteScanline call.
The skipleft field is the same as for the direct method.
The indirect method can be use to send the source data directly
to a memory mapped aperture represented by a single image write
buffer, scanline at a time, but more commonly it is used to place
the data into offscreen video memory so that the accelerator can
blit it to the visible screen from there. In the case where the
accelerator permits rendering into offscreen video memory while
the accelerator is active, several buffers can be used so that
XAA can be placing source data into the next buffer while the
accelerator is blitting the current buffer. For cases where
the accelerator requires some special manipulation of the source
data first, the buffers can be in system memory. The CPU can
manipulate these buffers and then send the data to the accelerator.
2.9 Clipping
XAA supports hardware clipping rectangles. To use clipping
in this way it is expected that the graphics accelerator can
clip primitives with verticies anywhere in the 16 bit signed
coordinate system.
void SetClippingRectangle ( ScrnInfoPtr pScrn,
int left, int top, int right, int bottom)
void DisableClipping (ScrnInfoPtr pScrn)
When SetClippingRectangle is called, all hardware rendering
following it should be clipped to the rectangle specified
until DisableClipping is called.
The ClippingFlags field indicates which operations this sort
of Set/Disable pairing can be used with. Any of the following
flags may be OR'd together.
HARDWARE_CLIP_SCREEN_TO_SCREEN_COLOR_EXPAND
HARDWARE_CLIP_SCREEN_TO_SCREEN_COPY
HARDWARE_CLIP_MONO_8x8_FILL
HARDWARE_CLIP_COLOR_8x8_FILL
HARDWARE_CLIP_SOLID_FILL
HARDWARE_CLIP_DASHED_LINE
HARDWARE_CLIP_SOLID_LINE
3) XAA PIXMAP CACHE
/* NOTE: XAA has no knowledge of framebuffer particulars so until
the framebuffer is able to render into offscreen memory, usage
of the pixmap cache requires that the driver provide ImageWrite
routines or a WritePixmap or WritePixmapToCache replacement so
that patterns can even be placed in the cache.
ADDENDUM: XAA can now load the pixmap cache without requiring
that the driver supply an ImageWrite function, but this can
only be done on linear framebuffers. If you have a linear
framebuffer, set LINEAR_FRAMEBUFFER in the XAAInfoRec.Flags
field and XAA will then be able to upload pixmaps into the
cache without the driver providing functions to do so.
*/
The XAA pixmap cache provides a mechanism for caching of patterns
in offscreen video memory so that tiled fills and in some cases
stippling can be done by blitting the source patterns from offscreen
video memory. The pixmap cache also provides the mechanism for caching
of 8x8 color and mono hardware patterns. Any unused offscreen video
memory gets used for the pixmap cache and that information is
provided by the XFree86 Offscreen Memory Manager. XAA registers a
callback with the manager so that it can be informed of any changes
in the offscreen memory configuration. The driver writer does not
need to deal with any of this since it is all automatic. The driver
merely needs to initialize the Offscreen Memory Manager as described
in the DESIGN document and set the PIXMAP_CACHE flag in the
XAAInfoRec.Flags field. The Offscreen Memory Manager initialization
must occur before XAA is initialized or else pixmap cache
initialization will fail.
PixmapCacheFlags is an XAAInfoRec field which allows the driver to
control pixmap cache behavior to some extent. Currently only one
flag is defined:
DO_NOT_BLIT_STIPPLES
This indicates that the stippling should not be done by blitting
from the pixmap cache. This does not apply to 8x8 pattern fills.
CachePixelGranularity is an optional field. If the hardware requires
that a 8x8 patterns have some particular pixel alignment it should
be reflected in this field. Ignoring this field or setting it to
zero or one means there are no alignment issues.
4) OFFSCREEN PIXMAPS
XAA has the ability to store pixmap drawables in offscreen video
memory and render into them with full hardware acceleration. Placement
of pixmaps in the cache is done automatically on a first-come basis and
only if there is room. To enable this feature, set the OFFSCREEN_PIXMAPS
flag in the XAAInfoRec.Flags field. This is only available when a
ScreenToScreenCopy function is provided, when the Offscreen memory
manager has been initialized and when the LINEAR_FRAMEBUFFER flag is
also set.
int maxOffPixWidth
int maxOffPixHeight
These two fields allow the driver to limit the maximum dimensions
of an offscreen pixmap. If one of these is not set, it is assumed
that there is no limit on that dimension. Note that if an offscreen
pixmap with a particular dimension is allowed, then your driver will be
expected to render primitives as large as that pixmap.
$XFree86: xc/programs/Xserver/hw/xfree86/xaa/XAA.HOWTO,v 1.12 2000/04/12 14:44:42 tsi Exp $