xorg-server-1.4/damageext/damageext.c

   1 /*
   2  * Copyright © 2002 Keith Packard
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of Keith Packard not be used in
   9  * advertising or publicity pertaining to distribution of the software without
  10  * specific, written prior permission.  Keith Packard makes no
  11  * representations about the suitability of this software for any purpose.  It
  12  * is provided "as is" without express or implied warranty.
  13  *
  14  * KEITH PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL KEITH PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  20  * PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #ifdef HAVE_DIX_CONFIG_H
  24 #include <dix-config.h>
  25 #endif
  26
  27 #include "damageextint.h"
  28
  29 static unsigned char    DamageReqCode;
  30 static int              DamageEventBase;
  31 static int              DamageErrorBase;
  32 static int              DamageClientPrivateIndex;
  33 static RESTYPE          DamageExtType;
  34 static RESTYPE          DamageExtWinType;
  35
  36 /* Version of the damage extension supported by the server, as opposed to the
  37  * DAMAGE_* defines from damageproto for what version the proto header
  38  * supports.
  39  */
  40 #define SERVER_DAMAGE_MAJOR     1
  41 #define SERVER_DAMAGE_MINOR     1
  42
  43 #define prScreen        screenInfo.screens[0]
  44
  45 static void
  46 DamageExtNotify (DamageExtPtr pDamageExt, BoxPtr pBoxes, int nBoxes)
  47 {
  48     ClientPtr           pClient = pDamageExt->pClient;
  49     DamageClientPtr     pDamageClient = GetDamageClient (pClient);
  50     DrawablePtr         pDrawable = pDamageExt->pDrawable;
  51     xDamageNotifyEvent  ev;
  52     int                 i;
  53
  54     UpdateCurrentTimeIf ();
  55     ev.type = DamageEventBase + XDamageNotify;
  56     ev.level = pDamageExt->level;
  57     ev.sequenceNumber = pClient->sequence;
  58     ev.drawable = pDrawable->id;
  59     ev.damage = pDamageExt->id;
  60     ev.timestamp = currentTime.milliseconds;
  61     ev.geometry.x = pDrawable->x;
  62     ev.geometry.y = pDrawable->y;
  63     ev.geometry.width = pDrawable->width;
  64     ev.geometry.height = pDrawable->height;
  65     if (pBoxes)
  66     {
  67         for (i = 0; i < nBoxes; i++)
  68         {
  69             ev.level = pDamageExt->level;
  70             if (i < nBoxes - 1)
  71                 ev.level |= DamageNotifyMore;
  72             ev.area.x = pBoxes[i].x1;
  73             ev.area.y = pBoxes[i].y1;
  74             ev.area.width = pBoxes[i].x2 - pBoxes[i].x1;
  75             ev.area.height = pBoxes[i].y2 - pBoxes[i].y1;
  76             if (!pClient->clientGone)
  77                 WriteEventsToClient (pClient, 1, (xEvent *) &ev);
  78         }
  79     }
  80     else
  81     {
  82         ev.area.x = 0;
  83         ev.area.y = 0;
  84         ev.area.width = pDrawable->width;
  85         ev.area.height = pDrawable->height;
  86         if (!pClient->clientGone)
  87             WriteEventsToClient (pClient, 1, (xEvent *) &ev);
  88     }
  89     /* Composite extension marks clients with manual Subwindows as critical */
  90     if (pDamageClient->critical > 0)
  91     {
  92         SetCriticalOutputPending ();
  93 #ifdef SMART_SCHEDULE
  94         pClient->smart_priority = SMART_MAX_PRIORITY;
  95 #endif
  96     }
  97 }
  98
  99 static void
 100 DamageExtReport (DamagePtr pDamage, RegionPtr pRegion, void *closure)
 101 {
 102     DamageExtPtr    pDamageExt = closure;
 103
 104     switch (pDamageExt->level) {
 105     case DamageReportRawRegion:
 106     case DamageReportDeltaRegion:
 107         DamageExtNotify (pDamageExt, REGION_RECTS(pRegion), REGION_NUM_RECTS(pRegion));
 108         break;
 109     case DamageReportBoundingBox:
 110         DamageExtNotify (pDamageExt, REGION_EXTENTS(prScreen, pRegion), 1);
 111         break;
 112     case DamageReportNonEmpty:
 113         DamageExtNotify (pDamageExt, NullBox, 0);
 114         break;
 115     case DamageReportNone:
 116         break;
 117     }
 118 }
 119
 120 static void
 121 DamageExtDestroy (DamagePtr pDamage, void *closure)
 122 {
 123     DamageExtPtr    pDamageExt = closure;
 124
 125     pDamageExt->pDamage = 0;
 126     if (pDamageExt->id)
 127         FreeResource (pDamageExt->id, RT_NONE);
 128 }
 129
 130 void
 131 DamageExtSetCritical (ClientPtr pClient, Bool critical)
 132 {
 133     DamageClientPtr pDamageClient = GetDamageClient (pClient);
 134
 135     if (pDamageClient)
 136         pDamageClient->critical += critical ? 1 : -1;
 137 }
 138
 139 static int
 140 ProcDamageQueryVersion(ClientPtr client)
 141 {
 142     DamageClientPtr pDamageClient = GetDamageClient (client);
 143     xDamageQueryVersionReply rep;
 144     register int n;
 145     REQUEST(xDamageQueryVersionReq);
 146
 147     REQUEST_SIZE_MATCH(xDamageQueryVersionReq);
 148     rep.type = X_Reply;
 149     rep.length = 0;
 150     rep.sequenceNumber = client->sequence;
 151     if (stuff->majorVersion < SERVER_DAMAGE_MAJOR) {
 152         rep.majorVersion = stuff->majorVersion;
 153         rep.minorVersion = stuff->minorVersion;
 154     } else {
 155         rep.majorVersion = SERVER_DAMAGE_MAJOR;
 156         if (stuff->majorVersion == SERVER_DAMAGE_MAJOR &&
 157             stuff->minorVersion < SERVER_DAMAGE_MINOR)
 158             rep.minorVersion = stuff->minorVersion;
 159         else
 160             rep.minorVersion = SERVER_DAMAGE_MINOR;
 161     }
 162     pDamageClient->major_version = rep.majorVersion;
 163     pDamageClient->minor_version = rep.minorVersion;
 164     if (client->swapped) {
 165         swaps(&rep.sequenceNumber, n);
 166         swapl(&rep.length, n);
 167         swapl(&rep.majorVersion, n);
 168         swapl(&rep.minorVersion, n);
 169     }
 170     WriteToClient(client, sizeof(xDamageQueryVersionReply), (char *)&rep);
 171     return(client->noClientException);
 172 }
 173
 174 static int
 175 ProcDamageCreate (ClientPtr client)
 176 {
 177     DrawablePtr         pDrawable;
 178     DamageExtPtr        pDamageExt;
 179     DamageReportLevel   level;
 180     RegionPtr           pRegion;
 181     int                 rc;
 182
 183     REQUEST(xDamageCreateReq);
 184
 185     REQUEST_SIZE_MATCH(xDamageCreateReq);
 186     LEGAL_NEW_RESOURCE(stuff->damage, client);
 187     rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
 188                            DixReadAccess);
 189     if (rc != Success)
 190         return rc;
 191
 192     switch (stuff->level) {
 193     case XDamageReportRawRectangles:
 194         level = DamageReportRawRegion;
 195         break;
 196     case XDamageReportDeltaRectangles:
 197         level = DamageReportDeltaRegion;
 198         break;
 199     case XDamageReportBoundingBox:
 200         level = DamageReportBoundingBox;
 201         break;
 202     case XDamageReportNonEmpty:
 203         level = DamageReportNonEmpty;
 204         break;
 205     default:
 206         client->errorValue = stuff->level;
 207         return BadValue;
 208     }
 209
 210     pDamageExt = xalloc (sizeof (DamageExtRec));
 211     if (!pDamageExt)
 212         return BadAlloc;
 213     pDamageExt->id = stuff->damage;
 214     pDamageExt->pDrawable = pDrawable;
 215     pDamageExt->level = level;
 216     pDamageExt->pClient = client;
 217     pDamageExt->pDamage = DamageCreate (DamageExtReport,
 218                                         DamageExtDestroy,
 219                                         level,
 220                                         FALSE,
 221                                         pDrawable->pScreen,
 222                                         pDamageExt);
 223     if (!pDamageExt->pDamage)
 224     {
 225         xfree (pDamageExt);
 226         return BadAlloc;
 227     }
 228     if (!AddResource (stuff->damage, DamageExtType, (pointer) pDamageExt))
 229         return BadAlloc;
 230
 231     DamageRegister (pDamageExt->pDrawable, pDamageExt->pDamage);
 232
 233     if (pDrawable->type == DRAWABLE_WINDOW)
 234     {
 235         pRegion = &((WindowPtr) pDrawable)->borderClip;
 236         DamageDamageRegion (pDrawable, pRegion);
 237     }
 238
 239     return (client->noClientException);
 240 }
 241
 242 static int
 243 ProcDamageDestroy (ClientPtr client)
 244 {
 245     REQUEST(xDamageDestroyReq);
 246     DamageExtPtr    pDamageExt;
 247
 248     REQUEST_SIZE_MATCH(xDamageDestroyReq);
 249     VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, DixWriteAccess);
 250     FreeResource (stuff->damage, RT_NONE);
 251     return (client->noClientException);
 252 }
 253
 254 static int
 255 ProcDamageSubtract (ClientPtr client)
 256 {
 257     REQUEST(xDamageSubtractReq);
 258     DamageExtPtr    pDamageExt;
 259     RegionPtr       pRepair;
 260     RegionPtr       pParts;
 261
 262     REQUEST_SIZE_MATCH(xDamageSubtractReq);
 263     VERIFY_DAMAGEEXT(pDamageExt, stuff->damage, client, DixWriteAccess);
 264     VERIFY_REGION_OR_NONE(pRepair, stuff->repair, client, DixWriteAccess);
 265     VERIFY_REGION_OR_NONE(pParts, stuff->parts, client, DixWriteAccess);
 266
 267     if (pDamageExt->level != DamageReportRawRegion)
 268     {
 269         DamagePtr   pDamage = pDamageExt->pDamage;
 270         if (pRepair)
 271         {
 272             if (pParts)
 273                 REGION_INTERSECT (prScreen, pParts, DamageRegion (pDamage), pRepair);
 274             if (DamageSubtract (pDamage, pRepair))
 275                 DamageExtReport (pDamage, DamageRegion (pDamage), (void *) pDamageExt);
 276         }
 277         else
 278         {
 279             if (pParts)
 280                 REGION_COPY (prScreen, pParts, DamageRegion (pDamage));
 281             DamageEmpty (pDamage);
 282         }
 283     }
 284     return (client->noClientException);
 285 }
 286
 287 static int
 288 ProcDamageAdd (ClientPtr client)
 289 {
 290     REQUEST(xDamageAddReq);
 291     DrawablePtr     pDrawable;
 292     RegionPtr       pRegion;
 293     int             rc;
 294
 295     REQUEST_SIZE_MATCH(xDamageAddReq);
 296     VERIFY_REGION(pRegion, stuff->region, client, DixWriteAccess);
 297     rc = dixLookupDrawable(&pDrawable, stuff->drawable, client, 0,
 298                            DixReadAccess);
 299     if (rc != Success)
 300         return rc;
 301
 302     /* The region is relative to the drawable origin, so translate it out to
 303      * screen coordinates like damage expects.
 304      */
 305     REGION_TRANSLATE(pScreen, pRegion, pDrawable->x, pDrawable->y);
 306     DamageDamageRegion(pDrawable, pRegion);
 307     REGION_TRANSLATE(pScreen, pRegion, -pDrawable->x, -pDrawable->y);
 308
 309     return (client->noClientException);
 310 }
 311
 312 /* Major version controls available requests */
 313 static const int version_requests[] = {
 314     X_DamageQueryVersion,       /* before client sends QueryVersion */
 315     X_DamageAdd,                /* Version 1 */
 316 };
 317
 318 #define NUM_VERSION_REQUESTS    (sizeof (version_requests) / sizeof (version_requests[0]))
 319
 320 static int (*ProcDamageVector[XDamageNumberRequests])(ClientPtr) = {
 321 /*************** Version 1 ******************/
 322     ProcDamageQueryVersion,
 323     ProcDamageCreate,
 324     ProcDamageDestroy,
 325     ProcDamageSubtract,
 326 /*************** Version 1.1 ****************/
 327     ProcDamageAdd,
 328 };
 329
 330
 331 static int
 332 ProcDamageDispatch (ClientPtr client)
 333 {
 334     REQUEST(xDamageReq);
 335     DamageClientPtr pDamageClient = GetDamageClient (client);
 336
 337     if (pDamageClient->major_version >= NUM_VERSION_REQUESTS)
 338         return BadRequest;
 339     if (stuff->damageReqType > version_requests[pDamageClient->major_version])
 340         return BadRequest;
 341     return (*ProcDamageVector[stuff->damageReqType]) (client);
 342 }
 343
 344 static int
 345 SProcDamageQueryVersion(ClientPtr client)
 346 {
 347     register int n;
 348     REQUEST(xDamageQueryVersionReq);
 349
 350     swaps(&stuff->length, n);
 351     REQUEST_SIZE_MATCH(xDamageQueryVersionReq);
 352     swapl(&stuff->majorVersion, n);
 353     swapl(&stuff->minorVersion, n);
 354     return (*ProcDamageVector[stuff->damageReqType]) (client);
 355 }
 356
 357 static int
 358 SProcDamageCreate (ClientPtr client)
 359 {
 360     register int n;
 361     REQUEST(xDamageCreateReq);
 362
 363     swaps (&stuff->length, n);
 364     REQUEST_SIZE_MATCH(xDamageCreateReq);
 365     swapl (&stuff->damage, n);
 366     swapl (&stuff->drawable, n);
 367     return (*ProcDamageVector[stuff->damageReqType]) (client);
 368 }
 369
 370 static int
 371 SProcDamageDestroy (ClientPtr client)
 372 {
 373     register int n;
 374     REQUEST(xDamageDestroyReq);
 375
 376     swaps (&stuff->length, n);
 377     REQUEST_SIZE_MATCH(xDamageDestroyReq);
 378     swapl (&stuff->damage, n);
 379     return (*ProcDamageVector[stuff->damageReqType]) (client);
 380 }
 381
 382 static int
 383 SProcDamageSubtract (ClientPtr client)
 384 {
 385     register int n;
 386     REQUEST(xDamageSubtractReq);
 387
 388     swaps (&stuff->length, n);
 389     REQUEST_SIZE_MATCH(xDamageSubtractReq);
 390     swapl (&stuff->damage, n);
 391     swapl (&stuff->repair, n);
 392     swapl (&stuff->parts, n);
 393     return (*ProcDamageVector[stuff->damageReqType]) (client);
 394 }
 395
 396 static int
 397 SProcDamageAdd (ClientPtr client)
 398 {
 399     register int n;
 400     REQUEST(xDamageAddReq);
 401
 402     swaps (&stuff->length, n);
 403     REQUEST_SIZE_MATCH(xDamageSubtractReq);
 404     swapl (&stuff->drawable, n);
 405     swapl (&stuff->region, n);
 406     return (*ProcDamageVector[stuff->damageReqType]) (client);
 407 }
 408
 409 static int (*SProcDamageVector[XDamageNumberRequests])(ClientPtr) = {
 410 /*************** Version 1 ******************/
 411     SProcDamageQueryVersion,
 412     SProcDamageCreate,
 413     SProcDamageDestroy,
 414     SProcDamageSubtract,
 415 /*************** Version 1.1 ****************/
 416     SProcDamageAdd,
 417 };
 418
 419 static int
 420 SProcDamageDispatch (ClientPtr client)
 421 {
 422     REQUEST(xDamageReq);
 423     if (stuff->damageReqType >= XDamageNumberRequests)
 424         return BadRequest;
 425     return (*SProcDamageVector[stuff->damageReqType]) (client);
 426 }
 427
 428 static void
 429 DamageClientCallback (CallbackListPtr   *list,
 430                       pointer           closure,
 431                       pointer           data)
 432 {
 433     NewClientInfoRec    *clientinfo = (NewClientInfoRec *) data;
 434     ClientPtr           pClient = clientinfo->client;
 435     DamageClientPtr     pDamageClient = GetDamageClient (pClient);
 436
 437     pDamageClient->critical = 0;
 438     pDamageClient->major_version = 0;
 439     pDamageClient->minor_version = 0;
 440 }
 441
 442 /*ARGSUSED*/
 443 static void
 444 DamageResetProc (ExtensionEntry *extEntry)
 445 {
 446     DeleteCallback (&ClientStateCallback, DamageClientCallback, 0);
 447 }
 448
 449 static int
 450 FreeDamageExt (pointer value, XID did)
 451 {
 452     DamageExtPtr    pDamageExt = (DamageExtPtr) value;
 453
 454     /*
 455      * Get rid of the resource table entry hanging from the window id
 456      */
 457     pDamageExt->id = 0;
 458     if (WindowDrawable(pDamageExt->pDrawable->type))
 459         FreeResourceByType (pDamageExt->pDrawable->id, DamageExtWinType, TRUE);
 460     if (pDamageExt->pDamage)
 461     {
 462         DamageUnregister (pDamageExt->pDrawable, pDamageExt->pDamage);
 463         DamageDestroy (pDamageExt->pDamage);
 464     }
 465     xfree (pDamageExt);
 466     return Success;
 467 }
 468
 469 static int
 470 FreeDamageExtWin (pointer value, XID wid)
 471 {
 472     DamageExtPtr    pDamageExt = (DamageExtPtr) value;
 473
 474     if (pDamageExt->id)
 475         FreeResource (pDamageExt->id, RT_NONE);
 476     return Success;
 477 }
 478
 479 static void
 480 SDamageNotifyEvent (xDamageNotifyEvent *from,
 481                     xDamageNotifyEvent *to)
 482 {
 483     to->type = from->type;
 484     cpswaps (from->sequenceNumber, to->sequenceNumber);
 485     cpswapl (from->drawable, to->drawable);
 486     cpswapl (from->damage, to->damage);
 487     cpswaps (from->area.x, to->area.x);
 488     cpswaps (from->area.y, to->area.y);
 489     cpswaps (from->area.width, to->area.width);
 490     cpswaps (from->area.height, to->area.height);
 491     cpswaps (from->geometry.x, to->geometry.x);
 492     cpswaps (from->geometry.y, to->geometry.y);
 493     cpswaps (from->geometry.width, to->geometry.width);
 494     cpswaps (from->geometry.height, to->geometry.height);
 495 }
 496
 497 void
 498 DamageExtensionInit(void)
 499 {
 500     ExtensionEntry *extEntry;
 501     int             s;
 502
 503     for (s = 0; s < screenInfo.numScreens; s++)
 504         DamageSetup (screenInfo.screens[s]);
 505
 506     DamageExtType = CreateNewResourceType (FreeDamageExt);
 507     if (!DamageExtType)
 508         return;
 509
 510     DamageExtWinType = CreateNewResourceType (FreeDamageExtWin);
 511     if (!DamageExtWinType)
 512         return;
 513
 514     DamageClientPrivateIndex = AllocateClientPrivateIndex ();
 515     if (!AllocateClientPrivate (DamageClientPrivateIndex,
 516                                 sizeof (DamageClientRec)))
 517         return;
 518     if (!AddCallback (&ClientStateCallback, DamageClientCallback, 0))
 519         return;
 520
 521     if ((extEntry = AddExtension(DAMAGE_NAME, XDamageNumberEvents,
 522                                  XDamageNumberErrors,
 523                                  ProcDamageDispatch, SProcDamageDispatch,
 524                                  DamageResetProc, StandardMinorOpcode)) != 0)
 525     {
 526         DamageReqCode = (unsigned char)extEntry->base;
 527         DamageEventBase = extEntry->eventBase;
 528         DamageErrorBase = extEntry->errorBase;
 529         EventSwapVector[DamageEventBase + XDamageNotify] =
 530                         (EventSwapPtr) SDamageNotifyEvent;
 531     }
 532 }