9838b7032e
This is strictly the application of the script 'x-indent-all.sh' from util/modular. Compared to the patch that Daniel posted in January, I've added a few indent flags: -bap -psl -T PrivatePtr -T pmWait -T _XFUNCPROTOBEGIN -T _XFUNCPROTOEND -T _X_EXPORT The typedefs were needed to make the output of sdksyms.sh match the previous output, otherwise, the code is formatted badly enough that sdksyms.sh generates incorrect output. The generated code was compared with the previous version and found to be essentially identical -- "assert" line numbers and BUILD_TIME were the only differences found. The comparison was done with this script: dir1=$1 dir2=$2 for dir in $dir1 $dir2; do (cd $dir && find . -name '*.o' | while read file; do dir=`dirname $file` base=`basename $file .o` dump=$dir/$base.dump objdump -d $file > $dump done) done find $dir1 -name '*.dump' | while read dump; do otherdump=`echo $dump | sed "s;$dir1;$dir2;"` diff -u $dump $otherdump done Signed-off-by: Keith Packard <keithp@keithp.com> Acked-by: Daniel Stone <daniel@fooishbar.org> Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
269 lines
9.0 KiB
C
269 lines
9.0 KiB
C
/*
|
|
* Copyright © 2009 Maarten Maathuis
|
|
*
|
|
* 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 (including the next
|
|
* paragraph) 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
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS 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.
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_DIX_CONFIG_H
|
|
#include <dix-config.h>
|
|
#endif
|
|
|
|
#include <string.h>
|
|
|
|
#include "exa_priv.h"
|
|
#include "exa.h"
|
|
|
|
void
|
|
exaCreateDriverPixmap_mixed(PixmapPtr pPixmap)
|
|
{
|
|
ScreenPtr pScreen = pPixmap->drawable.pScreen;
|
|
|
|
ExaScreenPriv(pScreen);
|
|
ExaPixmapPriv(pPixmap);
|
|
int w = pPixmap->drawable.width, h = pPixmap->drawable.height;
|
|
int depth = pPixmap->drawable.depth, bpp = pPixmap->drawable.bitsPerPixel;
|
|
int usage_hint = pPixmap->usage_hint;
|
|
int paddedWidth = pExaPixmap->sys_pitch;
|
|
|
|
/* Already done. */
|
|
if (pExaPixmap->driverPriv)
|
|
return;
|
|
|
|
if (exaPixmapIsPinned(pPixmap))
|
|
return;
|
|
|
|
/* Can't accel 1/4 bpp. */
|
|
if (pExaPixmap->accel_blocked || bpp < 8)
|
|
return;
|
|
|
|
if (pExaScr->info->CreatePixmap2) {
|
|
int new_pitch = 0;
|
|
|
|
pExaPixmap->driverPriv =
|
|
pExaScr->info->CreatePixmap2(pScreen, w, h, depth, usage_hint, bpp,
|
|
&new_pitch);
|
|
paddedWidth = pExaPixmap->fb_pitch = new_pitch;
|
|
}
|
|
else {
|
|
if (paddedWidth < pExaPixmap->fb_pitch)
|
|
paddedWidth = pExaPixmap->fb_pitch;
|
|
pExaPixmap->driverPriv =
|
|
pExaScr->info->CreatePixmap(pScreen, paddedWidth * h, 0);
|
|
}
|
|
|
|
if (!pExaPixmap->driverPriv)
|
|
return;
|
|
|
|
(*pScreen->ModifyPixmapHeader) (pPixmap, w, h, 0, 0, paddedWidth, NULL);
|
|
}
|
|
|
|
void
|
|
exaDoMigration_mixed(ExaMigrationPtr pixmaps, int npixmaps, Bool can_accel)
|
|
{
|
|
int i;
|
|
|
|
/* If anything is pinned in system memory, we won't be able to
|
|
* accelerate.
|
|
*/
|
|
for (i = 0; i < npixmaps; i++) {
|
|
if (exaPixmapIsPinned(pixmaps[i].pPix) &&
|
|
!exaPixmapHasGpuCopy(pixmaps[i].pPix)) {
|
|
can_accel = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* We can do nothing. */
|
|
if (!can_accel)
|
|
return;
|
|
|
|
for (i = 0; i < npixmaps; i++) {
|
|
PixmapPtr pPixmap = pixmaps[i].pPix;
|
|
|
|
ExaPixmapPriv(pPixmap);
|
|
|
|
if (!pExaPixmap->driverPriv)
|
|
exaCreateDriverPixmap_mixed(pPixmap);
|
|
|
|
if (pExaPixmap->pDamage && exaPixmapHasGpuCopy(pPixmap)) {
|
|
ExaScreenPriv(pPixmap->drawable.pScreen);
|
|
|
|
/* This pitch is needed for proper acceleration. For some reason
|
|
* there are pixmaps without pDamage and a bad fb_pitch value.
|
|
* So setting devKind when only exaPixmapHasGpuCopy() is true
|
|
* causes corruption. Pixmaps without pDamage are not migrated
|
|
* and should have a valid devKind at all times, so that's why this
|
|
* isn't causing problems. Pixmaps have their gpu pitch set the
|
|
* first time in the MPH call from exaCreateDriverPixmap_mixed().
|
|
*/
|
|
pPixmap->devKind = pExaPixmap->fb_pitch;
|
|
exaCopyDirtyToFb(pixmaps + i);
|
|
|
|
if (pExaScr->deferred_mixed_pixmap == pPixmap &&
|
|
!pixmaps[i].as_dst && !pixmaps[i].pReg)
|
|
pExaScr->deferred_mixed_pixmap = NULL;
|
|
}
|
|
|
|
pExaPixmap->use_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
|
|
}
|
|
}
|
|
|
|
void
|
|
exaMoveInPixmap_mixed(PixmapPtr pPixmap)
|
|
{
|
|
ExaMigrationRec pixmaps[1];
|
|
|
|
pixmaps[0].as_dst = FALSE;
|
|
pixmaps[0].as_src = TRUE;
|
|
pixmaps[0].pPix = pPixmap;
|
|
pixmaps[0].pReg = NULL;
|
|
|
|
exaDoMigration(pixmaps, 1, TRUE);
|
|
}
|
|
|
|
void
|
|
exaDamageReport_mixed(DamagePtr pDamage, RegionPtr pRegion, void *closure)
|
|
{
|
|
PixmapPtr pPixmap = closure;
|
|
|
|
ExaPixmapPriv(pPixmap);
|
|
|
|
/* Move back results of software rendering on system memory copy of mixed driver
|
|
* pixmap (see exaPrepareAccessReg_mixed).
|
|
*
|
|
* Defer moving the destination back into the driver pixmap, to try and save
|
|
* overhead on multiple subsequent software fallbacks.
|
|
*/
|
|
if (!pExaPixmap->use_gpu_copy && exaPixmapHasGpuCopy(pPixmap)) {
|
|
ExaScreenPriv(pPixmap->drawable.pScreen);
|
|
|
|
if (pExaScr->deferred_mixed_pixmap &&
|
|
pExaScr->deferred_mixed_pixmap != pPixmap)
|
|
exaMoveInPixmap_mixed(pExaScr->deferred_mixed_pixmap);
|
|
pExaScr->deferred_mixed_pixmap = pPixmap;
|
|
}
|
|
}
|
|
|
|
/* With mixed pixmaps, if we fail to get direct access to the driver pixmap, we
|
|
* use the DownloadFromScreen hook to retrieve contents to a copy in system
|
|
* memory, perform software rendering on that and move back the results with the
|
|
* UploadToScreen hook (see exaDamageReport_mixed).
|
|
*/
|
|
void
|
|
exaPrepareAccessReg_mixed(PixmapPtr pPixmap, int index, RegionPtr pReg)
|
|
{
|
|
ExaPixmapPriv(pPixmap);
|
|
Bool has_gpu_copy = exaPixmapHasGpuCopy(pPixmap);
|
|
Bool success;
|
|
|
|
success = ExaDoPrepareAccess(pPixmap, index);
|
|
|
|
if (success && has_gpu_copy && pExaPixmap->pDamage) {
|
|
/* You cannot do accelerated operations while a buffer is mapped. */
|
|
exaFinishAccess(&pPixmap->drawable, index);
|
|
/* Update the gpu view of both deferred destination pixmaps and of
|
|
* source pixmaps that were migrated with a bounding region.
|
|
*/
|
|
exaMoveInPixmap_mixed(pPixmap);
|
|
success = ExaDoPrepareAccess(pPixmap, index);
|
|
|
|
if (success) {
|
|
/* We have a gpu pixmap that can be accessed, we don't need the cpu
|
|
* copy anymore. Drivers that prefer DFS, should fail prepare
|
|
* access.
|
|
*/
|
|
DamageUnregister(&pPixmap->drawable, pExaPixmap->pDamage);
|
|
DamageDestroy(pExaPixmap->pDamage);
|
|
pExaPixmap->pDamage = NULL;
|
|
|
|
free(pExaPixmap->sys_ptr);
|
|
pExaPixmap->sys_ptr = NULL;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (!success) {
|
|
ExaMigrationRec pixmaps[1];
|
|
|
|
/* Do we need to allocate our system buffer? */
|
|
if (!pExaPixmap->sys_ptr) {
|
|
pExaPixmap->sys_ptr = malloc(pExaPixmap->sys_pitch *
|
|
pPixmap->drawable.height);
|
|
if (!pExaPixmap->sys_ptr)
|
|
FatalError("EXA: malloc failed for size %d bytes\n",
|
|
pExaPixmap->sys_pitch * pPixmap->drawable.height);
|
|
}
|
|
|
|
if (index == EXA_PREPARE_DEST || index == EXA_PREPARE_AUX_DEST) {
|
|
pixmaps[0].as_dst = TRUE;
|
|
pixmaps[0].as_src = FALSE;
|
|
}
|
|
else {
|
|
pixmaps[0].as_dst = FALSE;
|
|
pixmaps[0].as_src = TRUE;
|
|
}
|
|
pixmaps[0].pPix = pPixmap;
|
|
pixmaps[0].pReg = pReg;
|
|
|
|
if (!pExaPixmap->pDamage &&
|
|
(has_gpu_copy || !exaPixmapIsPinned(pPixmap))) {
|
|
Bool as_dst = pixmaps[0].as_dst;
|
|
|
|
/* Set up damage tracking */
|
|
pExaPixmap->pDamage = DamageCreate(exaDamageReport_mixed, NULL,
|
|
DamageReportNonEmpty, TRUE,
|
|
pPixmap->drawable.pScreen,
|
|
pPixmap);
|
|
|
|
DamageRegister(&pPixmap->drawable, pExaPixmap->pDamage);
|
|
/* This ensures that pending damage reflects the current operation. */
|
|
/* This is used by exa to optimize migration. */
|
|
DamageSetReportAfterOp(pExaPixmap->pDamage, TRUE);
|
|
|
|
if (has_gpu_copy) {
|
|
exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
|
|
pPixmap->drawable.height);
|
|
|
|
/* We don't know which region of the destination will be damaged,
|
|
* have to assume all of it
|
|
*/
|
|
if (as_dst) {
|
|
pixmaps[0].as_dst = FALSE;
|
|
pixmaps[0].as_src = TRUE;
|
|
pixmaps[0].pReg = NULL;
|
|
}
|
|
exaCopyDirtyToSys(pixmaps);
|
|
}
|
|
|
|
if (as_dst)
|
|
exaPixmapDirty(pPixmap, 0, 0, pPixmap->drawable.width,
|
|
pPixmap->drawable.height);
|
|
}
|
|
else if (has_gpu_copy)
|
|
exaCopyDirtyToSys(pixmaps);
|
|
|
|
pPixmap->devPrivate.ptr = pExaPixmap->sys_ptr;
|
|
pPixmap->devKind = pExaPixmap->sys_pitch;
|
|
pExaPixmap->use_gpu_copy = FALSE;
|
|
}
|
|
}
|