void
uxa_check_poly_arc(DrawablePtr pDrawable, GCPtr pGC, int narcs, xArc * pArcs)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
/* Disable this as fbPolyArc can call miZeroPolyArc which in turn
* can call accelerated functions, that as yet, haven't been notified
* with uxa_finish_access().
*/
#if 0
if (pGC->lineWidth == 0) {
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
if (uxa_prepare_access_gc(pGC)) {
fbPolyArc(pDrawable, pGC, narcs, pArcs);
uxa_finish_access_gc(pGC);
}
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
return;
}
#endif
miPolyArc(pDrawable, pGC, narcs, pArcs);
}
void
uxa_check_composite(CARD8 op,
PicturePtr pSrc,
PicturePtr pMask,
PicturePtr pDst,
INT16 xSrc, INT16 ySrc,
INT16 xMask, INT16 yMask,
INT16 xDst, INT16 yDst,
CARD16 width, CARD16 height)
{
ScreenPtr screen = pDst->pDrawable->pScreen;
UXA_FALLBACK(("from picts %p/%p to pict %p\n", pSrc, pMask, pDst));
if (uxa_picture_prepare_access(pDst, UXA_ACCESS_RW)) {
if (uxa_picture_prepare_access(pSrc, UXA_ACCESS_RO)) {
if (!pMask || uxa_picture_prepare_access(pMask, UXA_ACCESS_RO)) {
fbComposite(op, pSrc, pMask, pDst,
xSrc, ySrc,
xMask, yMask,
xDst, yDst,
width, height);
if (pMask)
uxa_picture_finish_access(pMask, UXA_ACCESS_RO);
}
uxa_picture_finish_access(pSrc, UXA_ACCESS_RO);
}
uxa_picture_finish_access(pDst, UXA_ACCESS_RW);
}
}
void
uxa_check_add_traps(PicturePtr pPicture,
INT16 x_off, INT16 y_off, int ntrap, xTrap * traps)
{
ScreenPtr screen = pPicture->pDrawable->pScreen;
UXA_FALLBACK(("to pict %p (%c)\n", pPicture,
uxa_drawable_location(pPicture->pDrawable)));
if (uxa_picture_prepare_access(pPicture, UXA_ACCESS_RW)) {
fbAddTraps(pPicture, x_off, y_off, ntrap, traps);
uxa_picture_finish_access(pPicture, UXA_ACCESS_RW);
}
}
void
uxa_check_set_spans(DrawablePtr pDrawable, GCPtr pGC, char *psrc,
DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
fbSetSpans(pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted);
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
}
void
uxa_check_poly_point(DrawablePtr pDrawable, GCPtr pGC, int mode, int npt,
DDXPointPtr pptInit)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
fbPolyPoint(pDrawable, pGC, mode, npt, pptInit);
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
}
void
uxa_check_get_spans(DrawablePtr pDrawable,
int wMax,
DDXPointPtr ppt, int *pwidth, int nspans, char *pdstStart)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("from %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RO)) {
fbGetSpans(pDrawable, wMax, ppt, pwidth, nspans, pdstStart);
uxa_finish_access(pDrawable, UXA_ACCESS_RO);
}
}
void
uxa_check_put_image(DrawablePtr pDrawable, GCPtr pGC, int depth,
int x, int y, int w, int h, int leftPad, int format,
char *bits)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
fbPutImage(pDrawable, pGC, depth, x, y, w, h, leftPad, format,
bits);
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
}
void
uxa_check_poly_fill_rect(DrawablePtr pDrawable, GCPtr pGC,
int nrect, xRectangle * prect)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
if (uxa_prepare_access_gc(pGC)) {
fbPolyFillRect(pDrawable, pGC, nrect, prect);
uxa_finish_access_gc(pGC);
}
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
}
void
uxa_check_fill_spans(DrawablePtr pDrawable, GCPtr pGC, int nspans,
DDXPointPtr ppt, int *pwidth, int fSorted)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
if (uxa_prepare_access_gc(pGC)) {
fbFillSpans(pDrawable, pGC, nspans, ppt, pwidth,
fSorted);
uxa_finish_access_gc(pGC);
}
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
}
void
uxa_check_image_glyph_blt(DrawablePtr pDrawable, GCPtr pGC,
int x, int y, unsigned int nglyph,
CharInfoPtr * ppci, pointer pglyphBase)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
if (uxa_prepare_access_gc(pGC)) {
fbImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppci,
pglyphBase);
uxa_finish_access_gc(pGC);
}
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
}
void
uxa_check_push_pixels(GCPtr pGC, PixmapPtr pBitmap,
DrawablePtr pDrawable, int w, int h, int x, int y)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("from %p to %p (%c,%c)\n", pBitmap, pDrawable,
uxa_drawable_location(&pBitmap->drawable),
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
if (uxa_prepare_access(&pBitmap->drawable, UXA_ACCESS_RO)) {
if (uxa_prepare_access_gc(pGC)) {
fbPushPixels(pGC, pBitmap, pDrawable, w, h, x,
y);
uxa_finish_access_gc(pGC);
}
uxa_finish_access(&pBitmap->drawable, UXA_ACCESS_RO);
}
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
}
RegionPtr
uxa_check_copy_area(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
int srcx, int srcy, int w, int h, int dstx, int dsty)
{
ScreenPtr screen = pSrc->pScreen;
RegionPtr ret = NULL;
UXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,
uxa_drawable_location(pSrc),
uxa_drawable_location(pDst)));
if (uxa_prepare_access(pDst, UXA_ACCESS_RW)) {
if (uxa_prepare_access(pSrc, UXA_ACCESS_RO)) {
ret =
fbCopyArea(pSrc, pDst, pGC, srcx, srcy, w, h, dstx,
dsty);
uxa_finish_access(pSrc, UXA_ACCESS_RO);
}
uxa_finish_access(pDst, UXA_ACCESS_RW);
}
return ret;
}
void
uxa_check_poly_segment(DrawablePtr pDrawable, GCPtr pGC,
int nsegInit, xSegment * pSegInit)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c) width %d, count %d\n", pDrawable,
uxa_drawable_location(pDrawable), pGC->lineWidth,
nsegInit));
if (pGC->lineWidth == 0) {
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
if (uxa_prepare_access_gc(pGC)) {
fbPolySegment(pDrawable, pGC, nsegInit,
pSegInit);
uxa_finish_access_gc(pGC);
}
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
return;
}
/* fb calls mi functions in the lineWidth != 0 case. */
fbPolySegment(pDrawable, pGC, nsegInit, pSegInit);
}
void
uxa_check_poly_lines(DrawablePtr pDrawable, GCPtr pGC,
int mode, int npt, DDXPointPtr ppt)
{
ScreenPtr screen = pDrawable->pScreen;
UXA_FALLBACK(("to %p (%c), width %d, mode %d, count %d\n",
pDrawable, uxa_drawable_location(pDrawable),
pGC->lineWidth, mode, npt));
if (pGC->lineWidth == 0) {
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RW)) {
if (uxa_prepare_access_gc(pGC)) {
fbPolyLine(pDrawable, pGC, mode, npt, ppt);
uxa_finish_access_gc(pGC);
}
uxa_finish_access(pDrawable, UXA_ACCESS_RW);
}
return;
}
/* fb calls mi functions in the lineWidth != 0 case. */
fbPolyLine(pDrawable, pGC, mode, npt, ppt);
}
void
uxa_copy_n_to_n(DrawablePtr pSrcDrawable,
DrawablePtr pDstDrawable,
GCPtr pGC,
BoxPtr pbox,
int nbox,
int dx,
int dy,
Bool reverse, Bool upsidedown, Pixel bitplane, void *closure)
{
ScreenPtr screen = pDstDrawable->pScreen;
uxa_screen_t *uxa_screen = uxa_get_screen(screen);
int src_off_x, src_off_y;
int dst_off_x, dst_off_y;
PixmapPtr pSrcPixmap, pDstPixmap;
if (uxa_screen->info->flags & UXA_USE_GLAMOR) {
int ok = 0;
if (uxa_prepare_access(pSrcDrawable, UXA_GLAMOR_ACCESS_RO)) {
if (uxa_prepare_access(pDstDrawable, UXA_GLAMOR_ACCESS_RW)) {
ok = glamor_copy_n_to_n_nf(pSrcDrawable, pDstDrawable,
pGC, pbox, nbox, dx, dy,
reverse, upsidedown, bitplane,
closure);
uxa_finish_access(pDstDrawable, UXA_GLAMOR_ACCESS_RW);
}
uxa_finish_access(pSrcDrawable, UXA_GLAMOR_ACCESS_RO);
}
if (!ok)
goto fallback;
return;
}
if (uxa_screen->force_fallback)
goto fallback;
pSrcPixmap = uxa_get_drawable_pixmap(pSrcDrawable);
pDstPixmap = uxa_get_drawable_pixmap(pDstDrawable);
if (!pSrcPixmap || !pDstPixmap)
goto fallback;
if (uxa_screen->info->check_copy &&
!uxa_screen->info->check_copy(pSrcPixmap, pDstPixmap,
pGC ? pGC->alu : GXcopy,
pGC ? pGC->planemask : FB_ALLONES))
goto fallback;
uxa_get_drawable_deltas(pSrcDrawable, pSrcPixmap, &src_off_x,
&src_off_y);
uxa_get_drawable_deltas(pDstDrawable, pDstPixmap, &dst_off_x,
&dst_off_y);
/* Mixed directions must be handled specially if the card is lame */
if ((uxa_screen->info->flags & UXA_TWO_BITBLT_DIRECTIONS) &&
reverse != upsidedown) {
if (uxa_copy_n_to_n_two_dir
(pSrcDrawable, pDstDrawable, pGC, pbox, nbox, dx, dy))
return;
goto fallback;
}
if (!uxa_pixmap_is_offscreen(pDstPixmap)) {
int stride, bpp;
char *dst;
if (!uxa_pixmap_is_offscreen(pSrcPixmap))
goto fallback;
if (!uxa_screen->info->get_image)
goto fallback;
/* Don't bother with under 8bpp, XYPixmaps. */
bpp = pSrcPixmap->drawable.bitsPerPixel;
if (bpp != pDstDrawable->bitsPerPixel || bpp < 8)
goto fallback;
/* Only accelerate copies: no rop or planemask. */
if (pGC && (!UXA_PM_IS_SOLID(pSrcDrawable, pGC->planemask) || pGC->alu != GXcopy))
goto fallback;
dst = pDstPixmap->devPrivate.ptr;
stride = pDstPixmap->devKind;
bpp /= 8;
while (nbox--) {
if (!uxa_screen->info->get_image(pSrcPixmap,
pbox->x1 + dx + src_off_x,
pbox->y1 + dy + src_off_y,
pbox->x2 - pbox->x1,
pbox->y2 - pbox->y1,
(char *) dst +
(pbox->y1 + dst_off_y) * stride +
(pbox->x1 + dst_off_x) * bpp,
stride))
goto fallback;
pbox++;
}
return;
}
if (uxa_pixmap_is_offscreen(pSrcPixmap)) {
if (!(*uxa_screen->info->prepare_copy) (pSrcPixmap, pDstPixmap,
reverse ? -1 : 1,
upsidedown ? -1 : 1,
pGC ? pGC->alu : GXcopy,
pGC ? pGC->
planemask : FB_ALLONES))
goto fallback;
while (nbox--) {
(*uxa_screen->info->copy) (pDstPixmap,
pbox->x1 + dx + src_off_x,
pbox->y1 + dy + src_off_y,
pbox->x1 + dst_off_x,
pbox->y1 + dst_off_y,
pbox->x2 - pbox->x1,
pbox->y2 - pbox->y1);
pbox++;
}
(*uxa_screen->info->done_copy) (pDstPixmap);
} else {
int stride, bpp;
char *src;
if (!uxa_screen->info->put_image)
goto fallback;
/* Don't bother with under 8bpp, XYPixmaps. */
bpp = pSrcPixmap->drawable.bitsPerPixel;
if (bpp != pDstDrawable->bitsPerPixel || bpp < 8)
goto fallback;
/* Only accelerate copies: no rop or planemask. */
if (pGC && (!UXA_PM_IS_SOLID(pSrcDrawable, pGC->planemask) || pGC->alu != GXcopy))
goto fallback;
src = pSrcPixmap->devPrivate.ptr;
stride = pSrcPixmap->devKind;
bpp /= 8;
while (nbox--) {
if (!uxa_screen->info->put_image(pDstPixmap,
pbox->x1 + dst_off_x,
pbox->y1 + dst_off_y,
pbox->x2 - pbox->x1,
pbox->y2 - pbox->y1,
(char *) src +
(pbox->y1 + dy + src_off_y) * stride +
(pbox->x1 + dx + src_off_x) * bpp,
stride))
goto fallback;
pbox++;
}
}
return;
fallback:
UXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrcDrawable, pDstDrawable,
uxa_drawable_location(pSrcDrawable),
uxa_drawable_location(pDstDrawable)));
if (uxa_prepare_access(pDstDrawable, UXA_ACCESS_RW)) {
if (pSrcDrawable == pDstDrawable ||
uxa_prepare_access(pSrcDrawable, UXA_ACCESS_RO)) {
fbCopyNtoN(pSrcDrawable, pDstDrawable, pGC, pbox, nbox,
dx, dy, reverse, upsidedown, bitplane,
closure);
if (pSrcDrawable != pDstDrawable)
uxa_finish_access(pSrcDrawable, UXA_ACCESS_RO);
}
uxa_finish_access(pDstDrawable, UXA_ACCESS_RW);
}
}
/**
* Accelerates GetImage for solid ZPixmap downloads from framebuffer memory.
*
* This is probably the only case we actually care about. The rest fall through
* to migration and fbGetImage, which hopefully will result in migration pushing
* the pixmap out of framebuffer.
*/
void
uxa_get_image(DrawablePtr pDrawable, int x, int y, int w, int h,
unsigned int format, unsigned long planeMask, char *d)
{
ScreenPtr screen = pDrawable->pScreen;
uxa_screen_t *uxa_screen = uxa_get_screen(screen);
BoxRec Box;
PixmapPtr pPix = uxa_get_drawable_pixmap(pDrawable);
int xoff, yoff;
Bool ok;
uxa_get_drawable_deltas(pDrawable, pPix, &xoff, &yoff);
Box.x1 = pDrawable->y + x + xoff;
Box.y1 = pDrawable->y + y + yoff;
Box.x2 = Box.x1 + w;
Box.y2 = Box.y1 + h;
if (uxa_screen->info->flags & UXA_USE_GLAMOR) {
ok = 0;
if (uxa_prepare_access(pDrawable, UXA_GLAMOR_ACCESS_RW)) {
ok = glamor_get_image_nf(pDrawable, x, y, w, h,
format, planeMask, d);
uxa_finish_access(pDrawable, UXA_GLAMOR_ACCESS_RW);
}
if (!ok)
goto fallback;
return;
}
if (uxa_screen->force_fallback)
goto fallback;
pPix = uxa_get_offscreen_pixmap(pDrawable, &xoff, &yoff);
if (pPix == NULL || uxa_screen->info->get_image == NULL)
goto fallback;
/* Only cover the ZPixmap, solid copy case. */
if (format != ZPixmap || !UXA_PM_IS_SOLID(pDrawable, planeMask))
goto fallback;
/* Only try to handle the 8bpp and up cases, since we don't want to
* think about <8bpp.
*/
if (pDrawable->bitsPerPixel < 8)
goto fallback;
ok = uxa_screen->info->get_image(pPix, pDrawable->x + x + xoff,
pDrawable->y + y + yoff, w, h, d,
PixmapBytePad(w, pDrawable->depth));
if (ok)
return;
fallback:
UXA_FALLBACK(("from %p (%c)\n", pDrawable,
uxa_drawable_location(pDrawable)));
if (uxa_prepare_access(pDrawable, UXA_ACCESS_RO)) {
fbGetImage(pDrawable, x, y, w, h, format, planeMask, d);
uxa_finish_access(pDrawable, UXA_ACCESS_RO);
}
return;
}
