down into an OutReverse and an Add. Turn off the fallback to software
glyphs when component alpha, now that we expect all (new) drivers to be
able to support it. Also, make Xephyr fall back in the CA Over case to
exercise this code. This speeds up my rgb24text and ls -lR in
gnome-terminal by a factor of 5.
lack of a better name. This one behaves somewhat between Greedy and
Always. It moves in if we can accelerate, unless the destination is
clean and shouldn't be kept in framebuffer according to the score, in
which case we migrate out (and force-migrate anything where migration
is free). This should help fix lack of acceleration for drivers without
UTS since removing exaAsyncPixmapGCOps, and has removed one performance
trap with Radeon I'd noticed. It is the new default.
devPrivate.ptr when pointing at offscreen memory, outside of
exaPrepare/FinishAccess(). This was used with fakexa to find (by NULL
dereference) many instances of un-Prepared CPU access to the
framebuffer:
- GC tiles used in several ops when fillStyle == FillTiled were never
Prepared.
- Migration could lead to un-Prepared access to mask data in render's
Trapezoids and Triangles
- PutImage's UploadToScreen failure fallback failed to Prepare.
acceleration, and set the migration scheme to Always on init (since
this is all for testing, and Always should make migration happen more
frequently than Greedy).
same width/height for front-buffer drawing. The fakexa code then uses
this extra space for offscreen pixmaps. Note that this tones down the
absurdity of fakexa's offscreen pixmap alignment requirements (odd
alignment is too weird, so stick with "24", which is still strange but
exists out there). It also fixes a couple of bugs in the fakexa
implementation revealed by using offscreen pixmaps.
when extending the driver interface. The card and accel structures are
merged into the ExaDriverRec, which is to be allocated using
exaDriverAlloc(). The driver structure also grows exa_major and
exa_minor, which drivers fill in and have checked by EXA
(double-checking that the driver really did check that the EXA version
was correct). Removes exaInitCard(), which is replaced by the driver
filling in the rec by hand, and the exaGetVersion() and related
EXA_*VERSION which are replaced by always using the XFree86 loadable
module versioning.
implementation that calls fb to get its work done. The purpose is to
have a trusted EXA driver for use with testing changes to the core of
EXA. However, fakexa has not received much testing yet, lacks offscreen
pixmaps support, and doesn't reliably provide garbage when EXA doesn't
get its syncing right. All of these should be fixed soon.
Attempt to build xeglmodule.c, not xglxmodule.c.
Add xf86Sbus.h to EXTRA_DIST, as _HEADERS doesn't appear to get the same
treatment as _SOURCES in terms of automatically DISTing.
Changed the semantics of the Convolution filter a bit. It now doesn't try
to normalize the filter values but leaves this to the client. This
gives more reasonable behaviour in the limit where the filter
parameters sum up to 0.
implementation. Includes cache flushing to prevent bad first reads of
the framebuffer, fixing blending of many formats, falling back on many
unsupported operations, and falling back early to prevent migration.
Passes all of rendercheck except some of the blend (!) tests.
in the kaa structure: markSync and waitMarker. The first, if set,
returns a hardware-dependent marker number which can then be waited for
with waitMarker. If markSync is absent (which is the case on all
drivers currently), waitMarker must wait for idle on any given marker
number. The intention is to allow for more parallelism when we get
downloading from framebuffer, or more fine-grained idling.
- Replace the KdMarkSync/KdCheckSync functions with kaaMarkSync and
kaaWaitSync. These will need to be refined when KAA starts being smart
about using them. Merge kpict.c into kasync.c since kasyn.c has all the
rest of these fallback funcs.
- Restructure all drivers to initialize a KaaInfo structure by hand rather
than statically in dubious order.
- Whack the i810 driver into shape in hopes that it'll work after this
change (it certainly wouldn't have before this). Doesn't support my
i845 though.
- Make a new KXV helper to avoid duplicated code to fill the region with
the necessary color key. Use it in i810 and mach64 (tested).
When COMPOSITE is enabled, call CopyWindow even when the pixels "don't
move" on screen.
Don't reject modes that are not supported by the unused monitor.
but includes debugging to ensure that the reg being submitted is the
one that follows in the packet. Convert most uses of OUT_RING to it,
and convert a couple of OUT_REG sets to DMA_PACKET0/OUT_RING_REG. Also,
add checking to see if more registers are submitted to a DMA_PACKET0
than should be, to avoid hangs during stupid mistakes (checking for
less isn't done).
reading a register/attempting DMA. Now it'll wait for a certain number
of seconds rather than a certain number of times through the loop
before deciding that it's timed out and resetting the hardware. Also,
add more timeout handling, and reset the draw state after resetting the
engine.
are always emitted. Fix the real problem, which was not enough regs
being initialized in ati_draw.c. Fix a typo that was resulting in alpha
coming out as 0 * src or 0 * broken instead of src * 1 or src * mask.
Assign the blending results to R0, as appears to be necessary. Unbreak
the dst-alpha-blend-with-no-dst-alpha code. Yow. And set the right DMA
count for the r200 traps code.
non-mask rendering. Reenable it. Also, R200TexFormats was used instead
of R100 in one place. Harmless so far, because the formats were in the
same order.
troubles.
- Move the RemoveBlockAndWakeupHandlers to match
RegisterBlockAndWakeupHandlers.
- Enable R100 trapezoid "acceleration" when DRI is working, so that it can
be exposed and worked on.
instead of ErrorFs for things that are really bad, and put limits on
some loops. Now, sometimes instead of hanging the entire system, we
(mostly-) cleanly drop to console when the card has hung.
not doing an add of 1 per triangle like I hoped, and instead seems to
be saturating all the pixels or something. The R100 acceleration
renders pretty well, with some gaps. Note that both are slower than
software due to lack of DMA to submit vertices.
- Mostly fix R128 and Radeon transform support, including supporting
bilinear filtering on R128. Subpixel offsets are still probably an
issue (reported by rendercheck), but I want to make 100% sure about my
understanding of the protocol before changing everybody, including fb.
- Add support for dst formats without alpha to R128 Composite.
- Remove the R128 Blend code, which has long outlived its usefulness. (I
kept it around for one reason: It could be useful for the w/h > 1024
case with no mask and a non-src op. That seems pretty infrequent and
not worth the trouble).
might be able to do Precise in hardware, so leave it up to the driver.
- Add a helper function for computing a set of offsets for smooth trapezoid
rasterizing using many sharp trapezoids.
RasterizeTrapezoid screen function. These hooks will be called for
imprecise, non-sharp trapezoids with A8 destinations.
Note that the current main consumer of trapezoids, cairo, is requesting
precise, sharp trapezoids by not changing the default Picture
attributes, but gets non-sharp effects in software because fb bases its
choice of sharp/non-sharp on the mask format being A8 vs A1, and cairo
asks for A8. Follow fb's (poor?) example by ignoring the sharp setting
and basing the choice off of the mask being A8.
heuristic, delay the decision until the first
kaaPixmapUse{Screen|Memory}, and put it in framebuffer if UseScreen was
called. Provides a significant improvement in cairo speeds (100%
speedup in cairogears here) and is likely to improve text performance
as well.
