diff options
Diffstat (limited to 'exa')
| -rw-r--r-- | exa/exa.c | 1252 | ||||
| -rw-r--r-- | exa/exa.h | 240 | ||||
| -rw-r--r-- | exa/exa_accel.c | 1252 | ||||
| -rw-r--r-- | exa/exa_migration.c | 1252 | ||||
| -rw-r--r-- | exa/exa_offscreen.c | 374 | ||||
| -rw-r--r-- | exa/exa_priv.h | 281 | ||||
| -rw-r--r-- | exa/exa_render.c | 572 | ||||
| -rw-r--r-- | exa/exa_unaccel.c | 365 |
8 files changed, 5588 insertions, 0 deletions
diff --git a/exa/exa.c b/exa/exa.c new file mode 100644 index 000000000..c2d0db063 --- /dev/null +++ b/exa/exa.c @@ -0,0 +1,1252 @@ +/* + * Copyright © 2001 Keith Packard + * + * Partly based on code that is Copyright © The XFree86 Project Inc. + * + * 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 Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD 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. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "exaPriv.h" +#include "fontstruct.h" +#include "dixfontstr.h" +#include "xf86str.h" +#include "xf86.h" +#include "exa.h" + +#define DEBUG_MIGRATE 0 +#define DEBUG_PIXMAP 0 +#if DEBUG_MIGRATE +#define DBG_MIGRATE(a) ErrorF a +#else +#define DBG_MIGRATE(a) +#endif +#if DEBUG_PIXMAP +#define DBG_PIXMAP(a) ErrorF a +#else +#define DBG_PIXMAP(a) +#endif +#define STRACE +#define TRACE + +int exaGeneration; +int exaScreenPrivateIndex; +int exaPixmapPrivateIndex; + +#define EXA_PIXMAP_SCORE_MOVE_IN 10 +#define EXA_PIXMAP_SCORE_MAX 20 +#define EXA_PIXMAP_SCORE_MOVE_OUT -10 +#define EXA_PIXMAP_SCORE_MIN -20 +#define EXA_PIXMAP_SCORE_PINNED 1000 +#define EXA_PIXMAP_SCORE_INIT 1001 + +void +exaDrawableDirty (DrawablePtr pDrawable) +{ + PixmapPtr pPixmap; + ExaPixmapPrivPtr pExaPixmap; + + if (pDrawable->type == DRAWABLE_WINDOW) + pPixmap = (*pDrawable->pScreen->GetWindowPixmap)((WindowPtr) pDrawable); + else + pPixmap = (PixmapPtr)pDrawable; + + pExaPixmap = ExaGetPixmapPriv(pPixmap); + if (pExaPixmap != NULL) + pExaPixmap->dirty = TRUE; +} + +static void +exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area) +{ + PixmapPtr pPixmap = area->privData; + ExaScreenPriv (pScreen); + ExaPixmapPriv(pPixmap); + int dst_pitch, src_pitch, bytes; + char *dst, *src; + int i; + + DBG_MIGRATE (("Save 0x%08p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + + src_pitch = pPixmap->devKind; + dst_pitch = pExaPixmap->devKind; + + src = pPixmap->devPrivate.ptr; + dst = pExaPixmap->devPrivate.ptr; + + if (pExaScr->info->accel.DownloadFromScreen) + { + if (pExaScr->info->accel.DownloadFromScreen(pPixmap, + pPixmap->drawable.x, + pPixmap->drawable.y, + pPixmap->drawable.width, + pPixmap->drawable.height, + dst, + dst_pitch)) { + + pPixmap->devKind = dst_pitch; + pPixmap->devPrivate.ptr = dst; + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + pExaPixmap->area = NULL; + return; + } + } + + pPixmap->devKind = dst_pitch; + pPixmap->devPrivate.ptr = dst; + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + pExaPixmap->area = NULL; + +#if 0 + if (!pExaPixmap->dirty) + return; +#endif + + exaWaitSync (pPixmap->drawable.pScreen); + + bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch; + + i = pPixmap->drawable.height; + while (i--) { + memcpy (dst, src, bytes); + dst += dst_pitch; + src += src_pitch; + } +} + +static int +exaLog2(int val) +{ + int bits; + + if (!val) + return 0; + for (bits = 0; val != 0; bits++) + val >>= 1; + return bits - 1; +} + +static Bool +exaPixmapAllocArea (PixmapPtr pPixmap) +{ + ScreenPtr pScreen = pPixmap->drawable.pScreen; + ExaScreenPriv (pScreen); + ExaPixmapPriv (pPixmap); + int bpp = pPixmap->drawable.bitsPerPixel; + CARD16 h = pPixmap->drawable.height; + CARD16 w = pPixmap->drawable.width; + int pitch; + + if (pExaScr->info->card.flags & EXA_OFFSCREEN_ALIGN_POT && w != 1) + w = 1 << (exaLog2(w - 1) + 1); + pitch = (w * bpp / 8 + pExaScr->info->card.offscreenPitch - 1) & + ~(pExaScr->info->card.offscreenPitch - 1); + + pExaPixmap->devKind = pPixmap->devKind; + pExaPixmap->devPrivate = pPixmap->devPrivate; + pExaPixmap->area = exaOffscreenAlloc (pScreen, pitch * h, + pExaScr->info->card.offscreenByteAlign, + FALSE, + exaPixmapSave, (pointer) pPixmap); + if (!pExaPixmap->area) + return FALSE; + + DBG_PIXMAP(("++ 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + pPixmap->devKind = pitch; + + pPixmap->devPrivate.ptr = (pointer) ((CARD8 *) pExaScr->info->card.memoryBase + pExaPixmap->area->offset); + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + return TRUE; +} + +void +exaMoveInPixmap (PixmapPtr pPixmap) +{ + ScreenPtr pScreen = pPixmap->drawable.pScreen; + ExaScreenPriv (pScreen); + ExaPixmapPriv (pPixmap); + int dst_pitch, src_pitch, bytes; + char *dst, *src; + int i; + + DBG_MIGRATE (("-> 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + + src = pPixmap->devPrivate.ptr; + src_pitch = pPixmap->devKind; + + if (!exaPixmapAllocArea (pPixmap)) + return; + + pExaPixmap->dirty = FALSE; + + if (pExaScr->info->accel.UploadToScreen) + { + if (pExaScr->info->accel.UploadToScreen(pPixmap, src, src_pitch)) + return; + } + + dst = pPixmap->devPrivate.ptr; + dst_pitch = pPixmap->devKind; + + bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch; + + exaWaitSync (pPixmap->drawable.pScreen); + + i = pPixmap->drawable.height; + ErrorF("dst = %p, src = %p,(%d, %d) height = %d, mem_base = %p, offset = %d\n", + dst, src, dst_pitch, src_pitch, + i, pExaScr->info->card.memoryBase, ExaGetPixmapPriv(pPixmap)->area->offset); + + while (i--) { + memcpy (dst, src, bytes); + dst += dst_pitch; + src += src_pitch; + } + ErrorF("done\n"); +} + +static void +exaMoveOutPixmap (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + ExaOffscreenArea *area = pExaPixmap->area; + + DBG_MIGRATE (("<- 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + STRACE; + if (area) + { + exaPixmapSave (pPixmap->drawable.pScreen, area); + exaOffscreenFree (pPixmap->drawable.pScreen, area); + } +} + +void +exaPixmapUseScreen (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + + STRACE; + if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) + return; + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) { + exaMoveInPixmap(pPixmap); + pExaPixmap->score = 0; + } + + if (pExaPixmap->score < EXA_PIXMAP_SCORE_MAX) + { + pExaPixmap->score++; + if (!exaPixmapIsOffscreen(pPixmap) && + pExaPixmap->score >= EXA_PIXMAP_SCORE_MOVE_IN) + exaMoveInPixmap (pPixmap); + } + ExaOffscreenMarkUsed (pPixmap); +} + +void +exaPixmapUseMemory (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) + return; + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) + pExaPixmap->score = 0; + + if (pExaPixmap->score > EXA_PIXMAP_SCORE_MIN) + { + pExaPixmap->score--; + if (pExaPixmap->area && + pExaPixmap->score <= EXA_PIXMAP_SCORE_MOVE_OUT) + exaMoveOutPixmap (pPixmap); + } +} + +static Bool +exaDestroyPixmap (PixmapPtr pPixmap) +{ + if (pPixmap->refcnt == 1) + { + ExaPixmapPriv (pPixmap); + if (pExaPixmap->area) + { + DBG_PIXMAP(("-- 0x%p (0x%x) (%dx%d)\n", + (void*)pPixmap->drawable.id, + ExaGetPixmapPriv(pPixmap)->area->offset, + pPixmap->drawable.width, + pPixmap->drawable.height)); + /* Free the offscreen area */ + exaOffscreenFree (pPixmap->drawable.pScreen, pExaPixmap->area); + pPixmap->devPrivate = pExaPixmap->devPrivate; + pPixmap->devKind = pExaPixmap->devKind; + } + } + return fbDestroyPixmap (pPixmap); +} + +static PixmapPtr +exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth) +{ + PixmapPtr pPixmap; + ExaPixmapPrivPtr pExaPixmap; + int bpp; + + bpp = BitsPerPixel (depth); + if (bpp == 32 && depth == 24) + { + int format; + ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen); + for (format = 0; format < MAXFORMATS && pScrn->formats[format].depth; ++format) + if (pScrn->formats[format].depth == 24) + { + bpp = pScrn->formats[format].bitsPerPixel; + break; + } + } + + pPixmap = fbCreatePixmapBpp (pScreen, w, h, depth, bpp); + if (!pPixmap) + return NULL; + pExaPixmap = ExaGetPixmapPriv(pPixmap); + if (!w || !h) + pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED; + else + pExaPixmap->score = EXA_PIXMAP_SCORE_INIT; + + pExaPixmap->area = NULL; + pExaPixmap->dirty = FALSE; + + return pPixmap; +} + +Bool +exaPixmapIsOffscreen(PixmapPtr p) +{ + ScreenPtr pScreen = p->drawable.pScreen; + ExaScreenPriv(pScreen); + + STRACE; + return ((unsigned long) ((CARD8 *) p->devPrivate.ptr - + (CARD8 *) pExaScr->info->card.memoryBase) < + pExaScr->info->card.memorySize); +} + +PixmapPtr +exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp) +{ + PixmapPtr pPixmap; + int x, y; + + STRACE; + if (pDrawable->type == DRAWABLE_WINDOW) { + pPixmap = (*pDrawable->pScreen->GetWindowPixmap) ((WindowPtr) pDrawable); +#ifdef COMPOSITE + x = -pPixmap->screen_x; + y = -pPixmap->screen_y; +#else + x = 0; + y = 0; +#endif + } + else + { + pPixmap = (PixmapPtr) pDrawable; + x = 0; + y = 0; + } + *xp = x; + *yp = y; + if (exaPixmapIsOffscreen (pPixmap)) + return pPixmap; + else + return NULL; +} + +Bool +exaDrawableIsOffscreen (DrawablePtr pDrawable) +{ + PixmapPtr pPixmap; + STRACE; + if (pDrawable->type == DRAWABLE_WINDOW) + pPixmap = (*pDrawable->pScreen->GetWindowPixmap) ((WindowPtr) pDrawable); + else + pPixmap = (PixmapPtr) pDrawable; + return exaPixmapIsOffscreen (pPixmap); +} + +#if 0 +static void +exaFillTiled(int dst_x, + int dst_y, + int width, + int height, + int src_x, + int src_y, + int src_width, + int src_height, + void (*Copy) (int srcX, + int srcY, + int dstX, + int dstY, + int width, + int height)) +{ + modulus (src_x, src_width, src_x); + modulus (src_y, src_height, src_y); + + while (height) + { + int dst_x_tmp = dst_x; + int src_x_tmp = src_x; + int width_tmp = width; + int height_left = src_height - src_y; + int height_this = min (height, height_left); + + while (width_tmp) + { + int width_left = src_width - src_x_tmp; + int width_this = min (width_tmp, width_left); + + (*Copy) (src_x_tmp, src_y, + dst_x_tmp, dst_y, + width_this, height_this); + + width_tmp -= width_this; + dst_x_tmp += width_this; + } + height -= height_this; + dst_y += height_this; + src_y = 0; + } +} +#endif + +static void +exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n, + DDXPointPtr ppt, int *pwidth, int fSorted) +{ + ScreenPtr pScreen = pDrawable->pScreen; + ExaScreenPriv (pScreen); + RegionPtr pClip = fbGetCompositeClip(pGC); + PixmapPtr pPixmap; + BoxPtr pextent, pbox; + int nbox; + int extentX1, extentX2, extentY1, extentY2; + int fullX1, fullX2, fullY1; + int partX1, partX2; + int off_x, off_y; + + STRACE; + if (pGC->fillStyle != FillSolid || + !(pPixmap = exaGetOffscreenPixmap (pDrawable, &off_x, &off_y)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, + pGC->alu, + pGC->planemask, + pGC->fgPixel)) + { + ExaCheckFillSpans (pDrawable, pGC, n, ppt, pwidth, fSorted); + return; + } + + pextent = REGION_EXTENTS(pGC->pScreen, pClip); + extentX1 = pextent->x1; + extentY1 = pextent->y1; + extentX2 = pextent->x2; + extentY2 = pextent->y2; + while (n--) + { + fullX1 = ppt->x; + fullY1 = ppt->y; + fullX2 = fullX1 + (int) *pwidth; + ppt++; + pwidth++; + + if (fullY1 < extentY1 || extentY2 <= fullY1) + continue; + + if (fullX1 < extentX1) + fullX1 = extentX1; + + if (fullX2 > extentX2) + fullX2 = extentX2; + + if (fullX1 >= fullX2) + continue; + + nbox = REGION_NUM_RECTS (pClip); + if (nbox == 1) + { + (*pExaScr->info->accel.Solid) (pPixmap, + fullX1 + off_x, fullY1 + off_y, + fullX2 + off_x, fullY1 + 1 + off_y); + } + else + { + pbox = REGION_RECTS(pClip); + while(nbox--) + { + if (pbox->y1 <= fullY1 && fullY1 < pbox->y2) + { + partX1 = pbox->x1; + if (partX1 < fullX1) + partX1 = fullX1; + partX2 = pbox->x2; + if (partX2 > fullX2) + partX2 = fullX2; + if (partX2 > partX1) + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + off_x, fullY1 + off_y, + partX2 + off_x, fullY1 + 1 + off_y); + } + pbox++; + } + } + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pScreen); +} + +void +exaCopyNtoN (DrawablePtr pSrcDrawable, + DrawablePtr pDstDrawable, + GCPtr pGC, + BoxPtr pbox, + int nbox, + int dx, + int dy, + Bool reverse, + Bool upsidedown, + Pixel bitplane, + void *closure) +{ + ExaScreenPriv (pDstDrawable->pScreen); + PixmapPtr pSrcPixmap, pDstPixmap; + int src_off_x, src_off_y; + int dst_off_x, dst_off_y; + STRACE; + + /* Migrate pixmaps to same place as destination */ + if (pSrcDrawable->type == DRAWABLE_PIXMAP) { + if (exaDrawableIsOffscreen (pDstDrawable)) + exaPixmapUseScreen ((PixmapPtr) pSrcDrawable); + else + exaPixmapUseMemory ((PixmapPtr) pSrcDrawable); + } + + if ((pSrcPixmap = exaGetOffscreenPixmap (pSrcDrawable, &src_off_x, &src_off_y)) && + (pDstPixmap = exaGetOffscreenPixmap (pDstDrawable, &dst_off_x, &dst_off_y)) && + (*pExaScr->info->accel.PrepareCopy) (pSrcPixmap, + pDstPixmap, + dx, + dy, + pGC ? pGC->alu : GXcopy, + pGC ? pGC->planemask : FB_ALLONES)) + { + while (nbox--) + { + (*pExaScr->info->accel.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++; + } + (*pExaScr->info->accel.DoneCopy) (pDstPixmap); + exaMarkSync(pDstDrawable->pScreen); + } + else + { + exaWaitSync (pDstDrawable->pScreen); + fbCopyNtoN (pSrcDrawable, pDstDrawable, pGC, + pbox, nbox, dx, dy, reverse, upsidedown, + bitplane, closure); + } + exaDrawableDirty (pDstDrawable); +} + +static RegionPtr +exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC, + int srcx, int srcy, int width, int height, int dstx, int dsty) +{ + return fbDoCopy (pSrcDrawable, pDstDrawable, pGC, + srcx, srcy, width, height, + dstx, dsty, exaCopyNtoN, 0, 0); +} + +static void +exaPolyFillRect(DrawablePtr pDrawable, + GCPtr pGC, + int nrect, + xRectangle *prect) +{ + ExaScreenPriv (pDrawable->pScreen); + RegionPtr pClip = fbGetCompositeClip(pGC); + PixmapPtr pPixmap; + register BoxPtr pbox; + BoxPtr pextent; + int extentX1, extentX2, extentY1, extentY2; + int fullX1, fullX2, fullY1, fullY2; + int partX1, partX2, partY1, partY2; + int xoff, yoff; + int xorg, yorg; + int n; + + STRACE; + if (pGC->fillStyle != FillSolid || + !(pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, + pGC->alu, + pGC->planemask, + pGC->fgPixel)) + { + ExaCheckPolyFillRect (pDrawable, pGC, nrect, prect); + return; + } + + xorg = pDrawable->x; + yorg = pDrawable->y; + + pextent = REGION_EXTENTS(pGC->pScreen, pClip); + extentX1 = pextent->x1; + extentY1 = pextent->y1; + extentX2 = pextent->x2; + extentY2 = pextent->y2; + while (nrect--) + { + fullX1 = prect->x + xorg; + fullY1 = prect->y + yorg; + fullX2 = fullX1 + (int) prect->width; + fullY2 = fullY1 + (int) prect->height; + prect++; + + if (fullX1 < extentX1) + fullX1 = extentX1; + + if (fullY1 < extentY1) + fullY1 = extentY1; + + if (fullX2 > extentX2) + fullX2 = extentX2; + + if (fullY2 > extentY2) + fullY2 = extentY2; + + if ((fullX1 >= fullX2) || (fullY1 >= fullY2)) + continue; + n = REGION_NUM_RECTS (pClip); + if (n == 1) + { + (*pExaScr->info->accel.Solid) (pPixmap, + fullX1 + xoff, fullY1 + yoff, + fullX2 + xoff, fullY2 + yoff); + } + else + { + pbox = REGION_RECTS(pClip); + /* + * clip the rectangle to each box in the clip region + * this is logically equivalent to calling Intersect() + */ + while(n--) + { + partX1 = pbox->x1; + if (partX1 < fullX1) + partX1 = fullX1; + partY1 = pbox->y1; + if (partY1 < fullY1) + partY1 = fullY1; + partX2 = pbox->x2; + if (partX2 > fullX2) + partX2 = fullX2; + partY2 = pbox->y2; + if (partY2 > fullY2) + partY2 = fullY2; + + pbox++; + + if (partX1 < partX2 && partY1 < partY2) + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + xoff, partY1 + yoff, + partX2 + xoff, partY2 + yoff); + } + } + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pDrawable->pScreen); +} + +static void +exaSolidBoxClipped (DrawablePtr pDrawable, + RegionPtr pClip, + FbBits pm, + FbBits fg, + int x1, + int y1, + int x2, + int y2) +{ + ExaScreenPriv (pDrawable->pScreen); + PixmapPtr pPixmap; + BoxPtr pbox; + int nbox; + int xoff, yoff; + int partX1, partX2, partY1, partY2; + + STRACE; + if (!(pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, GXcopy, pm, fg)) + { + exaWaitSync (pDrawable->pScreen); + fg = fbReplicatePixel (fg, pDrawable->bitsPerPixel); + fbSolidBoxClipped (pDrawable, pClip, x1, y1, x2, y2, + fbAnd (GXcopy, fg, pm), + fbXor (GXcopy, fg, pm)); + exaDrawableDirty (pDrawable); + return; + } + for (nbox = REGION_NUM_RECTS(pClip), pbox = REGION_RECTS(pClip); + nbox--; + pbox++) + { + partX1 = pbox->x1; + if (partX1 < x1) + partX1 = x1; + + partX2 = pbox->x2; + if (partX2 > x2) + partX2 = x2; + + if (partX2 <= partX1) + continue; + + partY1 = pbox->y1; + if (partY1 < y1) + partY1 = y1; + + partY2 = pbox->y2; + if (partY2 > y2) + partY2 = y2; + + if (partY2 <= partY1) + continue; + + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + xoff, partY1 + yoff, + partX2 + xoff, partY2 + yoff); + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pDrawable->pScreen); +} + +static void +exaImageGlyphBlt (DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, + CharInfoPtr *ppciInit, + pointer pglyphBase) +{ + FbGCPrivPtr pPriv = fbGetGCPrivate(pGC); + CharInfoPtr *ppci; + CharInfoPtr pci; + unsigned char *pglyph; /* pointer bits in glyph */ + int gWidth, gHeight; /* width and height of glyph */ + FbStride gStride; /* stride of glyph */ + Bool opaque; + int n; + int gx, gy; + void (*glyph) (FbBits *, + FbStride, + int, + FbStip *, + FbBits, + int, + int); + FbBits *dst; + FbStride dstStride; + int dstBpp; + int dstXoff, dstYoff; + FbBits depthMask; + + STRACE; + depthMask = FbFullMask(pDrawable->depth); + if ((pGC->planemask & depthMask) != depthMask) + { + ExaCheckImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppciInit, pglyphBase); + return; + } + glyph = 0; + fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff); + switch (dstBpp) { + case 8: glyph = fbGlyph8; break; + case 16: glyph = fbGlyph16; break; + case 24: glyph = fbGlyph24; break; + case 32: glyph = fbGlyph32; break; + } + + x += pDrawable->x; + y += pDrawable->y; + + if (TERMINALFONT (pGC->font) && !glyph) + { + opaque = TRUE; + } + else + { + int xBack, widthBack; + int yBack, heightBack; + + ppci = ppciInit; + n = nglyph; + widthBack = 0; + while (n--) + widthBack += (*ppci++)->metrics.characterWidth; + + xBack = x; + if (widthBack < 0) + { + xBack += widthBack; + widthBack = -widthBack; + } + yBack = y - FONTASCENT(pGC->font); + heightBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font); + exaSolidBoxClipped (pDrawable, + fbGetCompositeClip(pGC), + pGC->planemask, + pGC->bgPixel, + xBack, + yBack, + xBack + widthBack, + yBack + heightBack); + opaque = FALSE; + } + + exaWaitSync (pDrawable->pScreen); + exaDrawableDirty (pDrawable); + + ppci = ppciInit; + while (nglyph--) + { + pci = *ppci++; + pglyph = FONTGLYPHBITS(pglyphBase, pci); + gWidth = GLYPHWIDTHPIXELS(pci); + gHeight = GLYPHHEIGHTPIXELS(pci); + if (gWidth && gHeight) + { + gx = x + pci->metrics.leftSideBearing; + gy = y - pci->metrics.ascent; + if (glyph && gWidth <= sizeof (FbStip) * 8 && + fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight)) + { + (*glyph) (dst + (gy + dstYoff) * dstStride, + dstStride, + dstBpp, + (FbStip *) pglyph, + pPriv->fg, + gx + dstXoff, + gHeight); + } + else + { + gStride = GLYPHWIDTHBYTESPADDED(pci) / sizeof (FbStip); + fbPutXYImage (pDrawable, + fbGetCompositeClip(pGC), + pPriv->fg, + pPriv->bg, + pPriv->pm, + GXcopy, + opaque, + + gx, + gy, + gWidth, gHeight, + + (FbStip *) pglyph, + gStride, + 0); + } + } + x += pci->metrics.characterWidth; + } +} + +static const GCOps exaOps = { + exaFillSpans, + ExaCheckSetSpans, + ExaCheckPutImage, + exaCopyArea, + ExaCheckCopyPlane, + ExaCheckPolyPoint, + ExaCheckPolylines, + ExaCheckPolySegment, + miPolyRectangle, + ExaCheckPolyArc, + miFillPolygon, + exaPolyFillRect, + miPolyFillArc, + miPolyText8, + miPolyText16, + miImageText8, + miImageText16, + exaImageGlyphBlt, + ExaCheckPolyGlyphBlt, + ExaCheckPushPixels, +#ifdef NEED_LINEHELPER + ,NULL +#endif +}; + +static void +exaValidateGC (GCPtr pGC, Mask changes, DrawablePtr pDrawable) +{ + fbValidateGC (pGC, changes, pDrawable); + + if (exaDrawableIsOffscreen (pDrawable)) + pGC->ops = (GCOps *) &exaOps; + else + pGC->ops = (GCOps *) &exaAsyncPixmapGCOps; +} + +GCFuncs exaGCFuncs = { + exaValidateGC, + miChangeGC, + miCopyGC, + miDestroyGC, + miChangeClip, + miDestroyClip, + miCopyClip +}; + +static int +exaCreateGC (GCPtr pGC) +{ + STRACE; + if (!fbCreateGC (pGC)) + return FALSE; + + pGC->funcs = &exaGCFuncs; + + return TRUE; +} + + +static void +exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) +{ + RegionRec rgnDst; + int dx, dy; + PixmapPtr pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin); + + STRACE; + dx = ptOldOrg.x - pWin->drawable.x; + dy = ptOldOrg.y - pWin->drawable.y; + REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy); + + REGION_INIT (pWin->drawable.pScreen, &rgnDst, NullBox, 0); + + REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc); +#ifdef COMPOSITE + if (pPixmap->screen_x || pPixmap->screen_y) + REGION_TRANSLATE (pWin->drawable.pScreen, &rgnDst, + -pPixmap->screen_x, -pPixmap->screen_y); +#endif + + fbCopyRegion (&pPixmap->drawable, &pPixmap->drawable, + 0, + &rgnDst, dx, dy, exaCopyNtoN, 0, 0); + + REGION_UNINIT(pWin->drawable.pScreen, &rgnDst); +} + +static void +exaFillRegionSolid (DrawablePtr pDrawable, + RegionPtr pRegion, + Pixel pixel) +{ + ExaScreenPriv(pDrawable->pScreen); + PixmapPtr pPixmap; + int xoff, yoff; + + STRACE; + if ((pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) && + (*pExaScr->info->accel.PrepareSolid) (pPixmap, GXcopy, FB_ALLONES, pixel)) + { + int nbox = REGION_NUM_RECTS (pRegion); + BoxPtr pBox = REGION_RECTS (pRegion); + + while (nbox--) + { + (*pExaScr->info->accel.Solid) (pPixmap, + pBox->x1 + xoff, pBox->y1 + yoff, + pBox->x2 + xoff, pBox->y2 + yoff); + pBox++; + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaMarkSync(pDrawable->pScreen); + } + else + { + exaWaitSync (pDrawable->pScreen); + fbFillRegionSolid (pDrawable, pRegion, 0, + fbReplicatePixel (pixel, pDrawable->bitsPerPixel)); + } + exaDrawableDirty (pDrawable); +} + +static void +exaPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what) +{ + STRACE; + if (!REGION_NUM_RECTS(pRegion)) + return; + switch (what) { + case PW_BACKGROUND: + switch (pWin->backgroundState) { + case None: + return; + case ParentRelative: + do { + pWin = pWin->parent; + } while (pWin->backgroundState == ParentRelative); + (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion, + what); + return; + case BackgroundPixel: + exaFillRegionSolid((DrawablePtr)pWin, pRegion, pWin->background.pixel); + return; +#if 0 + case BackgroundPixmap: + exaFillRegionTiled((DrawablePtr)pWin, pRegion, pWin->background.pixmap); + return; +#endif + } + break; + case PW_BORDER: + if (pWin->borderIsPixel) + { + exaFillRegionSolid((DrawablePtr)pWin, pRegion, pWin->border.pixel); + return; + } +#if 0 + else + { + exaFillRegionTiled((DrawablePtr)pWin, pRegion, pWin->border.pixmap); + return; + } +#endif + break; + } + ExaCheckPaintWindow (pWin, pRegion, what); +} + +Bool +exaDriverInit (ScreenPtr pScreen, + ExaDriverPtr pScreenInfo) +{ + ExaScreenPrivPtr pExaScr; + +#ifdef RENDER + PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); +#endif + STRACE; + if (exaGeneration != serverGeneration) + { + exaScreenPrivateIndex = AllocateScreenPrivateIndex(); + exaPixmapPrivateIndex = AllocatePixmapPrivateIndex(); + exaGeneration = serverGeneration; + } + + pExaScr = xalloc (sizeof (ExaScreenPrivRec)); + + if (!pExaScr) + return FALSE; + + pExaScr->info = pScreenInfo; + + pScreen->devPrivates[exaScreenPrivateIndex].ptr = (pointer) pExaScr; + + /* + * Hook up asynchronous drawing + */ + ExaScreenInitAsync (pScreen); + /* + * Replace various fb screen functions + */ + pScreen->CreateGC = exaCreateGC; + pScreen->CopyWindow = exaCopyWindow; + pScreen->PaintWindowBackground = exaPaintWindow; + pScreen->PaintWindowBorder = exaPaintWindow; +#ifdef RENDER + if (ps) { + ps->Composite = exaComposite; + } +#endif + + /* + * Hookup offscreen pixmaps + */ + if ((pExaScr->info->card.flags & EXA_OFFSCREEN_PIXMAPS) && + pExaScr->info->card.offScreenBase < pExaScr->info->card.memorySize) + { + if (!AllocatePixmapPrivate(pScreen, exaPixmapPrivateIndex, + sizeof (ExaPixmapPrivRec))) + return FALSE; + pScreen->CreatePixmap = exaCreatePixmap; + pScreen->DestroyPixmap = exaDestroyPixmap; + } + else + { + if (!AllocatePixmapPrivate(pScreen, exaPixmapPrivateIndex, 0)) + return FALSE; + } + + ErrorF("============== %ld < %ld\n", pExaScr->info->card.offScreenBase, + pExaScr->info->card.memorySize); + if (pExaScr->info->card.offScreenBase < pExaScr->info->card.memorySize) { + if (!exaOffscreenInit (pScreen)) + return FALSE; + } + + return TRUE; +} + +void +exaDriverFini (ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + + STRACE; + xfree (pExaScr); +} + + +void exaMarkSync(ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + ExaCardInfoPtr card = &(pExaScr->info->card); + + card->needsSync = TRUE; + if (pExaScr->info->accel.MarkSync != NULL) { + card->lastMarker = (*pExaScr->info->accel.MarkSync)(pScreen); + } +} + +void exaWaitSync(ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + ExaCardInfoPtr card = &(pExaScr->info->card); + + if (card->needsSync) { + (*pExaScr->info->accel.WaitMarker)(pScreen, card->lastMarker); + card->needsSync = FALSE; + } +} + +unsigned int exaGetVersion(void) +{ + return EXA_VERSION; +} + +#ifdef XFree86LOADER +static MODULESETUPPROTO(exaSetup); + + +static const OptionInfoRec EXAOptions[] = { + { -1, NULL, + OPTV_NONE, {0}, FALSE } +}; + +/*ARGSUSED*/ +static const OptionInfoRec * +EXAAvailableOptions(void *unused) +{ + return (EXAOptions); +} + +static XF86ModuleVersionInfo exaVersRec = +{ + "exa", + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XORG_VERSION_CURRENT, + 1, 2, 0, + ABI_CLASS_VIDEODRV, /* requires the video driver ABI */ + ABI_VIDEODRV_VERSION, + MOD_CLASS_NONE, + {0,0,0,0} +}; + +XF86ModuleData exaModuleData = { &exaVersRec, exaSetup, NULL }; + +ModuleInfoRec EXA = { + 1, + "EXA", + NULL, + 0, + EXAAvailableOptions, +}; + +/*ARGSUSED*/ +static pointer +exaSetup(pointer Module, pointer Options, int *ErrorMajor, int *ErrorMinor) +{ + static Bool Initialised = FALSE; + + ErrorF("exa setup\n"); + if (!Initialised) { + Initialised = TRUE; +#ifndef REMOVE_LOADER_CHECK_MODULE_INFO + if (xf86LoaderCheckSymbol("xf86AddModuleInfo")) +#endif + xf86AddModuleInfo(&EXA, Module); + } + + return (pointer)TRUE; +} +#endif diff --git a/exa/exa.h b/exa/exa.h new file mode 100644 index 000000000..15945c1f1 --- /dev/null +++ b/exa/exa.h @@ -0,0 +1,240 @@ +/* + * + * Copyright (C) 2000 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. + */ +#ifndef EXA_H +#define EXA_H + +#include "scrnintstr.h" +#include "pixmapstr.h" +#include "windowstr.h" +#include "gcstruct.h" +#include "picturestr.h" + +#define EXA_VERSION_MAJOR 0 +#define EXA_VERSION_MINOR 1 +#define EXA_VERSION_RELEASE 0 + +typedef struct _ExaOffscreenArea ExaOffscreenArea; + +typedef void (*ExaOffscreenSaveProc) (ScreenPtr pScreen, ExaOffscreenArea *area); + +typedef enum _ExaOffscreenState { + ExaOffscreenAvail, + ExaOffscreenRemovable, + ExaOffscreenLocked +} ExaOffscreenState; + +struct _ExaOffscreenArea { + int offset; + int save_offset; + int size; + int score; + pointer privData; + + ExaOffscreenSaveProc save; + + ExaOffscreenState state; + + ExaOffscreenArea *next; +}; + +typedef struct _ExaCardInfo { + /* These are here because I don't want to be adding more to + * ScrnInfoRec */ + CARD8 *memoryBase; + unsigned long offScreenBase; + + /* It's fix.smem_len. + This one could be potentially substituted by ScrnInfoRec + videoRam member, but I do not want to be doing the silly + << 10, >>10 all over the place */ + unsigned long memorySize; + + int offscreenByteAlign; + int offscreenPitch; + int flags; + + /* The coordinate limitations for rendering for this hardware. + * Exa breaks larger pixmaps into smaller pieces and calls Prepare multiple times + * to handle larger pixmaps + */ + int maxX; + int maxY; + + /* private */ + ExaOffscreenArea *offScreenAreas; + Bool needsSync; + int lastMarker; +} ExaCardInfoRec, *ExaCardInfoPtr; + +typedef struct _ExaAccelInfo { + /* PrepareSolid may fail if the pixmaps can't be accelerated to/from. + * This is an important feature for handling strange corner cases + * in hardware that are poorly expressed through flags. + */ + Bool (*PrepareSolid) (PixmapPtr pPixmap, + int alu, + Pixel planemask, + Pixel fg); + void (*Solid) (PixmapPtr pPixmap, int x1, int y1, int x2, int y2); + void (*DoneSolid) (PixmapPtr pPixmap); + + /* PrepareSolid may fail if the pixmaps can't be accelerated to/from. + * This is an important feature for handling strange corner cases + * in hardware that are poorly expressed through flags. + */ + Bool (*PrepareCopy) (PixmapPtr pSrcPixmap, + PixmapPtr pDstPixmap, + Bool upsidedown, + Bool reverse, + int alu, + Pixel planemask); + void (*Copy) (PixmapPtr pDstPixmap, + int srcX, + int srcY, + int dstX, + int dstY, + int width, + int height); + void (*DoneCopy) (PixmapPtr pDstPixmap); + + /* The Composite hooks are a wrapper around the Composite operation. + * The CheckComposite occurs before pixmap migration occurs, + * and may fail for many hardware-dependent reasons. + * PrepareComposite should not fail, and the Bool return may + * not be necessary if we can + * adequately represent pixmap location/pitch limitations.. + */ + Bool (*CheckComposite) (int op, + PicturePtr pSrcPicture, + PicturePtr pMaskPicture, + PicturePtr pDstPicture); + Bool (*PrepareComposite) (int op, + PicturePtr pSrcPicture, + PicturePtr pMaskPicture, + PicturePtr pDstPicture, + PixmapPtr pSrc, + PixmapPtr pMask, + PixmapPtr pDst); + void (*Composite) (PixmapPtr pDst, + int srcX, + int srcY, + int maskX, + int maskY, + int dstX, + int dstY, + int width, + int height); + void (*DoneComposite) (PixmapPtr pDst); + + /* Attempt to upload the data from src into the rectangle of the + * in-framebuffer pDst beginning at x,y and of width w,h. May fail. + */ + Bool (*UploadToScreen) (PixmapPtr pDst, + char *src, + int src_pitch); + Bool (*UploadToScratch) (PixmapPtr pSrc, + PixmapPtr pDst); + + /* Attempt to download the rectangle from the in-framebuffer pSrc into + * dst, given the pitch. May fail. Since it is likely + * accelerated, a markSync will follow it as with other acceleration + * hooks. + */ + Bool (*DownloadFromScreen)(PixmapPtr pSrc, + int x, int y, + int w, int h, + char *dst, int dst_pitch); + + /* Should return a hrdware-dependent marker number which can + * be waited for with WaitMarker. It can be not implemented in which + * case WaitMarker must wait for idle on any given marker + * number. + */ + int (*MarkSync) (ScreenPtr pScreen); + void (*WaitMarker) (ScreenPtr pScreen, int marker); +} ExaAccelInfoRec, *ExaAccelInfoPtr; + +typedef struct _ExaDriver { + ExaCardInfoRec card; + ExaAccelInfoRec accel; +} ExaDriverRec, *ExaDriverPtr; + +typedef struct { + ExaDriverPtr info; +} ExaScreenPrivRec, *ExaScreenPrivPtr; + +#define EXA_OFFSCREEN_PIXMAPS (1 << 0) +#define EXA_OFFSCREEN_ALIGN_POT (1 << 1) + + +#define EXA_MAKE_VERSION(a, b, c) (((a) << 16) | ((b) << 8) | (c)) +#define EXA_VERSION \ + EXA_MAKE_VERSION(EXA_VERSION_MAJOR, EXA_VERSION_MINOR, EXA_VERSION_RELEASE) +#define EXA_IS_VERSION(a,b,c) (EXA_VERSION >= EXA_MAKE_VERSION(a,b,c)) + +unsigned int +exaGetVersion(void); + +Bool +exaDriverInit(ScreenPtr pScreen, + ExaDriverPtr pScreenInfo); + +void +exaDriverFini(ScreenPtr pScreen); + +void +exaMarkSync(ScreenPtr pScreen); +void +exaWaitSync(ScreenPtr pScreen); + +Bool +exaOffscreenInit(ScreenPtr pScreen); + +ExaOffscreenArea * +exaOffscreenAlloc(ScreenPtr pScreen, int size, int align, + Bool locked, + ExaOffscreenSaveProc save, + pointer privData); + +ExaOffscreenArea * +exaOffscreenFree(ScreenPtr pScreen, ExaOffscreenArea *area); + + + +#define exaInitCard(exa, sync, memory_base, off_screen_base, memory_size, \ + offscreen_byte_align, offscreen_pitch, flags, \ + max_x, max_y) \ + (exa)->card.Sync = sync; \ + (exa)->card.memoryBase = memory_base; \ + (exa)->card.offScreenBase = off_screen_base; \ + (exa)->card.memorySize = memory_size; \ + (exa)->card.offscreenByteAlign = offscreen_byte_align; \ + (exa)->card.offscreenPitch = offscreen_pitch; \ + (exa)->card.flags = flags; \ + (exa)->card.maxX = max_x; \ + (exa)->card.maxY = max_y + +#endif /* EXA_H */ diff --git a/exa/exa_accel.c b/exa/exa_accel.c new file mode 100644 index 000000000..c2d0db063 --- /dev/null +++ b/exa/exa_accel.c @@ -0,0 +1,1252 @@ +/* + * Copyright © 2001 Keith Packard + * + * Partly based on code that is Copyright © The XFree86 Project Inc. + * + * 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 Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD 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. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "exaPriv.h" +#include "fontstruct.h" +#include "dixfontstr.h" +#include "xf86str.h" +#include "xf86.h" +#include "exa.h" + +#define DEBUG_MIGRATE 0 +#define DEBUG_PIXMAP 0 +#if DEBUG_MIGRATE +#define DBG_MIGRATE(a) ErrorF a +#else +#define DBG_MIGRATE(a) +#endif +#if DEBUG_PIXMAP +#define DBG_PIXMAP(a) ErrorF a +#else +#define DBG_PIXMAP(a) +#endif +#define STRACE +#define TRACE + +int exaGeneration; +int exaScreenPrivateIndex; +int exaPixmapPrivateIndex; + +#define EXA_PIXMAP_SCORE_MOVE_IN 10 +#define EXA_PIXMAP_SCORE_MAX 20 +#define EXA_PIXMAP_SCORE_MOVE_OUT -10 +#define EXA_PIXMAP_SCORE_MIN -20 +#define EXA_PIXMAP_SCORE_PINNED 1000 +#define EXA_PIXMAP_SCORE_INIT 1001 + +void +exaDrawableDirty (DrawablePtr pDrawable) +{ + PixmapPtr pPixmap; + ExaPixmapPrivPtr pExaPixmap; + + if (pDrawable->type == DRAWABLE_WINDOW) + pPixmap = (*pDrawable->pScreen->GetWindowPixmap)((WindowPtr) pDrawable); + else + pPixmap = (PixmapPtr)pDrawable; + + pExaPixmap = ExaGetPixmapPriv(pPixmap); + if (pExaPixmap != NULL) + pExaPixmap->dirty = TRUE; +} + +static void +exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area) +{ + PixmapPtr pPixmap = area->privData; + ExaScreenPriv (pScreen); + ExaPixmapPriv(pPixmap); + int dst_pitch, src_pitch, bytes; + char *dst, *src; + int i; + + DBG_MIGRATE (("Save 0x%08p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + + src_pitch = pPixmap->devKind; + dst_pitch = pExaPixmap->devKind; + + src = pPixmap->devPrivate.ptr; + dst = pExaPixmap->devPrivate.ptr; + + if (pExaScr->info->accel.DownloadFromScreen) + { + if (pExaScr->info->accel.DownloadFromScreen(pPixmap, + pPixmap->drawable.x, + pPixmap->drawable.y, + pPixmap->drawable.width, + pPixmap->drawable.height, + dst, + dst_pitch)) { + + pPixmap->devKind = dst_pitch; + pPixmap->devPrivate.ptr = dst; + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + pExaPixmap->area = NULL; + return; + } + } + + pPixmap->devKind = dst_pitch; + pPixmap->devPrivate.ptr = dst; + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + pExaPixmap->area = NULL; + +#if 0 + if (!pExaPixmap->dirty) + return; +#endif + + exaWaitSync (pPixmap->drawable.pScreen); + + bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch; + + i = pPixmap->drawable.height; + while (i--) { + memcpy (dst, src, bytes); + dst += dst_pitch; + src += src_pitch; + } +} + +static int +exaLog2(int val) +{ + int bits; + + if (!val) + return 0; + for (bits = 0; val != 0; bits++) + val >>= 1; + return bits - 1; +} + +static Bool +exaPixmapAllocArea (PixmapPtr pPixmap) +{ + ScreenPtr pScreen = pPixmap->drawable.pScreen; + ExaScreenPriv (pScreen); + ExaPixmapPriv (pPixmap); + int bpp = pPixmap->drawable.bitsPerPixel; + CARD16 h = pPixmap->drawable.height; + CARD16 w = pPixmap->drawable.width; + int pitch; + + if (pExaScr->info->card.flags & EXA_OFFSCREEN_ALIGN_POT && w != 1) + w = 1 << (exaLog2(w - 1) + 1); + pitch = (w * bpp / 8 + pExaScr->info->card.offscreenPitch - 1) & + ~(pExaScr->info->card.offscreenPitch - 1); + + pExaPixmap->devKind = pPixmap->devKind; + pExaPixmap->devPrivate = pPixmap->devPrivate; + pExaPixmap->area = exaOffscreenAlloc (pScreen, pitch * h, + pExaScr->info->card.offscreenByteAlign, + FALSE, + exaPixmapSave, (pointer) pPixmap); + if (!pExaPixmap->area) + return FALSE; + + DBG_PIXMAP(("++ 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + pPixmap->devKind = pitch; + + pPixmap->devPrivate.ptr = (pointer) ((CARD8 *) pExaScr->info->card.memoryBase + pExaPixmap->area->offset); + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + return TRUE; +} + +void +exaMoveInPixmap (PixmapPtr pPixmap) +{ + ScreenPtr pScreen = pPixmap->drawable.pScreen; + ExaScreenPriv (pScreen); + ExaPixmapPriv (pPixmap); + int dst_pitch, src_pitch, bytes; + char *dst, *src; + int i; + + DBG_MIGRATE (("-> 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + + src = pPixmap->devPrivate.ptr; + src_pitch = pPixmap->devKind; + + if (!exaPixmapAllocArea (pPixmap)) + return; + + pExaPixmap->dirty = FALSE; + + if (pExaScr->info->accel.UploadToScreen) + { + if (pExaScr->info->accel.UploadToScreen(pPixmap, src, src_pitch)) + return; + } + + dst = pPixmap->devPrivate.ptr; + dst_pitch = pPixmap->devKind; + + bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch; + + exaWaitSync (pPixmap->drawable.pScreen); + + i = pPixmap->drawable.height; + ErrorF("dst = %p, src = %p,(%d, %d) height = %d, mem_base = %p, offset = %d\n", + dst, src, dst_pitch, src_pitch, + i, pExaScr->info->card.memoryBase, ExaGetPixmapPriv(pPixmap)->area->offset); + + while (i--) { + memcpy (dst, src, bytes); + dst += dst_pitch; + src += src_pitch; + } + ErrorF("done\n"); +} + +static void +exaMoveOutPixmap (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + ExaOffscreenArea *area = pExaPixmap->area; + + DBG_MIGRATE (("<- 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + STRACE; + if (area) + { + exaPixmapSave (pPixmap->drawable.pScreen, area); + exaOffscreenFree (pPixmap->drawable.pScreen, area); + } +} + +void +exaPixmapUseScreen (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + + STRACE; + if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) + return; + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) { + exaMoveInPixmap(pPixmap); + pExaPixmap->score = 0; + } + + if (pExaPixmap->score < EXA_PIXMAP_SCORE_MAX) + { + pExaPixmap->score++; + if (!exaPixmapIsOffscreen(pPixmap) && + pExaPixmap->score >= EXA_PIXMAP_SCORE_MOVE_IN) + exaMoveInPixmap (pPixmap); + } + ExaOffscreenMarkUsed (pPixmap); +} + +void +exaPixmapUseMemory (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) + return; + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) + pExaPixmap->score = 0; + + if (pExaPixmap->score > EXA_PIXMAP_SCORE_MIN) + { + pExaPixmap->score--; + if (pExaPixmap->area && + pExaPixmap->score <= EXA_PIXMAP_SCORE_MOVE_OUT) + exaMoveOutPixmap (pPixmap); + } +} + +static Bool +exaDestroyPixmap (PixmapPtr pPixmap) +{ + if (pPixmap->refcnt == 1) + { + ExaPixmapPriv (pPixmap); + if (pExaPixmap->area) + { + DBG_PIXMAP(("-- 0x%p (0x%x) (%dx%d)\n", + (void*)pPixmap->drawable.id, + ExaGetPixmapPriv(pPixmap)->area->offset, + pPixmap->drawable.width, + pPixmap->drawable.height)); + /* Free the offscreen area */ + exaOffscreenFree (pPixmap->drawable.pScreen, pExaPixmap->area); + pPixmap->devPrivate = pExaPixmap->devPrivate; + pPixmap->devKind = pExaPixmap->devKind; + } + } + return fbDestroyPixmap (pPixmap); +} + +static PixmapPtr +exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth) +{ + PixmapPtr pPixmap; + ExaPixmapPrivPtr pExaPixmap; + int bpp; + + bpp = BitsPerPixel (depth); + if (bpp == 32 && depth == 24) + { + int format; + ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen); + for (format = 0; format < MAXFORMATS && pScrn->formats[format].depth; ++format) + if (pScrn->formats[format].depth == 24) + { + bpp = pScrn->formats[format].bitsPerPixel; + break; + } + } + + pPixmap = fbCreatePixmapBpp (pScreen, w, h, depth, bpp); + if (!pPixmap) + return NULL; + pExaPixmap = ExaGetPixmapPriv(pPixmap); + if (!w || !h) + pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED; + else + pExaPixmap->score = EXA_PIXMAP_SCORE_INIT; + + pExaPixmap->area = NULL; + pExaPixmap->dirty = FALSE; + + return pPixmap; +} + +Bool +exaPixmapIsOffscreen(PixmapPtr p) +{ + ScreenPtr pScreen = p->drawable.pScreen; + ExaScreenPriv(pScreen); + + STRACE; + return ((unsigned long) ((CARD8 *) p->devPrivate.ptr - + (CARD8 *) pExaScr->info->card.memoryBase) < + pExaScr->info->card.memorySize); +} + +PixmapPtr +exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp) +{ + PixmapPtr pPixmap; + int x, y; + + STRACE; + if (pDrawable->type == DRAWABLE_WINDOW) { + pPixmap = (*pDrawable->pScreen->GetWindowPixmap) ((WindowPtr) pDrawable); +#ifdef COMPOSITE + x = -pPixmap->screen_x; + y = -pPixmap->screen_y; +#else + x = 0; + y = 0; +#endif + } + else + { + pPixmap = (PixmapPtr) pDrawable; + x = 0; + y = 0; + } + *xp = x; + *yp = y; + if (exaPixmapIsOffscreen (pPixmap)) + return pPixmap; + else + return NULL; +} + +Bool +exaDrawableIsOffscreen (DrawablePtr pDrawable) +{ + PixmapPtr pPixmap; + STRACE; + if (pDrawable->type == DRAWABLE_WINDOW) + pPixmap = (*pDrawable->pScreen->GetWindowPixmap) ((WindowPtr) pDrawable); + else + pPixmap = (PixmapPtr) pDrawable; + return exaPixmapIsOffscreen (pPixmap); +} + +#if 0 +static void +exaFillTiled(int dst_x, + int dst_y, + int width, + int height, + int src_x, + int src_y, + int src_width, + int src_height, + void (*Copy) (int srcX, + int srcY, + int dstX, + int dstY, + int width, + int height)) +{ + modulus (src_x, src_width, src_x); + modulus (src_y, src_height, src_y); + + while (height) + { + int dst_x_tmp = dst_x; + int src_x_tmp = src_x; + int width_tmp = width; + int height_left = src_height - src_y; + int height_this = min (height, height_left); + + while (width_tmp) + { + int width_left = src_width - src_x_tmp; + int width_this = min (width_tmp, width_left); + + (*Copy) (src_x_tmp, src_y, + dst_x_tmp, dst_y, + width_this, height_this); + + width_tmp -= width_this; + dst_x_tmp += width_this; + } + height -= height_this; + dst_y += height_this; + src_y = 0; + } +} +#endif + +static void +exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n, + DDXPointPtr ppt, int *pwidth, int fSorted) +{ + ScreenPtr pScreen = pDrawable->pScreen; + ExaScreenPriv (pScreen); + RegionPtr pClip = fbGetCompositeClip(pGC); + PixmapPtr pPixmap; + BoxPtr pextent, pbox; + int nbox; + int extentX1, extentX2, extentY1, extentY2; + int fullX1, fullX2, fullY1; + int partX1, partX2; + int off_x, off_y; + + STRACE; + if (pGC->fillStyle != FillSolid || + !(pPixmap = exaGetOffscreenPixmap (pDrawable, &off_x, &off_y)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, + pGC->alu, + pGC->planemask, + pGC->fgPixel)) + { + ExaCheckFillSpans (pDrawable, pGC, n, ppt, pwidth, fSorted); + return; + } + + pextent = REGION_EXTENTS(pGC->pScreen, pClip); + extentX1 = pextent->x1; + extentY1 = pextent->y1; + extentX2 = pextent->x2; + extentY2 = pextent->y2; + while (n--) + { + fullX1 = ppt->x; + fullY1 = ppt->y; + fullX2 = fullX1 + (int) *pwidth; + ppt++; + pwidth++; + + if (fullY1 < extentY1 || extentY2 <= fullY1) + continue; + + if (fullX1 < extentX1) + fullX1 = extentX1; + + if (fullX2 > extentX2) + fullX2 = extentX2; + + if (fullX1 >= fullX2) + continue; + + nbox = REGION_NUM_RECTS (pClip); + if (nbox == 1) + { + (*pExaScr->info->accel.Solid) (pPixmap, + fullX1 + off_x, fullY1 + off_y, + fullX2 + off_x, fullY1 + 1 + off_y); + } + else + { + pbox = REGION_RECTS(pClip); + while(nbox--) + { + if (pbox->y1 <= fullY1 && fullY1 < pbox->y2) + { + partX1 = pbox->x1; + if (partX1 < fullX1) + partX1 = fullX1; + partX2 = pbox->x2; + if (partX2 > fullX2) + partX2 = fullX2; + if (partX2 > partX1) + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + off_x, fullY1 + off_y, + partX2 + off_x, fullY1 + 1 + off_y); + } + pbox++; + } + } + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pScreen); +} + +void +exaCopyNtoN (DrawablePtr pSrcDrawable, + DrawablePtr pDstDrawable, + GCPtr pGC, + BoxPtr pbox, + int nbox, + int dx, + int dy, + Bool reverse, + Bool upsidedown, + Pixel bitplane, + void *closure) +{ + ExaScreenPriv (pDstDrawable->pScreen); + PixmapPtr pSrcPixmap, pDstPixmap; + int src_off_x, src_off_y; + int dst_off_x, dst_off_y; + STRACE; + + /* Migrate pixmaps to same place as destination */ + if (pSrcDrawable->type == DRAWABLE_PIXMAP) { + if (exaDrawableIsOffscreen (pDstDrawable)) + exaPixmapUseScreen ((PixmapPtr) pSrcDrawable); + else + exaPixmapUseMemory ((PixmapPtr) pSrcDrawable); + } + + if ((pSrcPixmap = exaGetOffscreenPixmap (pSrcDrawable, &src_off_x, &src_off_y)) && + (pDstPixmap = exaGetOffscreenPixmap (pDstDrawable, &dst_off_x, &dst_off_y)) && + (*pExaScr->info->accel.PrepareCopy) (pSrcPixmap, + pDstPixmap, + dx, + dy, + pGC ? pGC->alu : GXcopy, + pGC ? pGC->planemask : FB_ALLONES)) + { + while (nbox--) + { + (*pExaScr->info->accel.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++; + } + (*pExaScr->info->accel.DoneCopy) (pDstPixmap); + exaMarkSync(pDstDrawable->pScreen); + } + else + { + exaWaitSync (pDstDrawable->pScreen); + fbCopyNtoN (pSrcDrawable, pDstDrawable, pGC, + pbox, nbox, dx, dy, reverse, upsidedown, + bitplane, closure); + } + exaDrawableDirty (pDstDrawable); +} + +static RegionPtr +exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC, + int srcx, int srcy, int width, int height, int dstx, int dsty) +{ + return fbDoCopy (pSrcDrawable, pDstDrawable, pGC, + srcx, srcy, width, height, + dstx, dsty, exaCopyNtoN, 0, 0); +} + +static void +exaPolyFillRect(DrawablePtr pDrawable, + GCPtr pGC, + int nrect, + xRectangle *prect) +{ + ExaScreenPriv (pDrawable->pScreen); + RegionPtr pClip = fbGetCompositeClip(pGC); + PixmapPtr pPixmap; + register BoxPtr pbox; + BoxPtr pextent; + int extentX1, extentX2, extentY1, extentY2; + int fullX1, fullX2, fullY1, fullY2; + int partX1, partX2, partY1, partY2; + int xoff, yoff; + int xorg, yorg; + int n; + + STRACE; + if (pGC->fillStyle != FillSolid || + !(pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, + pGC->alu, + pGC->planemask, + pGC->fgPixel)) + { + ExaCheckPolyFillRect (pDrawable, pGC, nrect, prect); + return; + } + + xorg = pDrawable->x; + yorg = pDrawable->y; + + pextent = REGION_EXTENTS(pGC->pScreen, pClip); + extentX1 = pextent->x1; + extentY1 = pextent->y1; + extentX2 = pextent->x2; + extentY2 = pextent->y2; + while (nrect--) + { + fullX1 = prect->x + xorg; + fullY1 = prect->y + yorg; + fullX2 = fullX1 + (int) prect->width; + fullY2 = fullY1 + (int) prect->height; + prect++; + + if (fullX1 < extentX1) + fullX1 = extentX1; + + if (fullY1 < extentY1) + fullY1 = extentY1; + + if (fullX2 > extentX2) + fullX2 = extentX2; + + if (fullY2 > extentY2) + fullY2 = extentY2; + + if ((fullX1 >= fullX2) || (fullY1 >= fullY2)) + continue; + n = REGION_NUM_RECTS (pClip); + if (n == 1) + { + (*pExaScr->info->accel.Solid) (pPixmap, + fullX1 + xoff, fullY1 + yoff, + fullX2 + xoff, fullY2 + yoff); + } + else + { + pbox = REGION_RECTS(pClip); + /* + * clip the rectangle to each box in the clip region + * this is logically equivalent to calling Intersect() + */ + while(n--) + { + partX1 = pbox->x1; + if (partX1 < fullX1) + partX1 = fullX1; + partY1 = pbox->y1; + if (partY1 < fullY1) + partY1 = fullY1; + partX2 = pbox->x2; + if (partX2 > fullX2) + partX2 = fullX2; + partY2 = pbox->y2; + if (partY2 > fullY2) + partY2 = fullY2; + + pbox++; + + if (partX1 < partX2 && partY1 < partY2) + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + xoff, partY1 + yoff, + partX2 + xoff, partY2 + yoff); + } + } + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pDrawable->pScreen); +} + +static void +exaSolidBoxClipped (DrawablePtr pDrawable, + RegionPtr pClip, + FbBits pm, + FbBits fg, + int x1, + int y1, + int x2, + int y2) +{ + ExaScreenPriv (pDrawable->pScreen); + PixmapPtr pPixmap; + BoxPtr pbox; + int nbox; + int xoff, yoff; + int partX1, partX2, partY1, partY2; + + STRACE; + if (!(pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, GXcopy, pm, fg)) + { + exaWaitSync (pDrawable->pScreen); + fg = fbReplicatePixel (fg, pDrawable->bitsPerPixel); + fbSolidBoxClipped (pDrawable, pClip, x1, y1, x2, y2, + fbAnd (GXcopy, fg, pm), + fbXor (GXcopy, fg, pm)); + exaDrawableDirty (pDrawable); + return; + } + for (nbox = REGION_NUM_RECTS(pClip), pbox = REGION_RECTS(pClip); + nbox--; + pbox++) + { + partX1 = pbox->x1; + if (partX1 < x1) + partX1 = x1; + + partX2 = pbox->x2; + if (partX2 > x2) + partX2 = x2; + + if (partX2 <= partX1) + continue; + + partY1 = pbox->y1; + if (partY1 < y1) + partY1 = y1; + + partY2 = pbox->y2; + if (partY2 > y2) + partY2 = y2; + + if (partY2 <= partY1) + continue; + + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + xoff, partY1 + yoff, + partX2 + xoff, partY2 + yoff); + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pDrawable->pScreen); +} + +static void +exaImageGlyphBlt (DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, + CharInfoPtr *ppciInit, + pointer pglyphBase) +{ + FbGCPrivPtr pPriv = fbGetGCPrivate(pGC); + CharInfoPtr *ppci; + CharInfoPtr pci; + unsigned char *pglyph; /* pointer bits in glyph */ + int gWidth, gHeight; /* width and height of glyph */ + FbStride gStride; /* stride of glyph */ + Bool opaque; + int n; + int gx, gy; + void (*glyph) (FbBits *, + FbStride, + int, + FbStip *, + FbBits, + int, + int); + FbBits *dst; + FbStride dstStride; + int dstBpp; + int dstXoff, dstYoff; + FbBits depthMask; + + STRACE; + depthMask = FbFullMask(pDrawable->depth); + if ((pGC->planemask & depthMask) != depthMask) + { + ExaCheckImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppciInit, pglyphBase); + return; + } + glyph = 0; + fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff); + switch (dstBpp) { + case 8: glyph = fbGlyph8; break; + case 16: glyph = fbGlyph16; break; + case 24: glyph = fbGlyph24; break; + case 32: glyph = fbGlyph32; break; + } + + x += pDrawable->x; + y += pDrawable->y; + + if (TERMINALFONT (pGC->font) && !glyph) + { + opaque = TRUE; + } + else + { + int xBack, widthBack; + int yBack, heightBack; + + ppci = ppciInit; + n = nglyph; + widthBack = 0; + while (n--) + widthBack += (*ppci++)->metrics.characterWidth; + + xBack = x; + if (widthBack < 0) + { + xBack += widthBack; + widthBack = -widthBack; + } + yBack = y - FONTASCENT(pGC->font); + heightBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font); + exaSolidBoxClipped (pDrawable, + fbGetCompositeClip(pGC), + pGC->planemask, + pGC->bgPixel, + xBack, + yBack, + xBack + widthBack, + yBack + heightBack); + opaque = FALSE; + } + + exaWaitSync (pDrawable->pScreen); + exaDrawableDirty (pDrawable); + + ppci = ppciInit; + while (nglyph--) + { + pci = *ppci++; + pglyph = FONTGLYPHBITS(pglyphBase, pci); + gWidth = GLYPHWIDTHPIXELS(pci); + gHeight = GLYPHHEIGHTPIXELS(pci); + if (gWidth && gHeight) + { + gx = x + pci->metrics.leftSideBearing; + gy = y - pci->metrics.ascent; + if (glyph && gWidth <= sizeof (FbStip) * 8 && + fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight)) + { + (*glyph) (dst + (gy + dstYoff) * dstStride, + dstStride, + dstBpp, + (FbStip *) pglyph, + pPriv->fg, + gx + dstXoff, + gHeight); + } + else + { + gStride = GLYPHWIDTHBYTESPADDED(pci) / sizeof (FbStip); + fbPutXYImage (pDrawable, + fbGetCompositeClip(pGC), + pPriv->fg, + pPriv->bg, + pPriv->pm, + GXcopy, + opaque, + + gx, + gy, + gWidth, gHeight, + + (FbStip *) pglyph, + gStride, + 0); + } + } + x += pci->metrics.characterWidth; + } +} + +static const GCOps exaOps = { + exaFillSpans, + ExaCheckSetSpans, + ExaCheckPutImage, + exaCopyArea, + ExaCheckCopyPlane, + ExaCheckPolyPoint, + ExaCheckPolylines, + ExaCheckPolySegment, + miPolyRectangle, + ExaCheckPolyArc, + miFillPolygon, + exaPolyFillRect, + miPolyFillArc, + miPolyText8, + miPolyText16, + miImageText8, + miImageText16, + exaImageGlyphBlt, + ExaCheckPolyGlyphBlt, + ExaCheckPushPixels, +#ifdef NEED_LINEHELPER + ,NULL +#endif +}; + +static void +exaValidateGC (GCPtr pGC, Mask changes, DrawablePtr pDrawable) +{ + fbValidateGC (pGC, changes, pDrawable); + + if (exaDrawableIsOffscreen (pDrawable)) + pGC->ops = (GCOps *) &exaOps; + else + pGC->ops = (GCOps *) &exaAsyncPixmapGCOps; +} + +GCFuncs exaGCFuncs = { + exaValidateGC, + miChangeGC, + miCopyGC, + miDestroyGC, + miChangeClip, + miDestroyClip, + miCopyClip +}; + +static int +exaCreateGC (GCPtr pGC) +{ + STRACE; + if (!fbCreateGC (pGC)) + return FALSE; + + pGC->funcs = &exaGCFuncs; + + return TRUE; +} + + +static void +exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) +{ + RegionRec rgnDst; + int dx, dy; + PixmapPtr pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin); + + STRACE; + dx = ptOldOrg.x - pWin->drawable.x; + dy = ptOldOrg.y - pWin->drawable.y; + REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy); + + REGION_INIT (pWin->drawable.pScreen, &rgnDst, NullBox, 0); + + REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc); +#ifdef COMPOSITE + if (pPixmap->screen_x || pPixmap->screen_y) + REGION_TRANSLATE (pWin->drawable.pScreen, &rgnDst, + -pPixmap->screen_x, -pPixmap->screen_y); +#endif + + fbCopyRegion (&pPixmap->drawable, &pPixmap->drawable, + 0, + &rgnDst, dx, dy, exaCopyNtoN, 0, 0); + + REGION_UNINIT(pWin->drawable.pScreen, &rgnDst); +} + +static void +exaFillRegionSolid (DrawablePtr pDrawable, + RegionPtr pRegion, + Pixel pixel) +{ + ExaScreenPriv(pDrawable->pScreen); + PixmapPtr pPixmap; + int xoff, yoff; + + STRACE; + if ((pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) && + (*pExaScr->info->accel.PrepareSolid) (pPixmap, GXcopy, FB_ALLONES, pixel)) + { + int nbox = REGION_NUM_RECTS (pRegion); + BoxPtr pBox = REGION_RECTS (pRegion); + + while (nbox--) + { + (*pExaScr->info->accel.Solid) (pPixmap, + pBox->x1 + xoff, pBox->y1 + yoff, + pBox->x2 + xoff, pBox->y2 + yoff); + pBox++; + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaMarkSync(pDrawable->pScreen); + } + else + { + exaWaitSync (pDrawable->pScreen); + fbFillRegionSolid (pDrawable, pRegion, 0, + fbReplicatePixel (pixel, pDrawable->bitsPerPixel)); + } + exaDrawableDirty (pDrawable); +} + +static void +exaPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what) +{ + STRACE; + if (!REGION_NUM_RECTS(pRegion)) + return; + switch (what) { + case PW_BACKGROUND: + switch (pWin->backgroundState) { + case None: + return; + case ParentRelative: + do { + pWin = pWin->parent; + } while (pWin->backgroundState == ParentRelative); + (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion, + what); + return; + case BackgroundPixel: + exaFillRegionSolid((DrawablePtr)pWin, pRegion, pWin->background.pixel); + return; +#if 0 + case BackgroundPixmap: + exaFillRegionTiled((DrawablePtr)pWin, pRegion, pWin->background.pixmap); + return; +#endif + } + break; + case PW_BORDER: + if (pWin->borderIsPixel) + { + exaFillRegionSolid((DrawablePtr)pWin, pRegion, pWin->border.pixel); + return; + } +#if 0 + else + { + exaFillRegionTiled((DrawablePtr)pWin, pRegion, pWin->border.pixmap); + return; + } +#endif + break; + } + ExaCheckPaintWindow (pWin, pRegion, what); +} + +Bool +exaDriverInit (ScreenPtr pScreen, + ExaDriverPtr pScreenInfo) +{ + ExaScreenPrivPtr pExaScr; + +#ifdef RENDER + PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); +#endif + STRACE; + if (exaGeneration != serverGeneration) + { + exaScreenPrivateIndex = AllocateScreenPrivateIndex(); + exaPixmapPrivateIndex = AllocatePixmapPrivateIndex(); + exaGeneration = serverGeneration; + } + + pExaScr = xalloc (sizeof (ExaScreenPrivRec)); + + if (!pExaScr) + return FALSE; + + pExaScr->info = pScreenInfo; + + pScreen->devPrivates[exaScreenPrivateIndex].ptr = (pointer) pExaScr; + + /* + * Hook up asynchronous drawing + */ + ExaScreenInitAsync (pScreen); + /* + * Replace various fb screen functions + */ + pScreen->CreateGC = exaCreateGC; + pScreen->CopyWindow = exaCopyWindow; + pScreen->PaintWindowBackground = exaPaintWindow; + pScreen->PaintWindowBorder = exaPaintWindow; +#ifdef RENDER + if (ps) { + ps->Composite = exaComposite; + } +#endif + + /* + * Hookup offscreen pixmaps + */ + if ((pExaScr->info->card.flags & EXA_OFFSCREEN_PIXMAPS) && + pExaScr->info->card.offScreenBase < pExaScr->info->card.memorySize) + { + if (!AllocatePixmapPrivate(pScreen, exaPixmapPrivateIndex, + sizeof (ExaPixmapPrivRec))) + return FALSE; + pScreen->CreatePixmap = exaCreatePixmap; + pScreen->DestroyPixmap = exaDestroyPixmap; + } + else + { + if (!AllocatePixmapPrivate(pScreen, exaPixmapPrivateIndex, 0)) + return FALSE; + } + + ErrorF("============== %ld < %ld\n", pExaScr->info->card.offScreenBase, + pExaScr->info->card.memorySize); + if (pExaScr->info->card.offScreenBase < pExaScr->info->card.memorySize) { + if (!exaOffscreenInit (pScreen)) + return FALSE; + } + + return TRUE; +} + +void +exaDriverFini (ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + + STRACE; + xfree (pExaScr); +} + + +void exaMarkSync(ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + ExaCardInfoPtr card = &(pExaScr->info->card); + + card->needsSync = TRUE; + if (pExaScr->info->accel.MarkSync != NULL) { + card->lastMarker = (*pExaScr->info->accel.MarkSync)(pScreen); + } +} + +void exaWaitSync(ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + ExaCardInfoPtr card = &(pExaScr->info->card); + + if (card->needsSync) { + (*pExaScr->info->accel.WaitMarker)(pScreen, card->lastMarker); + card->needsSync = FALSE; + } +} + +unsigned int exaGetVersion(void) +{ + return EXA_VERSION; +} + +#ifdef XFree86LOADER +static MODULESETUPPROTO(exaSetup); + + +static const OptionInfoRec EXAOptions[] = { + { -1, NULL, + OPTV_NONE, {0}, FALSE } +}; + +/*ARGSUSED*/ +static const OptionInfoRec * +EXAAvailableOptions(void *unused) +{ + return (EXAOptions); +} + +static XF86ModuleVersionInfo exaVersRec = +{ + "exa", + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XORG_VERSION_CURRENT, + 1, 2, 0, + ABI_CLASS_VIDEODRV, /* requires the video driver ABI */ + ABI_VIDEODRV_VERSION, + MOD_CLASS_NONE, + {0,0,0,0} +}; + +XF86ModuleData exaModuleData = { &exaVersRec, exaSetup, NULL }; + +ModuleInfoRec EXA = { + 1, + "EXA", + NULL, + 0, + EXAAvailableOptions, +}; + +/*ARGSUSED*/ +static pointer +exaSetup(pointer Module, pointer Options, int *ErrorMajor, int *ErrorMinor) +{ + static Bool Initialised = FALSE; + + ErrorF("exa setup\n"); + if (!Initialised) { + Initialised = TRUE; +#ifndef REMOVE_LOADER_CHECK_MODULE_INFO + if (xf86LoaderCheckSymbol("xf86AddModuleInfo")) +#endif + xf86AddModuleInfo(&EXA, Module); + } + + return (pointer)TRUE; +} +#endif diff --git a/exa/exa_migration.c b/exa/exa_migration.c new file mode 100644 index 000000000..c2d0db063 --- /dev/null +++ b/exa/exa_migration.c @@ -0,0 +1,1252 @@ +/* + * Copyright © 2001 Keith Packard + * + * Partly based on code that is Copyright © The XFree86 Project Inc. + * + * 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 Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD 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. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "exaPriv.h" +#include "fontstruct.h" +#include "dixfontstr.h" +#include "xf86str.h" +#include "xf86.h" +#include "exa.h" + +#define DEBUG_MIGRATE 0 +#define DEBUG_PIXMAP 0 +#if DEBUG_MIGRATE +#define DBG_MIGRATE(a) ErrorF a +#else +#define DBG_MIGRATE(a) +#endif +#if DEBUG_PIXMAP +#define DBG_PIXMAP(a) ErrorF a +#else +#define DBG_PIXMAP(a) +#endif +#define STRACE +#define TRACE + +int exaGeneration; +int exaScreenPrivateIndex; +int exaPixmapPrivateIndex; + +#define EXA_PIXMAP_SCORE_MOVE_IN 10 +#define EXA_PIXMAP_SCORE_MAX 20 +#define EXA_PIXMAP_SCORE_MOVE_OUT -10 +#define EXA_PIXMAP_SCORE_MIN -20 +#define EXA_PIXMAP_SCORE_PINNED 1000 +#define EXA_PIXMAP_SCORE_INIT 1001 + +void +exaDrawableDirty (DrawablePtr pDrawable) +{ + PixmapPtr pPixmap; + ExaPixmapPrivPtr pExaPixmap; + + if (pDrawable->type == DRAWABLE_WINDOW) + pPixmap = (*pDrawable->pScreen->GetWindowPixmap)((WindowPtr) pDrawable); + else + pPixmap = (PixmapPtr)pDrawable; + + pExaPixmap = ExaGetPixmapPriv(pPixmap); + if (pExaPixmap != NULL) + pExaPixmap->dirty = TRUE; +} + +static void +exaPixmapSave (ScreenPtr pScreen, ExaOffscreenArea *area) +{ + PixmapPtr pPixmap = area->privData; + ExaScreenPriv (pScreen); + ExaPixmapPriv(pPixmap); + int dst_pitch, src_pitch, bytes; + char *dst, *src; + int i; + + DBG_MIGRATE (("Save 0x%08p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + + src_pitch = pPixmap->devKind; + dst_pitch = pExaPixmap->devKind; + + src = pPixmap->devPrivate.ptr; + dst = pExaPixmap->devPrivate.ptr; + + if (pExaScr->info->accel.DownloadFromScreen) + { + if (pExaScr->info->accel.DownloadFromScreen(pPixmap, + pPixmap->drawable.x, + pPixmap->drawable.y, + pPixmap->drawable.width, + pPixmap->drawable.height, + dst, + dst_pitch)) { + + pPixmap->devKind = dst_pitch; + pPixmap->devPrivate.ptr = dst; + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + pExaPixmap->area = NULL; + return; + } + } + + pPixmap->devKind = dst_pitch; + pPixmap->devPrivate.ptr = dst; + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + pExaPixmap->area = NULL; + +#if 0 + if (!pExaPixmap->dirty) + return; +#endif + + exaWaitSync (pPixmap->drawable.pScreen); + + bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch; + + i = pPixmap->drawable.height; + while (i--) { + memcpy (dst, src, bytes); + dst += dst_pitch; + src += src_pitch; + } +} + +static int +exaLog2(int val) +{ + int bits; + + if (!val) + return 0; + for (bits = 0; val != 0; bits++) + val >>= 1; + return bits - 1; +} + +static Bool +exaPixmapAllocArea (PixmapPtr pPixmap) +{ + ScreenPtr pScreen = pPixmap->drawable.pScreen; + ExaScreenPriv (pScreen); + ExaPixmapPriv (pPixmap); + int bpp = pPixmap->drawable.bitsPerPixel; + CARD16 h = pPixmap->drawable.height; + CARD16 w = pPixmap->drawable.width; + int pitch; + + if (pExaScr->info->card.flags & EXA_OFFSCREEN_ALIGN_POT && w != 1) + w = 1 << (exaLog2(w - 1) + 1); + pitch = (w * bpp / 8 + pExaScr->info->card.offscreenPitch - 1) & + ~(pExaScr->info->card.offscreenPitch - 1); + + pExaPixmap->devKind = pPixmap->devKind; + pExaPixmap->devPrivate = pPixmap->devPrivate; + pExaPixmap->area = exaOffscreenAlloc (pScreen, pitch * h, + pExaScr->info->card.offscreenByteAlign, + FALSE, + exaPixmapSave, (pointer) pPixmap); + if (!pExaPixmap->area) + return FALSE; + + DBG_PIXMAP(("++ 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + pPixmap->devKind = pitch; + + pPixmap->devPrivate.ptr = (pointer) ((CARD8 *) pExaScr->info->card.memoryBase + pExaPixmap->area->offset); + pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER; + return TRUE; +} + +void +exaMoveInPixmap (PixmapPtr pPixmap) +{ + ScreenPtr pScreen = pPixmap->drawable.pScreen; + ExaScreenPriv (pScreen); + ExaPixmapPriv (pPixmap); + int dst_pitch, src_pitch, bytes; + char *dst, *src; + int i; + + DBG_MIGRATE (("-> 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + + src = pPixmap->devPrivate.ptr; + src_pitch = pPixmap->devKind; + + if (!exaPixmapAllocArea (pPixmap)) + return; + + pExaPixmap->dirty = FALSE; + + if (pExaScr->info->accel.UploadToScreen) + { + if (pExaScr->info->accel.UploadToScreen(pPixmap, src, src_pitch)) + return; + } + + dst = pPixmap->devPrivate.ptr; + dst_pitch = pPixmap->devKind; + + bytes = src_pitch < dst_pitch ? src_pitch : dst_pitch; + + exaWaitSync (pPixmap->drawable.pScreen); + + i = pPixmap->drawable.height; + ErrorF("dst = %p, src = %p,(%d, %d) height = %d, mem_base = %p, offset = %d\n", + dst, src, dst_pitch, src_pitch, + i, pExaScr->info->card.memoryBase, ExaGetPixmapPriv(pPixmap)->area->offset); + + while (i--) { + memcpy (dst, src, bytes); + dst += dst_pitch; + src += src_pitch; + } + ErrorF("done\n"); +} + +static void +exaMoveOutPixmap (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + ExaOffscreenArea *area = pExaPixmap->area; + + DBG_MIGRATE (("<- 0x%p (0x%p) (%dx%d)\n", + (void*)pPixmap->drawable.id, + (void*)(ExaGetPixmapPriv(pPixmap)->area ? + ExaGetPixmapPriv(pPixmap)->area->offset : 0), + pPixmap->drawable.width, + pPixmap->drawable.height)); + STRACE; + if (area) + { + exaPixmapSave (pPixmap->drawable.pScreen, area); + exaOffscreenFree (pPixmap->drawable.pScreen, area); + } +} + +void +exaPixmapUseScreen (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + + STRACE; + if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) + return; + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) { + exaMoveInPixmap(pPixmap); + pExaPixmap->score = 0; + } + + if (pExaPixmap->score < EXA_PIXMAP_SCORE_MAX) + { + pExaPixmap->score++; + if (!exaPixmapIsOffscreen(pPixmap) && + pExaPixmap->score >= EXA_PIXMAP_SCORE_MOVE_IN) + exaMoveInPixmap (pPixmap); + } + ExaOffscreenMarkUsed (pPixmap); +} + +void +exaPixmapUseMemory (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_PINNED) + return; + + if (pExaPixmap->score == EXA_PIXMAP_SCORE_INIT) + pExaPixmap->score = 0; + + if (pExaPixmap->score > EXA_PIXMAP_SCORE_MIN) + { + pExaPixmap->score--; + if (pExaPixmap->area && + pExaPixmap->score <= EXA_PIXMAP_SCORE_MOVE_OUT) + exaMoveOutPixmap (pPixmap); + } +} + +static Bool +exaDestroyPixmap (PixmapPtr pPixmap) +{ + if (pPixmap->refcnt == 1) + { + ExaPixmapPriv (pPixmap); + if (pExaPixmap->area) + { + DBG_PIXMAP(("-- 0x%p (0x%x) (%dx%d)\n", + (void*)pPixmap->drawable.id, + ExaGetPixmapPriv(pPixmap)->area->offset, + pPixmap->drawable.width, + pPixmap->drawable.height)); + /* Free the offscreen area */ + exaOffscreenFree (pPixmap->drawable.pScreen, pExaPixmap->area); + pPixmap->devPrivate = pExaPixmap->devPrivate; + pPixmap->devKind = pExaPixmap->devKind; + } + } + return fbDestroyPixmap (pPixmap); +} + +static PixmapPtr +exaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth) +{ + PixmapPtr pPixmap; + ExaPixmapPrivPtr pExaPixmap; + int bpp; + + bpp = BitsPerPixel (depth); + if (bpp == 32 && depth == 24) + { + int format; + ScrnInfoPtr pScrn = XF86SCRNINFO(pScreen); + for (format = 0; format < MAXFORMATS && pScrn->formats[format].depth; ++format) + if (pScrn->formats[format].depth == 24) + { + bpp = pScrn->formats[format].bitsPerPixel; + break; + } + } + + pPixmap = fbCreatePixmapBpp (pScreen, w, h, depth, bpp); + if (!pPixmap) + return NULL; + pExaPixmap = ExaGetPixmapPriv(pPixmap); + if (!w || !h) + pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED; + else + pExaPixmap->score = EXA_PIXMAP_SCORE_INIT; + + pExaPixmap->area = NULL; + pExaPixmap->dirty = FALSE; + + return pPixmap; +} + +Bool +exaPixmapIsOffscreen(PixmapPtr p) +{ + ScreenPtr pScreen = p->drawable.pScreen; + ExaScreenPriv(pScreen); + + STRACE; + return ((unsigned long) ((CARD8 *) p->devPrivate.ptr - + (CARD8 *) pExaScr->info->card.memoryBase) < + pExaScr->info->card.memorySize); +} + +PixmapPtr +exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp) +{ + PixmapPtr pPixmap; + int x, y; + + STRACE; + if (pDrawable->type == DRAWABLE_WINDOW) { + pPixmap = (*pDrawable->pScreen->GetWindowPixmap) ((WindowPtr) pDrawable); +#ifdef COMPOSITE + x = -pPixmap->screen_x; + y = -pPixmap->screen_y; +#else + x = 0; + y = 0; +#endif + } + else + { + pPixmap = (PixmapPtr) pDrawable; + x = 0; + y = 0; + } + *xp = x; + *yp = y; + if (exaPixmapIsOffscreen (pPixmap)) + return pPixmap; + else + return NULL; +} + +Bool +exaDrawableIsOffscreen (DrawablePtr pDrawable) +{ + PixmapPtr pPixmap; + STRACE; + if (pDrawable->type == DRAWABLE_WINDOW) + pPixmap = (*pDrawable->pScreen->GetWindowPixmap) ((WindowPtr) pDrawable); + else + pPixmap = (PixmapPtr) pDrawable; + return exaPixmapIsOffscreen (pPixmap); +} + +#if 0 +static void +exaFillTiled(int dst_x, + int dst_y, + int width, + int height, + int src_x, + int src_y, + int src_width, + int src_height, + void (*Copy) (int srcX, + int srcY, + int dstX, + int dstY, + int width, + int height)) +{ + modulus (src_x, src_width, src_x); + modulus (src_y, src_height, src_y); + + while (height) + { + int dst_x_tmp = dst_x; + int src_x_tmp = src_x; + int width_tmp = width; + int height_left = src_height - src_y; + int height_this = min (height, height_left); + + while (width_tmp) + { + int width_left = src_width - src_x_tmp; + int width_this = min (width_tmp, width_left); + + (*Copy) (src_x_tmp, src_y, + dst_x_tmp, dst_y, + width_this, height_this); + + width_tmp -= width_this; + dst_x_tmp += width_this; + } + height -= height_this; + dst_y += height_this; + src_y = 0; + } +} +#endif + +static void +exaFillSpans(DrawablePtr pDrawable, GCPtr pGC, int n, + DDXPointPtr ppt, int *pwidth, int fSorted) +{ + ScreenPtr pScreen = pDrawable->pScreen; + ExaScreenPriv (pScreen); + RegionPtr pClip = fbGetCompositeClip(pGC); + PixmapPtr pPixmap; + BoxPtr pextent, pbox; + int nbox; + int extentX1, extentX2, extentY1, extentY2; + int fullX1, fullX2, fullY1; + int partX1, partX2; + int off_x, off_y; + + STRACE; + if (pGC->fillStyle != FillSolid || + !(pPixmap = exaGetOffscreenPixmap (pDrawable, &off_x, &off_y)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, + pGC->alu, + pGC->planemask, + pGC->fgPixel)) + { + ExaCheckFillSpans (pDrawable, pGC, n, ppt, pwidth, fSorted); + return; + } + + pextent = REGION_EXTENTS(pGC->pScreen, pClip); + extentX1 = pextent->x1; + extentY1 = pextent->y1; + extentX2 = pextent->x2; + extentY2 = pextent->y2; + while (n--) + { + fullX1 = ppt->x; + fullY1 = ppt->y; + fullX2 = fullX1 + (int) *pwidth; + ppt++; + pwidth++; + + if (fullY1 < extentY1 || extentY2 <= fullY1) + continue; + + if (fullX1 < extentX1) + fullX1 = extentX1; + + if (fullX2 > extentX2) + fullX2 = extentX2; + + if (fullX1 >= fullX2) + continue; + + nbox = REGION_NUM_RECTS (pClip); + if (nbox == 1) + { + (*pExaScr->info->accel.Solid) (pPixmap, + fullX1 + off_x, fullY1 + off_y, + fullX2 + off_x, fullY1 + 1 + off_y); + } + else + { + pbox = REGION_RECTS(pClip); + while(nbox--) + { + if (pbox->y1 <= fullY1 && fullY1 < pbox->y2) + { + partX1 = pbox->x1; + if (partX1 < fullX1) + partX1 = fullX1; + partX2 = pbox->x2; + if (partX2 > fullX2) + partX2 = fullX2; + if (partX2 > partX1) + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + off_x, fullY1 + off_y, + partX2 + off_x, fullY1 + 1 + off_y); + } + pbox++; + } + } + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pScreen); +} + +void +exaCopyNtoN (DrawablePtr pSrcDrawable, + DrawablePtr pDstDrawable, + GCPtr pGC, + BoxPtr pbox, + int nbox, + int dx, + int dy, + Bool reverse, + Bool upsidedown, + Pixel bitplane, + void *closure) +{ + ExaScreenPriv (pDstDrawable->pScreen); + PixmapPtr pSrcPixmap, pDstPixmap; + int src_off_x, src_off_y; + int dst_off_x, dst_off_y; + STRACE; + + /* Migrate pixmaps to same place as destination */ + if (pSrcDrawable->type == DRAWABLE_PIXMAP) { + if (exaDrawableIsOffscreen (pDstDrawable)) + exaPixmapUseScreen ((PixmapPtr) pSrcDrawable); + else + exaPixmapUseMemory ((PixmapPtr) pSrcDrawable); + } + + if ((pSrcPixmap = exaGetOffscreenPixmap (pSrcDrawable, &src_off_x, &src_off_y)) && + (pDstPixmap = exaGetOffscreenPixmap (pDstDrawable, &dst_off_x, &dst_off_y)) && + (*pExaScr->info->accel.PrepareCopy) (pSrcPixmap, + pDstPixmap, + dx, + dy, + pGC ? pGC->alu : GXcopy, + pGC ? pGC->planemask : FB_ALLONES)) + { + while (nbox--) + { + (*pExaScr->info->accel.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++; + } + (*pExaScr->info->accel.DoneCopy) (pDstPixmap); + exaMarkSync(pDstDrawable->pScreen); + } + else + { + exaWaitSync (pDstDrawable->pScreen); + fbCopyNtoN (pSrcDrawable, pDstDrawable, pGC, + pbox, nbox, dx, dy, reverse, upsidedown, + bitplane, closure); + } + exaDrawableDirty (pDstDrawable); +} + +static RegionPtr +exaCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC, + int srcx, int srcy, int width, int height, int dstx, int dsty) +{ + return fbDoCopy (pSrcDrawable, pDstDrawable, pGC, + srcx, srcy, width, height, + dstx, dsty, exaCopyNtoN, 0, 0); +} + +static void +exaPolyFillRect(DrawablePtr pDrawable, + GCPtr pGC, + int nrect, + xRectangle *prect) +{ + ExaScreenPriv (pDrawable->pScreen); + RegionPtr pClip = fbGetCompositeClip(pGC); + PixmapPtr pPixmap; + register BoxPtr pbox; + BoxPtr pextent; + int extentX1, extentX2, extentY1, extentY2; + int fullX1, fullX2, fullY1, fullY2; + int partX1, partX2, partY1, partY2; + int xoff, yoff; + int xorg, yorg; + int n; + + STRACE; + if (pGC->fillStyle != FillSolid || + !(pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, + pGC->alu, + pGC->planemask, + pGC->fgPixel)) + { + ExaCheckPolyFillRect (pDrawable, pGC, nrect, prect); + return; + } + + xorg = pDrawable->x; + yorg = pDrawable->y; + + pextent = REGION_EXTENTS(pGC->pScreen, pClip); + extentX1 = pextent->x1; + extentY1 = pextent->y1; + extentX2 = pextent->x2; + extentY2 = pextent->y2; + while (nrect--) + { + fullX1 = prect->x + xorg; + fullY1 = prect->y + yorg; + fullX2 = fullX1 + (int) prect->width; + fullY2 = fullY1 + (int) prect->height; + prect++; + + if (fullX1 < extentX1) + fullX1 = extentX1; + + if (fullY1 < extentY1) + fullY1 = extentY1; + + if (fullX2 > extentX2) + fullX2 = extentX2; + + if (fullY2 > extentY2) + fullY2 = extentY2; + + if ((fullX1 >= fullX2) || (fullY1 >= fullY2)) + continue; + n = REGION_NUM_RECTS (pClip); + if (n == 1) + { + (*pExaScr->info->accel.Solid) (pPixmap, + fullX1 + xoff, fullY1 + yoff, + fullX2 + xoff, fullY2 + yoff); + } + else + { + pbox = REGION_RECTS(pClip); + /* + * clip the rectangle to each box in the clip region + * this is logically equivalent to calling Intersect() + */ + while(n--) + { + partX1 = pbox->x1; + if (partX1 < fullX1) + partX1 = fullX1; + partY1 = pbox->y1; + if (partY1 < fullY1) + partY1 = fullY1; + partX2 = pbox->x2; + if (partX2 > fullX2) + partX2 = fullX2; + partY2 = pbox->y2; + if (partY2 > fullY2) + partY2 = fullY2; + + pbox++; + + if (partX1 < partX2 && partY1 < partY2) + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + xoff, partY1 + yoff, + partX2 + xoff, partY2 + yoff); + } + } + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pDrawable->pScreen); +} + +static void +exaSolidBoxClipped (DrawablePtr pDrawable, + RegionPtr pClip, + FbBits pm, + FbBits fg, + int x1, + int y1, + int x2, + int y2) +{ + ExaScreenPriv (pDrawable->pScreen); + PixmapPtr pPixmap; + BoxPtr pbox; + int nbox; + int xoff, yoff; + int partX1, partX2, partY1, partY2; + + STRACE; + if (!(pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) || + !(*pExaScr->info->accel.PrepareSolid) (pPixmap, GXcopy, pm, fg)) + { + exaWaitSync (pDrawable->pScreen); + fg = fbReplicatePixel (fg, pDrawable->bitsPerPixel); + fbSolidBoxClipped (pDrawable, pClip, x1, y1, x2, y2, + fbAnd (GXcopy, fg, pm), + fbXor (GXcopy, fg, pm)); + exaDrawableDirty (pDrawable); + return; + } + for (nbox = REGION_NUM_RECTS(pClip), pbox = REGION_RECTS(pClip); + nbox--; + pbox++) + { + partX1 = pbox->x1; + if (partX1 < x1) + partX1 = x1; + + partX2 = pbox->x2; + if (partX2 > x2) + partX2 = x2; + + if (partX2 <= partX1) + continue; + + partY1 = pbox->y1; + if (partY1 < y1) + partY1 = y1; + + partY2 = pbox->y2; + if (partY2 > y2) + partY2 = y2; + + if (partY2 <= partY1) + continue; + + (*pExaScr->info->accel.Solid) (pPixmap, + partX1 + xoff, partY1 + yoff, + partX2 + xoff, partY2 + yoff); + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaDrawableDirty (pDrawable); + exaMarkSync(pDrawable->pScreen); +} + +static void +exaImageGlyphBlt (DrawablePtr pDrawable, + GCPtr pGC, + int x, + int y, + unsigned int nglyph, + CharInfoPtr *ppciInit, + pointer pglyphBase) +{ + FbGCPrivPtr pPriv = fbGetGCPrivate(pGC); + CharInfoPtr *ppci; + CharInfoPtr pci; + unsigned char *pglyph; /* pointer bits in glyph */ + int gWidth, gHeight; /* width and height of glyph */ + FbStride gStride; /* stride of glyph */ + Bool opaque; + int n; + int gx, gy; + void (*glyph) (FbBits *, + FbStride, + int, + FbStip *, + FbBits, + int, + int); + FbBits *dst; + FbStride dstStride; + int dstBpp; + int dstXoff, dstYoff; + FbBits depthMask; + + STRACE; + depthMask = FbFullMask(pDrawable->depth); + if ((pGC->planemask & depthMask) != depthMask) + { + ExaCheckImageGlyphBlt(pDrawable, pGC, x, y, nglyph, ppciInit, pglyphBase); + return; + } + glyph = 0; + fbGetDrawable (pDrawable, dst, dstStride, dstBpp, dstXoff, dstYoff); + switch (dstBpp) { + case 8: glyph = fbGlyph8; break; + case 16: glyph = fbGlyph16; break; + case 24: glyph = fbGlyph24; break; + case 32: glyph = fbGlyph32; break; + } + + x += pDrawable->x; + y += pDrawable->y; + + if (TERMINALFONT (pGC->font) && !glyph) + { + opaque = TRUE; + } + else + { + int xBack, widthBack; + int yBack, heightBack; + + ppci = ppciInit; + n = nglyph; + widthBack = 0; + while (n--) + widthBack += (*ppci++)->metrics.characterWidth; + + xBack = x; + if (widthBack < 0) + { + xBack += widthBack; + widthBack = -widthBack; + } + yBack = y - FONTASCENT(pGC->font); + heightBack = FONTASCENT(pGC->font) + FONTDESCENT(pGC->font); + exaSolidBoxClipped (pDrawable, + fbGetCompositeClip(pGC), + pGC->planemask, + pGC->bgPixel, + xBack, + yBack, + xBack + widthBack, + yBack + heightBack); + opaque = FALSE; + } + + exaWaitSync (pDrawable->pScreen); + exaDrawableDirty (pDrawable); + + ppci = ppciInit; + while (nglyph--) + { + pci = *ppci++; + pglyph = FONTGLYPHBITS(pglyphBase, pci); + gWidth = GLYPHWIDTHPIXELS(pci); + gHeight = GLYPHHEIGHTPIXELS(pci); + if (gWidth && gHeight) + { + gx = x + pci->metrics.leftSideBearing; + gy = y - pci->metrics.ascent; + if (glyph && gWidth <= sizeof (FbStip) * 8 && + fbGlyphIn (fbGetCompositeClip(pGC), gx, gy, gWidth, gHeight)) + { + (*glyph) (dst + (gy + dstYoff) * dstStride, + dstStride, + dstBpp, + (FbStip *) pglyph, + pPriv->fg, + gx + dstXoff, + gHeight); + } + else + { + gStride = GLYPHWIDTHBYTESPADDED(pci) / sizeof (FbStip); + fbPutXYImage (pDrawable, + fbGetCompositeClip(pGC), + pPriv->fg, + pPriv->bg, + pPriv->pm, + GXcopy, + opaque, + + gx, + gy, + gWidth, gHeight, + + (FbStip *) pglyph, + gStride, + 0); + } + } + x += pci->metrics.characterWidth; + } +} + +static const GCOps exaOps = { + exaFillSpans, + ExaCheckSetSpans, + ExaCheckPutImage, + exaCopyArea, + ExaCheckCopyPlane, + ExaCheckPolyPoint, + ExaCheckPolylines, + ExaCheckPolySegment, + miPolyRectangle, + ExaCheckPolyArc, + miFillPolygon, + exaPolyFillRect, + miPolyFillArc, + miPolyText8, + miPolyText16, + miImageText8, + miImageText16, + exaImageGlyphBlt, + ExaCheckPolyGlyphBlt, + ExaCheckPushPixels, +#ifdef NEED_LINEHELPER + ,NULL +#endif +}; + +static void +exaValidateGC (GCPtr pGC, Mask changes, DrawablePtr pDrawable) +{ + fbValidateGC (pGC, changes, pDrawable); + + if (exaDrawableIsOffscreen (pDrawable)) + pGC->ops = (GCOps *) &exaOps; + else + pGC->ops = (GCOps *) &exaAsyncPixmapGCOps; +} + +GCFuncs exaGCFuncs = { + exaValidateGC, + miChangeGC, + miCopyGC, + miDestroyGC, + miChangeClip, + miDestroyClip, + miCopyClip +}; + +static int +exaCreateGC (GCPtr pGC) +{ + STRACE; + if (!fbCreateGC (pGC)) + return FALSE; + + pGC->funcs = &exaGCFuncs; + + return TRUE; +} + + +static void +exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) +{ + RegionRec rgnDst; + int dx, dy; + PixmapPtr pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin); + + STRACE; + dx = ptOldOrg.x - pWin->drawable.x; + dy = ptOldOrg.y - pWin->drawable.y; + REGION_TRANSLATE(pWin->drawable.pScreen, prgnSrc, -dx, -dy); + + REGION_INIT (pWin->drawable.pScreen, &rgnDst, NullBox, 0); + + REGION_INTERSECT(pWin->drawable.pScreen, &rgnDst, &pWin->borderClip, prgnSrc); +#ifdef COMPOSITE + if (pPixmap->screen_x || pPixmap->screen_y) + REGION_TRANSLATE (pWin->drawable.pScreen, &rgnDst, + -pPixmap->screen_x, -pPixmap->screen_y); +#endif + + fbCopyRegion (&pPixmap->drawable, &pPixmap->drawable, + 0, + &rgnDst, dx, dy, exaCopyNtoN, 0, 0); + + REGION_UNINIT(pWin->drawable.pScreen, &rgnDst); +} + +static void +exaFillRegionSolid (DrawablePtr pDrawable, + RegionPtr pRegion, + Pixel pixel) +{ + ExaScreenPriv(pDrawable->pScreen); + PixmapPtr pPixmap; + int xoff, yoff; + + STRACE; + if ((pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) && + (*pExaScr->info->accel.PrepareSolid) (pPixmap, GXcopy, FB_ALLONES, pixel)) + { + int nbox = REGION_NUM_RECTS (pRegion); + BoxPtr pBox = REGION_RECTS (pRegion); + + while (nbox--) + { + (*pExaScr->info->accel.Solid) (pPixmap, + pBox->x1 + xoff, pBox->y1 + yoff, + pBox->x2 + xoff, pBox->y2 + yoff); + pBox++; + } + (*pExaScr->info->accel.DoneSolid) (pPixmap); + exaMarkSync(pDrawable->pScreen); + } + else + { + exaWaitSync (pDrawable->pScreen); + fbFillRegionSolid (pDrawable, pRegion, 0, + fbReplicatePixel (pixel, pDrawable->bitsPerPixel)); + } + exaDrawableDirty (pDrawable); +} + +static void +exaPaintWindow(WindowPtr pWin, RegionPtr pRegion, int what) +{ + STRACE; + if (!REGION_NUM_RECTS(pRegion)) + return; + switch (what) { + case PW_BACKGROUND: + switch (pWin->backgroundState) { + case None: + return; + case ParentRelative: + do { + pWin = pWin->parent; + } while (pWin->backgroundState == ParentRelative); + (*pWin->drawable.pScreen->PaintWindowBackground)(pWin, pRegion, + what); + return; + case BackgroundPixel: + exaFillRegionSolid((DrawablePtr)pWin, pRegion, pWin->background.pixel); + return; +#if 0 + case BackgroundPixmap: + exaFillRegionTiled((DrawablePtr)pWin, pRegion, pWin->background.pixmap); + return; +#endif + } + break; + case PW_BORDER: + if (pWin->borderIsPixel) + { + exaFillRegionSolid((DrawablePtr)pWin, pRegion, pWin->border.pixel); + return; + } +#if 0 + else + { + exaFillRegionTiled((DrawablePtr)pWin, pRegion, pWin->border.pixmap); + return; + } +#endif + break; + } + ExaCheckPaintWindow (pWin, pRegion, what); +} + +Bool +exaDriverInit (ScreenPtr pScreen, + ExaDriverPtr pScreenInfo) +{ + ExaScreenPrivPtr pExaScr; + +#ifdef RENDER + PictureScreenPtr ps = GetPictureScreenIfSet(pScreen); +#endif + STRACE; + if (exaGeneration != serverGeneration) + { + exaScreenPrivateIndex = AllocateScreenPrivateIndex(); + exaPixmapPrivateIndex = AllocatePixmapPrivateIndex(); + exaGeneration = serverGeneration; + } + + pExaScr = xalloc (sizeof (ExaScreenPrivRec)); + + if (!pExaScr) + return FALSE; + + pExaScr->info = pScreenInfo; + + pScreen->devPrivates[exaScreenPrivateIndex].ptr = (pointer) pExaScr; + + /* + * Hook up asynchronous drawing + */ + ExaScreenInitAsync (pScreen); + /* + * Replace various fb screen functions + */ + pScreen->CreateGC = exaCreateGC; + pScreen->CopyWindow = exaCopyWindow; + pScreen->PaintWindowBackground = exaPaintWindow; + pScreen->PaintWindowBorder = exaPaintWindow; +#ifdef RENDER + if (ps) { + ps->Composite = exaComposite; + } +#endif + + /* + * Hookup offscreen pixmaps + */ + if ((pExaScr->info->card.flags & EXA_OFFSCREEN_PIXMAPS) && + pExaScr->info->card.offScreenBase < pExaScr->info->card.memorySize) + { + if (!AllocatePixmapPrivate(pScreen, exaPixmapPrivateIndex, + sizeof (ExaPixmapPrivRec))) + return FALSE; + pScreen->CreatePixmap = exaCreatePixmap; + pScreen->DestroyPixmap = exaDestroyPixmap; + } + else + { + if (!AllocatePixmapPrivate(pScreen, exaPixmapPrivateIndex, 0)) + return FALSE; + } + + ErrorF("============== %ld < %ld\n", pExaScr->info->card.offScreenBase, + pExaScr->info->card.memorySize); + if (pExaScr->info->card.offScreenBase < pExaScr->info->card.memorySize) { + if (!exaOffscreenInit (pScreen)) + return FALSE; + } + + return TRUE; +} + +void +exaDriverFini (ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + + STRACE; + xfree (pExaScr); +} + + +void exaMarkSync(ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + ExaCardInfoPtr card = &(pExaScr->info->card); + + card->needsSync = TRUE; + if (pExaScr->info->accel.MarkSync != NULL) { + card->lastMarker = (*pExaScr->info->accel.MarkSync)(pScreen); + } +} + +void exaWaitSync(ScreenPtr pScreen) +{ + ExaScreenPriv(pScreen); + ExaCardInfoPtr card = &(pExaScr->info->card); + + if (card->needsSync) { + (*pExaScr->info->accel.WaitMarker)(pScreen, card->lastMarker); + card->needsSync = FALSE; + } +} + +unsigned int exaGetVersion(void) +{ + return EXA_VERSION; +} + +#ifdef XFree86LOADER +static MODULESETUPPROTO(exaSetup); + + +static const OptionInfoRec EXAOptions[] = { + { -1, NULL, + OPTV_NONE, {0}, FALSE } +}; + +/*ARGSUSED*/ +static const OptionInfoRec * +EXAAvailableOptions(void *unused) +{ + return (EXAOptions); +} + +static XF86ModuleVersionInfo exaVersRec = +{ + "exa", + MODULEVENDORSTRING, + MODINFOSTRING1, + MODINFOSTRING2, + XORG_VERSION_CURRENT, + 1, 2, 0, + ABI_CLASS_VIDEODRV, /* requires the video driver ABI */ + ABI_VIDEODRV_VERSION, + MOD_CLASS_NONE, + {0,0,0,0} +}; + +XF86ModuleData exaModuleData = { &exaVersRec, exaSetup, NULL }; + +ModuleInfoRec EXA = { + 1, + "EXA", + NULL, + 0, + EXAAvailableOptions, +}; + +/*ARGSUSED*/ +static pointer +exaSetup(pointer Module, pointer Options, int *ErrorMajor, int *ErrorMinor) +{ + static Bool Initialised = FALSE; + + ErrorF("exa setup\n"); + if (!Initialised) { + Initialised = TRUE; +#ifndef REMOVE_LOADER_CHECK_MODULE_INFO + if (xf86LoaderCheckSymbol("xf86AddModuleInfo")) +#endif + xf86AddModuleInfo(&EXA, Module); + } + + return (pointer)TRUE; +} +#endif diff --git a/exa/exa_offscreen.c b/exa/exa_offscreen.c new file mode 100644 index 000000000..def3fbdbb --- /dev/null +++ b/exa/exa_offscreen.c @@ -0,0 +1,374 @@ +/* + * Copyright © 2003 Anders Carlsson + * + * 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 Anders Carlsson not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Anders Carlsson makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * ANDERS CARLSSON DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL ANDERS CARLSSON 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. + */ + +#include "exaPriv.h" + +#define DEBUG_OFFSCREEN 1 +#if DEBUG_OFFSCREEN +#define DBG_OFFSCREEN(a) ErrorF a +#else +#define DBG_OFFSCREEN(a) +#endif + +#if DEBUG_OFFSCREEN +static void +ExaOffscreenValidate (ScreenPtr pScreen) +{ + ExaScreenPriv (pScreen); + ExaOffscreenArea *prev = 0, *area; + + assert (pExaScr->info->card.offScreenAreas->area.offset == 0); + for (area = pExaScr->info->card.offScreenAreas; area; area = area->next) + { + if (prev) + assert (prev->area.offset + prev->area.size == area->area.offset); + + prev = area; + } + assert (prev->area.offset + prev->area.size == pExaScr->info->card.memorySize); +} +#else +#define ExaOffscreenValidate(s) +#endif + +static ExaOffscreenArea * +ExaOffscreenKickOut (ScreenPtr pScreen, ExaOffscreenArea *area) +{ + if (area->save) + (*area->save) (pScreen, area); + return exaOffscreenFree (pScreen, area); +} + +ExaOffscreenArea * +exaOffscreenAlloc (ScreenPtr pScreen, int size, int align, + Bool locked, + ExaOffscreenSaveProc save, + pointer privData) +{ + ExaOffscreenArea *area, *begin, *best; + ExaScreenPriv (pScreen); + int tmp, real_size = 0, best_score; +#if DEBUG_OFFSCREEN + static int number = 0; + ErrorF("================= ============ allocating a new pixmap %d\n", ++number); +#endif + + ExaOffscreenValidate (pScreen); + if (!align) + align = 1; + + if (!size) + { + DBG_OFFSCREEN (("Alloc 0x%x -> EMPTY\n", size)); + return NULL; + } + + /* throw out requests that cannot fit */ + if (size > (pExaScr->info->card.memorySize - pExaScr->info->card.offScreenBase)) + { + DBG_OFFSCREEN (("Alloc 0x%x -> TOBIG\n", size)); + return NULL; + } + + /* Try to find a free space that'll fit. */ + for (area = pExaScr->info->card.offScreenAreas; area; area = area->next) + { + /* skip allocated areas */ + if (area->state != ExaOffscreenAvail) + continue; + + /* adjust size to match alignment requirement */ + real_size = size; + tmp = area->offset % align; + if (tmp) + real_size += (align - tmp); + + /* does it fit? */ + if (real_size <= area->size) + break; + } + + if (!area) + { + /* + * Kick out existing users to make space. + * + * First, locate a region which can hold the desired object. + */ + + /* prev points at the first object to boot */ + best = NULL; + best_score = MAXINT; + for (begin = pExaScr->info->card.offScreenAreas; begin != NULL; + begin = begin->next) + { + int avail, score; + ExaOffscreenArea *scan; + + if (begin->state == ExaOffscreenLocked) + continue; + + /* adjust size to match alignment requirement */ + real_size = size; + tmp = begin->offset % align; + if (tmp) + real_size += (align - tmp); + + avail = 0; + score = 0; + /* now see if we can make room here, and how "costly" it'll be. */ + for (scan = begin; scan != NULL; scan = scan->next) + { + if (scan->state == ExaOffscreenLocked) { + /* Can't make room here, start after this locked area. */ + begin = scan->next; + break; + } + /* Score should only be non-zero for ExaOffscreenRemovable */ + score += scan->score; + avail += scan->size; + if (avail >= real_size) + break; + } + /* Is it the best option we've found so far? */ + if (avail >= real_size && score < best_score) { + best = begin; + best_score = score; + } + } + area = best; + if (!area) + { + DBG_OFFSCREEN (("Alloc 0x%x -> NOSPACE\n", size)); + /* Could not allocate memory */ + ExaOffscreenValidate (pScreen); + return NULL; + } + + /* adjust size to match alignment requirement */ + real_size = size; + tmp = begin->offset % align; + if (tmp) + real_size += (align - tmp); + + /* + * Kick out first area if in use + */ + if (area->state != ExaOffscreenAvail) + area = ExaOffscreenKickOut (pScreen, area); + /* + * Now get the system to merge the other needed areas together + */ + while (area->size < real_size) + { + assert (area->next && area->next->state == ExaOffscreenRemovable); + (void) ExaOffscreenKickOut (pScreen, area->next); + } + } + + /* save extra space in new area */ + if (real_size < area->size) + { + ExaOffscreenArea *new_area = xalloc (sizeof (ExaOffscreenArea)); + if (!new_area) + return NULL; + new_area->offset = area->offset + real_size; + new_area->size = area->size - real_size; + new_area->state = ExaOffscreenAvail; + new_area->save = 0; + new_area->score = 0; + new_area->next = area->next; + area->next = new_area; + area->size = real_size; + } + /* + * Mark this area as in use + */ + if (locked) + area->state = ExaOffscreenLocked; + else + area->state = ExaOffscreenRemovable; + area->privData = privData; + area->save = save; + area->score = 0; + + area->save_offset = area->offset; + area->offset = (area->offset + align - 1) & ~(align - 1); + + ExaOffscreenValidate (pScreen); + + DBG_OFFSCREEN (("Alloc 0x%x -> 0x%x\n", size, area->offset)); + return area; +} + +void +ExaOffscreenSwapOut (ScreenPtr pScreen) +{ + ExaScreenPriv (pScreen); + + ExaOffscreenValidate (pScreen); + /* loop until a single free area spans the space */ + for (;;) + { + ExaOffscreenArea *area = pExaScr->info->card.offScreenAreas; + + if (!area) + break; + if (area->state == ExaOffscreenAvail) + { + area = area->next; + if (!area) + break; + } + assert (area->state != ExaOffscreenAvail); + (void) ExaOffscreenKickOut (pScreen, area); + ExaOffscreenValidate (pScreen); + } + ExaOffscreenValidate (pScreen); + ExaOffscreenFini (pScreen); +} + +void +ExaOffscreenSwapIn (ScreenPtr pScreen) +{ + exaOffscreenInit (pScreen); +} + +/* merge the next free area into this one */ +static void +ExaOffscreenMerge (ExaOffscreenArea *area) +{ + ExaOffscreenArea *next = area->next; + + /* account for space */ + area->size += next->size; + /* frob pointer */ + area->next = next->next; + xfree (next); +} + +ExaOffscreenArea * +exaOffscreenFree (ScreenPtr pScreen, ExaOffscreenArea *area) +{ + ExaScreenPriv(pScreen); + ExaOffscreenArea *next = area->next; + ExaOffscreenArea *prev; + + DBG_OFFSCREEN (("Free 0x%x -> 0x%x\n", area->size, area->offset)); + ExaOffscreenValidate (pScreen); + + area->state = ExaOffscreenAvail; + area->save = 0; + area->offset = area->save_offset; + area->score = 0; + /* + * Find previous area + */ + if (area == pExaScr->info->card.offScreenAreas) + prev = 0; + else + for (prev = pExaScr->info->card.offScreenAreas; prev; prev = prev->next) + if (prev->next == area) + break; + + /* link with next area if free */ + if (next && next->state == ExaOffscreenAvail) + ExaOffscreenMerge (area); + + /* link with prev area if free */ + if (prev && prev->state == ExaOffscreenAvail) + { + area = prev; + ExaOffscreenMerge (area); + } + + ExaOffscreenValidate (pScreen); + DBG_OFFSCREEN(("\tdone freeing\n")); + return area; +} + +void +ExaOffscreenMarkUsed (PixmapPtr pPixmap) +{ + ExaPixmapPriv (pPixmap); + ExaScreenPriv (pPixmap->drawable.pScreen); + static int iter = 0; + + if (!pExaPixmap->area) + return; + + /* The numbers here are arbitrary. We may want to tune these. */ + pExaPixmap->area->score += 100; + if (++iter == 10) { + ExaOffscreenArea *area; + for (area = pExaScr->info->card.offScreenAreas; area != NULL; + area = area->next) + { + if (area->state == ExaOffscreenRemovable) + area->score = (area->score * 7) / 8; + } + } +} + +Bool +exaOffscreenInit (ScreenPtr pScreen) +{ + ExaScreenPriv (pScreen); + ExaOffscreenArea *area; + + /* Allocate a big free area */ + area = xalloc (sizeof (ExaOffscreenArea)); + + if (!area) + return FALSE; + + + area->state = ExaOffscreenAvail; + area->offset = pExaScr->info->card.offScreenBase; + area->size = pExaScr->info->card.memorySize - area->offset; + area->save = 0; + area->next = NULL; + area->score = 0; + + ErrorF("============ initial memory block of %d\n", area->size); + + /* Add it to the free areas */ + pExaScr->info->card.offScreenAreas = area; + + ExaOffscreenValidate (pScreen); + + return TRUE; +} + +void +ExaOffscreenFini (ScreenPtr pScreen) +{ + ExaScreenPriv (pScreen); + ExaOffscreenArea *area; + + /* just free all of the area records */ + while ((area = pExaScr->info->card.offScreenAreas)) + { + pExaScr->info->card.offScreenAreas = area->next; + xfree (area); + } +} diff --git a/exa/exa_priv.h b/exa/exa_priv.h new file mode 100644 index 000000000..546a538cc --- /dev/null +++ b/exa/exa_priv.h @@ -0,0 +1,281 @@ +/* + * + * Copyright (C) 2000 Keith Packard, member of The XFree86 Project, Inc. + * 2005 Zack Rusin, Trolltech + * + * 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 Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes 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. + */ + +#ifndef EXAPRIV_H +#define EXAPRIV_H + +#include "exa.h" + +#include <X11/X.h> +#define NEED_EVENTS +#include <X11/Xproto.h> +#include "scrnintstr.h" +#include "pixmapstr.h" +#include "windowstr.h" +#include "servermd.h" +#include "mibstore.h" +#include "colormapst.h" +#include "gcstruct.h" +#include "input.h" +#include "mipointer.h" +#include "mi.h" +#include "dix.h" +#include "fb.h" +#include "fboverlay.h" + +#ifndef EXA_MAX_FB +#define EXA_MAX_FB FB_OVERLAY_MAX +#endif + + +/* + * This is the only completely portable way to + * compute this info. + */ +#ifndef BitsPerPixel +#define BitsPerPixel(d) (\ + PixmapWidthPaddingInfo[d].notPower2 ? \ + (PixmapWidthPaddingInfo[d].bytesPerPixel * 8) : \ + ((1 << PixmapWidthPaddingInfo[d].padBytesLog2) * 8 / \ + (PixmapWidthPaddingInfo[d].padRoundUp+1))) +#endif + +extern int exaScreenPrivateIndex; +extern int exaPixmapPrivateIndex; +#define ExaGetScreenPriv(s) ((ExaScreenPrivPtr)(s)->devPrivates[exaScreenPrivateIndex].ptr) +#define ExaScreenPriv(s) ExaScreenPrivPtr pExaScr = ExaGetScreenPriv(s) + +#define ExaGetPixmapPriv(p) ((ExaPixmapPrivPtr)(p)->devPrivates[exaPixmapPrivateIndex].ptr) +#define ExaSetPixmapPriv(p,a) ((p)->devPrivates[exaPixmapPrivateIndex].ptr = (pointer) (a)) +#define ExaPixmapPriv(p) ExaPixmapPrivPtr pExaPixmap = ExaGetPixmapPriv(p) + +typedef struct { + ExaOffscreenArea *area; + int score; + int devKind; + DevUnion devPrivate; + Bool dirty; +} ExaPixmapPrivRec, *ExaPixmapPrivPtr; + + +/* exaasync.c */ +void +ExaCheckFillSpans (DrawablePtr pDrawable, GCPtr pGC, int nspans, + DDXPointPtr ppt, int *pwidth, int fSorted); + +void +ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc, + DDXPointPtr ppt, int *pwidth, int nspans, int fSorted); + +void +ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, + int x, int y, int w, int h, int leftPad, int format, + char *bits); + +RegionPtr +ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, + int srcx, int srcy, int w, int h, int dstx, int dsty); + +RegionPtr +ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, + int srcx, int srcy, int w, int h, int dstx, int dsty, + unsigned long bitPlane); + +void +ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, + DDXPointPtr pptInit); + +void +ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC, + int mode, int npt, DDXPointPtr ppt); + +void +ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC, + int nsegInit, xSegment *pSegInit); + +void +ExaCheckPolyRectangle (DrawablePtr pDrawable, GCPtr pGC, + int nrects, xRectangle *prect); + +void +ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC, + int narcs, xArc *pArcs); + +#define ExaCheckFillPolygon miFillPolygon + +void +ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC, + int nrect, xRectangle *prect); + +void +ExaCheckPolyFillArc (DrawablePtr pDrawable, GCPtr pGC, + int narcs, xArc *pArcs); + +void +ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, + int x, int y, unsigned int nglyph, + CharInfoPtr *ppci, pointer pglyphBase); + +void +ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, + int x, int y, unsigned int nglyph, + CharInfoPtr *ppci, pointer pglyphBase); + +void +ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap, + DrawablePtr pDrawable, + int w, int h, int x, int y); + +void +ExaCheckGetImage (DrawablePtr pDrawable, + int x, int y, int w, int h, + unsigned int format, unsigned long planeMask, + char *d); + +void +ExaCheckGetSpans (DrawablePtr pDrawable, + int wMax, + DDXPointPtr ppt, + int *pwidth, + int nspans, + char *pdstStart); + +void +ExaCheckSaveAreas (PixmapPtr pPixmap, + RegionPtr prgnSave, + int xorg, + int yorg, + WindowPtr pWin); + +void +ExaCheckRestoreAreas (PixmapPtr pPixmap, + RegionPtr prgnSave, + int xorg, + int yorg, + WindowPtr pWin); + +void +ExaCheckPaintWindow (WindowPtr pWin, RegionPtr pRegion, int what); + +void +ExaCheckCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc); + +void +ExaCheckPaintKey(DrawablePtr pDrawable, + RegionPtr pRegion, + CARD32 pixel, + int layer); + +void +ExaCheckOverlayCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc); + +void +ExaScreenInitAsync (ScreenPtr pScreen); + +extern const GCOps exaAsyncPixmapGCOps; + +/* exapict.c */ +void +ExaPictureInitAsync (ScreenPtr pScreen); + +#ifdef RENDER +void +ExaCheckComposite (CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height); +#endif + +/* exaoffscreen.c */ +void +ExaOffscreenMarkUsed (PixmapPtr pPixmap); + +void +ExaOffscreenSwapOut (ScreenPtr pScreen); + +void +ExaOffscreenSwapIn (ScreenPtr pScreen); + +void +ExaOffscreenFini (ScreenPtr pScreen); + +/* exa.c */ +void +exaPixmapUseScreen (PixmapPtr pPixmap); + +void +exaPixmapUseMemory (PixmapPtr pPixmap); + +void +exaDrawableDirty(DrawablePtr pDrawable); + +Bool +exaDrawableIsOffscreen (DrawablePtr pDrawable); + +Bool +exaPixmapIsOffscreen(PixmapPtr p); + +PixmapPtr +exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp); + +void +exaMoveInPixmap (PixmapPtr pPixmap); + +void +exaCopyNtoN (DrawablePtr pSrcDrawable, + DrawablePtr pDstDrawable, + GCPtr pGC, + BoxPtr pbox, + int nbox, + int dx, + int dy, + Bool reverse, + Bool upsidedown, + Pixel bitplane, + void *closure); + +void +exaComposite(CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height); + +#endif /* EXAPRIV_H */ diff --git a/exa/exa_render.c b/exa/exa_render.c new file mode 100644 index 000000000..b48e9c701 --- /dev/null +++ b/exa/exa_render.c @@ -0,0 +1,572 @@ +/* + * Copyright © 2001 Keith Packard + * + * Partly based on code that is Copyright © The XFree86 Project Inc. + * + * 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 Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD 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. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif +#include "exaPriv.h" + +#ifdef RENDER +#include "mipict.h" + +#define EXA_DEBUG_FALLBACKS 0 + +#if EXA_DEBUG_FALLBACKS +static void exaCompositeFallbackPictDesc(PicturePtr pict, char *string, int n) +{ + char format[20]; + char size[20]; + char loc; + int temp; + + if (!pict) { + snprintf(string, n, "None"); + return; + } + + switch (pict->format) + { + case PICT_a8r8g8b8: + snprintf(format, 20, "ARGB8888"); + break; + case PICT_r5g6b5: + snprintf(format, 20, "RGB565 "); + break; + case PICT_x1r5g5b5: + snprintf(format, 20, "RGB555 "); + break; + case PICT_a8: + snprintf(format, 20, "A8 "); + break; + case PICT_a1: + snprintf(format, 20, "A1 "); + break; + default: + snprintf(format, 20, "0x%x", (int)pict->format); + break; + } + + loc = exaGetOffscreenPixmap(pict->pDrawable, &temp, &temp) ? 's' : 'm'; + + snprintf(size, 20, "%dx%d%s", pict->pDrawable->width, + pict->pDrawable->height, pict->repeat ? + " R" : ""); + + snprintf(string, n, "0x%lx:%c fmt %s (%s)", (long)pict, loc, format, size); +} + +static void +exaPrintCompositeFallback(CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst) +{ + char sop[20]; + char srcdesc[40], maskdesc[40], dstdesc[40]; + + switch(op) + { + case PictOpSrc: + sprintf(sop, "Src"); + break; + case PictOpOver: + sprintf(sop, "Over"); + break; + default: + sprintf(sop, "0x%x", (int)op); + break; + } + + exaCompositeFallbackPictDesc(pSrc, srcdesc, 40); + exaCompositeFallbackPictDesc(pMask, maskdesc, 40); + exaCompositeFallbackPictDesc(pDst, dstdesc, 40); + + ErrorF("Composite fallback: op %s, \n" + " src %s, \n" + " mask %s, \n" + " dst %s, \n", + sop, srcdesc, maskdesc, dstdesc); +} +#endif + +static Bool +exaGetPixelFromRGBA(CARD32 *pixel, + CARD16 red, + CARD16 green, + CARD16 blue, + CARD16 alpha, + CARD32 format) +{ + int rbits, bbits, gbits, abits; + int rshift, bshift, gshift, ashift; + + *pixel = 0; + + if (!PICT_FORMAT_COLOR(format)) + return FALSE; + + rbits = PICT_FORMAT_R(format); + gbits = PICT_FORMAT_G(format); + bbits = PICT_FORMAT_B(format); + abits = PICT_FORMAT_A(format); + + if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ARGB) { + bshift = 0; + gshift = bbits; + rshift = gshift + gbits; + ashift = rshift + rbits; + } else { /* PICT_TYPE_ABGR */ + rshift = 0; + gshift = rbits; + bshift = gshift + gbits; + ashift = bshift + bbits; + } + + *pixel |= ( blue >> (16 - bbits)) << bshift; + *pixel |= ( red >> (16 - rbits)) << rshift; + *pixel |= (green >> (16 - gbits)) << gshift; + *pixel |= (alpha >> (16 - abits)) << ashift; + + return TRUE; +} + + +static Bool +exaGetRGBAFromPixel(CARD32 pixel, + CARD16 *red, + CARD16 *green, + CARD16 *blue, + CARD16 *alpha, + CARD32 format) +{ + int rbits, bbits, gbits, abits; + int rshift, bshift, gshift, ashift; + + if (!PICT_FORMAT_COLOR(format)) + return FALSE; + + rbits = PICT_FORMAT_R(format); + gbits = PICT_FORMAT_G(format); + bbits = PICT_FORMAT_B(format); + abits = PICT_FORMAT_A(format); + + if (PICT_FORMAT_TYPE(format) == PICT_TYPE_ARGB) { + bshift = 0; + gshift = bbits; + rshift = gshift + gbits; + ashift = rshift + rbits; + } else { /* PICT_TYPE_ABGR */ + rshift = 0; + gshift = rbits; + bshift = gshift + gbits; + ashift = bshift + bbits; + } + + *red = ((pixel >> rshift ) & ((1 << rbits) - 1)) << (16 - rbits); + while (rbits < 16) { + *red |= *red >> rbits; + rbits <<= 1; + } + + *green = ((pixel >> gshift ) & ((1 << gbits) - 1)) << (16 - gbits); + while (gbits < 16) { + *green |= *green >> gbits; + gbits <<= 1; + } + + *blue = ((pixel >> bshift ) & ((1 << bbits) - 1)) << (16 - bbits); + while (bbits < 16) { + *blue |= *blue >> bbits; + bbits <<= 1; + } + + if (abits) { + *alpha = ((pixel >> ashift ) & ((1 << abits) - 1)) << (16 - abits); + while (abits < 16) { + *alpha |= *alpha >> abits; + abits <<= 1; + } + } else + *alpha = 0xffff; + + return TRUE; +} + +static int +exaTryDriverSolidFill(PicturePtr pSrc, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height) +{ + ExaScreenPriv (pDst->pDrawable->pScreen); + RegionRec region; + BoxPtr pbox; + int nbox; + int dst_off_x, dst_off_y; + PixmapPtr pSrcPix, pDstPix; + CARD32 pixel; + CARD16 red, green, blue, alpha; + + xDst += pDst->pDrawable->x; + yDst += pDst->pDrawable->y; + xSrc += pSrc->pDrawable->x; + ySrc += pSrc->pDrawable->y; + + if (!miComputeCompositeRegion (®ion, pSrc, NULL, pDst, + xSrc, ySrc, 0, 0, xDst, yDst, + width, height)) + return 1; + + if (pSrc->pDrawable->type == DRAWABLE_PIXMAP) + exaPixmapUseMemory ((PixmapPtr) pSrc->pDrawable); + if (pDst->pDrawable->type == DRAWABLE_PIXMAP) + exaPixmapUseScreen ((PixmapPtr) pDst->pDrawable); + + pDstPix = exaGetOffscreenPixmap (pDst->pDrawable, &dst_off_x, &dst_off_y); + if (!pDstPix) { + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return 0; + } + + if (pSrc->pDrawable->type == DRAWABLE_WINDOW) + pSrcPix = (*pSrc->pDrawable->pScreen->GetWindowPixmap)( + (WindowPtr) (pSrc->pDrawable)); + else + pSrcPix = (PixmapPtr) (pSrc->pDrawable); + + /* If source is offscreen, we need to sync the accelerator + * before accessing it. We'd prefer for it to be in memory. + */ + if (exaPixmapIsOffscreen(pSrcPix)) { + exaWaitSync(pDst->pDrawable->pScreen); + } + + pixel = *(CARD32 *)(pSrcPix->devPrivate.ptr); + if (!exaGetRGBAFromPixel(pixel, &red, &green, &blue, &alpha, + pSrc->format)) + { + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return -1; + } + exaGetPixelFromRGBA(&pixel, red, green, blue, alpha, + pDst->format); + + if (!(*pExaScr->info->accel.PrepareSolid) (pDstPix, GXcopy, 0xffffffff, pixel)) + { + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return -1; + } + + nbox = REGION_NUM_RECTS(®ion); + pbox = REGION_RECTS(®ion); + while (nbox--) + { + (*pExaScr->info->accel.Solid) (pDstPix, + pbox->x1 + dst_off_x, + pbox->y1 + dst_off_y, + pbox->x2 + dst_off_x, + pbox->y2 + dst_off_y); + pbox++; + } + + (*pExaScr->info->accel.DoneSolid) (pDstPix); + exaMarkSync(pDst->pDrawable->pScreen); + exaDrawableDirty (pDst->pDrawable); + + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return 1; +} + +static int +exaTryDriverComposite(CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height) +{ + ExaScreenPriv (pDst->pDrawable->pScreen); + RegionRec region; + BoxPtr pbox; + int nbox; + int src_off_x, src_off_y, mask_off_x, mask_off_y, dst_off_x, dst_off_y; + PixmapPtr pSrcPix, pMaskPix = NULL, pDstPix; + struct _Pixmap scratch; + + if (pExaScr->info->card.maxX < width || + pExaScr->info->card.maxY < height) + { + int total_width = width; + int total_height = height; + int xOff = 0; + int yOff = 0; + while (total_width > pExaScr->info->card.maxX) { + while (total_height > pExaScr->info->card.maxY) { + exaTryDriverComposite(op, + pSrc, + pMask, + pDst, + xSrc + xOff, + ySrc + yOff, + xMask + xOff, + yMask + yOff, + xDst + xOff, + yDst + yOff, + pExaScr->info->card.maxX, + pExaScr->info->card.maxY); + total_width -= pExaScr->info->card.maxX; + xOff += pExaScr->info->card.maxX; + yOff = 0; + } + if (total_height) + exaTryDriverComposite(op, + pSrc, + pMask, + pDst, + xSrc + xOff, + ySrc + yOff, + xMask + xOff, + yMask + yOff, + xDst + xOff, + yDst + yOff, + pExaScr->info->card.maxX, + total_height); + total_height -= pExaScr->info->card.maxY; + yOff += pExaScr->info->card.maxY; + } + if (total_width && total_height) + exaTryDriverComposite(op, + pSrc, + pMask, + pDst, + xSrc + xOff, + ySrc + yOff, + xMask + xOff, + yMask + yOff, + xDst + xOff, + yDst + yOff, + total_width, + total_height); + + return -1; + } + + + xDst += pDst->pDrawable->x; + yDst += pDst->pDrawable->y; + + if (pMask) { + xMask += pMask->pDrawable->x; + yMask += pMask->pDrawable->y; + } + + xSrc += pSrc->pDrawable->x; + ySrc += pSrc->pDrawable->y; + + if (!miComputeCompositeRegion (®ion, pSrc, pMask, pDst, + xSrc, ySrc, xMask, yMask, xDst, yDst, + width, height)) + return 1; + + if (pExaScr->info->accel.CheckComposite && + !(*pExaScr->info->accel.CheckComposite) (op, pSrc, pMask, pDst)) + { + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return -1; + } + + if (pSrc->pDrawable->type == DRAWABLE_PIXMAP) + exaPixmapUseScreen ((PixmapPtr) pSrc->pDrawable); + if (pMask && pMask->pDrawable->type == DRAWABLE_PIXMAP) + exaPixmapUseScreen ((PixmapPtr) pMask->pDrawable); + if (pDst->pDrawable->type == DRAWABLE_PIXMAP) + exaPixmapUseScreen ((PixmapPtr) pDst->pDrawable); + + pSrcPix = exaGetOffscreenPixmap (pSrc->pDrawable, &src_off_x, &src_off_y); + if (pMask) + pMaskPix = exaGetOffscreenPixmap (pMask->pDrawable, &mask_off_x, + &mask_off_y); + pDstPix = exaGetOffscreenPixmap (pDst->pDrawable, &dst_off_x, &dst_off_y); + + if (!pDstPix) { + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return 0; + } + + if (!pSrcPix && (!pMask || pMaskPix) && pExaScr->info->accel.UploadToScratch) { + if (pSrc->pDrawable->type == DRAWABLE_WINDOW) + pSrcPix = (*pSrc->pDrawable->pScreen->GetWindowPixmap) ( + (WindowPtr) pSrc->pDrawable); + else + pSrcPix = (PixmapPtr) pSrc->pDrawable; + if ((*pExaScr->info->accel.UploadToScratch) (pSrcPix, &scratch)) + pSrcPix = &scratch; + } else if (pSrcPix && pMask && !pMaskPix && pExaScr->info->accel.UploadToScratch) { + if (pMask->pDrawable->type == DRAWABLE_WINDOW) + pMaskPix = (*pMask->pDrawable->pScreen->GetWindowPixmap) ( + (WindowPtr) pMask->pDrawable); + else + pMaskPix = (PixmapPtr) pMask->pDrawable; + if ((*pExaScr->info->accel.UploadToScratch) (pMaskPix, &scratch)) + pMaskPix = &scratch; + } + + if (!pSrcPix || (pMask && !pMaskPix)) { + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return 0; + } + + if (!(*pExaScr->info->accel.PrepareComposite) (op, pSrc, pMask, pDst, pSrcPix, + pMaskPix, pDstPix)) + { + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return -1; + } + + nbox = REGION_NUM_RECTS(®ion); + pbox = REGION_RECTS(®ion); + + xMask -= xDst; + yMask -= yDst; + + xSrc -= xDst; + ySrc -= yDst; + + while (nbox--) + { + (*pExaScr->info->accel.Composite) (pDstPix, + pbox->x1 + xSrc + src_off_x, + pbox->y1 + ySrc + src_off_y, + pbox->x1 + xMask + mask_off_x, + pbox->y1 + yMask + mask_off_y, + pbox->x1 + dst_off_x, + pbox->y1 + dst_off_y, + pbox->x2 - pbox->x1, + pbox->y2 - pbox->y1); + pbox++; + } + + (*pExaScr->info->accel.DoneComposite) (pDstPix); + exaMarkSync(pDst->pDrawable->pScreen); + exaDrawableDirty (pDst->pDrawable); + + REGION_UNINIT(pDst->pDrawable->pScreen, ®ion); + return 1; +} + + +void +exaComposite(CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height) +{ + ExaScreenPriv (pDst->pDrawable->pScreen); + int ret = -1; + + if (!pMask && pSrc->pDrawable) + { + if (op == PictOpSrc) + { + if (pSrc->pDrawable->width == 1 && + pSrc->pDrawable->height == 1 && pSrc->repeat) + { + ret = exaTryDriverSolidFill(pSrc, pDst, xSrc, ySrc, xDst, yDst, + width, height); + if (ret == 1) + return; + } + else if (!pSrc->repeat && !pSrc->transform && + pSrc->format == pDst->format) + { + RegionRec region; + + xDst += pDst->pDrawable->x; + yDst += pDst->pDrawable->y; + xSrc += pSrc->pDrawable->x; + ySrc += pSrc->pDrawable->y; + + if (!miComputeCompositeRegion (®ion, pSrc, pMask, pDst, + xSrc, ySrc, xMask, yMask, xDst, + yDst, width, height)) + return; + + + exaCopyNtoN (pSrc->pDrawable, pDst->pDrawable, 0, + REGION_RECTS(®ion), REGION_NUM_RECTS(®ion), + xSrc - xDst, ySrc - yDst, + FALSE, FALSE, 0, 0); + return; + } + } + } + + if (pSrc->pDrawable && (!pMask || pMask->pDrawable) && + pExaScr->info->accel.PrepareComposite && + !pSrc->alphaMap && (!pMask || !pMask->alphaMap) && !pDst->alphaMap) + { + ret = exaTryDriverComposite(op, pSrc, pMask, pDst, xSrc, ySrc, xMask, + yMask, xDst, yDst, width, height); + if (ret == 1) + return; + } + + if (ret != 0) { + /* failure to accelerate was not due to pixmaps being in the wrong + * locations. + */ + if (pSrc->pDrawable->type == DRAWABLE_PIXMAP) + exaPixmapUseMemory ((PixmapPtr) pSrc->pDrawable); + if (pMask && pMask->pDrawable->type == DRAWABLE_PIXMAP) + exaPixmapUseMemory ((PixmapPtr) pMask->pDrawable); + if (pDst->pDrawable->type == DRAWABLE_PIXMAP) + exaPixmapUseMemory ((PixmapPtr) pDst->pDrawable); + } + +#if EXA_DEBUG_FALLBACKS + exaPrintCompositeFallback (op, pSrc, pMask, pDst); +#endif + + ExaCheckComposite (op, pSrc, pMask, pDst, xSrc, ySrc, + xMask, yMask, xDst, yDst, width, height); +} +#endif diff --git a/exa/exa_unaccel.c b/exa/exa_unaccel.c new file mode 100644 index 000000000..79c407417 --- /dev/null +++ b/exa/exa_unaccel.c @@ -0,0 +1,365 @@ +/* + * + * Copyright © 1999 Keith Packard + * + * 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 Keith Packard not be used in + * advertising or publicity pertaining to distribution of the software without + * specific, written prior permission. Keith Packard makes no + * representations about the suitability of this software for any purpose. It + * is provided "as is" without express or implied warranty. + * + * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, + * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO + * EVENT SHALL KEITH PACKARD 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. + */ + +#include "exaPriv.h" + +/* + * These functions wrap the low-level fb rendering functions and + * synchronize framebuffer/accelerated drawing by stalling until + * the accelerator is idle + */ + +void +ExaCheckFillSpans (DrawablePtr pDrawable, GCPtr pGC, int nspans, + DDXPointPtr ppt, int *pwidth, int fSorted) +{ + exaWaitSync (pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbFillSpans (pDrawable, pGC, nspans, ppt, pwidth, fSorted); +} + +void +ExaCheckSetSpans (DrawablePtr pDrawable, GCPtr pGC, char *psrc, + DDXPointPtr ppt, int *pwidth, int nspans, int fSorted) +{ + exaWaitSync (pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbSetSpans (pDrawable, pGC, psrc, ppt, pwidth, nspans, fSorted); +} + +void +ExaCheckPutImage (DrawablePtr pDrawable, GCPtr pGC, int depth, + int x, int y, int w, int h, int leftPad, int format, + char *bits) +{ + exaWaitSync (pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbPutImage (pDrawable, pGC, depth, x, y, w, h, leftPad, format, bits); +} + +RegionPtr +ExaCheckCopyArea (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, + int srcx, int srcy, int w, int h, int dstx, int dsty) +{ + exaWaitSync (pSrc->pScreen); + exaDrawableDirty (pDst); + return fbCopyArea (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty); +} + +RegionPtr +ExaCheckCopyPlane (DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC, + int srcx, int srcy, int w, int h, int dstx, int dsty, + unsigned long bitPlane) +{ + exaWaitSync (pSrc->pScreen); + exaDrawableDirty (pDst); + return fbCopyPlane (pSrc, pDst, pGC, srcx, srcy, w, h, dstx, dsty, + bitPlane); +} + +void +ExaCheckPolyPoint (DrawablePtr pDrawable, GCPtr pGC, int mode, int npt, + DDXPointPtr pptInit) +{ + exaWaitSync (pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbPolyPoint (pDrawable, pGC, mode, npt, pptInit); +} + +void +ExaCheckPolylines (DrawablePtr pDrawable, GCPtr pGC, + int mode, int npt, DDXPointPtr ppt) +{ + + if (pGC->lineWidth == 0) { + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + } + exaDrawableDirty (pDrawable); + fbPolyLine (pDrawable, pGC, mode, npt, ppt); +} + +void +ExaCheckPolySegment (DrawablePtr pDrawable, GCPtr pGC, + int nsegInit, xSegment *pSegInit) +{ + if (pGC->lineWidth == 0) { + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + } + exaDrawableDirty (pDrawable); + fbPolySegment (pDrawable, pGC, nsegInit, pSegInit); +} + +void +ExaCheckPolyRectangle (DrawablePtr pDrawable, GCPtr pGC, + int nrects, xRectangle *prect) +{ + if (pGC->lineWidth == 0) { + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + } + fbPolyRectangle (pDrawable, pGC, nrects, prect); +} + +void +ExaCheckPolyArc (DrawablePtr pDrawable, GCPtr pGC, + int narcs, xArc *pArcs) +{ + if (pGC->lineWidth == 0) + { + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbPolyArc (pDrawable, pGC, narcs, pArcs); + } + else + miPolyArc (pDrawable, pGC, narcs, pArcs); +} + +#if 0 +void +ExaCheckFillPolygon (DrawablePtr pDrawable, GCPtr pGC, + int shape, int mode, int count, DDXPointPtr pPts) +{ + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbFillPolygon (pDrawable, pGC, mode, count, pPts); +} +#endif + +void +ExaCheckPolyFillRect (DrawablePtr pDrawable, GCPtr pGC, + int nrect, xRectangle *prect) +{ + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbPolyFillRect (pDrawable, pGC, nrect, prect); +} + +void +ExaCheckPolyFillArc (DrawablePtr pDrawable, GCPtr pGC, + int narcs, xArc *pArcs) +{ + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbPolyFillArc (pDrawable, pGC, narcs, pArcs); +} + +void +ExaCheckImageGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, + int x, int y, unsigned int nglyph, + CharInfoPtr *ppci, pointer pglyphBase) +{ + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbImageGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); +} + +void +ExaCheckPolyGlyphBlt (DrawablePtr pDrawable, GCPtr pGC, + int x, int y, unsigned int nglyph, + CharInfoPtr *ppci, pointer pglyphBase) +{ + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbPolyGlyphBlt (pDrawable, pGC, x, y, nglyph, ppci, pglyphBase); +} + +void +ExaCheckPushPixels (GCPtr pGC, PixmapPtr pBitmap, + DrawablePtr pDrawable, + int w, int h, int x, int y) +{ + exaWaitSync(pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbPushPixels (pGC, pBitmap, pDrawable, w, h, x, y); +} + +void +ExaCheckGetImage (DrawablePtr pDrawable, + int x, int y, int w, int h, + unsigned int format, unsigned long planeMask, + char *d) +{ + exaWaitSync(pDrawable->pScreen); + fbGetImage (pDrawable, x, y, w, h, format, planeMask, d); +} + +void +ExaCheckGetSpans (DrawablePtr pDrawable, + int wMax, + DDXPointPtr ppt, + int *pwidth, + int nspans, + char *pdstStart) +{ + exaWaitSync(pDrawable->pScreen); + fbGetSpans (pDrawable, wMax, ppt, pwidth, nspans, pdstStart); +} + +void +ExaCheckSaveAreas (PixmapPtr pPixmap, + RegionPtr prgnSave, + int xorg, + int yorg, + WindowPtr pWin) +{ + exaWaitSync(pWin->drawable.pScreen); + exaDrawableDirty (&pPixmap->drawable); + fbSaveAreas (pPixmap, prgnSave, xorg, yorg, pWin); +} + +void +ExaCheckRestoreAreas (PixmapPtr pPixmap, + RegionPtr prgnSave, + int xorg, + int yorg, + WindowPtr pWin) +{ + exaWaitSync(pWin->drawable.pScreen); + exaDrawableDirty ((DrawablePtr)pWin); + fbRestoreAreas (pPixmap, prgnSave, xorg, yorg, pWin); +} + +void +ExaCheckPaintWindow (WindowPtr pWin, RegionPtr pRegion, int what) +{ + exaWaitSync (pWin->drawable.pScreen); + exaDrawableDirty ((DrawablePtr)pWin); + fbPaintWindow (pWin, pRegion, what); +} + +void +ExaCheckCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) +{ + exaWaitSync (pWin->drawable.pScreen); + exaDrawableDirty ((DrawablePtr)pWin); + fbCopyWindow (pWin, ptOldOrg, prgnSrc); +} + +#if EXA_MAX_FB > 1 +void +ExaCheckPaintKey(DrawablePtr pDrawable, + RegionPtr pRegion, + CARD32 pixel, + int layer) +{ + exaWaitSync (pDrawable->pScreen); + exaDrawableDirty (pDrawable); + fbOverlayPaintKey (pDrawable, pRegion, pixel, layer); +} + +void +ExaCheckOverlayCopyWindow (WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc) +{ + exaWaitSync (pWin->drawable.pScreen); + exaDrawableDirty ((DrawablePtr)pWin); + fbOverlayCopyWindow (pWin, ptOldOrg, prgnSrc); +} +#endif + +void +ExaScreenInitAsync (ScreenPtr pScreen) +{ + pScreen->GetImage = ExaCheckGetImage; + pScreen->GetSpans = ExaCheckGetSpans; + pScreen->PaintWindowBackground = ExaCheckPaintWindow; + pScreen->PaintWindowBorder = ExaCheckPaintWindow; + pScreen->CopyWindow = ExaCheckCopyWindow; + pScreen->BackingStoreFuncs.SaveAreas = ExaCheckSaveAreas; + pScreen->BackingStoreFuncs.RestoreAreas = ExaCheckRestoreAreas; + +#ifdef RENDER + ExaPictureInitAsync (pScreen); +#endif +} + + +void +ExaCheckComposite (CARD8 op, + PicturePtr pSrc, + PicturePtr pMask, + PicturePtr pDst, + INT16 xSrc, + INT16 ySrc, + INT16 xMask, + INT16 yMask, + INT16 xDst, + INT16 yDst, + CARD16 width, + CARD16 height) +{ + exaWaitSync (pDst->pDrawable->pScreen); + exaDrawableDirty (pDst->pDrawable); + fbComposite (op, + pSrc, + pMask, + pDst, + xSrc, + ySrc, + xMask, + yMask, + xDst, + yDst, + width, + height); +} + +void +ExaPictureInitAsync (ScreenPtr pScreen) +{ + PictureScreenPtr ps; + + ps = GetPictureScreen(pScreen); + ps->Composite = ExaCheckComposite; +} + + +/* + * Only need to stall for copyarea/copyplane + */ +const GCOps exaAsyncPixmapGCOps = { + fbFillSpans, + fbSetSpans, + fbPutImage, + ExaCheckCopyArea, + ExaCheckCopyPlane, + fbPolyPoint, + fbPolyLine, + fbPolySegment, + fbPolyRectangle, + fbPolyArc, + fbFillPolygon, + fbPolyFillRect, + fbPolyFillArc, + miPolyText8, + miPolyText16, + miImageText8, + miImageText16, + fbImageGlyphBlt, + fbPolyGlyphBlt, + fbPushPixels +#ifdef NEED_LINEHELPER + ,NULL +#endif +}; |