Xext/xvmain.c

   1 /***********************************************************
   2 Copyright 1991 by Digital Equipment Corporation, Maynard, Massachusetts,
   3 and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Digital or MIT not be
  12 used in advertising or publicity pertaining to distribution of the
  13 software without specific, written prior permission.
  14
  15 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21 SOFTWARE.
  22
  23 ******************************************************************/
  24
  25 /*
  26 ** File:
  27 **
  28 **   xvmain.c --- Xv server extension main device independent module.
  29 **
  30 ** Author:
  31 **
  32 **   David Carver (Digital Workstation Engineering/Project Athena)
  33 **
  34 ** Revisions:
  35 **
  36 **   04.09.91 Carver
  37 **     - change: stop video always generates an event even when video
  38 **       wasn't active
  39 **
  40 **   29.08.91 Carver
  41 **     - change: unrealizing windows no longer preempts video
  42 **
  43 **   11.06.91 Carver
  44 **     - changed SetPortControl to SetPortAttribute
  45 **     - changed GetPortControl to GetPortAttribute
  46 **     - changed QueryBestSize
  47 **
  48 **   28.05.91 Carver
  49 **     - fixed Put and Get requests to not preempt operations to same drawable
  50 **
  51 **   15.05.91 Carver
  52 **     - version 2.0 upgrade
  53 **
  54 **   19.03.91 Carver
  55 **     - fixed Put and Get requests to honor grabbed ports.
  56 **     - fixed Video requests to update di structure with new drawable, and
  57 **       client after calling ddx.
  58 **
  59 **   24.01.91 Carver
  60 **     - version 1.4 upgrade
  61 **
  62 ** Notes:
  63 **
  64 **   Port structures reference client structures in a two different
  65 **   ways: when grabs, or video is active.  Each reference is encoded
  66 **   as fake client resources and thus when the client is goes away so
  67 **   does the reference (it is zeroed).  No other action is taken, so
  68 **   video doesn't necessarily stop.  It probably will as a result of
  69 **   other resources going away, but if a client starts video using
  70 **   none of its own resources, then the video will continue to play
  71 **   after the client disappears.
  72 **
  73 **
  74 */
  75
  76 #include <dix-config.h>
  77
  78 #include <string.h>
  79 #include <X11/X.h>
  80 #include <X11/Xproto.h>
  81 #include <X11/extensions/Xv.h>
  82 #include <X11/extensions/Xvproto.h>
  83
  84 #include "Xext/xvdix_priv.h"
  85
  86 #include "misc.h"
  87 #include "os.h"
  88 #include "scrnintstr.h"
  89 #include "windowstr.h"
  90 #include "pixmapstr.h"
  91 #include "gcstruct.h"
  92 #include "extnsionst.h"
  93 #include "extinit_priv.h"
  94 #include "dixstruct.h"
  95 #include "resource.h"
  96 #include "opaque.h"
  97 #include "input.h"
  98
  99 #ifdef PANORAMIX
 100 #include "panoramiX.h"
 101 #include "panoramiXsrv.h"
 102 #endif
 103 #include "xvdisp.h"
 104
 105 #define SCREEN_PROLOGUE(pScreen, field) ((pScreen)->field = ((XvScreenPtr) \
 106     dixLookupPrivate(&(pScreen)->devPrivates, XvScreenKey))->field)
 107
 108 #define SCREEN_EPILOGUE(pScreen, field, wrapper)\
 109     ((pScreen)->field = wrapper)
 110
 111 typedef struct _XvVideoNotifyRec {
 112     struct _XvVideoNotifyRec *next;
 113     ClientPtr client;
 114     unsigned long id;
 115     unsigned long mask;
 116 } XvVideoNotifyRec, *XvVideoNotifyPtr;
 117
 118 static DevPrivateKeyRec XvScreenKeyRec;
 119
 120 Bool noXvExtension = FALSE;
 121
 122 #define XvScreenKey (&XvScreenKeyRec)
 123 static unsigned long XvExtensionGeneration = 0;
 124 static unsigned long XvScreenGeneration = 0;
 125 static unsigned long XvResourceGeneration = 0;
 126
 127 int XvReqCode;
 128 static int XvEventBase;
 129 int XvErrorBase;
 130
 131 RESTYPE XvRTPort;
 132 static RESTYPE XvRTEncoding;
 133 static RESTYPE XvRTGrab;
 134 static RESTYPE XvRTVideoNotify;
 135 static RESTYPE XvRTVideoNotifyList;
 136 static RESTYPE XvRTPortNotify;
 137
 138 /* EXTERNAL */
 139
 140 static void WriteSwappedVideoNotifyEvent(xvEvent *, xvEvent *);
 141 static void WriteSwappedPortNotifyEvent(xvEvent *, xvEvent *);
 142 static Bool CreateResourceTypes(void);
 143
 144 static Bool XvCloseScreen(ScreenPtr);
 145 static Bool XvDestroyPixmap(PixmapPtr);
 146 static Bool XvDestroyWindow(WindowPtr);
 147 static void XvResetProc(ExtensionEntry *);
 148 static int XvdiDestroyGrab(void *, XID);
 149 static int XvdiDestroyEncoding(void *, XID);
 150 static int XvdiDestroyVideoNotify(void *, XID);
 151 static int XvdiDestroyPortNotify(void *, XID);
 152 static int XvdiDestroyVideoNotifyList(void *, XID);
 153 static int XvdiDestroyPort(void *, XID);
 154 static int XvdiSendVideoNotify(XvPortPtr, DrawablePtr, int);
 155
 156 /*
 157 ** XvExtensionInit
 158 **
 159 **
 160 */
 161
 162 void
 163 XvExtensionInit(void)
 164 {
 165     ExtensionEntry *extEntry;
 166
 167     if (!dixRegisterPrivateKey(&XvScreenKeyRec, PRIVATE_SCREEN, 0))
 168         return;
 169
 170     /* Look to see if any screens were initialized; if not then
 171        init global variables so the extension can function */
 172     if (XvScreenGeneration != serverGeneration) {
 173         if (!CreateResourceTypes()) {
 174             ErrorF("XvExtensionInit: Unable to allocate resource types\n");
 175             return;
 176         }
 177 #ifdef PANORAMIX
 178         XineramaRegisterConnectionBlockCallback(XineramifyXv);
 179 #endif
 180         XvScreenGeneration = serverGeneration;
 181     }
 182
 183     if (XvExtensionGeneration != serverGeneration) {
 184         XvExtensionGeneration = serverGeneration;
 185
 186         extEntry = AddExtension(XvName, XvNumEvents, XvNumErrors,
 187                                 ProcXvDispatch, SProcXvDispatch,
 188                                 XvResetProc, StandardMinorOpcode);
 189         if (!extEntry) {
 190             FatalError("XvExtensionInit: AddExtensions failed\n");
 191         }
 192
 193         XvReqCode = extEntry->base;
 194         XvEventBase = extEntry->eventBase;
 195         XvErrorBase = extEntry->errorBase;
 196
 197         EventSwapVector[XvEventBase + XvVideoNotify] =
 198             (EventSwapPtr) WriteSwappedVideoNotifyEvent;
 199         EventSwapVector[XvEventBase + XvPortNotify] =
 200             (EventSwapPtr) WriteSwappedPortNotifyEvent;
 201
 202         SetResourceTypeErrorValue(XvRTPort, _XvBadPort);
 203         (void) MakeAtom(XvName, strlen(XvName), xTrue);
 204
 205     }
 206 }
 207
 208 static Bool
 209 CreateResourceTypes(void)
 210 {
 211
 212     if (XvResourceGeneration == serverGeneration)
 213         return TRUE;
 214
 215     XvResourceGeneration = serverGeneration;
 216
 217     if (!(XvRTPort = CreateNewResourceType(XvdiDestroyPort, "XvRTPort"))) {
 218         ErrorF("CreateResourceTypes: failed to allocate port resource.\n");
 219         return FALSE;
 220     }
 221
 222     if (!(XvRTGrab = CreateNewResourceType(XvdiDestroyGrab, "XvRTGrab"))) {
 223         ErrorF("CreateResourceTypes: failed to allocate grab resource.\n");
 224         return FALSE;
 225     }
 226
 227     if (!(XvRTEncoding = CreateNewResourceType(XvdiDestroyEncoding,
 228                                                "XvRTEncoding"))) {
 229         ErrorF("CreateResourceTypes: failed to allocate encoding resource.\n");
 230         return FALSE;
 231     }
 232
 233     if (!(XvRTVideoNotify = CreateNewResourceType(XvdiDestroyVideoNotify,
 234                                                   "XvRTVideoNotify"))) {
 235         ErrorF
 236             ("CreateResourceTypes: failed to allocate video notify resource.\n");
 237         return FALSE;
 238     }
 239
 240     if (!
 241         (XvRTVideoNotifyList =
 242          CreateNewResourceType(XvdiDestroyVideoNotifyList,
 243                                "XvRTVideoNotifyList"))) {
 244         ErrorF
 245             ("CreateResourceTypes: failed to allocate video notify list resource.\n");
 246         return FALSE;
 247     }
 248
 249     if (!(XvRTPortNotify = CreateNewResourceType(XvdiDestroyPortNotify,
 250                                                  "XvRTPortNotify"))) {
 251         ErrorF
 252             ("CreateResourceTypes: failed to allocate port notify resource.\n");
 253         return FALSE;
 254     }
 255
 256     return TRUE;
 257
 258 }
 259
 260 int
 261 XvScreenInit(ScreenPtr pScreen)
 262 {
 263     XvScreenPtr pxvs;
 264
 265     if (XvScreenGeneration != serverGeneration) {
 266         if (!CreateResourceTypes()) {
 267             ErrorF("XvScreenInit: Unable to allocate resource types\n");
 268             return BadAlloc;
 269         }
 270 #ifdef PANORAMIX
 271         XineramaRegisterConnectionBlockCallback(XineramifyXv);
 272 #endif
 273         XvScreenGeneration = serverGeneration;
 274     }
 275
 276     if (!dixRegisterPrivateKey(&XvScreenKeyRec, PRIVATE_SCREEN, 0))
 277         return BadAlloc;
 278
 279     if (dixLookupPrivate(&pScreen->devPrivates, XvScreenKey)) {
 280         ErrorF("XvScreenInit: screen devPrivates ptr non-NULL before init\n");
 281     }
 282
 283     /* ALLOCATE SCREEN PRIVATE RECORD */
 284
 285     pxvs = malloc(sizeof(XvScreenRec));
 286     if (!pxvs) {
 287         ErrorF("XvScreenInit: Unable to allocate screen private structure\n");
 288         return BadAlloc;
 289     }
 290
 291     dixSetPrivate(&pScreen->devPrivates, XvScreenKey, pxvs);
 292
 293     pxvs->DestroyPixmap = pScreen->DestroyPixmap;
 294     pxvs->DestroyWindow = pScreen->DestroyWindow;
 295     pxvs->CloseScreen = pScreen->CloseScreen;
 296
 297     pScreen->DestroyPixmap = XvDestroyPixmap;
 298     pScreen->DestroyWindow = XvDestroyWindow;
 299     pScreen->CloseScreen = XvCloseScreen;
 300
 301     return Success;
 302 }
 303
 304 static Bool
 305 XvCloseScreen(ScreenPtr pScreen)
 306 {
 307
 308     XvScreenPtr pxvs;
 309
 310     pxvs = (XvScreenPtr) dixLookupPrivate(&pScreen->devPrivates, XvScreenKey);
 311
 312     pScreen->DestroyPixmap = pxvs->DestroyPixmap;
 313     pScreen->DestroyWindow = pxvs->DestroyWindow;
 314     pScreen->CloseScreen = pxvs->CloseScreen;
 315
 316     free(pxvs);
 317
 318     dixSetPrivate(&pScreen->devPrivates, XvScreenKey, NULL);
 319
 320     return (*pScreen->CloseScreen) (pScreen);
 321 }
 322
 323 static void
 324 XvResetProc(ExtensionEntry * extEntry)
 325 {
 326     XvResetProcVector();
 327 }
 328
 329 DevPrivateKey
 330 XvGetScreenKey(void)
 331 {
 332     return XvScreenKey;
 333 }
 334
 335 unsigned long
 336 XvGetRTPort(void)
 337 {
 338     return XvRTPort;
 339 }
 340
 341 static void
 342 XvStopAdaptors(DrawablePtr pDrawable)
 343 {
 344     ScreenPtr pScreen = pDrawable->pScreen;
 345     XvScreenPtr pxvs = dixLookupPrivate(&pScreen->devPrivates, XvScreenKey);
 346     XvAdaptorPtr pa = pxvs->pAdaptors;
 347     int na = pxvs->nAdaptors;
 348
 349     /* CHECK TO SEE IF THIS PORT IS IN USE */
 350     while (na--) {
 351         XvPortPtr pp = pa->pPorts;
 352         int np = pa->nPorts;
 353
 354         while (np--) {
 355             if (pp->pDraw == pDrawable) {
 356                 XvdiSendVideoNotify(pp, pDrawable, XvPreempted);
 357
 358                 (void) (*pp->pAdaptor->ddStopVideo) (pp, pDrawable);
 359
 360                 pp->pDraw = NULL;
 361                 pp->client = NULL;
 362                 pp->time = currentTime;
 363             }
 364             pp++;
 365         }
 366         pa++;
 367     }
 368 }
 369
 370 static Bool
 371 XvDestroyPixmap(PixmapPtr pPix)
 372 {
 373     ScreenPtr pScreen = pPix->drawable.pScreen;
 374     Bool status;
 375
 376     if (pPix->refcnt == 1)
 377         XvStopAdaptors(&pPix->drawable);
 378
 379     SCREEN_PROLOGUE(pScreen, DestroyPixmap);
 380     status = (*pScreen->DestroyPixmap) (pPix);
 381     SCREEN_EPILOGUE(pScreen, DestroyPixmap, XvDestroyPixmap);
 382
 383     return status;
 384
 385 }
 386
 387 static Bool
 388 XvDestroyWindow(WindowPtr pWin)
 389 {
 390     ScreenPtr pScreen = pWin->drawable.pScreen;
 391     Bool status;
 392
 393     XvStopAdaptors(&pWin->drawable);
 394
 395     SCREEN_PROLOGUE(pScreen, DestroyWindow);
 396     status = (*pScreen->DestroyWindow) (pWin);
 397     SCREEN_EPILOGUE(pScreen, DestroyWindow, XvDestroyWindow);
 398
 399     return status;
 400
 401 }
 402
 403 static int
 404 XvdiDestroyPort(void *pPort, XID id)
 405 {
 406     return Success;
 407 }
 408
 409 static int
 410 XvdiDestroyGrab(void *pGrab, XID id)
 411 {
 412     ((XvGrabPtr) pGrab)->client = NULL;
 413     return Success;
 414 }
 415
 416 static int
 417 XvdiDestroyVideoNotify(void *pn, XID id)
 418 {
 419     /* JUST CLEAR OUT THE client POINTER FIELD */
 420
 421     ((XvVideoNotifyPtr) pn)->client = NULL;
 422     return Success;
 423 }
 424
 425 static int
 426 XvdiDestroyPortNotify(void *pn, XID id)
 427 {
 428     /* JUST CLEAR OUT THE client POINTER FIELD */
 429
 430     ((XvPortNotifyPtr) pn)->client = NULL;
 431     return Success;
 432 }
 433
 434 static int
 435 XvdiDestroyVideoNotifyList(void *pn, XID id)
 436 {
 437     XvVideoNotifyPtr npn, cpn;
 438
 439     /* ACTUALLY DESTROY THE NOTIFY LIST */
 440
 441     cpn = (XvVideoNotifyPtr) pn;
 442
 443     while (cpn) {
 444         npn = cpn->next;
 445         if (cpn->client)
 446             FreeResource(cpn->id, XvRTVideoNotify);
 447         free(cpn);
 448         cpn = npn;
 449     }
 450     return Success;
 451 }
 452
 453 static int
 454 XvdiDestroyEncoding(void *value, XID id)
 455 {
 456     return Success;
 457 }
 458
 459 static int
 460 XvdiSendVideoNotify(XvPortPtr pPort, DrawablePtr pDraw, int reason)
 461 {
 462     XvVideoNotifyPtr pn;
 463
 464     dixLookupResourceByType((void **) &pn, pDraw->id, XvRTVideoNotifyList,
 465                             serverClient, DixReadAccess);
 466
 467     while (pn) {
 468         xvEvent event = {
 469             .u.videoNotify.reason = reason,
 470             .u.videoNotify.time = currentTime.milliseconds,
 471             .u.videoNotify.drawable = pDraw->id,
 472             .u.videoNotify.port = pPort->id
 473         };
 474         event.u.u.type = XvEventBase + XvVideoNotify;
 475         WriteEventsToClient(pn->client, 1, (xEventPtr) &event);
 476         pn = pn->next;
 477     }
 478
 479     return Success;
 480
 481 }
 482
 483 static int
 484 XvdiSendPortNotify(XvPortPtr pPort, Atom attribute, INT32 value)
 485 {
 486     XvPortNotifyPtr pn;
 487
 488     pn = pPort->pNotify;
 489
 490     while (pn) {
 491         xvEvent event = {
 492             .u.portNotify.time = currentTime.milliseconds,
 493             .u.portNotify.port = pPort->id,
 494             .u.portNotify.attribute = attribute,
 495             .u.portNotify.value = value
 496         };
 497         event.u.u.type = XvEventBase + XvPortNotify;
 498         WriteEventsToClient(pn->client, 1, (xEventPtr) &event);
 499         pn = pn->next;
 500     }
 501
 502     return Success;
 503
 504 }
 505
 506 #define CHECK_SIZE(dw, dh, sw, sh) {                                  \
 507   if(!dw || !dh || !sw || !sh)  return Success;                       \
 508   /* The region code will break these if they are too large */        \
 509   if((dw > 32767) || (dh > 32767) || (sw > 32767) || (sh > 32767))    \
 510         return BadValue;                                              \
 511 }
 512
 513 int
 514 XvdiPutVideo(ClientPtr client,
 515              DrawablePtr pDraw,
 516              XvPortPtr pPort,
 517              GCPtr pGC,
 518              INT16 vid_x, INT16 vid_y,
 519              CARD16 vid_w, CARD16 vid_h,
 520              INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
 521 {
 522     DrawablePtr pOldDraw;
 523
 524     CHECK_SIZE(drw_w, drw_h, vid_w, vid_h);
 525
 526     /* UPDATE TIME VARIABLES FOR USE IN EVENTS */
 527
 528     UpdateCurrentTime();
 529
 530     /* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
 531        INFORM CLIENT OF ITS FAILURE */
 532
 533     if (pPort->grab.client && (pPort->grab.client != client)) {
 534         XvdiSendVideoNotify(pPort, pDraw, XvBusy);
 535         return Success;
 536     }
 537
 538     /* CHECK TO SEE IF PORT IS IN USE; IF SO THEN WE MUST DELIVER INTERRUPTED
 539        EVENTS TO ANY CLIENTS WHO WANT THEM */
 540
 541     pOldDraw = pPort->pDraw;
 542     if ((pOldDraw) && (pOldDraw != pDraw)) {
 543         XvdiSendVideoNotify(pPort, pPort->pDraw, XvPreempted);
 544     }
 545
 546     (void) (*pPort->pAdaptor->ddPutVideo) (pDraw, pPort, pGC,
 547                                            vid_x, vid_y, vid_w, vid_h,
 548                                            drw_x, drw_y, drw_w, drw_h);
 549
 550     if ((pPort->pDraw) && (pOldDraw != pDraw)) {
 551         pPort->client = client;
 552         XvdiSendVideoNotify(pPort, pPort->pDraw, XvStarted);
 553     }
 554
 555     pPort->time = currentTime;
 556
 557     return Success;
 558
 559 }
 560
 561 int
 562 XvdiPutStill(ClientPtr client,
 563              DrawablePtr pDraw,
 564              XvPortPtr pPort,
 565              GCPtr pGC,
 566              INT16 vid_x, INT16 vid_y,
 567              CARD16 vid_w, CARD16 vid_h,
 568              INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
 569 {
 570     int status;
 571
 572     CHECK_SIZE(drw_w, drw_h, vid_w, vid_h);
 573
 574     /* UPDATE TIME VARIABLES FOR USE IN EVENTS */
 575
 576     UpdateCurrentTime();
 577
 578     /* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
 579        INFORM CLIENT OF ITS FAILURE */
 580
 581     if (pPort->grab.client && (pPort->grab.client != client)) {
 582         XvdiSendVideoNotify(pPort, pDraw, XvBusy);
 583         return Success;
 584     }
 585
 586     pPort->time = currentTime;
 587
 588     status = (*pPort->pAdaptor->ddPutStill) (pDraw, pPort, pGC,
 589                                              vid_x, vid_y, vid_w, vid_h,
 590                                              drw_x, drw_y, drw_w, drw_h);
 591
 592     return status;
 593
 594 }
 595
 596 int
 597 XvdiPutImage(ClientPtr client,
 598              DrawablePtr pDraw,
 599              XvPortPtr pPort,
 600              GCPtr pGC,
 601              INT16 src_x, INT16 src_y,
 602              CARD16 src_w, CARD16 src_h,
 603              INT16 drw_x, INT16 drw_y,
 604              CARD16 drw_w, CARD16 drw_h,
 605              XvImagePtr image,
 606              unsigned char *data, Bool sync, CARD16 width, CARD16 height)
 607 {
 608     CHECK_SIZE(drw_w, drw_h, src_w, src_h);
 609
 610     /* UPDATE TIME VARIABLES FOR USE IN EVENTS */
 611
 612     UpdateCurrentTime();
 613
 614     /* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
 615        INFORM CLIENT OF ITS FAILURE */
 616
 617     if (pPort->grab.client && (pPort->grab.client != client)) {
 618         XvdiSendVideoNotify(pPort, pDraw, XvBusy);
 619         return Success;
 620     }
 621
 622     pPort->time = currentTime;
 623
 624     return (*pPort->pAdaptor->ddPutImage) (pDraw, pPort, pGC,
 625                                            src_x, src_y, src_w, src_h,
 626                                            drw_x, drw_y, drw_w, drw_h,
 627                                            image, data, sync, width, height);
 628 }
 629
 630 int
 631 XvdiGetVideo(ClientPtr client,
 632              DrawablePtr pDraw,
 633              XvPortPtr pPort,
 634              GCPtr pGC,
 635              INT16 vid_x, INT16 vid_y,
 636              CARD16 vid_w, CARD16 vid_h,
 637              INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
 638 {
 639     DrawablePtr pOldDraw;
 640
 641     CHECK_SIZE(drw_w, drw_h, vid_w, vid_h);
 642
 643     /* UPDATE TIME VARIABLES FOR USE IN EVENTS */
 644
 645     UpdateCurrentTime();
 646
 647     /* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
 648        INFORM CLIENT OF ITS FAILURE */
 649
 650     if (pPort->grab.client && (pPort->grab.client != client)) {
 651         XvdiSendVideoNotify(pPort, pDraw, XvBusy);
 652         return Success;
 653     }
 654
 655     /* CHECK TO SEE IF PORT IS IN USE; IF SO THEN WE MUST DELIVER INTERRUPTED
 656        EVENTS TO ANY CLIENTS WHO WANT THEM */
 657
 658     pOldDraw = pPort->pDraw;
 659     if ((pOldDraw) && (pOldDraw != pDraw)) {
 660         XvdiSendVideoNotify(pPort, pPort->pDraw, XvPreempted);
 661     }
 662
 663     (void) (*pPort->pAdaptor->ddGetVideo) (pDraw, pPort, pGC,
 664                                            vid_x, vid_y, vid_w, vid_h,
 665                                            drw_x, drw_y, drw_w, drw_h);
 666
 667     if ((pPort->pDraw) && (pOldDraw != pDraw)) {
 668         pPort->client = client;
 669         XvdiSendVideoNotify(pPort, pPort->pDraw, XvStarted);
 670     }
 671
 672     pPort->time = currentTime;
 673
 674     return Success;
 675
 676 }
 677
 678 int
 679 XvdiGetStill(ClientPtr client,
 680              DrawablePtr pDraw,
 681              XvPortPtr pPort,
 682              GCPtr pGC,
 683              INT16 vid_x, INT16 vid_y,
 684              CARD16 vid_w, CARD16 vid_h,
 685              INT16 drw_x, INT16 drw_y, CARD16 drw_w, CARD16 drw_h)
 686 {
 687     int status;
 688
 689     CHECK_SIZE(drw_w, drw_h, vid_w, vid_h);
 690
 691     /* UPDATE TIME VARIABLES FOR USE IN EVENTS */
 692
 693     UpdateCurrentTime();
 694
 695     /* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
 696        INFORM CLIENT OF ITS FAILURE */
 697
 698     if (pPort->grab.client && (pPort->grab.client != client)) {
 699         XvdiSendVideoNotify(pPort, pDraw, XvBusy);
 700         return Success;
 701     }
 702
 703     status = (*pPort->pAdaptor->ddGetStill) (pDraw, pPort, pGC,
 704                                              vid_x, vid_y, vid_w, vid_h,
 705                                              drw_x, drw_y, drw_w, drw_h);
 706
 707     pPort->time = currentTime;
 708
 709     return status;
 710
 711 }
 712
 713 int
 714 XvdiGrabPort(ClientPtr client, XvPortPtr pPort, Time ctime, int *p_result)
 715 {
 716     unsigned long id;
 717     TimeStamp time;
 718
 719     UpdateCurrentTime();
 720     time = ClientTimeToServerTime(ctime);
 721
 722     if (pPort->grab.client && (client != pPort->grab.client)) {
 723         *p_result = XvAlreadyGrabbed;
 724         return Success;
 725     }
 726
 727     if ((CompareTimeStamps(time, currentTime) == LATER) ||
 728         (CompareTimeStamps(time, pPort->time) == EARLIER)) {
 729         *p_result = XvInvalidTime;
 730         return Success;
 731     }
 732
 733     if (client == pPort->grab.client) {
 734         *p_result = Success;
 735         return Success;
 736     }
 737
 738     id = FakeClientID(client->index);
 739
 740     if (!AddResource(id, XvRTGrab, &pPort->grab)) {
 741         return BadAlloc;
 742     }
 743
 744     /* IF THERE IS ACTIVE VIDEO THEN STOP IT */
 745
 746     if ((pPort->pDraw) && (client != pPort->client)) {
 747         XvdiStopVideo(NULL, pPort, pPort->pDraw);
 748     }
 749
 750     pPort->grab.client = client;
 751     pPort->grab.id = id;
 752
 753     pPort->time = currentTime;
 754
 755     *p_result = Success;
 756
 757     return Success;
 758
 759 }
 760
 761 int
 762 XvdiUngrabPort(ClientPtr client, XvPortPtr pPort, Time ctime)
 763 {
 764     TimeStamp time;
 765
 766     UpdateCurrentTime();
 767     time = ClientTimeToServerTime(ctime);
 768
 769     if ((!pPort->grab.client) || (client != pPort->grab.client)) {
 770         return Success;
 771     }
 772
 773     if ((CompareTimeStamps(time, currentTime) == LATER) ||
 774         (CompareTimeStamps(time, pPort->time) == EARLIER)) {
 775         return Success;
 776     }
 777
 778     /* FREE THE GRAB RESOURCE; AND SET THE GRAB CLIENT TO NULL */
 779
 780     FreeResource(pPort->grab.id, XvRTGrab);
 781     pPort->grab.client = NULL;
 782
 783     pPort->time = currentTime;
 784
 785     return Success;
 786
 787 }
 788
 789 int
 790 XvdiSelectVideoNotify(ClientPtr client, DrawablePtr pDraw, BOOL onoff)
 791 {
 792     XvVideoNotifyPtr pn, tpn, fpn;
 793     int rc;
 794
 795     /* FIND VideoNotify LIST */
 796
 797     rc = dixLookupResourceByType((void **) &pn, pDraw->id,
 798                                  XvRTVideoNotifyList, client, DixWriteAccess);
 799     if (rc != Success && rc != BadValue)
 800         return rc;
 801
 802     /* IF ONE DONES'T EXIST AND NO MASK, THEN JUST RETURN */
 803
 804     if (!onoff && !pn)
 805         return Success;
 806
 807     /* IF ONE DOESN'T EXIST CREATE IT AND ADD A RESOURCE SO THAT THE LIST
 808        WILL BE DELETED WHEN THE DRAWABLE IS DESTROYED */
 809
 810     if (!pn) {
 811         if (!(tpn = malloc(sizeof(XvVideoNotifyRec))))
 812             return BadAlloc;
 813         tpn->next = NULL;
 814         tpn->client = NULL;
 815         if (!AddResource(pDraw->id, XvRTVideoNotifyList, tpn))
 816             return BadAlloc;
 817     }
 818     else {
 819         /* LOOK TO SEE IF ENTRY ALREADY EXISTS */
 820
 821         fpn = NULL;
 822         tpn = pn;
 823         while (tpn) {
 824             if (tpn->client == client) {
 825                 if (!onoff) {
 826                     tpn->client = NULL;
 827                     FreeResource(tpn->id, XvRTVideoNotify);
 828                 }
 829                 return Success;
 830             }
 831             if (!tpn->client)
 832                 fpn = tpn;      /* TAKE NOTE OF FREE ENTRY */
 833             tpn = tpn->next;
 834         }
 835
 836         /* IF TURNING OFF, THEN JUST RETURN */
 837
 838         if (!onoff)
 839             return Success;
 840
 841         /* IF ONE ISN'T FOUND THEN ALLOCATE ONE AND LINK IT INTO THE LIST */
 842
 843         if (fpn) {
 844             tpn = fpn;
 845         }
 846         else {
 847             if (!(tpn = malloc(sizeof(XvVideoNotifyRec))))
 848                 return BadAlloc;
 849             tpn->next = pn->next;
 850             pn->next = tpn;
 851         }
 852     }
 853
 854     /* INIT CLIENT PTR IN CASE WE CAN'T ADD RESOURCE */
 855     /* ADD RESOURCE SO THAT IF CLIENT EXITS THE CLIENT PTR WILL BE CLEARED */
 856
 857     tpn->client = NULL;
 858     tpn->id = FakeClientID(client->index);
 859     if (!AddResource(tpn->id, XvRTVideoNotify, tpn))
 860         return BadAlloc;
 861
 862     tpn->client = client;
 863     return Success;
 864
 865 }
 866
 867 int
 868 XvdiSelectPortNotify(ClientPtr client, XvPortPtr pPort, BOOL onoff)
 869 {
 870     XvPortNotifyPtr pn, tpn;
 871
 872     /* SEE IF CLIENT IS ALREADY IN LIST */
 873
 874     tpn = NULL;
 875     pn = pPort->pNotify;
 876     while (pn) {
 877         if (!pn->client)
 878             tpn = pn;           /* TAKE NOTE OF FREE ENTRY */
 879         if (pn->client == client)
 880             break;
 881         pn = pn->next;
 882     }
 883
 884     /* IS THE CLIENT ALREADY ON THE LIST? */
 885
 886     if (pn) {
 887         /* REMOVE IT? */
 888
 889         if (!onoff) {
 890             pn->client = NULL;
 891             FreeResource(pn->id, XvRTPortNotify);
 892         }
 893
 894         return Success;
 895     }
 896
 897     /* DIDN'T FIND IT; SO REUSE LIST ELEMENT IF ONE IS FREE OTHERWISE
 898        CREATE A NEW ONE AND ADD IT TO THE BEGINNING OF THE LIST */
 899
 900     if (!tpn) {
 901         if (!(tpn = malloc(sizeof(XvPortNotifyRec))))
 902             return BadAlloc;
 903         tpn->next = pPort->pNotify;
 904         pPort->pNotify = tpn;
 905     }
 906
 907     tpn->client = client;
 908     tpn->id = FakeClientID(client->index);
 909     if (!AddResource(tpn->id, XvRTPortNotify, tpn))
 910         return BadAlloc;
 911
 912     return Success;
 913
 914 }
 915
 916 int
 917 XvdiStopVideo(ClientPtr client, XvPortPtr pPort, DrawablePtr pDraw)
 918 {
 919     int status;
 920
 921     /* IF PORT ISN'T ACTIVE THEN WE'RE DONE */
 922
 923     if (!pPort->pDraw || (pPort->pDraw != pDraw)) {
 924         XvdiSendVideoNotify(pPort, pDraw, XvStopped);
 925         return Success;
 926     }
 927
 928     /* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN
 929        INFORM CLIENT OF ITS FAILURE */
 930
 931     if ((client) && (pPort->grab.client) && (pPort->grab.client != client)) {
 932         XvdiSendVideoNotify(pPort, pDraw, XvBusy);
 933         return Success;
 934     }
 935
 936     XvdiSendVideoNotify(pPort, pDraw, XvStopped);
 937
 938     status = (*pPort->pAdaptor->ddStopVideo) (pPort, pDraw);
 939
 940     pPort->pDraw = NULL;
 941     pPort->client = (ClientPtr) client;
 942     pPort->time = currentTime;
 943
 944     return status;
 945
 946 }
 947
 948 int
 949 XvdiMatchPort(XvPortPtr pPort, DrawablePtr pDraw)
 950 {
 951
 952     XvAdaptorPtr pa;
 953     XvFormatPtr pf;
 954     int nf;
 955
 956     pa = pPort->pAdaptor;
 957
 958     if (pa->pScreen != pDraw->pScreen)
 959         return BadMatch;
 960
 961     nf = pa->nFormats;
 962     pf = pa->pFormats;
 963
 964     while (nf--) {
 965         if (pf->depth == pDraw->depth)
 966             return Success;
 967         pf++;
 968     }
 969
 970     return BadMatch;
 971
 972 }
 973
 974 int
 975 XvdiSetPortAttribute(ClientPtr client,
 976                      XvPortPtr pPort, Atom attribute, INT32 value)
 977 {
 978     int status;
 979
 980     status =
 981         (*pPort->pAdaptor->ddSetPortAttribute) (pPort, attribute,
 982                                                 value);
 983     if (status == Success)
 984         XvdiSendPortNotify(pPort, attribute, value);
 985
 986     return status;
 987 }
 988
 989 int
 990 XvdiGetPortAttribute(ClientPtr client,
 991                      XvPortPtr pPort, Atom attribute, INT32 *p_value)
 992 {
 993
 994     return
 995         (*pPort->pAdaptor->ddGetPortAttribute) (pPort, attribute,
 996                                                 p_value);
 997
 998 }
 999
1000 static void _X_COLD
1001 WriteSwappedVideoNotifyEvent(xvEvent * from, xvEvent * to)
1002 {
1003
1004     to->u.u.type = from->u.u.type;
1005     to->u.u.detail = from->u.u.detail;
1006     cpswaps(from->u.videoNotify.sequenceNumber,
1007             to->u.videoNotify.sequenceNumber);
1008     cpswapl(from->u.videoNotify.time, to->u.videoNotify.time);
1009     cpswapl(from->u.videoNotify.drawable, to->u.videoNotify.drawable);
1010     cpswapl(from->u.videoNotify.port, to->u.videoNotify.port);
1011
1012 }
1013
1014 static void _X_COLD
1015 WriteSwappedPortNotifyEvent(xvEvent * from, xvEvent * to)
1016 {
1017
1018     to->u.u.type = from->u.u.type;
1019     to->u.u.detail = from->u.u.detail;
1020     cpswaps(from->u.portNotify.sequenceNumber, to->u.portNotify.sequenceNumber);
1021     cpswapl(from->u.portNotify.time, to->u.portNotify.time);
1022     cpswapl(from->u.portNotify.port, to->u.portNotify.port);
1023     cpswapl(from->u.portNotify.value, to->u.portNotify.value);
1024
1025 }
1026
1027 void
1028 XvFreeAdaptor(XvAdaptorPtr pAdaptor)
1029 {
1030     int i;
1031
1032     free(pAdaptor->name);
1033     pAdaptor->name = NULL;
1034
1035     if (pAdaptor->pEncodings) {
1036         XvEncodingPtr pEncode = pAdaptor->pEncodings;
1037
1038         for (i = 0; i < pAdaptor->nEncodings; i++, pEncode++)
1039             free(pEncode->name);
1040         free(pAdaptor->pEncodings);
1041         pAdaptor->pEncodings = NULL;
1042     }
1043
1044     free(pAdaptor->pFormats);
1045     pAdaptor->pFormats = NULL;
1046
1047     free(pAdaptor->pPorts);
1048     pAdaptor->pPorts = NULL;
1049
1050     if (pAdaptor->pAttributes) {
1051         XvAttributePtr pAttribute = pAdaptor->pAttributes;
1052
1053         for (i = 0; i < pAdaptor->nAttributes; i++, pAttribute++)
1054             free(pAttribute->name);
1055         free(pAdaptor->pAttributes);
1056         pAdaptor->pAttributes = NULL;
1057     }
1058
1059     free(pAdaptor->pImages);
1060     pAdaptor->pImages = NULL;
1061
1062     free(pAdaptor->devPriv.ptr);
1063     pAdaptor->devPriv.ptr = NULL;
1064 }
1065
1066 void
1067 XvFillColorKey(DrawablePtr pDraw, CARD32 key, RegionPtr region)
1068 {
1069     ScreenPtr pScreen = pDraw->pScreen;
1070     ChangeGCVal pval[2];
1071     BoxPtr pbox = RegionRects(region);
1072     int i, nbox = RegionNumRects(region);
1073     xRectangle *rects;
1074     GCPtr gc;
1075
1076     gc = GetScratchGC(pDraw->depth, pScreen);
1077     if (!gc)
1078         return;
1079
1080     pval[0].val = key;
1081     pval[1].val = IncludeInferiors;
1082     (void) ChangeGC(NullClient, gc, GCForeground | GCSubwindowMode, pval);
1083     ValidateGC(pDraw, gc);
1084
1085     rects = xallocarray(nbox, sizeof(xRectangle));
1086     if (rects) {
1087         for (i = 0; i < nbox; i++, pbox++) {
1088             rects[i].x = pbox->x1 - pDraw->x;
1089             rects[i].y = pbox->y1 - pDraw->y;
1090             rects[i].width = pbox->x2 - pbox->x1;
1091             rects[i].height = pbox->y2 - pbox->y1;
1092         }
1093
1094         (*gc->ops->PolyFillRect) (pDraw, gc, nbox, rects);
1095
1096         free(rects);
1097     }
1098     FreeScratchGC(gc);
1099 }