Bool
exaDestroyPixmap_classic(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);
Bool ret;
if (pPixmap->refcnt == 1) {
ExaPixmapPriv(pPixmap);
exaDestroyPixmap(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.ptr = pExaPixmap->sys_ptr;
pPixmap->devKind = pExaPixmap->sys_pitch;
}
RegionUninit(&pExaPixmap->validSys);
RegionUninit(&pExaPixmap->validFB);
}
swap(pExaScr, pScreen, DestroyPixmap);
ret = pScreen->DestroyPixmap(pPixmap);
swap(pExaScr, pScreen, DestroyPixmap);
return ret;
}
static void
ShadowCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgn)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
ShadowScreenPtr pPriv = GET_SCREEN_PRIVATE(pScreen);
int num = 0;
RegionRec rgnDst;
if (pPriv->vtSema) {
RegionNull(&rgnDst);
RegionCopy(&rgnDst, prgn);
RegionTranslate(&rgnDst,
pWin->drawable.x - ptOldOrg.x,
pWin->drawable.y - ptOldOrg.y);
RegionIntersect(&rgnDst, &pWin->borderClip, &rgnDst);
if ((num = RegionNumRects(&rgnDst))) {
if (pPriv->preRefresh)
(*pPriv->preRefresh) (pPriv->pScrn, num, RegionRects(&rgnDst));
}
else {
RegionUninit(&rgnDst);
}
}
pScreen->CopyWindow = pPriv->CopyWindow;
(*pScreen->CopyWindow) (pWin, ptOldOrg, prgn);
pScreen->CopyWindow = ShadowCopyWindow;
if (num) {
if (pPriv->postRefresh)
(*pPriv->postRefresh) (pPriv->pScrn, num, RegionRects(&rgnDst));
RegionUninit(&rgnDst);
}
}
/*****
* miHandleValidateExposures(pWin)
* starting at pWin, draw background in any windows that have exposure
* regions, translate the regions, restore any backing store,
* and then send any regions still exposed to the client
*****/
void
miHandleValidateExposures(WindowPtr pWin)
{
WindowPtr pChild;
ValidatePtr val;
WindowExposuresProcPtr WindowExposures;
pChild = pWin;
WindowExposures = pChild->drawable.pScreen->WindowExposures;
while (1) {
if ((val = pChild->valdata)) {
if (RegionNotEmpty(&val->after.borderExposed))
miPaintWindow(pChild, &val->after.borderExposed, PW_BORDER);
RegionUninit(&val->after.borderExposed);
(*WindowExposures) (pChild, &val->after.exposed, NullRegion);
RegionUninit(&val->after.exposed);
free(val);
pChild->valdata = NULL;
if (pChild->firstChild) {
pChild = pChild->firstChild;
continue;
}
}
while (!pChild->nextSib && (pChild != pWin))
pChild = pChild->parent;
if (pChild == pWin)
break;
pChild = pChild->nextSib;
}
}
void
XAACopyWindow(
WindowPtr pWin,
DDXPointRec ptOldOrg,
RegionPtr prgnSrc )
{
DDXPointPtr pptSrc, ppt;
RegionRec rgnDst;
BoxPtr pbox;
int dx, dy, nbox;
WindowPtr pwinRoot;
ScreenPtr pScreen = pWin->drawable.pScreen;
XAAInfoRecPtr infoRec =
GET_XAAINFORECPTR_FROM_DRAWABLE((&pWin->drawable));
if (!infoRec->pScrn->vtSema || !infoRec->ScreenToScreenBitBlt) {
XAA_SCREEN_PROLOGUE (pScreen, CopyWindow);
if(infoRec->pScrn->vtSema && infoRec->NeedToSync) {
(*infoRec->Sync)(infoRec->pScrn);
infoRec->NeedToSync = FALSE;
}
(*pScreen->CopyWindow) (pWin, ptOldOrg, prgnSrc);
XAA_SCREEN_EPILOGUE (pScreen, CopyWindow, XAACopyWindow);
return;
}
pwinRoot = pScreen->root;
RegionNull(&rgnDst);
dx = ptOldOrg.x - pWin->drawable.x;
dy = ptOldOrg.y - pWin->drawable.y;
RegionTranslate(prgnSrc, -dx, -dy);
RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
pbox = RegionRects(&rgnDst);
nbox = RegionNumRects(&rgnDst);
if(!nbox ||
!(pptSrc = (DDXPointPtr )malloc(nbox * sizeof(DDXPointRec)))) {
RegionUninit(&rgnDst);
return;
}
ppt = pptSrc;
while(nbox--) {
ppt->x = pbox->x1 + dx;
ppt->y = pbox->y1 + dy;
ppt++; pbox++;
}
infoRec->ScratchGC.planemask = ~0L;
infoRec->ScratchGC.alu = GXcopy;
XAADoBitBlt((DrawablePtr)pwinRoot, (DrawablePtr)pwinRoot,
&(infoRec->ScratchGC), &rgnDst, pptSrc);
free(pptSrc);
RegionUninit(&rgnDst);
}
void
ExaCheckCopyNtoN(DrawablePtr pSrc, DrawablePtr pDst, GCPtr pGC,
BoxPtr pbox, int nbox, int dx, int dy, Bool reverse,
Bool upsidedown, Pixel bitplane, void *closure)
{
RegionRec reg;
int xoff, yoff;
EXA_PRE_FALLBACK_GC(pGC);
EXA_FALLBACK(("from %p to %p (%c,%c)\n", pSrc, pDst,
exaDrawableLocation(pSrc), exaDrawableLocation(pDst)));
if (pExaScr->prepare_access_reg && RegionInitBoxes(®, pbox, nbox)) {
PixmapPtr pPixmap = exaGetDrawablePixmap(pSrc);
exaGetDrawableDeltas(pSrc, pPixmap, &xoff, &yoff);
RegionTranslate(®, xoff + dx, yoff + dy);
pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_SRC, ®);
RegionUninit(®);
}
else
exaPrepareAccess(pSrc, EXA_PREPARE_SRC);
if (pExaScr->prepare_access_reg &&
!exaGCReadsDestination(pDst, pGC->planemask, pGC->fillStyle,
pGC->alu, pGC->clientClipType) &&
RegionInitBoxes(®, pbox, nbox)) {
PixmapPtr pPixmap = exaGetDrawablePixmap(pDst);
exaGetDrawableDeltas(pDst, pPixmap, &xoff, &yoff);
RegionTranslate(®, xoff, yoff);
pExaScr->prepare_access_reg(pPixmap, EXA_PREPARE_DEST, ®);
RegionUninit(®);
}
else
exaPrepareAccess(pDst, EXA_PREPARE_DEST);
/* This will eventually call fbCopyNtoN, with some calculation overhead. */
while (nbox--) {
pGC->ops->CopyArea(pSrc, pDst, pGC, pbox->x1 - pSrc->x + dx,
pbox->y1 - pSrc->y + dy, pbox->x2 - pbox->x1,
pbox->y2 - pbox->y1, pbox->x1 - pDst->x,
pbox->y1 - pDst->y);
pbox++;
}
exaFinishAccess(pSrc, EXA_PREPARE_SRC);
exaFinishAccess(pDst, EXA_PREPARE_DEST);
EXA_POST_FALLBACK_GC(pGC);
}
Bool
compAllocPixmap(WindowPtr pWin)
{
int bw = (int) pWin->borderWidth;
int x = pWin->drawable.x - bw;
int y = pWin->drawable.y - bw;
int w = pWin->drawable.width + (bw << 1);
int h = pWin->drawable.height + (bw << 1);
PixmapPtr pPixmap = compNewPixmap(pWin, x, y, w, h);
CompWindowPtr cw = GetCompWindow(pWin);
if (!pPixmap)
return FALSE;
if (cw->update == CompositeRedirectAutomatic)
pWin->redirectDraw = RedirectDrawAutomatic;
else
pWin->redirectDraw = RedirectDrawManual;
compSetPixmap(pWin, pPixmap);
cw->oldx = COMP_ORIGIN_INVALID;
cw->oldy = COMP_ORIGIN_INVALID;
cw->damageRegistered = FALSE;
if (cw->update == CompositeRedirectAutomatic) {
DamageRegister(&pWin->drawable, cw->damage);
cw->damageRegistered = TRUE;
}
/* Make sure our borderClip is up to date */
RegionUninit(&cw->borderClip);
RegionCopy(&cw->borderClip, &pWin->borderClip);
cw->borderClipX = pWin->drawable.x;
cw->borderClipY = pWin->drawable.y;
return TRUE;
}
static void
ExaFallbackPrepareReg(DrawablePtr pDrawable,
GCPtr pGC,
int x, int y, int width, int height,
int index, Bool checkReads)
{
ScreenPtr pScreen = pDrawable->pScreen;
ExaScreenPriv(pScreen);
if (pExaScr->prepare_access_reg &&
!(checkReads && exaGCReadsDestination(pDrawable,
pGC->planemask,
pGC->fillStyle,
pGC->alu, pGC->clientClipType))) {
BoxRec box;
RegionRec reg;
int xoff, yoff;
PixmapPtr pPixmap = exaGetDrawablePixmap(pDrawable);
exaGetDrawableDeltas(pDrawable, pPixmap, &xoff, &yoff);
box.x1 = pDrawable->x + x + xoff;
box.y1 = pDrawable->y + y + yoff;
box.x2 = box.x1 + width;
box.y2 = box.y1 + height;
RegionInit(®, &box, 1);
pExaScr->prepare_access_reg(pPixmap, index, ®);
RegionUninit(®);
}
else
exaPrepareAccess(pDrawable, index);
}
static RegionPtr
rdpCopyAreaWndToPixmap(WindowPtr pSrcWnd,
PixmapPtr pDstPixmap, rdpPixmapRec *pDstPriv,
GCPtr pGC, int srcx, int srcy, int w, int h,
int dstx, int dsty)
{
int cd;
int lsrcx;
int lsrcy;
int ldstx;
int ldsty;
int num_clips;
int j;
BoxRec box;
RegionPtr rv;
RegionRec clip_reg;
LLOGLN(10, ("rdpCopyAreaWndToPixmap:"));
RegionInit(&clip_reg, NullBox, 0);
cd = rdp_get_clip(&clip_reg, &(pDstPixmap->drawable), pGC);
lsrcx = pSrcWnd->drawable.x + srcx;
lsrcy = pSrcWnd->drawable.y + srcy;
ldstx = pDstPixmap->drawable.x + dstx;
ldsty = pDstPixmap->drawable.y + dsty;
if (cd == 1)
{
rdpup_switch_os_surface(pDstPriv->rdpindex);
rdpup_begin_update();
rdpup_screen_blt(ldstx, ldsty, w, h, lsrcx, lsrcy);
rdpup_end_update();
rdpup_switch_os_surface(-1);
}
else if (cd == 2)
{
num_clips = REGION_NUM_RECTS(&clip_reg);
if (num_clips > 0)
{
rdpup_switch_os_surface(pDstPriv->rdpindex);
rdpup_begin_update();
for (j = 0; j < num_clips; j++)
{
box = REGION_RECTS(&clip_reg)[j];
rdpup_set_clip(box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
rdpup_screen_blt(ldstx, ldsty, w, h, lsrcx, lsrcy);
}
rdpup_reset_clip();
rdpup_end_update();
rdpup_switch_os_surface(-1);
}
}
RegionUninit(&clip_reg);
rv = rdpCopyAreaOrg(&(pSrcWnd->drawable), &(pDstPixmap->drawable),
pGC, srcx, srcy, w, h, dstx, dsty);
return rv;
}
void
miWindowExposures(WindowPtr pWin, RegionPtr prgn)
{
RegionPtr exposures = prgn;
if (prgn && !RegionNil(prgn)) {
RegionRec expRec;
int clientInterested =
(pWin->eventMask | wOtherEventMasks(pWin)) & ExposureMask;
if (clientInterested && (RegionNumRects(prgn) > RECTLIMIT)) {
/*
* If we have LOTS of rectangles, we decide to take the extents
* and force an exposure on that. This should require much less
* work overall, on both client and server. This is cheating, but
* isn't prohibited by the protocol ("spontaneous combustion" :-).
*/
BoxRec box = *RegionExtents(prgn);
exposures = &expRec;
RegionInit(exposures, &box, 1);
RegionReset(prgn, &box);
/* miPaintWindow doesn't clip, so we have to */
RegionIntersect(prgn, prgn, &pWin->clipList);
}
pWin->drawable.pScreen->PaintWindow(pWin, prgn, PW_BACKGROUND);
if (clientInterested)
miSendExposures(pWin, exposures,
pWin->drawable.x, pWin->drawable.y);
if (exposures == &expRec)
RegionUninit(exposures);
RegionEmpty(prgn);
}
}
RegionPtr
rdpRestoreAreas(WindowPtr pWin, RegionPtr prgnExposed)
{
RegionRec reg;
RegionPtr rv;
int j;
BoxRec box;
LLOGLN(0, ("in rdpRestoreAreas"));
RegionInit(®, NullBox, 0);
RegionCopy(®, prgnExposed);
g_pScreen->RestoreAreas = g_rdpScreen.RestoreAreas;
rv = g_pScreen->RestoreAreas(pWin, prgnExposed);
if (g_do_dirty_ons)
{
draw_item_add_img_region(&g_screenPriv, ®, GXcopy, RDI_IMGLL);
}
else
{
rdpup_begin_update();
for (j = REGION_NUM_RECTS(®) - 1; j >= 0; j--)
{
box = REGION_RECTS(®)[j];
rdpup_send_area(0, box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
}
rdpup_end_update();
}
RegionUninit(®);
g_pScreen->RestoreAreas = rdpRestoreAreas;
return rv;
}
static void
xf86CrtcDamageShadow(xf86CrtcPtr crtc)
{
ScrnInfoPtr pScrn = crtc->scrn;
BoxRec damage_box;
RegionRec damage_region;
ScreenPtr pScreen = xf86ScrnToScreen(pScrn);
damage_box.x1 = 0;
damage_box.x2 = crtc->mode.HDisplay;
damage_box.y1 = 0;
damage_box.y2 = crtc->mode.VDisplay;
if (!pixman_transform_bounds(&crtc->crtc_to_framebuffer, &damage_box)) {
damage_box.x1 = 0;
damage_box.y1 = 0;
damage_box.x2 = pScreen->width;
damage_box.y2 = pScreen->height;
}
if (damage_box.x1 < 0)
damage_box.x1 = 0;
if (damage_box.y1 < 0)
damage_box.y1 = 0;
if (damage_box.x2 > pScreen->width)
damage_box.x2 = pScreen->width;
if (damage_box.y2 > pScreen->height)
damage_box.y2 = pScreen->height;
RegionInit(&damage_region, &damage_box, 1);
DamageDamageRegion(&(*pScreen->GetScreenPixmap) (pScreen)->drawable,
&damage_region);
RegionUninit(&damage_region);
crtc->shadowClear = TRUE;
}
void
fbCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{
RegionRec rgnDst;
int dx, dy;
PixmapPtr pPixmap = fbGetWindowPixmap(pWin);
DrawablePtr pDrawable = &pPixmap->drawable;
dx = ptOldOrg.x - pWin->drawable.x;
dy = ptOldOrg.y - pWin->drawable.y;
RegionTranslate(prgnSrc, -dx, -dy);
RegionNull(&rgnDst);
RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
#ifdef COMPOSITE
if (pPixmap->screen_x || pPixmap->screen_y)
RegionTranslate(&rgnDst, -pPixmap->screen_x, -pPixmap->screen_y);
#endif
miCopyRegion(pDrawable, pDrawable,
0, &rgnDst, dx, dy, fbCopyWindowProc, 0, 0);
RegionUninit(&rgnDst);
fbValidateDrawable(&pWin->drawable);
}
/* draw from an off screen pixmap to a visible window */
static RegionPtr
rdpCopyAreaPixmapToWnd(PixmapPtr pSrcPixmap, rdpPixmapRec *pSrcPriv,
WindowPtr pDstWnd, GCPtr pGC,
int srcx, int srcy, int w, int h,
int dstx, int dsty)
{
int lsrcx;
int lsrcy;
int ldstx;
int ldsty;
int cd;
int j;
int num_clips;
RegionPtr rv;
RegionRec clip_reg;
BoxRec box;
LLOGLN(10, ("rdpCopyAreaPixmapToWnd:"));
RegionInit(&clip_reg, NullBox, 0);
cd = rdp_get_clip(&clip_reg, &(pDstWnd->drawable), pGC);
ldstx = pDstWnd->drawable.x + dstx;
ldsty = pDstWnd->drawable.y + dsty;
lsrcx = pSrcPixmap->drawable.x + srcx;
lsrcy = pSrcPixmap->drawable.y + srcy;
if (cd == 1)
{
rdpup_begin_update();
rdpup_paint_rect_os(ldstx, ldsty, w, h, pSrcPriv->rdpindex, lsrcx, lsrcy);
rdpup_end_update();
}
else if (cd == 2)
{
num_clips = REGION_NUM_RECTS(&clip_reg);
if (num_clips > 0)
{
rdpup_begin_update();
LLOGLN(10, ("rdpCopyAreaPixmapToWnd: num_clips %d", num_clips));
for (j = 0; j < num_clips; j++)
{
box = REGION_RECTS(&clip_reg)[j];
LLOGLN(10, ("rdpCopyAreaPixmapToWnd: %d %d %d %d", box.x1, box.y1, box.x2, box.y2));
rdpup_set_clip(box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
LLOGLN(10, ("rdpCopyAreaPixmapToWnd: %d %d", w, h));
rdpup_paint_rect_os(ldstx, ldsty, w, h, pSrcPriv->rdpindex, lsrcx, lsrcy);
}
rdpup_reset_clip();
rdpup_end_update();
}
}
RegionUninit(&clip_reg);
rv = rdpCopyAreaOrg(&(pSrcPixmap->drawable), &(pDstWnd->drawable),
pGC, srcx, srcy, w, h, dstx, dsty);
return rv;
}
/*
* Free one of the per-client per-window resources, clearing
* redirect and the per-window pointer as appropriate
*/
void
compFreeClientWindow (WindowPtr pWin, XID id)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
CompWindowPtr cw = GetCompWindow (pWin);
CompClientWindowPtr ccw, *prev;
Bool anyMarked = FALSE;
WindowPtr pLayerWin;
PixmapPtr pPixmap = NULL;
if (!cw)
return;
for (prev = &cw->clients; (ccw = *prev); prev = &ccw->next)
{
if (ccw->id == id)
{
*prev = ccw->next;
if (ccw->update == CompositeRedirectManual)
cw->update = CompositeRedirectAutomatic;
free(ccw);
break;
}
}
if (!cw->clients)
{
anyMarked = compMarkWindows (pWin, &pLayerWin);
if (pWin->redirectDraw != RedirectDrawNone) {
pPixmap = (*pScreen->GetWindowPixmap) (pWin);
compSetParentPixmap (pWin);
}
if (cw->damage)
DamageDestroy (cw->damage);
RegionUninit(&cw->borderClip);
dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, NULL);
free(cw);
}
else if (cw->update == CompositeRedirectAutomatic &&
!cw->damageRegistered && pWin->redirectDraw != RedirectDrawNone)
{
anyMarked = compMarkWindows (pWin, &pLayerWin);
DamageRegister (&pWin->drawable, cw->damage);
cw->damageRegistered = TRUE;
pWin->redirectDraw = RedirectDrawAutomatic;
DamageDamageRegion(&pWin->drawable, &pWin->borderSize);
}
if (anyMarked)
compHandleMarkedWindows (pWin, pLayerWin);
if (pPixmap) {
compRestoreWindow (pWin, pPixmap);
(*pScreen->DestroyPixmap) (pPixmap);
}
}
/*
* Free one of the per-client per-window resources, clearing
* redirect and the per-window pointer as appropriate
*/
void
compFreeClientWindow (WindowPtr pWin, XID id)
{
CompWindowPtr cw = GetCompWindow (pWin);
CompClientWindowPtr ccw, *prev;
Bool wasMapped = pWin->mapped;
if (!cw)
return;
for (prev = &cw->clients; (ccw = *prev); prev = &ccw->next)
{
if (ccw->id == id)
{
*prev = ccw->next;
if (ccw->update == CompositeRedirectManual)
cw->update = CompositeRedirectAutomatic;
free(ccw);
break;
}
}
if (!cw->clients)
{
if (wasMapped)
{
DisableMapUnmapEvents (pWin);
UnmapWindow (pWin, FALSE);
EnableMapUnmapEvents (pWin);
}
if (pWin->redirectDraw != RedirectDrawNone)
compFreePixmap (pWin);
if (cw->damage)
DamageDestroy (cw->damage);
RegionUninit(&cw->borderClip);
dixSetPrivate(&pWin->devPrivates, CompWindowPrivateKey, NULL);
free(cw);
}
else if (cw->update == CompositeRedirectAutomatic &&
!cw->damageRegistered && pWin->redirectDraw != RedirectDrawNone)
{
DamageRegister (&pWin->drawable, cw->damage);
cw->damageRegistered = TRUE;
pWin->redirectDraw = RedirectDrawAutomatic;
DamageRegionAppend(&pWin->drawable, &pWin->borderSize);
}
if (wasMapped && !pWin->mapped)
{
Bool overrideRedirect = pWin->overrideRedirect;
pWin->overrideRedirect = TRUE;
DisableMapUnmapEvents (pWin);
MapWindow (pWin, clients[CLIENT_ID(id)]);
EnableMapUnmapEvents (pWin);
pWin->overrideRedirect = overrideRedirect;
}
}
void
miClearToBackground(WindowPtr pWin,
int x, int y, int w, int h, Bool generateExposures)
{
BoxRec box;
RegionRec reg;
BoxPtr extents;
int x1, y1, x2, y2;
/* compute everything using ints to avoid overflow */
x1 = pWin->drawable.x + x;
y1 = pWin->drawable.y + y;
if (w)
x2 = x1 + (int) w;
else
x2 = x1 + (int) pWin->drawable.width - (int) x;
if (h)
y2 = y1 + h;
else
y2 = y1 + (int) pWin->drawable.height - (int) y;
extents = &pWin->clipList.extents;
/* clip the resulting rectangle to the window clipList extents. This
* makes sure that the result will fit in a box, given that the
* screen is < 32768 on a side.
*/
if (x1 < extents->x1)
x1 = extents->x1;
if (x2 > extents->x2)
x2 = extents->x2;
if (y1 < extents->y1)
y1 = extents->y1;
if (y2 > extents->y2)
y2 = extents->y2;
if (x2 <= x1 || y2 <= y1) {
x2 = x1 = 0;
y2 = y1 = 0;
}
box.x1 = x1;
box.x2 = x2;
box.y1 = y1;
box.y2 = y2;
RegionInit(®, &box, 1);
RegionIntersect(®, ®, &pWin->clipList);
if (generateExposures)
(*pWin->drawable.pScreen->WindowExposures) (pWin, ®, NULL);
else if (pWin->backgroundState != None)
miPaintWindow(pWin, ®, PW_BACKGROUND);
RegionUninit(®);
}
int
xrdp_is_os(PixmapPtr pix, rdpPixmapPtr priv)
{
RegionRec reg1;
BoxRec box;
int width;
int height;
struct image_data id;
if (!XRDP_IS_OS(priv))
{
width = pix->drawable.width;
height = pix->drawable.height;
if ((pix->usage_hint == 0) &&
(pix->drawable.depth >= g_rdpScreen.depth) &&
(width > 1) && (height > 1) && (priv->kind_width > 0))
{
LLOGLN(10, ("%d %d", priv->kind_width, pix->drawable.width));
priv->rdpindex = rdpup_add_os_bitmap(pix, priv);
if (priv->rdpindex >= 0)
{
priv->status = 1;
rdpup_create_os_surface(priv->rdpindex,
priv->kind_width, height);
box.x1 = 0;
box.y1 = 0;
box.x2 = width;
box.y2 = height;
if (g_do_dirty_os)
{
if (priv->con_number != g_con_number)
{
draw_item_remove_all(priv);
RegionInit(®1, &box, 0);
draw_item_add_img_region(priv, ®1, GXcopy, RDI_IMGLL);
RegionUninit(®1);
priv->is_dirty = 1;
priv->con_number = g_con_number;
}
}
else
{
rdpup_get_pixmap_image_rect(pix, &id);
rdpup_switch_os_surface(priv->rdpindex);
rdpup_begin_update();
rdpup_send_area(&id, box.x1, box.y1, box.x2 - box.x1,
box.y2 - box.y1);
rdpup_end_update();
rdpup_switch_os_surface(-1);
}
return 1;
}
}
return 0;
}
return 1;
}
static Bool
glamor_put_image_gl(DrawablePtr drawable, GCPtr gc, int depth, int x, int y,
int w, int h, int leftPad, int format, char *bits)
{
ScreenPtr screen = drawable->pScreen;
glamor_screen_private *glamor_priv = glamor_get_screen_private(screen);
PixmapPtr pixmap = glamor_get_drawable_pixmap(drawable);
glamor_pixmap_private *pixmap_priv;
uint32_t byte_stride = PixmapBytePad(w, drawable->depth);
RegionRec region;
BoxRec box;
int off_x, off_y;
pixmap_priv = glamor_get_pixmap_private(pixmap);
if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv))
return FALSE;
if (gc->alu != GXcopy)
goto bail;
if (!glamor_pm_is_solid(&pixmap->drawable, gc->planemask))
goto bail;
if (format == XYPixmap && drawable->depth == 1 && leftPad == 0)
format = ZPixmap;
if (format != ZPixmap)
goto bail;
x += drawable->x;
y += drawable->y;
box.x1 = x;
box.y1 = y;
box.x2 = box.x1 + w;
box.y2 = box.y1 + h;
RegionInit(®ion, &box, 1);
RegionIntersect(®ion, ®ion, gc->pCompositeClip);
glamor_get_drawable_deltas(drawable, pixmap, &off_x, &off_y);
if (off_x || off_y) {
x += off_x;
y += off_y;
RegionTranslate(®ion, off_x, off_y);
}
glamor_make_current(glamor_priv);
glamor_upload_region(pixmap, ®ion, x, y, (uint8_t *) bits, byte_stride);
RegionUninit(®ion);
return TRUE;
bail:
return FALSE;
}
bool
sna_video_clip_helper(ScrnInfoPtr scrn,
struct sna_video *video,
struct sna_video_frame *frame,
xf86CrtcPtr * crtc_ret,
BoxPtr dst,
short src_x, short src_y,
short drw_x, short drw_y,
short src_w, short src_h,
short drw_w, short drw_h,
RegionPtr reg)
{
bool ret;
RegionRec crtc_region_local;
RegionPtr crtc_region = reg;
INT32 x1, x2, y1, y2;
xf86CrtcPtr crtc;
x1 = src_x;
x2 = src_x + src_w;
y1 = src_y;
y2 = src_y + src_h;
dst->x1 = drw_x;
dst->x2 = drw_x + drw_w;
dst->y1 = drw_y;
dst->y2 = drw_y + drw_h;
/*
* For overlay video, compute the relevant CRTC and
* clip video to that
*/
crtc = sna_covering_crtc(scrn, dst, video->desired_crtc);
/* For textured video, we don't actually want to clip at all. */
if (crtc && !video->textured) {
crtc_region_local.extents = crtc->bounds;
crtc_region_local.data = NULL;
crtc_region = &crtc_region_local;
RegionIntersect(crtc_region, crtc_region, reg);
}
*crtc_ret = crtc;
ret = xf86XVClipVideoHelper(dst, &x1, &x2, &y1, &y2,
crtc_region, frame->width, frame->height);
if (crtc_region != reg)
RegionUninit(crtc_region);
frame->top = y1 >> 16;
frame->left = (x1 >> 16) & ~1;
frame->npixels = ALIGN(((x2 + 0xffff) >> 16), 2) - frame->left;
if (is_planar_fourcc(frame->id)) {
frame->top &= ~1;
frame->nlines = ALIGN(((y2 + 0xffff) >> 16), 2) - frame->top;
} else
void
rdpClearToBackground(WindowPtr pWin, int x, int y, int w, int h,
Bool generateExposures)
{
int j;
BoxRec box;
RegionRec reg;
LLOGLN(10, ("in rdpClearToBackground"));
g_pScreen->ClearToBackground = g_rdpScreen.ClearToBackground;
g_pScreen->ClearToBackground(pWin, x, y, w, h, generateExposures);
if (!generateExposures)
{
if (w > 0 && h > 0)
{
box.x1 = x;
box.y1 = y;
box.x2 = box.x1 + w;
box.y2 = box.y1 + h;
}
else
{
box.x1 = pWin->drawable.x;
box.y1 = pWin->drawable.y;
box.x2 = box.x1 + pWin->drawable.width;
box.y2 = box.y1 + pWin->drawable.height;
}
RegionInit(®, &box, 0);
RegionIntersect(®, ®, &pWin->clipList);
if (g_do_dirty_ons)
{
draw_item_add_img_region(&g_screenPriv, ®, GXcopy, RDI_IMGLL);
}
else
{
rdpup_begin_update();
for (j = REGION_NUM_RECTS(®) - 1; j >= 0; j--)
{
box = REGION_RECTS(®)[j];
rdpup_send_area(0, box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
}
rdpup_end_update();
}
RegionUninit(®);
}
g_pScreen->ClearToBackground = rdpClearToBackground;
}
Bool
xf86InitFBManager(ScreenPtr pScreen, BoxPtr FullBox)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
RegionRec ScreenRegion;
RegionRec FullRegion;
BoxRec ScreenBox;
Bool ret;
ScreenBox.x1 = 0;
ScreenBox.y1 = 0;
ScreenBox.x2 = pScrn->virtualX;
ScreenBox.y2 = pScrn->virtualY;
if ((FullBox->x1 > ScreenBox.x1) || (FullBox->y1 > ScreenBox.y1) ||
(FullBox->x2 < ScreenBox.x2) || (FullBox->y2 < ScreenBox.y2)) {
return FALSE;
}
if (FullBox->y2 < FullBox->y1)
return FALSE;
if (FullBox->x2 < FullBox->x1)
return FALSE;
RegionInit(&ScreenRegion, &ScreenBox, 1);
RegionInit(&FullRegion, FullBox, 1);
RegionSubtract(&FullRegion, &FullRegion, &ScreenRegion);
ret = xf86InitFBManagerRegion(pScreen, &FullRegion);
RegionUninit(&ScreenRegion);
RegionUninit(&FullRegion);
return ret;
}
static Bool
xf86RotateRedisplay(ScreenPtr pScreen)
{
ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
DamagePtr damage = xf86_config->rotation_damage;
RegionPtr region;
if (!damage)
return FALSE;
xf86RotatePrepare(pScreen);
region = DamageRegion(damage);
if (RegionNotEmpty(region)) {
int c;
SourceValidateProcPtr SourceValidate;
/*
* SourceValidate is used by the software cursor code
* to pull the cursor off of the screen when reading
* bits from the frame buffer. Bypassing this function
* leaves the software cursor in place
*/
SourceValidate = pScreen->SourceValidate;
pScreen->SourceValidate = NULL;
for (c = 0; c < xf86_config->num_crtc; c++) {
xf86CrtcPtr crtc = xf86_config->crtc[c];
if (crtc->transform_in_use && crtc->enabled) {
RegionRec crtc_damage;
/* compute portion of damage that overlaps crtc */
RegionInit(&crtc_damage, &crtc->bounds, 1);
RegionIntersect(&crtc_damage, &crtc_damage, region);
/* update damaged region */
if (RegionNotEmpty(&crtc_damage))
xf86RotateCrtcRedisplay(crtc, &crtc_damage);
RegionUninit(&crtc_damage);
}
}
pScreen->SourceValidate = SourceValidate;
DamageEmpty(damage);
}
return TRUE;
}
/**
* find if the remote window denoted by a_remote
* is paired with an internal Window within the Xephyr server.
* If the remove window is paired with an internal window, send an
* expose event to the client insterested in the internal window expose event.
*
* Pairing happens when a drawable inside Xephyr is associated with
* a GL surface in a DRI environment.
* Look at the function ProcXF86DRICreateDrawable in ephyrdriext.c to
* know a paired window is created.
*
* This is useful to make GL drawables (only windows for now) handle
* expose events and send those events to clients.
*/
static void
ephyrExposePairedWindow(int a_remote)
{
EphyrWindowPair *pair = NULL;
RegionRec reg;
ScreenPtr screen;
if (!findWindowPairFromRemote(a_remote, &pair)) {
EPHYR_LOG("did not find a pair for this window\n");
return;
}
screen = pair->local->drawable.pScreen;
RegionNull(®);
RegionCopy(®, &pair->local->clipList);
screen->WindowExposures(pair->local, ®);
RegionUninit(®);
}
static Bool
shadowCloseScreen(ScreenPtr pScreen)
{
shadowBuf(pScreen);
unwrap(pBuf, pScreen, GetImage);
unwrap(pBuf, pScreen, CloseScreen);
shadowRemove(pScreen, pBuf->pPixmap);
DamageDestroy(pBuf->pDamage);
#ifdef BACKWARDS_COMPATIBILITY
RegionUninit(&pBuf->damage); /* bc */
#endif
if (pBuf->pPixmap)
pScreen->DestroyPixmap(pBuf->pPixmap);
free(pBuf);
return pScreen->CloseScreen(pScreen);
}
Bool
glamor_solid_boxes(PixmapPtr pixmap,
BoxPtr box, int nbox, unsigned long fg_pixel)
{
glamor_pixmap_private *pixmap_priv;
GLfloat color[4];
pixmap_priv = glamor_get_pixmap_private(pixmap);
if (!GLAMOR_PIXMAP_PRIV_HAS_FBO(pixmap_priv))
return FALSE;
glamor_get_rgba_from_pixel(fg_pixel,
&color[0],
&color[1],
&color[2], &color[3], format_for_pixmap(pixmap));
if (pixmap_priv->type == GLAMOR_TEXTURE_LARGE) {
RegionRec region;
int n_region;
glamor_pixmap_clipped_regions *clipped_regions;
int i;
RegionInitBoxes(®ion, box, nbox);
clipped_regions =
glamor_compute_clipped_regions(pixmap_priv, ®ion, &n_region, 0,
0, 0);
for (i = 0; i < n_region; i++) {
BoxPtr inner_box;
int inner_nbox;
SET_PIXMAP_FBO_CURRENT(pixmap_priv, clipped_regions[i].block_idx);
inner_box = RegionRects(clipped_regions[i].region);
inner_nbox = RegionNumRects(clipped_regions[i].region);
_glamor_solid_boxes(pixmap, inner_box, inner_nbox, color);
RegionDestroy(clipped_regions[i].region);
}
free(clipped_regions);
RegionUninit(®ion);
}
else
_glamor_solid_boxes(pixmap, box, nbox, color);
return TRUE;
}
static Bool
localPurgeUnlockedOffscreenAreas(ScreenPtr pScreen)
{
FBManagerPtr offman;
FBLinkPtr pLink, tmp, pPrev = NULL;
RegionRec FreedRegion;
Bool anyUsed = FALSE;
offman = (FBManagerPtr) dixLookupPrivate(&pScreen->devPrivates,
xf86FBScreenKey);
pLink = offman->UsedAreas;
if (!pLink)
return TRUE;
while (pLink) {
if (pLink->area.RemoveAreaCallback) {
(*pLink->area.RemoveAreaCallback) (&pLink->area);
RegionInit(&FreedRegion, &(pLink->area.box), 1);
RegionAppend(offman->FreeBoxes, &FreedRegion);
RegionUninit(&FreedRegion);
if (pPrev)
pPrev->next = pLink->next;
else
offman->UsedAreas = pLink->next;
tmp = pLink;
pLink = pLink->next;
free(tmp);
offman->NumUsedAreas--;
anyUsed = TRUE;
}
else {
pPrev = pLink;
pLink = pLink->next;
}
}
if (anyUsed) {
RegionValidate(offman->FreeBoxes, &anyUsed);
SendCallFreeBoxCallbacks(offman);
}
return TRUE;
}
void
exaCopyWindow(WindowPtr pWin, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
{
RegionRec rgnDst;
int dx, dy;
PixmapPtr pPixmap = (*pWin->drawable.pScreen->GetWindowPixmap) (pWin);
ExaScreenPriv(pWin->drawable.pScreen);
dx = ptOldOrg.x - pWin->drawable.x;
dy = ptOldOrg.y - pWin->drawable.y;
RegionTranslate(prgnSrc, -dx, -dy);
RegionInit(&rgnDst, NullBox, 0);
RegionIntersect(&rgnDst, &pWin->borderClip, prgnSrc);
#ifdef COMPOSITE
if (pPixmap->screen_x || pPixmap->screen_y)
RegionTranslate(&rgnDst,
-pPixmap->screen_x, -pPixmap->screen_y);
#endif
if (pExaScr->fallback_counter) {
pExaScr->fallback_flags |= EXA_FALLBACK_COPYWINDOW;
goto fallback;
}
pExaScr->fallback_flags |= EXA_ACCEL_COPYWINDOW;
miCopyRegion (&pPixmap->drawable, &pPixmap->drawable,
NULL,
&rgnDst, dx, dy, exaCopyNtoN, 0, NULL);
pExaScr->fallback_flags &= ~EXA_ACCEL_COPYWINDOW;
fallback:
RegionUninit(&rgnDst);
if (pExaScr->fallback_flags & EXA_FALLBACK_COPYWINDOW) {
pExaScr->fallback_flags &= ~EXA_FALLBACK_COPYWINDOW;
RegionTranslate(prgnSrc, dx, dy);
ExaCheckCopyWindow(pWin, ptOldOrg, prgnSrc);
}
}
void
rdpClearToBackground(WindowPtr pWin, int x, int y, int w, int h,
Bool generateExposures)
{
int j;
BoxRec box;
RegionRec reg;
DEBUG_OUT_OPS(("in rdpClearToBackground\n"));
g_pScreen->ClearToBackground = g_rdpScreen.ClearToBackground;
g_pScreen->ClearToBackground(pWin, x, y, w, h, generateExposures);
if (!generateExposures)
{
if (w > 0 && h > 0)
{
box.x1 = x;
box.y1 = y;
box.x2 = box.x1 + w;
box.y2 = box.y1 + h;
}
else
{
box.x1 = pWin->drawable.x;
box.y1 = pWin->drawable.y;
box.x2 = box.x1 + pWin->drawable.width;
box.y2 = box.y1 + pWin->drawable.height;
}
RegionInit(®, &box, 0);
RegionIntersect(®, ®, &pWin->clipList);
rdpup_begin_update();
for (j = REGION_NUM_RECTS(®) - 1; j >= 0; j--)
{
box = REGION_RECTS(®)[j];
rdpup_send_area(0, box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1);
}
rdpup_end_update();
RegionUninit(®);
}
g_pScreen->ClearToBackground = rdpClearToBackground;
}
void
ephyrPutColors(ScreenPtr pScreen, int n, xColorItem * pdefs)
{
KdScreenPriv(pScreen);
KdScreenInfo *screen = pScreenPriv->screen;
EphyrScrPriv *scrpriv = screen->driver;
int min, max, p;
/* XXX Not sure if this is right */
min = 256;
max = 0;
while (n--) {
p = pdefs->pixel;
if (p < min)
min = p;
if (p > max)
max = p;
hostx_set_cmap_entry(pScreen, p,
pdefs->red >> 8,
pdefs->green >> 8, pdefs->blue >> 8);
pdefs++;
}
if (scrpriv->pDamage) {
BoxRec box;
RegionRec region;
box.x1 = 0;
box.y1 = 0;
box.x2 = pScreen->width;
box.y2 = pScreen->height;
RegionInit(®ion, &box, 1);
DamageReportDamage(scrpriv->pDamage, ®ion);
RegionUninit(®ion);
}
}
static void
ExaSrcValidate(DrawablePtr pDrawable,
int x, int y, int width, int height, unsigned int subWindowMode)
{
ScreenPtr pScreen = pDrawable->pScreen;
ExaScreenPriv(pScreen);
PixmapPtr pPix = exaGetDrawablePixmap(pDrawable);
BoxRec box;
RegionRec reg;
RegionPtr dst;
int xoff, yoff;
if (pExaScr->srcPix == pPix)
dst = &pExaScr->srcReg;
else if (pExaScr->maskPix == pPix)
dst = &pExaScr->maskReg;
else
return;
exaGetDrawableDeltas(pDrawable, pPix, &xoff, &yoff);
box.x1 = x + xoff;
box.y1 = y + yoff;
box.x2 = box.x1 + width;
box.y2 = box.y1 + height;
RegionInit(®, &box, 1);
RegionUnion(dst, dst, ®);
RegionUninit(®);
if (pExaScr->SavedSourceValidate) {
swap(pExaScr, pScreen, SourceValidate);
pScreen->SourceValidate(pDrawable, x, y, width, height, subWindowMode);
swap(pExaScr, pScreen, SourceValidate);
}
}
