andreacavalli
/
xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

exa: s/PixmapIsOffscreen/PixmapHasGpuCopy and s/pExaPixmap->offscreen/pExaPixmap->use_gpu_copy 

- Fixup some variable names as well.

Signed-off-by: Maarten Maathuis <madman2003@gmail.com>
Acked-by: Michel Dänzer <michel@daenzer.net>
Signed-off-by: Keith Packard <keithp@keithp.com>
This commit is contained in:
Maarten Maathuis 2009-11-28 10:34:44 +01:00 committed by Keith Packard
parent 342f3689d1
commit a54c23fe64
12 changed files with 96 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
exa/exa.c
View File

@ -233,19 +233,19 @@ exaPixmapIsPinned (PixmapPtr pPix)
}
/**
* exaPixmapIsOffscreen() is used to determine if a pixmap is in offscreen
* exaPixmapHasGpuCopy() is used to determine if a pixmap is in offscreen
* memory, meaning that acceleration could probably be done to it, and that it
* will need to be wrapped by PrepareAccess()/FinishAccess() when accessing it
* with the CPU.
*
* Note that except for UploadToScreen()/DownloadFromScreen() (which explicitly
* deal with moving pixmaps in and out of system memory), EXA will give drivers
* pixmaps as arguments for which exaPixmapIsOffscreen() is TRUE.
* pixmaps as arguments for which exaPixmapHasGpuCopy() is TRUE.
*
* @return TRUE if the given drawable is in framebuffer memory.
*/
Bool
exaPixmapIsOffscreen(PixmapPtr pPixmap)
exaPixmapHasGpuCopy(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);
@ -253,16 +253,16 @@ exaPixmapIsOffscreen(PixmapPtr pPixmap)
if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
return FALSE;
return (*pExaScr->pixmap_is_offscreen)(pPixmap);
return (*pExaScr->pixmap_has_gpu_copy)(pPixmap);
}
/**
* exaDrawableIsOffscreen() is a convenience wrapper for exaPixmapIsOffscreen().
* exaDrawableIsOffscreen() is a convenience wrapper for exaPixmapHasGpuCopy().
*/
Bool
exaDrawableIsOffscreen (DrawablePtr pDrawable)
{
return exaPixmapIsOffscreen (exaGetDrawablePixmap (pDrawable));
return exaPixmapHasGpuCopy (exaGetDrawablePixmap (pDrawable));
}
/**
@ -276,7 +276,7 @@ exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp)
exaGetDrawableDeltas (pDrawable, pPixmap, xp, yp);
if (exaPixmapIsOffscreen (pPixmap))
if (exaPixmapHasGpuCopy (pPixmap))
return pPixmap;
else
return NULL;
@ -291,7 +291,7 @@ ExaDoPrepareAccess(PixmapPtr pPixmap, int index)
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv (pScreen);
ExaPixmapPriv(pPixmap);
Bool offscreen;
Bool has_gpu_copy;
int i;
if (!(pExaScr->info->flags & EXA_OFFSCREEN_PIXMAPS))
@ -321,9 +321,9 @@ ExaDoPrepareAccess(PixmapPtr pPixmap, int index)
pPixmap->devPrivate.ptr));
}
offscreen = exaPixmapIsOffscreen(pPixmap);
has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
if (offscreen && pExaPixmap->fb_ptr)
if (has_gpu_copy && pExaPixmap->fb_ptr)
pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
else
pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
@ -332,7 +332,7 @@ ExaDoPrepareAccess(PixmapPtr pPixmap, int index)
pExaScr->access[index].pixmap = pPixmap;
pExaScr->access[index].count = 1;
if (!offscreen)
if (!has_gpu_copy)
return FALSE;
exaWaitSync (pScreen);
@ -420,7 +420,7 @@ exaFinishAccess(DrawablePtr pDrawable, int index)
if (pExaScr->finish_access)
pExaScr->finish_access(pPixmap, index);
if (!pExaScr->info->FinishAccess || !exaPixmapIsOffscreen(pPixmap))
if (!pExaScr->info->FinishAccess || !exaPixmapHasGpuCopy(pPixmap))
return;
if (i >= EXA_PREPARE_AUX_DEST &&
@ -969,7 +969,7 @@ exaDriverInit (ScreenPtr pScreen,
wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_mixed);
wrap(pExaScr, pScreen, ModifyPixmapHeader, exaModifyPixmapHeader_mixed);
pExaScr->do_migration = exaDoMigration_mixed;
pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_mixed;
pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_mixed;
pExaScr->do_move_in_pixmap = exaMoveInPixmap_mixed;
pExaScr->do_move_out_pixmap = NULL;
pExaScr->prepare_access_reg = exaPrepareAccessReg_mixed;
@ -979,7 +979,7 @@ exaDriverInit (ScreenPtr pScreen,
wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_driver);
wrap(pExaScr, pScreen, ModifyPixmapHeader, exaModifyPixmapHeader_driver);
pExaScr->do_migration = NULL;
pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_driver;
pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_driver;
pExaScr->do_move_in_pixmap = NULL;
pExaScr->do_move_out_pixmap = NULL;
pExaScr->prepare_access_reg = NULL;
@ -990,7 +990,7 @@ exaDriverInit (ScreenPtr pScreen,
wrap(pExaScr, pScreen, DestroyPixmap, exaDestroyPixmap_classic);
wrap(pExaScr, pScreen, ModifyPixmapHeader, exaModifyPixmapHeader_classic);
pExaScr->do_migration = exaDoMigration_classic;
pExaScr->pixmap_is_offscreen = exaPixmapIsOffscreen_classic;
pExaScr->pixmap_has_gpu_copy = exaPixmapHasGpuCopy_classic;
pExaScr->do_move_in_pixmap = exaMoveInPixmap_classic;
pExaScr->do_move_out_pixmap = exaMoveOutPixmap_classic;
pExaScr->prepare_access_reg = exaPrepareAccessReg_classic;

6
exa/exa.h
View File

@ -624,13 +624,13 @@ typedef struct _ExaDriver {
/**
* PixmapIsOffscreen() is an optional driver replacement to
* exaPixmapIsOffscreen(). Set to NULL if you want the standard behaviour
* of exaPixmapIsOffscreen().
* exaPixmapHasGpuCopy(). Set to NULL if you want the standard behaviour
* of exaPixmapHasGpuCopy().
*
* @param pPix the pixmap
* @return TRUE if the given drawable is in framebuffer memory.
*
* exaPixmapIsOffscreen() is used to determine if a pixmap is in offscreen
* exaPixmapHasGpuCopy() is used to determine if a pixmap is in offscreen
* memory, meaning that acceleration could probably be done to it, and that it
* will need to be wrapped by PrepareAccess()/FinishAccess() when accessing it
* with the CPU.

10
exa/exa_accel.c
View File

@ -482,9 +482,9 @@ exaHWCopyNtoN (DrawablePtr pSrcDrawable,
goto fallback;
}
if (exaPixmapIsOffscreen(pDstPixmap)) {
if (exaPixmapHasGpuCopy(pDstPixmap)) {
/* Normal blitting. */
if (exaPixmapIsOffscreen(pSrcPixmap)) {
if (exaPixmapHasGpuCopy(pSrcPixmap)) {
if (!(*pExaScr->info->PrepareCopy) (pSrcPixmap, pDstPixmap, reverse ? -1 : 1,
upsidedown ? -1 : 1,
pGC ? pGC->alu : GXcopy,
@ -840,7 +840,7 @@ exaPolyFillRect(DrawablePtr pDrawable,
exaDoMigration (pixmaps, 1, TRUE);
}
if (!exaPixmapIsOffscreen (pPixmap) ||
if (!exaPixmapHasGpuCopy (pPixmap) ||
!(*pExaScr->info->PrepareSolid) (pPixmap,
pGC->alu,
pGC->planemask,
@ -1022,7 +1022,7 @@ exaFillRegionSolid (DrawablePtr pDrawable, RegionPtr pRegion, Pixel pixel,
exaDoMigration (pixmaps, 1, TRUE);
}
if (exaPixmapIsOffscreen (pPixmap) &&
if (exaPixmapHasGpuCopy (pPixmap) &&
(*pExaScr->info->PrepareSolid) (pPixmap, alu, planemask, pixel))
{
int nbox;
@ -1125,7 +1125,7 @@ exaFillRegionTiled (DrawablePtr pDrawable, RegionPtr pRegion, PixmapPtr pTile,
pPixmap = exaGetOffscreenPixmap (pDrawable, &xoff, &yoff);
if (!pPixmap || !exaPixmapIsOffscreen(pTile))
if (!pPixmap || !exaPixmapHasGpuCopy(pTile))
return FALSE;
if ((*pExaScr->info->PrepareCopy) (pTile, pPixmap, 1, 1, alu, planemask))

14
exa/exa_classic.c
View File

@ -38,7 +38,7 @@ ExaGetPixmapAddress(PixmapPtr p)
{
ExaPixmapPriv(p);
if (pExaPixmap->offscreen && pExaPixmap->fb_ptr)
if (pExaPixmap->use_gpu_copy && pExaPixmap->fb_ptr)
return pExaPixmap->fb_ptr;
else
return pExaPixmap->sys_ptr;
@ -90,7 +90,7 @@ exaCreatePixmap_classic(ScreenPtr pScreen, int w, int h, int depth,
pExaPixmap->sys_pitch = pPixmap->devKind;
pPixmap->devPrivate.ptr = NULL;
pExaPixmap->offscreen = FALSE;
pExaPixmap->use_gpu_copy = FALSE;
pExaPixmap->fb_ptr = NULL;
exaSetFbPitch(pExaScr, pExaPixmap, w, h, bpp);
@ -168,7 +168,7 @@ exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int dept
/* Classic EXA:
* - Framebuffer.
* - Scratch pixmap with offscreen memory.
* - Scratch pixmap with gpu memory.
*/
if (pExaScr->info->memoryBase && pPixData) {
if ((CARD8 *)pPixData >= pExaScr->info->memoryBase &&
@ -176,7 +176,7 @@ exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int dept
pExaScr->info->memorySize) {
pExaPixmap->fb_ptr = pPixData;
pExaPixmap->fb_pitch = devKind;
pExaPixmap->offscreen = TRUE;
pExaPixmap->use_gpu_copy = TRUE;
}
}
@ -189,7 +189,7 @@ exaModifyPixmapHeader_classic(PixmapPtr pPixmap, int width, int height, int dept
}
/* Pixmaps subject to ModifyPixmapHeader will be pinned to system or
* offscreen memory, so there's no need to track damage.
* gpu memory, so there's no need to track damage.
*/
if (pExaPixmap->pDamage) {
DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
@ -248,7 +248,7 @@ exaDestroyPixmap_classic (PixmapPtr pPixmap)
}
Bool
exaPixmapIsOffscreen_classic(PixmapPtr pPixmap)
exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);
@ -260,7 +260,7 @@ exaPixmapIsOffscreen_classic(PixmapPtr pPixmap)
ret = pExaScr->info->PixmapIsOffscreen(pPixmap);
pPixmap->devPrivate.ptr = NULL;
} else
ret = (pExaPixmap->offscreen && pExaPixmap->fb_ptr);
ret = (pExaPixmap->use_gpu_copy && pExaPixmap->fb_ptr);
return ret;
}

11
exa/exa_driver.c
View File

@ -71,8 +71,8 @@ exaCreatePixmap_driver(ScreenPtr pScreen, int w, int h, int depth,
bpp = pPixmap->drawable.bitsPerPixel;
/* Set this before driver hooks, to allow for !offscreen pixmaps.
* !offscreen pixmaps have a valid pointer at all times.
/* Set this before driver hooks, to allow for driver pixmaps without gpu
* memory to back it. These pixmaps have a valid pointer at all times.
*/
pPixmap->devPrivate.ptr = NULL;
@ -157,8 +157,9 @@ exaModifyPixmapHeader_driver(PixmapPtr pPixmap, int width, int height, int depth
ret = pExaScr->info->ModifyPixmapHeader(pPixmap, width, height, depth,
bitsPerPixel, devKind, pPixData);
/* For EXA_HANDLES_PIXMAPS, we set pPixData to NULL.
* If pPixmap->devPrivate.ptr is non-NULL, then we've got a non-offscreen pixmap.
* We need to store the pointer, because PrepareAccess won't be called.
* If pPixmap->devPrivate.ptr is non-NULL, then we've got a
* !has_gpu_copy pixmap. We need to store the pointer,
* because PrepareAccess won't be called.
*/
if (!pPixData && pPixmap->devPrivate.ptr && pPixmap->devKind) {
pExaPixmap->sys_ptr = pPixmap->devPrivate.ptr;
@ -208,7 +209,7 @@ exaDestroyPixmap_driver (PixmapPtr pPixmap)
}
Bool
exaPixmapIsOffscreen_driver(PixmapPtr pPixmap)
exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);

12
exa/exa_glyphs.c
View File

@ -347,11 +347,11 @@ exaGlyphCacheHashRemove(ExaGlyphCachePtr cache,
/* The most efficient thing to way to upload the glyph to the screen
* is to use the UploadToScreen() driver hook; this allows us to
* pipeline glyph uploads and to avoid creating offscreen pixmaps for
* pipeline glyph uploads and to avoid creating gpu backed pixmaps for
* glyphs that we'll never use again.
*
* If we can't do it with UploadToScreen (because the glyph is offscreen, etc),
* we fall back to CompositePicture.
* If we can't do it with UploadToScreen (because the glyph has a gpu copy,
* etc), we fall back to CompositePicture.
*
* We need to damage the cache pixmap manually in either case because the damage
* layer unwrapped the picture screen before calling exaGlyphs.
@ -374,7 +374,7 @@ exaGlyphCacheUploadGlyph(ScreenPtr pScreen,
/* If the glyph pixmap is already uploaded, no point in doing
* things this way */
if (exaPixmapIsOffscreen(pGlyphPixmap))
if (exaPixmapHasGpuCopy(pGlyphPixmap))
goto composite;
/* UploadToScreen only works if bpp match */
@ -384,7 +384,7 @@ exaGlyphCacheUploadGlyph(ScreenPtr pScreen,
if (pExaScr->do_migration) {
ExaMigrationRec pixmaps[1];
/* cache pixmap must be offscreen. */
/* cache pixmap must have a gpu copy. */
pixmaps[0].as_dst = TRUE;
pixmaps[0].as_src = FALSE;
pixmaps[0].pPix = pCachePixmap;
@ -392,7 +392,7 @@ exaGlyphCacheUploadGlyph(ScreenPtr pScreen,
exaDoMigration (pixmaps, 1, TRUE);
}
if (!exaPixmapIsOffscreen(pCachePixmap))
if (!exaPixmapHasGpuCopy(pCachePixmap))
goto composite;
/* x,y are in pixmap coordinates, no need for cache{X,Y}off */

40
exa/exa_migration_classic.c
View File

@ -111,7 +111,7 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
ExaPixmapPriv (pPixmap);
RegionPtr damage = DamageRegion (pExaPixmap->pDamage);
RegionRec CopyReg;
Bool save_offscreen;
Bool save_use_gpu_copy;
int save_pitch;
BoxPtr pBox;
int nbox;
@ -119,7 +119,7 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
Bool need_sync = FALSE;
/* Damaged bits are valid in current copy but invalid in other one */
if (pExaPixmap->offscreen) {
if (pExaPixmap->use_gpu_copy) {
REGION_UNION(pScreen, &pExaPixmap->validFB, &pExaPixmap->validFB,
damage);
REGION_SUBTRACT(pScreen, &pExaPixmap->validSys, &pExaPixmap->validSys,
@ -200,9 +200,9 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
pBox = REGION_RECTS(&CopyReg);
nbox = REGION_NUM_RECTS(&CopyReg);
save_offscreen = pExaPixmap->offscreen;
save_use_gpu_copy = pExaPixmap->use_gpu_copy;
save_pitch = pPixmap->devKind;
pExaPixmap->offscreen = TRUE;
pExaPixmap->use_gpu_copy = TRUE;
pPixmap->devKind = pExaPixmap->fb_pitch;
while (nbox--) {
@ -242,7 +242,7 @@ exaCopyDirty(ExaMigrationPtr migrate, RegionPtr pValidDst, RegionPtr pValidSrc,
pBox++;
}
pExaPixmap->offscreen = save_offscreen;
pExaPixmap->use_gpu_copy = save_use_gpu_copy;
pPixmap->devKind = save_pitch;
/* Try to prevent source valid region from growing too many rects by
@ -351,7 +351,7 @@ exaDoMoveInPixmap (ExaMigrationPtr migrate)
exaCopyDirtyToFb (migrate);
if (exaPixmapIsOffscreen(pPixmap))
if (exaPixmapHasGpuCopy(pPixmap))
return;
DBG_MIGRATE (("-> %p (0x%x) (%dx%d) (%c)\n", pPixmap,
@ -361,7 +361,7 @@ exaDoMoveInPixmap (ExaMigrationPtr migrate)
pPixmap->drawable.height,
exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));
pExaPixmap->offscreen = TRUE;
pExaPixmap->use_gpu_copy = TRUE;
pPixmap->devKind = pExaPixmap->fb_pitch;
pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
@ -392,7 +392,7 @@ exaDoMoveOutPixmap (ExaMigrationPtr migrate)
exaCopyDirtyToSys (migrate);
if (exaPixmapIsOffscreen(pPixmap)) {
if (exaPixmapHasGpuCopy(pPixmap)) {
DBG_MIGRATE (("<- %p (%p) (%dx%d) (%c)\n", pPixmap,
(void*)(ExaGetPixmapPriv(pPixmap)->area ?
@ -401,7 +401,7 @@ exaDoMoveOutPixmap (ExaMigrationPtr migrate)
pPixmap->drawable.height,
exaPixmapIsDirty(pPixmap) ? 'd' : 'c'));
pExaPixmap->offscreen = FALSE;
pExaPixmap->use_gpu_copy = FALSE;
pPixmap->devKind = pExaPixmap->sys_pitch;
pPixmap->drawable.serialNumber = NEXT_SERIAL_NUMBER;
@ -468,12 +468,12 @@ exaMigrateTowardFb (ExaMigrationPtr migrate)
pExaPixmap->score++;
if (pExaPixmap->score >= EXA_PIXMAP_SCORE_MOVE_IN &&
!exaPixmapIsOffscreen(pPixmap))
!exaPixmapHasGpuCopy(pPixmap))
{
exaDoMoveInPixmap(migrate);
}
if (exaPixmapIsOffscreen(pPixmap)) {
if (exaPixmapHasGpuCopy(pPixmap)) {
exaCopyDirtyToFb (migrate);
ExaOffscreenMarkUsed (pPixmap);
} else
@ -504,7 +504,7 @@ exaMigrateTowardSys (ExaMigrationPtr migrate)
if (pExaPixmap->score <= EXA_PIXMAP_SCORE_MOVE_OUT && pExaPixmap->area)
exaDoMoveOutPixmap(migrate);
if (exaPixmapIsOffscreen(pPixmap)) {
if (exaPixmapHasGpuCopy(pPixmap)) {
exaCopyDirtyToFb (migrate);
ExaOffscreenMarkUsed (pPixmap);
} else
@ -523,7 +523,7 @@ exaAssertNotDirty (PixmapPtr pPixmap)
RegionRec ValidReg;
int dst_pitch, src_pitch, cpp, y, nbox, save_pitch;
BoxPtr pBox;
Bool ret = TRUE, save_offscreen;
Bool ret = TRUE, save_use_gpu_copy;
if (exaPixmapIsPinned(pPixmap) || pExaPixmap->area == NULL)
return ret;
@ -542,9 +542,9 @@ exaAssertNotDirty (PixmapPtr pPixmap)
src_pitch = pExaPixmap->fb_pitch;
cpp = pPixmap->drawable.bitsPerPixel / 8;
save_offscreen = pExaPixmap->offscreen;
save_use_gpu_copy = pExaPixmap->use_gpu_copy;
save_pitch = pPixmap->devKind;
pExaPixmap->offscreen = TRUE;
pExaPixmap->use_gpu_copy = TRUE;
pPixmap->devKind = pExaPixmap->fb_pitch;
if (!ExaDoPrepareAccess(pPixmap, EXA_PREPARE_SRC))
@ -579,7 +579,7 @@ exaAssertNotDirty (PixmapPtr pPixmap)
skip:
exaFinishAccess(&pPixmap->drawable, EXA_PREPARE_SRC);
pExaPixmap->offscreen = save_offscreen;
pExaPixmap->use_gpu_copy = save_use_gpu_copy;
pPixmap->devKind = save_pitch;
out:
@ -618,7 +618,7 @@ exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
*/
for (i = 0; i < npixmaps; i++) {
if (exaPixmapIsPinned (pixmaps[i].pPix) &&
!exaPixmapIsOffscreen (pixmaps[i].pPix))
!exaPixmapHasGpuCopy (pixmaps[i].pPix))
{
EXA_FALLBACK(("Pixmap %p (%dx%d) pinned in sys\n", pixmaps[i].pPix,
pixmaps[i].pPix->drawable.width,
@ -680,7 +680,7 @@ exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
}
for (i = 0; i < npixmaps; i++) {
if (exaPixmapIsOffscreen(pixmaps[i].pPix)) {
if (exaPixmapHasGpuCopy(pixmaps[i].pPix)) {
/* Found one in FB, so move all to FB. */
for (j = 0; j < npixmaps; j++)
exaMigrateTowardFb(pixmaps + i);
@ -709,12 +709,12 @@ exaDoMigration_classic (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
/* If we couldn't fit everything in, abort */
for (i = 0; i < npixmaps; i++) {
if (!exaPixmapIsOffscreen(pixmaps[i].pPix)) {
if (!exaPixmapHasGpuCopy(pixmaps[i].pPix)) {
return;
}
}
/* Yay, everything's offscreen, mark memory as used */
/* Yay, everything has a gpu copy, mark memory as used */
for (i = 0; i < npixmaps; i++) {
ExaOffscreenMarkUsed (pixmaps[i].pPix);
}

21
exa/exa_migration_mixed.c
View File

@ -80,7 +80,7 @@ exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
*/
for (i = 0; i < npixmaps; i++) {
if (exaPixmapIsPinned (pixmaps[i].pPix) &&
!exaPixmapIsOffscreen (pixmaps[i].pPix))
!exaPixmapHasGpuCopy (pixmaps[i].pPix))
{
can_accel = FALSE;
break;
@ -98,7 +98,7 @@ exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
if (!pExaPixmap->driverPriv)
exaCreateDriverPixmap_mixed(pPixmap);
if (pExaPixmap->pDamage && exaPixmapIsOffscreen(pPixmap)) {
if (pExaPixmap->pDamage && exaPixmapHasGpuCopy(pPixmap)) {
ExaScreenPriv(pPixmap->drawable.pScreen);
pPixmap->devKind = pExaPixmap->fb_pitch;
@ -108,7 +108,7 @@ exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
pExaScr->deferred_mixed_pixmap = NULL;
}
pExaPixmap->offscreen = exaPixmapIsOffscreen(pPixmap);
pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
}
}
@ -135,7 +135,7 @@ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
{
if (!ExaDoPrepareAccess(pPixmap, index)) {
ExaPixmapPriv(pPixmap);
Bool is_offscreen = exaPixmapIsOffscreen(pPixmap);
Bool has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
ExaMigrationRec pixmaps[1];
/* Do we need to allocate our system buffer? */
@ -157,7 +157,8 @@ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
pixmaps[0].pPix = pPixmap;
pixmaps[0].pReg = pReg;
if (!pExaPixmap->pDamage && (is_offscreen || !exaPixmapIsPinned(pPixmap))) {
if (!pExaPixmap->pDamage &&
(has_gpu_copy || !exaPixmapIsPinned(pPixmap))) {
Bool as_dst = pixmaps[0].as_dst;
/* Set up damage tracking */
@ -170,7 +171,7 @@ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
/* This is used by exa to optimize migration. */
DamageSetReportAfterOp(pExaPixmap->pDamage, TRUE);
if (is_offscreen) {
if (has_gpu_copy) {
exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
pPixmap->drawable.height);
@ -189,14 +190,14 @@ exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
if (as_dst)
exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
pPixmap->drawable.height);
} else if (is_offscreen) {
} else if (has_gpu_copy) {
pPixmap->devKind = pExaPixmap->fb_pitch;
exaCopyDirtyToSys(pixmaps);
}
pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
pPixmap->devKind = pExaPixmap->sys_pitch;
pExaPixmap->offscreen = FALSE;
pExaPixmap->use_gpu_copy = FALSE;
}
}
@ -210,8 +211,8 @@ void exaFinishAccess_mixed(PixmapPtr pPixmap, int index)
{
ExaPixmapPriv(pPixmap);
if (pExaPixmap->pDamage && !pExaPixmap->offscreen &&
exaPixmapIsOffscreen(pPixmap)){
if (pExaPixmap->pDamage && !pExaPixmap->use_gpu_copy &&
exaPixmapHasGpuCopy(pPixmap)) {
DamageRegionProcessPending(&pPixmap->drawable);
if (index == EXA_PREPARE_DEST || index == EXA_PREPARE_AUX_DEST) {

16
exa/exa_mixed.c
View File

@ -93,9 +93,9 @@ exaCreatePixmap_mixed(ScreenPtr pScreen, int w, int h, int depth,
/* A scratch pixmap will become a driver pixmap right away. */
if (!w || !h) {
exaCreateDriverPixmap_mixed(pPixmap);
pExaPixmap->offscreen = exaPixmapIsOffscreen(pPixmap);
pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
} else
pExaPixmap->offscreen = FALSE;
pExaPixmap->use_gpu_copy = FALSE;
/* During a fallback we must prepare access. */
if (pExaScr->fallback_counter)
@ -111,7 +111,7 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPrivPtr pExaScr;
ExaPixmapPrivPtr pExaPixmap;
Bool ret, is_offscreen;
Bool ret, has_gpu_copy;
if (!pPixmap)
return FALSE;
@ -131,7 +131,7 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
pExaPixmap->driverPriv = NULL;
}
pExaPixmap->offscreen = FALSE;
pExaPixmap->use_gpu_copy = FALSE;
pExaPixmap->score = EXA_PIXMAP_SCORE_PINNED;
}
@ -145,8 +145,8 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
}
}
is_offscreen = exaPixmapIsOffscreen(pPixmap);
if (is_offscreen) {
has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
if (has_gpu_copy) {
pPixmap->devPrivate.ptr = pExaPixmap->fb_ptr;
pPixmap->devKind = pExaPixmap->fb_pitch;
} else {
@ -168,7 +168,7 @@ exaModifyPixmapHeader_mixed(PixmapPtr pPixmap, int width, int height, int depth,
swap(pExaScr, pScreen, ModifyPixmapHeader);
out:
if (is_offscreen) {
if (has_gpu_copy) {
pExaPixmap->fb_ptr = pPixmap->devPrivate.ptr;
pExaPixmap->fb_pitch = pPixmap->devKind;
} else {
@ -219,7 +219,7 @@ exaDestroyPixmap_mixed(PixmapPtr pPixmap)
}
Bool
exaPixmapIsOffscreen_mixed(PixmapPtr pPixmap)
exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap)
{
ScreenPtr pScreen = pPixmap->drawable.pScreen;
ExaScreenPriv(pScreen);

12
exa/exa_offscreen.c
View File

@ -522,7 +522,7 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
return NULL;
pExaDstPix = ExaGetPixmapPriv (pDstPix);
pExaDstPix->offscreen = TRUE;
pExaDstPix->use_gpu_copy = TRUE;
for (area = pExaScr->info->offScreenAreas->prev;
area != pExaScr->info->offScreenAreas;
@ -531,7 +531,7 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
ExaOffscreenArea *prev = area->prev;
PixmapPtr pSrcPix;
ExaPixmapPrivPtr pExaSrcPix;
Bool save_offscreen;
Bool save_use_gpu_copy;
int save_pitch;
if (area->state != ExaOffscreenAvail ||
@ -576,10 +576,10 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
continue;
}
save_offscreen = pExaSrcPix->offscreen;
save_use_gpu_copy = pExaSrcPix->use_gpu_copy;
save_pitch = pSrcPix->devKind;
pExaSrcPix->offscreen = TRUE;
pExaSrcPix->use_gpu_copy = TRUE;
pSrcPix->devKind = pExaSrcPix->fb_pitch;
pDstPix->drawable.width = pSrcPix->drawable.width;
@ -589,7 +589,7 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
pDstPix->drawable.bitsPerPixel = pSrcPix->drawable.bitsPerPixel;
if (!pExaScr->info->PrepareCopy (pSrcPix, pDstPix, -1, -1, GXcopy, ~0)) {
pExaSrcPix->offscreen = save_offscreen;
pExaSrcPix->use_gpu_copy = save_use_gpu_copy;
pSrcPix->devKind = save_pitch;
area = prev;
continue;
@ -646,7 +646,7 @@ ExaOffscreenDefragment (ScreenPtr pScreen)
#endif
pExaSrcPix->fb_ptr = pExaDstPix->fb_ptr;
pExaSrcPix->offscreen = save_offscreen;
pExaSrcPix->use_gpu_copy = save_use_gpu_copy;
pSrcPix->devKind = save_pitch;
}

12
exa/exa_priv.h
View File

@ -173,7 +173,7 @@ typedef struct {
AddTrapsProcPtr SavedAddTraps;
#endif
void (*do_migration) (ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel);
Bool (*pixmap_is_offscreen) (PixmapPtr pPixmap);
Bool (*pixmap_has_gpu_copy) (PixmapPtr pPixmap);
void (*do_move_in_pixmap) (PixmapPtr pPixmap);
void (*do_move_out_pixmap) (PixmapPtr pPixmap);
void (*prepare_access_reg)(PixmapPtr pPixmap, int index, RegionPtr pReg);
@ -283,7 +283,7 @@ extern DevPrivateKey exaGCPrivateKey;
typedef struct {
ExaOffscreenArea *area;
int score; /**< score for the move-in vs move-out heuristic */
Bool offscreen;
Bool use_gpu_copy;
CARD8 *sys_ptr; /**< pointer to pixmap data in system memory */
int sys_pitch; /**< pitch of pixmap in system memory */
@ -539,7 +539,7 @@ exaGetDrawableDeltas (DrawablePtr pDrawable, PixmapPtr pPixmap,
int *xp, int *yp);
Bool
exaPixmapIsOffscreen(PixmapPtr p);
exaPixmapHasGpuCopy(PixmapPtr p);
PixmapPtr
exaGetOffscreenPixmap (DrawablePtr pDrawable, int *xp, int *yp);
@ -576,7 +576,7 @@ Bool
exaDestroyPixmap_classic (PixmapPtr pPixmap);
Bool
exaPixmapIsOffscreen_classic(PixmapPtr pPixmap);
exaPixmapHasGpuCopy_classic(PixmapPtr pPixmap);
/* exa_driver.c */
PixmapPtr
@ -591,7 +591,7 @@ Bool
exaDestroyPixmap_driver (PixmapPtr pPixmap);
Bool
exaPixmapIsOffscreen_driver(PixmapPtr pPixmap);
exaPixmapHasGpuCopy_driver(PixmapPtr pPixmap);
/* exa_mixed.c */
PixmapPtr
@ -606,7 +606,7 @@ Bool
exaDestroyPixmap_mixed(PixmapPtr pPixmap);
Bool
exaPixmapIsOffscreen_mixed(PixmapPtr pPixmap);
exaPixmapHasGpuCopy_mixed(PixmapPtr pPixmap);
/* exa_migration_mixed.c */
void

6
exa/exa_render.c
View File

@ -320,7 +320,7 @@ exaTryDriverSolidFill(PicturePtr pSrc,
exaDoMigration(pixmaps, 1, TRUE);
}
if (!exaPixmapIsOffscreen(pDstPix)) {
if (!exaPixmapHasGpuCopy(pDstPix)) {
REGION_UNINIT(pDst->pDrawable->pScreen, &region);
return 0;
}
@ -540,7 +540,7 @@ exaCompositeRects(CARD8 op,
/* We have to manage the damage ourselves, since CompositeRects isn't
* something in the screen that can be managed by the damage extension,
* and EXA depends on damage to track what needs to be migrated between
* offscreen and onscreen.
* the gpu and the cpu.
*/
/* Compute the overall extents of the composited region - we're making
@ -752,7 +752,7 @@ exaTryDriverComposite(CARD8 op,
}
}
if (!exaPixmapIsOffscreen(pDstPix)) {
if (!exaPixmapHasGpuCopy(pDstPix)) {
REGION_UNINIT(pDst->pDrawable->pScreen, &region);
return 0;
}