src/glx/dri2.c

   1 /*
   2  * Copyright © 2008 Red Hat, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Soft-
   6  * ware"), to deal in the Software without restriction, including without
   7  * limitation the rights to use, copy, modify, merge, publish, distribute,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, provided that the above copyright
  10  * notice(s) and this permission notice appear in all copies of the Soft-
  11  * ware and that both the above copyright notice(s) and this permission
  12  * notice appear in supporting documentation.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
  16  * ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY
  17  * RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN
  18  * THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSE-
  19  * QUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  20  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  21  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFOR-
  22  * MANCE OF THIS SOFTWARE.
  23  *
  24  * Except as contained in this notice, the name of a copyright holder shall
  25  * not be used in advertising or otherwise to promote the sale, use or
  26  * other dealings in this Software without prior written authorization of
  27  * the copyright holder.
  28  *
  29  * Authors:
  30  *   Kristian Høgsberg (krh@redhat.com)
  31  */
  32
  33
  34 #ifdef GLX_DIRECT_RENDERING
  35
  36 #include <stdio.h>
  37 #include <X11/Xlibint.h>
  38 #include <X11/extensions/Xext.h>
  39 #include <X11/extensions/extutil.h>
  40 #include <X11/extensions/dri2proto.h>
  41 #include "xf86drm.h"
  42 #include "dri2.h"
  43 #include "glxclient.h"
  44 #include "GL/glxext.h"
  45
  46 /* Allow the build to work with an older versions of dri2proto.h and
  47  * dri2tokens.h.
  48  */
  49 #if DRI2_MINOR < 1
  50 #undef DRI2_MINOR
  51 #define DRI2_MINOR 1
  52 #define X_DRI2GetBuffersWithFormat 7
  53 #endif
  54
  55
  56 static char dri2ExtensionName[] = DRI2_NAME;
  57 static XExtensionInfo *dri2Info;
  58 static XEXT_GENERATE_CLOSE_DISPLAY (DRI2CloseDisplay, dri2Info)
  59
  60 static Bool
  61 DRI2WireToEvent(Display *dpy, XEvent *event, xEvent *wire);
  62 static Status
  63 DRI2EventToWire(Display *dpy, XEvent *event, xEvent *wire);
  64 static int
  65 DRI2Error(Display *display, xError *err, XExtCodes *codes, int *ret_code);
  66
  67 static /* const */ XExtensionHooks dri2ExtensionHooks = {
  68   NULL,                   /* create_gc */
  69   NULL,                   /* copy_gc */
  70   NULL,                   /* flush_gc */
  71   NULL,                   /* free_gc */
  72   NULL,                   /* create_font */
  73   NULL,                   /* free_font */
  74   DRI2CloseDisplay,       /* close_display */
  75   DRI2WireToEvent,        /* wire_to_event */
  76   DRI2EventToWire,        /* event_to_wire */
  77   DRI2Error,              /* error */
  78   NULL,                   /* error_string */
  79 };
  80
  81 static XEXT_GENERATE_FIND_DISPLAY (DRI2FindDisplay,
  82                                    dri2Info,
  83                                    dri2ExtensionName,
  84                                    &dri2ExtensionHooks,
  85                                    0, NULL)
  86
  87 static Bool
  88 DRI2WireToEvent(Display *dpy, XEvent *event, xEvent *wire)
  89 {
  90    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
  91
  92    XextCheckExtension(dpy, info, dri2ExtensionName, False);
  93
  94    switch ((wire->u.u.type & 0x7f) - info->codes->first_event) {
  95
  96 #ifdef X_DRI2SwapBuffers
  97    case DRI2_BufferSwapComplete:
  98    {
  99       GLXBufferSwapComplete *aevent = (GLXBufferSwapComplete *)event;
 100       xDRI2BufferSwapComplete *awire = (xDRI2BufferSwapComplete *)wire;
 101
 102       /* Ignore swap events if we're not looking for them */
 103       aevent->type = dri2GetSwapEventType(dpy, awire->drawable);
 104       if(!aevent->type)
 105          return False;
 106
 107       aevent->serial = _XSetLastRequestRead(dpy, (xGenericReply *) wire);
 108       aevent->send_event = (awire->type & 0x80) != 0;
 109       aevent->display = dpy;
 110       aevent->drawable = awire->drawable;
 111       switch (awire->event_type) {
 112       case DRI2_EXCHANGE_COMPLETE:
 113          aevent->event_type = GLX_EXCHANGE_COMPLETE_INTEL;
 114          break;
 115       case DRI2_BLIT_COMPLETE:
 116          aevent->event_type = GLX_COPY_COMPLETE_INTEL;
 117          break;
 118       case DRI2_FLIP_COMPLETE:
 119          aevent->event_type = GLX_FLIP_COMPLETE_INTEL;
 120          break;
 121       default:
 122          /* unknown swap completion type */
 123          return False;
 124       }
 125       aevent->ust = ((CARD64)awire->ust_hi << 32) | awire->ust_lo;
 126       aevent->msc = ((CARD64)awire->msc_hi << 32) | awire->msc_lo;
 127       aevent->sbc = ((CARD64)awire->sbc_hi << 32) | awire->sbc_lo;
 128       return True;
 129    }
 130 #endif
 131 #ifdef DRI2_InvalidateBuffers
 132    case DRI2_InvalidateBuffers:
 133    {
 134       xDRI2InvalidateBuffers *awire = (xDRI2InvalidateBuffers *)wire;
 135
 136       dri2InvalidateBuffers(dpy, awire->drawable);
 137       return False;
 138    }
 139 #endif
 140    default:
 141       /* client doesn't support server event */
 142       break;
 143    }
 144
 145    return False;
 146 }
 147
 148 /* We don't actually support this.  It doesn't make sense for clients to
 149  * send each other DRI2 events.
 150  */
 151 static Status
 152 DRI2EventToWire(Display *dpy, XEvent *event, xEvent *wire)
 153 {
 154    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 155
 156    XextCheckExtension(dpy, info, dri2ExtensionName, False);
 157
 158    switch (event->type) {
 159    default:
 160       /* client doesn't support server event */
 161       break;
 162    }
 163
 164    return Success;
 165 }
 166
 167 static int
 168 DRI2Error(Display *display, xError *err, XExtCodes *codes, int *ret_code)
 169 {
 170     if (err->majorCode == codes->major_opcode &&
 171         err->errorCode == BadDrawable &&
 172         err->minorCode == X_DRI2CopyRegion)
 173         return True;
 174
 175     /* If the X drawable was destroyed before the GLX drawable, the
 176      * DRI2 drawble will be gone by the time we call
 177      * DRI2DestroyDrawable.  So just ignore BadDrawable here. */
 178     if (err->majorCode == codes->major_opcode &&
 179         err->errorCode == BadDrawable &&
 180         err->minorCode == X_DRI2DestroyDrawable)
 181         return True;
 182
 183     return False;
 184 }
 185
 186 Bool
 187 DRI2QueryExtension(Display * dpy, int *eventBase, int *errorBase)
 188 {
 189    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 190
 191    if (XextHasExtension(info)) {
 192       *eventBase = info->codes->first_event;
 193       *errorBase = info->codes->first_error;
 194       return True;
 195    }
 196
 197    return False;
 198 }
 199
 200 Bool
 201 DRI2QueryVersion(Display * dpy, int *major, int *minor)
 202 {
 203    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 204    xDRI2QueryVersionReply rep;
 205    xDRI2QueryVersionReq *req;
 206    int i, nevents;
 207
 208    XextCheckExtension(dpy, info, dri2ExtensionName, False);
 209
 210    LockDisplay(dpy);
 211    GetReq(DRI2QueryVersion, req);
 212    req->reqType = info->codes->major_opcode;
 213    req->dri2ReqType = X_DRI2QueryVersion;
 214    req->majorVersion = DRI2_MAJOR;
 215    req->minorVersion = DRI2_MINOR;
 216    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 217       UnlockDisplay(dpy);
 218       SyncHandle();
 219       return False;
 220    }
 221    *major = rep.majorVersion;
 222    *minor = rep.minorVersion;
 223    UnlockDisplay(dpy);
 224    SyncHandle();
 225
 226    switch (rep.minorVersion) {
 227    case 1:
 228            nevents = 0;
 229            break;
 230    case 2:
 231            nevents = 1;
 232            break;
 233    case 3:
 234    default:
 235            nevents = 2;
 236            break;
 237    }
 238
 239    for (i = 0; i < nevents; i++) {
 240        XESetWireToEvent (dpy, info->codes->first_event + i, DRI2WireToEvent);
 241        XESetEventToWire (dpy, info->codes->first_event + i, DRI2EventToWire);
 242    }
 243
 244    return True;
 245 }
 246
 247 Bool
 248 DRI2Connect(Display * dpy, XID window, char **driverName, char **deviceName)
 249 {
 250    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 251    xDRI2ConnectReply rep;
 252    xDRI2ConnectReq *req;
 253
 254    XextCheckExtension(dpy, info, dri2ExtensionName, False);
 255
 256    LockDisplay(dpy);
 257    GetReq(DRI2Connect, req);
 258    req->reqType = info->codes->major_opcode;
 259    req->dri2ReqType = X_DRI2Connect;
 260    req->window = window;
 261    req->driverType = DRI2DriverDRI;
 262    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 263       UnlockDisplay(dpy);
 264       SyncHandle();
 265       return False;
 266    }
 267
 268    if (rep.driverNameLength == 0 && rep.deviceNameLength == 0) {
 269       UnlockDisplay(dpy);
 270       SyncHandle();
 271       return False;
 272    }
 273
 274    *driverName = Xmalloc(rep.driverNameLength + 1);
 275    if (*driverName == NULL) {
 276       _XEatData(dpy,
 277                 ((rep.driverNameLength + 3) & ~3) +
 278                 ((rep.deviceNameLength + 3) & ~3));
 279       UnlockDisplay(dpy);
 280       SyncHandle();
 281       return False;
 282    }
 283    _XReadPad(dpy, *driverName, rep.driverNameLength);
 284    (*driverName)[rep.driverNameLength] = '\0';
 285
 286    *deviceName = Xmalloc(rep.deviceNameLength + 1);
 287    if (*deviceName == NULL) {
 288       Xfree(*driverName);
 289       _XEatData(dpy, ((rep.deviceNameLength + 3) & ~3));
 290       UnlockDisplay(dpy);
 291       SyncHandle();
 292       return False;
 293    }
 294    _XReadPad(dpy, *deviceName, rep.deviceNameLength);
 295    (*deviceName)[rep.deviceNameLength] = '\0';
 296
 297    UnlockDisplay(dpy);
 298    SyncHandle();
 299
 300    return True;
 301 }
 302
 303 Bool
 304 DRI2Authenticate(Display * dpy, XID window, drm_magic_t magic)
 305 {
 306    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 307    xDRI2AuthenticateReq *req;
 308    xDRI2AuthenticateReply rep;
 309
 310    XextCheckExtension(dpy, info, dri2ExtensionName, False);
 311
 312    LockDisplay(dpy);
 313    GetReq(DRI2Authenticate, req);
 314    req->reqType = info->codes->major_opcode;
 315    req->dri2ReqType = X_DRI2Authenticate;
 316    req->window = window;
 317    req->magic = magic;
 318
 319    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 320       UnlockDisplay(dpy);
 321       SyncHandle();
 322       return False;
 323    }
 324
 325    UnlockDisplay(dpy);
 326    SyncHandle();
 327
 328    return rep.authenticated;
 329 }
 330
 331 void
 332 DRI2CreateDrawable(Display * dpy, XID drawable)
 333 {
 334    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 335    xDRI2CreateDrawableReq *req;
 336
 337    XextSimpleCheckExtension(dpy, info, dri2ExtensionName);
 338
 339    LockDisplay(dpy);
 340    GetReq(DRI2CreateDrawable, req);
 341    req->reqType = info->codes->major_opcode;
 342    req->dri2ReqType = X_DRI2CreateDrawable;
 343    req->drawable = drawable;
 344    UnlockDisplay(dpy);
 345    SyncHandle();
 346 }
 347
 348 void
 349 DRI2DestroyDrawable(Display * dpy, XID drawable)
 350 {
 351    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 352    xDRI2DestroyDrawableReq *req;
 353
 354    XextSimpleCheckExtension(dpy, info, dri2ExtensionName);
 355
 356    XSync(dpy, False);
 357
 358    LockDisplay(dpy);
 359    GetReq(DRI2DestroyDrawable, req);
 360    req->reqType = info->codes->major_opcode;
 361    req->dri2ReqType = X_DRI2DestroyDrawable;
 362    req->drawable = drawable;
 363    UnlockDisplay(dpy);
 364    SyncHandle();
 365 }
 366
 367 DRI2Buffer *
 368 DRI2GetBuffers(Display * dpy, XID drawable,
 369                int *width, int *height,
 370                unsigned int *attachments, int count, int *outCount)
 371 {
 372    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 373    xDRI2GetBuffersReply rep;
 374    xDRI2GetBuffersReq *req;
 375    DRI2Buffer *buffers;
 376    xDRI2Buffer repBuffer;
 377    CARD32 *p;
 378    int i;
 379
 380    XextCheckExtension(dpy, info, dri2ExtensionName, False);
 381
 382    LockDisplay(dpy);
 383    GetReqExtra(DRI2GetBuffers, count * 4, req);
 384    req->reqType = info->codes->major_opcode;
 385    req->dri2ReqType = X_DRI2GetBuffers;
 386    req->drawable = drawable;
 387    req->count = count;
 388    p = (CARD32 *) & req[1];
 389    for (i = 0; i < count; i++)
 390       p[i] = attachments[i];
 391
 392    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 393       UnlockDisplay(dpy);
 394       SyncHandle();
 395       return NULL;
 396    }
 397
 398    *width = rep.width;
 399    *height = rep.height;
 400    *outCount = rep.count;
 401
 402    buffers = Xmalloc(rep.count * sizeof buffers[0]);
 403    if (buffers == NULL) {
 404       _XEatData(dpy, rep.count * sizeof repBuffer);
 405       UnlockDisplay(dpy);
 406       SyncHandle();
 407       return NULL;
 408    }
 409
 410    for (i = 0; i < rep.count; i++) {
 411       _XReadPad(dpy, (char *) &repBuffer, sizeof repBuffer);
 412       buffers[i].attachment = repBuffer.attachment;
 413       buffers[i].name = repBuffer.name;
 414       buffers[i].pitch = repBuffer.pitch;
 415       buffers[i].cpp = repBuffer.cpp;
 416       buffers[i].flags = repBuffer.flags;
 417    }
 418
 419    UnlockDisplay(dpy);
 420    SyncHandle();
 421
 422    return buffers;
 423 }
 424
 425
 426 DRI2Buffer *
 427 DRI2GetBuffersWithFormat(Display * dpy, XID drawable,
 428                          int *width, int *height,
 429                          unsigned int *attachments, int count, int *outCount)
 430 {
 431    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 432    xDRI2GetBuffersReply rep;
 433    xDRI2GetBuffersReq *req;
 434    DRI2Buffer *buffers;
 435    xDRI2Buffer repBuffer;
 436    CARD32 *p;
 437    int i;
 438
 439    XextCheckExtension(dpy, info, dri2ExtensionName, False);
 440
 441    LockDisplay(dpy);
 442    GetReqExtra(DRI2GetBuffers, count * (4 * 2), req);
 443    req->reqType = info->codes->major_opcode;
 444    req->dri2ReqType = X_DRI2GetBuffersWithFormat;
 445    req->drawable = drawable;
 446    req->count = count;
 447    p = (CARD32 *) & req[1];
 448    for (i = 0; i < (count * 2); i++)
 449       p[i] = attachments[i];
 450
 451    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 452       UnlockDisplay(dpy);
 453       SyncHandle();
 454       return NULL;
 455    }
 456
 457    *width = rep.width;
 458    *height = rep.height;
 459    *outCount = rep.count;
 460
 461    buffers = Xmalloc(rep.count * sizeof buffers[0]);
 462    if (buffers == NULL) {
 463       _XEatData(dpy, rep.count * sizeof repBuffer);
 464       UnlockDisplay(dpy);
 465       SyncHandle();
 466       return NULL;
 467    }
 468
 469    for (i = 0; i < rep.count; i++) {
 470       _XReadPad(dpy, (char *) &repBuffer, sizeof repBuffer);
 471       buffers[i].attachment = repBuffer.attachment;
 472       buffers[i].name = repBuffer.name;
 473       buffers[i].pitch = repBuffer.pitch;
 474       buffers[i].cpp = repBuffer.cpp;
 475       buffers[i].flags = repBuffer.flags;
 476    }
 477
 478    UnlockDisplay(dpy);
 479    SyncHandle();
 480
 481    return buffers;
 482 }
 483
 484
 485 void
 486 DRI2CopyRegion(Display * dpy, XID drawable, XserverRegion region,
 487                CARD32 dest, CARD32 src)
 488 {
 489    XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 490    xDRI2CopyRegionReq *req;
 491    xDRI2CopyRegionReply rep;
 492
 493    XextSimpleCheckExtension(dpy, info, dri2ExtensionName);
 494
 495    LockDisplay(dpy);
 496    GetReq(DRI2CopyRegion, req);
 497    req->reqType = info->codes->major_opcode;
 498    req->dri2ReqType = X_DRI2CopyRegion;
 499    req->drawable = drawable;
 500    req->region = region;
 501    req->dest = dest;
 502    req->src = src;
 503
 504    _XReply(dpy, (xReply *) & rep, 0, xFalse);
 505
 506    UnlockDisplay(dpy);
 507    SyncHandle();
 508 }
 509
 510 #ifdef X_DRI2SwapBuffers
 511 static void
 512 load_swap_req(xDRI2SwapBuffersReq *req, CARD64 target, CARD64 divisor,
 513              CARD64 remainder)
 514 {
 515     req->target_msc_hi = target >> 32;
 516     req->target_msc_lo = target & 0xffffffff;
 517     req->divisor_hi = divisor >> 32;
 518     req->divisor_lo = divisor & 0xffffffff;
 519     req->remainder_hi = remainder >> 32;
 520     req->remainder_lo = remainder & 0xffffffff;
 521 }
 522
 523 static CARD64
 524 vals_to_card64(CARD32 lo, CARD32 hi)
 525 {
 526     return (CARD64)hi << 32 | lo;
 527 }
 528
 529 void DRI2SwapBuffers(Display *dpy, XID drawable, CARD64 target_msc,
 530                      CARD64 divisor, CARD64 remainder, CARD64 *count)
 531 {
 532     XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 533     xDRI2SwapBuffersReq *req;
 534     xDRI2SwapBuffersReply rep;
 535
 536     XextSimpleCheckExtension (dpy, info, dri2ExtensionName);
 537
 538     LockDisplay(dpy);
 539     GetReq(DRI2SwapBuffers, req);
 540     req->reqType = info->codes->major_opcode;
 541     req->dri2ReqType = X_DRI2SwapBuffers;
 542     req->drawable = drawable;
 543     load_swap_req(req, target_msc, divisor, remainder);
 544
 545     _XReply(dpy, (xReply *)&rep, 0, xFalse);
 546
 547     *count = vals_to_card64(rep.swap_lo, rep.swap_hi);
 548
 549     UnlockDisplay(dpy);
 550     SyncHandle();
 551 }
 552 #endif
 553
 554 #ifdef X_DRI2GetMSC
 555 Bool DRI2GetMSC(Display *dpy, XID drawable, CARD64 *ust, CARD64 *msc,
 556                 CARD64 *sbc)
 557 {
 558     XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 559     xDRI2GetMSCReq *req;
 560     xDRI2MSCReply rep;
 561
 562     XextCheckExtension (dpy, info, dri2ExtensionName, False);
 563
 564     LockDisplay(dpy);
 565     GetReq(DRI2GetMSC, req);
 566     req->reqType = info->codes->major_opcode;
 567     req->dri2ReqType = X_DRI2GetMSC;
 568     req->drawable = drawable;
 569
 570     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 571         UnlockDisplay(dpy);
 572         SyncHandle();
 573         return False;
 574     }
 575
 576     *ust = vals_to_card64(rep.ust_lo, rep.ust_hi);
 577     *msc = vals_to_card64(rep.msc_lo, rep.msc_hi);
 578     *sbc = vals_to_card64(rep.sbc_lo, rep.sbc_hi);
 579
 580     UnlockDisplay(dpy);
 581     SyncHandle();
 582
 583     return True;
 584 }
 585 #endif
 586
 587 #ifdef X_DRI2WaitMSC
 588 static void
 589 load_msc_req(xDRI2WaitMSCReq *req, CARD64 target, CARD64 divisor,
 590              CARD64 remainder)
 591 {
 592     req->target_msc_hi = target >> 32;
 593     req->target_msc_lo = target & 0xffffffff;
 594     req->divisor_hi = divisor >> 32;
 595     req->divisor_lo = divisor & 0xffffffff;
 596     req->remainder_hi = remainder >> 32;
 597     req->remainder_lo = remainder & 0xffffffff;
 598 }
 599
 600 Bool DRI2WaitMSC(Display *dpy, XID drawable, CARD64 target_msc, CARD64 divisor,
 601                  CARD64 remainder, CARD64 *ust, CARD64 *msc, CARD64 *sbc)
 602 {
 603     XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 604     xDRI2WaitMSCReq *req;
 605     xDRI2MSCReply rep;
 606
 607     XextCheckExtension (dpy, info, dri2ExtensionName, False);
 608
 609     LockDisplay(dpy);
 610     GetReq(DRI2WaitMSC, req);
 611     req->reqType = info->codes->major_opcode;
 612     req->dri2ReqType = X_DRI2WaitMSC;
 613     req->drawable = drawable;
 614     load_msc_req(req, target_msc, divisor, remainder);
 615
 616     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 617         UnlockDisplay(dpy);
 618         SyncHandle();
 619         return False;
 620     }
 621
 622     *ust = ((CARD64)rep.ust_hi << 32) | (CARD64)rep.ust_lo;
 623     *msc = ((CARD64)rep.msc_hi << 32) | (CARD64)rep.msc_lo;
 624     *sbc = ((CARD64)rep.sbc_hi << 32) | (CARD64)rep.sbc_lo;
 625
 626     UnlockDisplay(dpy);
 627     SyncHandle();
 628
 629     return True;
 630 }
 631 #endif
 632
 633 #ifdef X_DRI2WaitSBC
 634 static void
 635 load_sbc_req(xDRI2WaitSBCReq *req, CARD64 target)
 636 {
 637     req->target_sbc_hi = target >> 32;
 638     req->target_sbc_lo = target & 0xffffffff;
 639 }
 640
 641 Bool DRI2WaitSBC(Display *dpy, XID drawable, CARD64 target_sbc, CARD64 *ust,
 642                  CARD64 *msc, CARD64 *sbc)
 643 {
 644     XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 645     xDRI2WaitSBCReq *req;
 646     xDRI2MSCReply rep;
 647
 648     XextCheckExtension (dpy, info, dri2ExtensionName, False);
 649
 650     LockDisplay(dpy);
 651     GetReq(DRI2WaitSBC, req);
 652     req->reqType = info->codes->major_opcode;
 653     req->dri2ReqType = X_DRI2WaitSBC;
 654     req->drawable = drawable;
 655     load_sbc_req(req, target_sbc);
 656
 657     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
 658         UnlockDisplay(dpy);
 659         SyncHandle();
 660         return False;
 661     }
 662
 663     *ust = ((CARD64)rep.ust_hi << 32) | rep.ust_lo;
 664     *msc = ((CARD64)rep.msc_hi << 32) | rep.msc_lo;
 665     *sbc = ((CARD64)rep.sbc_hi << 32) | rep.sbc_lo;
 666
 667     UnlockDisplay(dpy);
 668     SyncHandle();
 669
 670     return True;
 671 }
 672 #endif
 673
 674 #ifdef X_DRI2SwapInterval
 675 void DRI2SwapInterval(Display *dpy, XID drawable, int interval)
 676 {
 677     XExtDisplayInfo *info = DRI2FindDisplay(dpy);
 678     xDRI2SwapIntervalReq *req;
 679
 680     XextSimpleCheckExtension (dpy, info, dri2ExtensionName);
 681
 682     LockDisplay(dpy);
 683     GetReq(DRI2SwapInterval, req);
 684     req->reqType = info->codes->major_opcode;
 685     req->dri2ReqType = X_DRI2SwapInterval;
 686     req->drawable = drawable;
 687     req->interval = interval;
 688     UnlockDisplay(dpy);
 689     SyncHandle();
 690 }
 691 #endif
 692
 693 #endif /* GLX_DIRECT_RENDERING */