/* * Acceleration for the Creator and Creator3D framebuffer - Dbe Acceleration. * * Copyright (C) 2000 David S. Miller (davem@redhat.com) * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * DAVID MILLER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * */ /* $XFree86: xc/programs/Xserver/hw/xfree86/drivers/sunffb/ffb_dbe.c,v 1.1 2000/05/23 04:47:44 dawes Exp $ */ #define NEED_REPLIES #define NEED_EVENTS #include #include #include #include #include "windowstr.h" #include "scrnintstr.h" #include "pixmapstr.h" #include "extnsionst.h" #include "dixstruct.h" #include "resource.h" #include "opaque.h" #include "dbestruct.h" #include "regionstr.h" #include "gcstruct.h" #include "inputstr.h" #define PSZ 8 #include "cfb.h" #undef PSZ #include "cfb32.h" #include "xf86_ansic.h" #include "xf86.h" #include "ffb.h" #include "ffb_fifo.h" #include "ffb_rcache.h" static int FFBDbePrivPrivGeneration = 0; static int FFBDbeWindowPrivPrivIndex = -1; static RESTYPE dbeDrawableResType; static RESTYPE dbeWindowPrivResType; static int dbeScreenPrivIndex = -1; static int dbeWindowPrivIndex = -1; #define FFB_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv) \ (((FFBDbeWindowPrivPrivIndex < 0) || (!pDbeWindowPriv)) ? \ NULL : \ ((FFBDbeWindowPrivPrivPtr) \ ((pDbeWindowPriv)->devPrivates[FFBDbeWindowPrivPrivIndex].ptr))) #define FFB_DBE_WINDOW_PRIV_PRIV_FROM_WINDOW(pWin) \ FFB_DBE_WINDOW_PRIV_PRIV(DBE_WINDOW_PRIV(pWin)) typedef struct _FFBDbeWindowPrivPrivRec { int HwAccelerated; int HwCurrentBuf; /* 0 = buffer A, 1 = buffer B */ /* We need also what midbe would use in case we must * revert to unaccelerated dbe. */ PixmapPtr pBackBuffer; PixmapPtr pFrontBuffer; /* Back pointer to generic DBE layer window private. */ DbeWindowPrivPtr pDbeWindowPriv; } FFBDbeWindowPrivPrivRec, *FFBDbeWindowPrivPrivPtr; static Bool FFBDbeGetVisualInfo(ScreenPtr pScreen, XdbeScreenVisualInfo *pScrVisInfo) { XdbeVisualInfo *visInfo; DepthPtr pDepth; int i, j, k, count; /* XXX Should check for double-buffer presence. But even if * XXX the double-buffer is not present we can still play * XXX tricks with GetWindowPixmap in 8bpp mode, ie. double * XXX buffer between the R and G planes of buffer A. -DaveM */ /* Determine number of visuals for this screen. */ for (i = 0, count = 0; i < pScreen->numDepths; i++) count += pScreen->allowedDepths[i].numVids; /* Allocate an array of XdbeVisualInfo items. */ if (!(visInfo = (XdbeVisualInfo *)xalloc(count * sizeof(XdbeVisualInfo)))) return FALSE; for (i = 0, k = 0; i < pScreen->numDepths; i++) { /* For each depth of this screen, get visual information. */ pDepth = &pScreen->allowedDepths[i]; for (j = 0; j < pDepth->numVids; j++) { /* For each visual for this depth of this screen, get visual ID * and visual depth. For now, we will always return * the same performance level for all visuals (0). A higher * performance level value indicates higher performance. */ visInfo[k].visual = pDepth->vids[j]; visInfo[k].depth = pDepth->depth; /* XXX We should set this appropriately... -DaveM */ visInfo[k].perflevel = 0; k++; } } /* Record the number of visuals and point visual_depth to * the array of visual info. */ pScrVisInfo->count = count; pScrVisInfo->visinfo = visInfo; return TRUE; } static void FFBDbeUpdateWidPlane(WindowPtr pWin, GCPtr pGC) { FFBPtr pFfb = GET_FFB_FROM_SCREEN(pWin->drawable.pScreen); CreatorPrivWinPtr pFfbPrivWin = CreatorGetWindowPrivate(pWin); RegionPtr prgnClip; BoxPtr pboxClipped, pboxClippedBase; unsigned int fbc; int numRects; int x, y, w, h; x = pWin->drawable.x; y = pWin->drawable.y; w = pWin->drawable.width; h = pWin->drawable.height; fbc = pFfbPrivWin->fbc_base; fbc = (fbc & ~FFB_FBC_WB_MASK) | FFB_FBC_WB_AB; fbc = (fbc & ~FFB_FBC_XE_MASK) | FFB_FBC_XE_ON; fbc = (fbc & ~FFB_FBC_RGBE_MASK) | FFB_FBC_RGBE_OFF; prgnClip = cfbGetCompositeClip(pGC); numRects = REGION_NUM_RECTS (prgnClip); pboxClippedBase = (BoxPtr) ALLOCATE_LOCAL(numRects * sizeof(BoxRec)); if (!pboxClippedBase) return; pboxClipped = pboxClippedBase; { int x1, y1, x2, y2, bx2, by2; BoxRec box; BoxPtr pextent; pextent = REGION_EXTENTS(pGC->pScreen, prgnClip); x1 = pextent->x1; y1 = pextent->y1; x2 = pextent->x2; y2 = pextent->y2; if ((box.x1 = x) < x1) box.x1 = x1; if ((box.y1 = y) < y1) box.y1 = y1; bx2 = (int) x + (int) w; if (bx2 > x2) bx2 = x2; box.x2 = bx2; by2 = (int) y + (int) h; if (by2 > y2) by2 = y2; box.y2 = by2; if ((box.x1 < box.x2) && (box.y1 < box.y2)) { int n = REGION_NUM_RECTS (prgnClip); BoxPtr pbox = REGION_RECTS(prgnClip); /* Clip the rectangle to each box in the clip region * this is logically equivalent to calling Intersect() */ while(n--) { pboxClipped->x1 = max(box.x1, pbox->x1); pboxClipped->y1 = max(box.y1, pbox->y1); pboxClipped->x2 = min(box.x2, pbox->x2); pboxClipped->y2 = min(box.y2, pbox->y2); pbox++; /* see if clipping left anything */ if(pboxClipped->x1 < pboxClipped->x2 && pboxClipped->y1 < pboxClipped->y2) pboxClipped++; } } } if (pboxClipped != pboxClippedBase) { ffb_fbcPtr ffb = pFfb->regs; int num = (pboxClipped - pboxClippedBase); FFB_ATTR_RAW(pFfb, FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST | FFB_PPC_XS_WID, FFB_PPC_APE_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK, pGC->planemask, ((FFB_ROP_EDIT_BIT | pGC->alu) | (FFB_ROP_NEW << 8)), FFB_DRAWOP_RECTANGLE, pGC->fgPixel, fbc, pFfbPrivWin->wid); pboxClipped = pboxClippedBase; while (num--) { int xx, yy, ww, hh; xx = pboxClipped->x1; yy = pboxClipped->y1; ww = (pboxClipped->x2 - xx); hh = (pboxClipped->y2 - yy); FFBFifo(pFfb, 4); FFB_WRITE64(&ffb->by, yy, xx); FFB_WRITE64_2(&ffb->bh, hh, ww); } } DEALLOCATE_LOCAL (pboxClippedBase); } static int FFBDbeAllocBackBufferName(WindowPtr pWin, XID bufId, int swapAction) { ScreenPtr pScreen; FFBPtr pFfb; DbeWindowPrivPtr pDbeWindowPriv; FFBDbeWindowPrivPrivPtr pDbeWindowPrivPriv; DbeScreenPrivPtr pDbeScreenPriv; GCPtr pGC; xRectangle clearRect; pScreen = pWin->drawable.pScreen; pDbeWindowPriv = DBE_WINDOW_PRIV(pWin); pFfb = GET_FFB_FROM_SCREEN(pScreen); pDbeWindowPrivPriv = FFB_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv); if (pDbeWindowPriv->nBufferIDs == 0) { /* There is no buffer associated with the window. * We have to create the window priv priv. Remember, the window * priv was created at the DIX level, so all we need to do is * create the priv priv and attach it to the priv. */ pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen); /* Setup the window priv priv. */ pDbeWindowPrivPriv->pDbeWindowPriv = pDbeWindowPriv; if (!pFfb->NoAccel && pFfb->has_double_buffer) { CreatorPrivWinPtr pFfbPrivWin; unsigned int wid, fbc; /* We just render directly into the hardware, all * that is needed is to swap the rendering attributes * and the WID settings during a swap. */ if (!AddResource(bufId, dbeDrawableResType, (pointer)&pWin->drawable)) { /* Free the buffer and the drawable resource. */ FreeResource(bufId, RT_NONE); return BadAlloc; } pFfbPrivWin = CreatorGetWindowPrivate(pWin); wid = FFBWidUnshare(pFfb, pFfbPrivWin->wid); if (wid == (unsigned int)-1) return BadAlloc; pFfbPrivWin->wid = wid; /* Attach the priv priv to the priv. */ pDbeWindowPriv->devPrivates[FFBDbeWindowPrivPrivIndex].ptr = (pointer)pDbeWindowPrivPriv; /* Indicate we are doing hw acceleration. */ pDbeWindowPrivPriv->HwAccelerated = 1; /* Start rendering into buffer B. */ pDbeWindowPrivPriv->HwCurrentBuf = 1; /* No back/front temporary pixmaps. */ pDbeWindowPrivPriv->pFrontBuffer = NULL; pDbeWindowPrivPriv->pBackBuffer = NULL; /* Switch to writing into buffer B. */ fbc = pFfbPrivWin->fbc_base; fbc &= ~(FFB_FBC_WB_MASK | FFB_FBC_RB_MASK); fbc |= (FFB_FBC_WB_B | FFB_FBC_RB_B); pFfbPrivWin->fbc_base = fbc; pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen); /* Fill X plane of front and back buffers. */ if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC)) { ValidateGC(&pWin->drawable, pGC); FFBDbeUpdateWidPlane(pWin, pGC); } /* Clear out buffer B. */ clearRect.x = clearRect.y = 0; clearRect.width = pWin->drawable.width; clearRect.height = pWin->drawable.height; if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC)) { ValidateGC(&pWin->drawable, pGC); (*pGC->ops->PolyFillRect)(&pWin->drawable, pGC, 1, &clearRect); } FreeScratchGC(pGC); } else { /* Get a front pixmap. */ if (!(pDbeWindowPrivPriv->pFrontBuffer = (*pScreen->CreatePixmap)(pScreen, pDbeWindowPriv->width, pDbeWindowPriv->height, pWin->drawable.depth))) return BadAlloc; /* Get a back pixmap. */ if (!(pDbeWindowPrivPriv->pBackBuffer = (*pScreen->CreatePixmap)(pScreen, pDbeWindowPriv->width, pDbeWindowPriv->height, pWin->drawable.depth))) { (*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pFrontBuffer); return BadAlloc; } /* Make the back pixmap a DBE drawable resource. */ if (!AddResource(bufId, dbeDrawableResType, (pointer)pDbeWindowPrivPriv->pBackBuffer)) { /* Free the buffer and the drawable resource. */ FreeResource(bufId, RT_NONE); return(BadAlloc); } /* Attach the priv priv to the priv. */ pDbeWindowPriv->devPrivates[FFBDbeWindowPrivPrivIndex].ptr = (pointer)pDbeWindowPrivPriv; /* Indicate we are doing this non-accelerated. */ pDbeWindowPrivPriv->HwAccelerated = 0; /* Clear the back buffer. */ pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen); if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC)) { ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC); clearRect.x = clearRect.y = 0; clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width; clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height; (*pGC->ops->PolyFillRect)( (DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC, 1, &clearRect); } FreeScratchGC(pGC); } } else { pointer cookie; /* A buffer is already associated with the window. * Place the new buffer ID information at the head of the ID list. */ if (pDbeWindowPrivPriv->HwAccelerated != 0) cookie = (pointer)&pWin->drawable; else cookie = (pointer)pDbeWindowPrivPriv->pBackBuffer; /* Associate the new ID with an existing pixmap. */ if (!AddResource(bufId, dbeDrawableResType, cookie)) return BadAlloc; } return Success; } static void FFBDbeAliasBuffers(DbeWindowPrivPtr pDbeWindowPriv) { FFBDbeWindowPrivPrivPtr pDbeWindowPrivPriv = FFB_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv); pointer cookie; int i; if (pDbeWindowPrivPriv->HwAccelerated != 0) cookie = (pointer) &pDbeWindowPriv->pWindow->drawable; else cookie = (pointer) pDbeWindowPrivPriv->pBackBuffer; for (i = 0; i < pDbeWindowPriv->nBufferIDs; i++) ChangeResourceValue(pDbeWindowPriv->IDs[i], dbeDrawableResType, cookie); } static int FFBDbeSwapBuffers(ClientPtr client, int *pNumWindows, DbeSwapInfoPtr swapInfo) { FFBDbeWindowPrivPrivPtr pDbeWindowPrivPriv; DbeScreenPrivPtr pDbeScreenPriv; PixmapPtr pTmpBuffer; xRectangle clearRect; WindowPtr pWin; GCPtr pGC; pWin = swapInfo[0].pWindow; pDbeScreenPriv = DBE_SCREEN_PRIV_FROM_WINDOW(pWin); pDbeWindowPrivPriv = FFB_DBE_WINDOW_PRIV_PRIV_FROM_WINDOW(pWin); pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen); if (pDbeWindowPrivPriv->HwAccelerated != 0) { FFBPtr pFfb = GET_FFB_FROM_SCREEN(pWin->drawable.pScreen); CreatorPrivWinPtr pFfbPrivWin = CreatorGetWindowPrivate(pWin); unsigned int fbc; int visible; /* Unfortunately, this is necessary for correctness. */ FFBWait(pFfb, pFfb->regs); /* Flip front/back in the WID. */ visible = 0; if (pWin->viewable && pWin->visibility != VisibilityFullyObscured) visible = 1; FFBWidChangeBuffer(pFfb, pFfbPrivWin->wid, visible); /* Indicate where we are rendering now. */ pDbeWindowPrivPriv->HwCurrentBuf ^= 1; /* Update framebuffer controls. */ fbc = pFfbPrivWin->fbc_base; fbc &= ~(FFB_FBC_WB_MASK | FFB_FBC_RB_MASK); if (pDbeWindowPrivPriv->HwCurrentBuf == 0) fbc |= FFB_FBC_WB_A | FFB_FBC_RB_A; else fbc |= FFB_FBC_WB_B | FFB_FBC_RB_B; /* For XdbeUndefined we do not have to do anything. * This is true for XdbeUntouched as well because we * do in fact retain the unobscured contents of the * front buffer while it is being displayed, thus now * when it has become the back buffer it is still holding * those contents. * * The XdbeUntouched case is important because most apps * using dbe use this type of swap. */ if (swapInfo[0].swapAction == XdbeCopied) { unsigned int fbc_front_to_back; /* Do a GCOPY, front to back. */ fbc_front_to_back = fbc & ~FFB_FBC_RB_MASK; if (pDbeWindowPrivPriv->HwCurrentBuf == 0) fbc_front_to_back |= FFB_FBC_RB_B; else fbc_front_to_back |= FFB_FBC_RB_A; pFfbPrivWin->fbc_base = fbc_front_to_back; ValidateGC(&pWin->drawable, pGC); (*pGC->ops->CopyArea)(&pWin->drawable, &pWin->drawable, pGC, 0, 0, pWin->drawable.width, pWin->drawable.height, 0, 0); } else if (swapInfo[0].swapAction == XdbeBackground) { if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC)) { ValidateGC(&pWin->drawable, pGC); clearRect.x = 0; clearRect.y = 0; clearRect.width = pWin->drawable.width; clearRect.height = pWin->drawable.height; (*pGC->ops->PolyFillRect)(&pWin->drawable, pGC, 1, &clearRect); } } /* Ok, now render with these fb controls. */ pFfbPrivWin->fbc_base = fbc; } else { if (swapInfo[0].swapAction == XdbeUntouched) { ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer, pGC); (*pGC->ops->CopyArea)((DrawablePtr)pWin, (DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer, pGC, 0, 0, pWin->drawable.width, pWin->drawable.height, 0, 0); } ValidateGC((DrawablePtr)pWin, pGC); (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, (DrawablePtr)pWin, pGC, 0, 0, pWin->drawable.width, pWin->drawable.height, 0, 0); if (swapInfo[0].swapAction == XdbeBackground) { if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC)) { ValidateGC((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC); clearRect.x = 0; clearRect.y = 0; clearRect.width = pDbeWindowPrivPriv->pBackBuffer->drawable.width; clearRect.height = pDbeWindowPrivPriv->pBackBuffer->drawable.height; (*pGC->ops->PolyFillRect)( (DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, pGC, 1, &clearRect); } } else if (swapInfo[0].swapAction == XdbeUntouched) { /* Swap pixmap pointers. */ pTmpBuffer = pDbeWindowPrivPriv->pBackBuffer; pDbeWindowPrivPriv->pBackBuffer = pDbeWindowPrivPriv->pFrontBuffer; pDbeWindowPrivPriv->pFrontBuffer = pTmpBuffer; FFBDbeAliasBuffers(pDbeWindowPrivPriv->pDbeWindowPriv); } } /* Remove the swapped window from the swap information array and decrement * pNumWindows to indicate to the DIX level how many windows were actually * swapped. */ if (*pNumWindows > 1) { /* We were told to swap more than one window, but we only swapped the * first one. Remove the first window in the list by moving the last * window to the beginning. */ swapInfo[0].pWindow = swapInfo[*pNumWindows - 1].pWindow; swapInfo[0].swapAction = swapInfo[*pNumWindows - 1].swapAction; /* Clear the last window information just to be safe. */ swapInfo[*pNumWindows - 1].pWindow = (WindowPtr)NULL; swapInfo[*pNumWindows - 1].swapAction = 0; } else { /* Clear the window information just to be safe. */ swapInfo[0].pWindow = (WindowPtr)NULL; swapInfo[0].swapAction = 0; } (*pNumWindows)--; FreeScratchGC(pGC); return Success; } static void FFBDbeWinPrivDelete(DbeWindowPrivPtr pDbeWindowPriv, XID bufId) { WindowPtr pWin = pDbeWindowPriv->pWindow; FFBDbeWindowPrivPrivPtr pDbeWindowPrivPriv; if (pDbeWindowPriv->nBufferIDs != 0) { /* We still have at least one more buffer ID associated with this * window. */ return; } /* We have no more buffer IDs associated with this window. We need to * free some stuff. */ pDbeWindowPrivPriv = FFB_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv); /* If we were accelerating we need to restore the framebuffer * attributes. We need to also free up the Dbe WID and go * back to using the shared one. */ if (pDbeWindowPrivPriv->HwAccelerated != 0) { FFBPtr pFfb = GET_FFB_FROM_SCREEN(pWin->drawable.pScreen); CreatorPrivWinPtr pFfbPrivWin = CreatorGetWindowPrivate(pWin); xRectangle clearRect; unsigned int fbc; GCPtr pGC; pFfbPrivWin->wid = FFBWidReshare(pFfb, pFfbPrivWin->wid); /* Go back to using buffer A. */ fbc = pFfbPrivWin->fbc_base; fbc &= ~(FFB_FBC_WB_MASK | FFB_FBC_RB_MASK); fbc |= FFB_FBC_WB_A | FFB_FBC_RB_A; /* Now fixup the WID channel. */ pFfbPrivWin->fbc_base = (fbc & ~FFB_FBC_RGBE_MASK) | FFB_FBC_RGBE_OFF; pGC = GetScratchGC(pWin->drawable.depth, pWin->drawable.pScreen); clearRect.x = clearRect.y = 0; clearRect.width = pWin->drawable.width; clearRect.height = pWin->drawable.height; ValidateGC(&pWin->drawable, pGC); FFBDbeUpdateWidPlane(pWin, pGC); (*pGC->ops->PolyFillRect)(&pWin->drawable, pGC, 1, &clearRect); FreeScratchGC(pGC); pFfbPrivWin->fbc_base = fbc; } else { /* Destroy the front and back pixmaps. */ if (pDbeWindowPrivPriv->pFrontBuffer) (*pDbeWindowPriv->pWindow->drawable.pScreen->DestroyPixmap)( pDbeWindowPrivPriv->pFrontBuffer); if (pDbeWindowPrivPriv->pBackBuffer) (*pDbeWindowPriv->pWindow->drawable.pScreen->DestroyPixmap)( pDbeWindowPrivPriv->pBackBuffer); } } static Bool FFBDbePositionWindow(WindowPtr pWin, int x, int y) { ScreenPtr pScreen; DbeScreenPrivPtr pDbeScreenPriv; DbeWindowPrivPtr pDbeWindowPriv; FFBDbeWindowPrivPrivPtr pDbeWindowPrivPriv; int width, height; int dx, dy, dw, dh; int sourcex, sourcey; int destx, desty; int savewidth, saveheight; PixmapPtr pFrontBuffer; PixmapPtr pBackBuffer; Bool clear; GCPtr pGC; xRectangle clearRect; Bool ret; /* 1. Unwrap the member routine. */ pScreen = pWin->drawable.pScreen; pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen); pScreen->PositionWindow = pDbeScreenPriv->PositionWindow; /* 2. Do any work necessary before the member routine is called. * * In this case we do not need to do anything. */ /* 3. Call the member routine, saving its result if necessary. */ ret = (*pScreen->PositionWindow)(pWin, x, y); /* 4. Rewrap the member routine, restoring the wrapper value first in case * the wrapper (or something that it wrapped) change this value. */ pDbeScreenPriv->PositionWindow = pScreen->PositionWindow; pScreen->PositionWindow = FFBDbePositionWindow; /* 5. Do any work necessary after the member routine has been called. */ if (!(pDbeWindowPriv = DBE_WINDOW_PRIV(pWin))) return ret; if (pDbeWindowPriv->width == pWin->drawable.width && pDbeWindowPriv->height == pWin->drawable.height) return ret; width = pWin->drawable.width; height = pWin->drawable.height; dx = pWin->drawable.x - pDbeWindowPriv->x; dy = pWin->drawable.y - pDbeWindowPriv->y; dw = width - pDbeWindowPriv->width; dh = height - pDbeWindowPriv->height; GravityTranslate (0, 0, -dx, -dy, dw, dh, pWin->bitGravity, &destx, &desty); clear = ((pDbeWindowPriv->width < (unsigned short)width ) || (pDbeWindowPriv->height < (unsigned short)height) || (pWin->bitGravity == ForgetGravity)); sourcex = 0; sourcey = 0; savewidth = pDbeWindowPriv->width; saveheight = pDbeWindowPriv->height; /* Clip rectangle to source and destination. */ if (destx < 0) { savewidth += destx; sourcex -= destx; destx = 0; } if (destx + savewidth > width) savewidth = width - destx; if (desty < 0) { saveheight += desty; sourcey -= desty; desty = 0; } if (desty + saveheight > height) saveheight = height - desty; pDbeWindowPriv->width = width; pDbeWindowPriv->height = height; pDbeWindowPriv->x = pWin->drawable.x; pDbeWindowPriv->y = pWin->drawable.y; pGC = GetScratchGC (pWin->drawable.depth, pScreen); if (clear) { if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC)) { clearRect.x = 0; clearRect.y = 0; clearRect.width = width; clearRect.height = height; } else { clear = FALSE; } } pDbeWindowPrivPriv = FFB_DBE_WINDOW_PRIV_PRIV(pDbeWindowPriv); if (pDbeWindowPrivPriv->HwAccelerated != 0) { /* If we're hw accelerating, things are much easier. */ ValidateGC(&pWin->drawable, pGC); FFBDbeUpdateWidPlane(pWin, pGC); if (clear) { CreatorPrivWinPtr pFfbPrivWin = CreatorGetWindowPrivate(pWin); unsigned int fbc, orig_fbc; ValidateGC(&pWin->drawable, pGC); (*pGC->ops->PolyFillRect)(&pWin->drawable, pGC, 1, &clearRect); orig_fbc = fbc = pFfbPrivWin->fbc_base; fbc &= ~(FFB_FBC_WB_MASK); if (pDbeWindowPrivPriv->HwCurrentBuf == 0) fbc |= FFB_FBC_WB_B; else fbc |= FFB_FBC_WB_A; pFfbPrivWin->fbc_base = fbc; if ((*pDbeScreenPriv->SetupBackgroundPainter)(pWin, pGC)) { ValidateGC(&pWin->drawable, pGC); clearRect.x = 0; clearRect.y = 0; clearRect.width = width; clearRect.height = height; (*pGC->ops->PolyFillRect)(&pWin->drawable, pGC, 1, &clearRect); } pFfbPrivWin->fbc_base = orig_fbc; } FreeScratchGC(pGC); } else { /* Create DBE buffer pixmaps equal to size of resized window. */ pFrontBuffer = (*pScreen->CreatePixmap)(pScreen, width, height, pWin->drawable.depth); pBackBuffer = (*pScreen->CreatePixmap)(pScreen, width, height, pWin->drawable.depth); if (!pFrontBuffer || !pBackBuffer) { /* We failed at creating 1 or 2 of the pixmaps. */ if (pFrontBuffer) (*pScreen->DestroyPixmap)(pFrontBuffer); if (pBackBuffer) (*pScreen->DestroyPixmap)(pBackBuffer); /* Destroy all buffers for this window. */ while (pDbeWindowPriv) { /* DbeWindowPrivDelete() will free the window private * if there no more buffer IDs associated with this * window. */ FreeResource(pDbeWindowPriv->IDs[0], RT_NONE); pDbeWindowPriv = DBE_WINDOW_PRIV(pWin); } FreeScratchGC(pGC); return FALSE; } else { /* Clear out the new DBE buffer pixmaps. */ ValidateGC((DrawablePtr)pFrontBuffer, pGC); /* I suppose this could avoid quite a bit of work if * it computed the minimal area required. */ if (clear) { (*pGC->ops->PolyFillRect)((DrawablePtr)pFrontBuffer, pGC, 1, &clearRect); (*pGC->ops->PolyFillRect)((DrawablePtr)pBackBuffer , pGC, 1, &clearRect); } /* Copy the contents of the old DBE pixmaps to the new pixmaps. */ if (pWin->bitGravity != ForgetGravity) { (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pFrontBuffer, (DrawablePtr)pFrontBuffer, pGC, sourcex, sourcey, savewidth, saveheight, destx, desty); (*pGC->ops->CopyArea)((DrawablePtr)pDbeWindowPrivPriv->pBackBuffer, (DrawablePtr)pBackBuffer, pGC, sourcex, sourcey, savewidth, saveheight, destx, desty); } /* Destroy the old pixmaps, and point the DBE window priv to the new * pixmaps. */ (*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pFrontBuffer); (*pScreen->DestroyPixmap)(pDbeWindowPrivPriv->pBackBuffer); pDbeWindowPrivPriv->pFrontBuffer = pFrontBuffer; pDbeWindowPrivPriv->pBackBuffer = pBackBuffer; /* Make sure all XID are associated with the new back pixmap. */ FFBDbeAliasBuffers(pDbeWindowPriv); FreeScratchGC(pGC); } } return ret; } static void FFBDbeResetProc(ScreenPtr pScreen) { DbeScreenPrivPtr pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen); /* Unwrap wrappers */ pScreen->PositionWindow = pDbeScreenPriv->PositionWindow; } static Bool FFBDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv) { ScrnInfoPtr pScrn; FFBPtr pFfb; pScrn = xf86Screens[pScreen->myNum]; pFfb = GET_FFB_FROM_SCRN(pScrn); xf86Msg(X_INFO, "%s: Setting up double-buffer acceleration.\n", pFfb->psdp->device); /* Copy resource types created by DIX */ dbeDrawableResType = pDbeScreenPriv->dbeDrawableResType; dbeWindowPrivResType = pDbeScreenPriv->dbeWindowPrivResType; /* Copy private indices created by DIX */ dbeScreenPrivIndex = pDbeScreenPriv->dbeScreenPrivIndex; dbeWindowPrivIndex = pDbeScreenPriv->dbeWindowPrivIndex; /* Reset the window priv privs if generations do not match. */ if (FFBDbePrivPrivGeneration != serverGeneration) { /* Allocate the window priv priv. */ FFBDbeWindowPrivPrivIndex = (*pDbeScreenPriv->AllocWinPrivPrivIndex)(); if (!(*pDbeScreenPriv->AllocWinPrivPriv)(pScreen, FFBDbeWindowPrivPrivIndex, sizeof(FFBDbeWindowPrivPrivRec))) return FALSE; /* Make sure we only do this code once. */ FFBDbePrivPrivGeneration = serverGeneration; } /* Wrap functions. */ pDbeScreenPriv->PositionWindow = pScreen->PositionWindow; pScreen->PositionWindow = FFBDbePositionWindow; /* Initialize the per-screen DBE function pointers. */ pDbeScreenPriv->GetVisualInfo = FFBDbeGetVisualInfo; pDbeScreenPriv->AllocBackBufferName = FFBDbeAllocBackBufferName; pDbeScreenPriv->SwapBuffers = FFBDbeSwapBuffers; pDbeScreenPriv->BeginIdiom = 0; pDbeScreenPriv->EndIdiom = 0; pDbeScreenPriv->ResetProc = FFBDbeResetProc; pDbeScreenPriv->WinPrivDelete = FFBDbeWinPrivDelete; /* The FFB implementation doesn't need buffer validation. */ pDbeScreenPriv->ValidateBuffer = (void (*)())NoopDDA; return TRUE; } extern void DbeRegisterFunction(ScreenPtr pScreen, Bool (*funct)(ScreenPtr, DbeScreenPrivPtr)); Bool FFBDbePreInit(ScreenPtr pScreen) { DbeRegisterFunction(pScreen, FFBDbeInit); return TRUE; }