- Fixup some variable names as well.
Signed-off-by: Maarten Maathuis <[email protected]>
Acked-by: Michel Dänzer <[email protected]>
---
exa/exa.c | 30 +++++++++++++++---------------
exa/exa.h | 6 +++---
exa/exa_accel.c | 10 +++++-----
exa/exa_classic.c | 14 +++++++-------
exa/exa_driver.c | 11 ++++++-----
exa/exa_glyphs.c | 12 ++++++------
exa/exa_migration_classic.c | 40 ++++++++++++++++++++--------------------
exa/exa_migration_mixed.c | 21 +++++++++++----------
exa/exa_mixed.c | 16 ++++++++--------
exa/exa_offscreen.c | 12 ++++++------
exa/exa_priv.h | 12 ++++++------
exa/exa_render.c | 6 +++---
12 files changed, 96 insertions(+), 94 deletions(-)
diff --git a/exa/exa.c b/exa/exa.c
index ed28431..023288c 100644
--- a/exa/exa.c
+++ b/exa/exa.c
@@ -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;
diff --git a/exa/exa.h b/exa/exa.h
index 4b39473..8c93d15 100644
--- a/exa/exa.h
+++ b/exa/exa.h
@@ -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.
diff --git a/exa/exa_accel.c b/exa/exa_accel.c
index 3de7307..1d88acb 100644
--- a/exa/exa_accel.c
+++ b/exa/exa_accel.c
@@ -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))
diff --git a/exa/exa_classic.c b/exa/exa_classic.c
index 12f3987..c31e2d4 100644
--- a/exa/exa_classic.c
+++ b/exa/exa_classic.c
@@ -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;
}
diff --git a/exa/exa_driver.c b/exa/exa_driver.c
index f55c300..dcf1a98 100644
--- a/exa/exa_driver.c
+++ b/exa/exa_driver.c
@@ -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);
diff --git a/exa/exa_glyphs.c b/exa/exa_glyphs.c
index 5a37004..4bc80eb 100644
--- a/exa/exa_glyphs.c
+++ b/exa/exa_glyphs.c
@@ -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 */
diff --git a/exa/exa_migration_classic.c b/exa/exa_migration_classic.c
index 6d7b9f5..95189be 100644
--- a/exa/exa_migration_classic.c
+++ b/exa/exa_migration_classic.c
@@ -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);
}
diff --git a/exa/exa_migration_mixed.c b/exa/exa_migration_mixed.c
index ea6f878..a7fdf63 100644
--- a/exa/exa_migration_mixed.c
+++ b/exa/exa_migration_mixed.c
@@ -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) {
diff --git a/exa/exa_mixed.c b/exa/exa_mixed.c
index bbbf1af..764c7dd 100644
--- a/exa/exa_mixed.c
+++ b/exa/exa_mixed.c
@@ -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);
diff --git a/exa/exa_offscreen.c b/exa/exa_offscreen.c
index eb53b2a..acdf439 100644
--- a/exa/exa_offscreen.c
+++ b/exa/exa_offscreen.c
@@ -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;
}
diff --git a/exa/exa_priv.h b/exa/exa_priv.h
index 5764bb4..69c0d24 100644
--- a/exa/exa_priv.h
+++ b/exa/exa_priv.h
@@ -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
diff --git a/exa/exa_render.c b/exa/exa_render.c
index db355d6..1b68e1c 100644
--- a/exa/exa_render.c
+++ b/exa/exa_render.c
@@ -320,7 +320,7 @@ exaTryDriverSolidFill(PicturePtr pSrc,
exaDoMigration(pixmaps, 1, TRUE);
}
- if (!exaPixmapIsOffscreen(pDstPix)) {
+ if (!exaPixmapHasGpuCopy(pDstPix)) {
REGION_UNINIT(pDst->pDrawable->pScreen, ®ion);
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, ®ion);
return 0;
}
--
1.6.5.3
_______________________________________________
xorg-devel mailing list
[email protected]
http://lists.x.org/mailman/listinfo/xorg-devel
