src/glx/apple/appledri.c

   1 /* $XFree86: xc/lib/GL/dri/XF86dri.c,v 1.12 2001/08/27 17:40:57 dawes Exp $ */
   2 /**************************************************************************
   3
   4 Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
   5 Copyright 2000 VA Linux Systems, Inc.
   6 Copyright (c) 2002, 2008 Apple Computer, Inc.
   7 All Rights Reserved.
   8
   9 Permission is hereby granted, free of charge, to any person obtaining a
  10 copy of this software and associated documentation files (the
  11 "Software"), to deal in the Software without restriction, including
  12 without limitation the rights to use, copy, modify, merge, publish,
  13 distribute, sub license, and/or sell copies of the Software, and to
  14 permit persons to whom the Software is furnished to do so, subject to
  15 the following conditions:
  16
  17 The above copyright notice and this permission notice (including the
  18 next paragraph) shall be included in all copies or substantial portions
  19 of the Software.
  20
  21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  24 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  25 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28
  29 **************************************************************************/
  30
  31 /*
  32  * Authors:
  33  *   Kevin E. Martin <martin@valinux.com>
  34  *   Jens Owen <jens@valinux.com>
  35  *   Rickard E. (Rik) Faith <faith@valinux.com>
  36  *
  37  */
  38
  39 /* THIS IS NOT AN X CONSORTIUM STANDARD */
  40
  41 #include <X11/Xlibint.h>
  42 #include "appledristr.h"
  43 #include <X11/extensions/Xext.h>
  44 #include <X11/extensions/extutil.h>
  45 #include <stdio.h>
  46
  47 static XExtensionInfo _appledri_info_data;
  48 static XExtensionInfo *appledri_info = &_appledri_info_data;
  49 static char *appledri_extension_name = APPLEDRINAME;
  50
  51 #define AppleDRICheckExtension(dpy,i,val) \
  52   XextCheckExtension (dpy, i, appledri_extension_name, val)
  53
  54 /*****************************************************************************
  55  *                                                                           *
  56  *                         private utility routines                          *
  57  *                                                                           *
  58  *****************************************************************************/
  59
  60 static int close_display(Display * dpy, XExtCodes * extCodes);
  61 static Bool wire_to_event(Display * dpy, XEvent * re, xEvent * event);
  62
  63 static /* const */ XExtensionHooks appledri_extension_hooks = {
  64    NULL,                        /* create_gc */
  65    NULL,                        /* copy_gc */
  66    NULL,                        /* flush_gc */
  67    NULL,                        /* free_gc */
  68    NULL,                        /* create_font */
  69    NULL,                        /* free_font */
  70    close_display,               /* close_display */
  71    wire_to_event,               /* wire_to_event */
  72    NULL,                        /* event_to_wire */
  73    NULL,                        /* error */
  74    NULL,                        /* error_string */
  75 };
  76
  77 static
  78 XEXT_GENERATE_FIND_DISPLAY(find_display, appledri_info,
  79                            appledri_extension_name,
  80                            &appledri_extension_hooks,
  81                            AppleDRINumberEvents, NULL)
  82
  83      static XEXT_GENERATE_CLOSE_DISPLAY(close_display, appledri_info)
  84
  85      static void (*surface_notify_handler) ();
  86
  87      void *XAppleDRISetSurfaceNotifyHandler(void (*fun) ())
  88 {
  89    void *old = surface_notify_handler;
  90    surface_notify_handler = fun;
  91    return old;
  92 }
  93
  94 static Bool
  95 wire_to_event(Display *dpy, XEvent *re, xEvent *event)
  96 {
  97    XExtDisplayInfo *info = find_display(dpy);
  98    xAppleDRINotifyEvent *sevent;
  99
 100    AppleDRICheckExtension(dpy, info, False);
 101
 102    switch ((event->u.u.type & 0x7f) - info->codes->first_event) {
 103    case AppleDRISurfaceNotify:
 104       sevent = (xAppleDRINotifyEvent *) event;
 105       if (surface_notify_handler != NULL) {
 106          (*surface_notify_handler) (dpy, (unsigned int) sevent->arg,
 107                                     (int) sevent->kind);
 108       }
 109       return False;
 110    }
 111    return False;
 112 }
 113
 114 /*****************************************************************************
 115  *                                                                           *
 116  *                  public Apple-DRI Extension routines                      *
 117  *                                                                           *
 118  *****************************************************************************/
 119
 120 #if 0
 121 #include <stdio.h>
 122 #define TRACE(msg)  fprintf(stderr, "AppleDRI%s\n", msg);
 123 #else
 124 #define TRACE(msg)
 125 #endif
 126
 127
 128 Bool
 129 XAppleDRIQueryExtension(dpy, event_basep, error_basep)
 130      Display *dpy;
 131      int *event_basep, *error_basep;
 132 {
 133    XExtDisplayInfo *info = find_display(dpy);
 134
 135    TRACE("QueryExtension...");
 136    if (XextHasExtension(info)) {
 137       *event_basep = info->codes->first_event;
 138       *error_basep = info->codes->first_error;
 139       TRACE("QueryExtension... return True");
 140       return True;
 141    }
 142    else {
 143       TRACE("QueryExtension... return False");
 144       return False;
 145    }
 146 }
 147
 148 Bool
 149 XAppleDRIQueryVersion(dpy, majorVersion, minorVersion, patchVersion)
 150      Display *dpy;
 151      int *majorVersion;
 152      int *minorVersion;
 153      int *patchVersion;
 154 {
 155    XExtDisplayInfo *info = find_display(dpy);
 156    xAppleDRIQueryVersionReply rep;
 157    xAppleDRIQueryVersionReq *req;
 158
 159    TRACE("QueryVersion...");
 160    AppleDRICheckExtension(dpy, info, False);
 161
 162    LockDisplay(dpy);
 163    GetReq(AppleDRIQueryVersion, req);
 164    req->reqType = info->codes->major_opcode;
 165    req->driReqType = X_AppleDRIQueryVersion;
 166    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 167       UnlockDisplay(dpy);
 168       SyncHandle();
 169       TRACE("QueryVersion... return False");
 170       return False;
 171    }
 172    *majorVersion = rep.majorVersion;
 173    *minorVersion = rep.minorVersion;
 174    *patchVersion = rep.patchVersion;
 175    UnlockDisplay(dpy);
 176    SyncHandle();
 177    TRACE("QueryVersion... return True");
 178    return True;
 179 }
 180
 181 Bool
 182 XAppleDRIQueryDirectRenderingCapable(dpy, screen, isCapable)
 183      Display *dpy;
 184      int screen;
 185      Bool *isCapable;
 186 {
 187    XExtDisplayInfo *info = find_display(dpy);
 188    xAppleDRIQueryDirectRenderingCapableReply rep;
 189    xAppleDRIQueryDirectRenderingCapableReq *req;
 190
 191    TRACE("QueryDirectRenderingCapable...");
 192    AppleDRICheckExtension(dpy, info, False);
 193
 194    LockDisplay(dpy);
 195    GetReq(AppleDRIQueryDirectRenderingCapable, req);
 196    req->reqType = info->codes->major_opcode;
 197    req->driReqType = X_AppleDRIQueryDirectRenderingCapable;
 198    req->screen = screen;
 199    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 200       UnlockDisplay(dpy);
 201       SyncHandle();
 202       TRACE("QueryDirectRenderingCapable... return False");
 203       return False;
 204    }
 205    *isCapable = rep.isCapable;
 206    UnlockDisplay(dpy);
 207    SyncHandle();
 208    TRACE("QueryDirectRenderingCapable... return True");
 209    return True;
 210 }
 211
 212 Bool
 213 XAppleDRIAuthConnection(dpy, screen, magic)
 214      Display *dpy;
 215      int screen;
 216      unsigned int magic;
 217 {
 218    XExtDisplayInfo *info = find_display(dpy);
 219    xAppleDRIAuthConnectionReq *req;
 220    xAppleDRIAuthConnectionReply rep;
 221
 222    TRACE("AuthConnection...");
 223    AppleDRICheckExtension(dpy, info, False);
 224
 225    LockDisplay(dpy);
 226    GetReq(AppleDRIAuthConnection, req);
 227    req->reqType = info->codes->major_opcode;
 228    req->driReqType = X_AppleDRIAuthConnection;
 229    req->screen = screen;
 230    req->magic = magic;
 231    rep.authenticated = 0;
 232    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse) || !rep.authenticated) {
 233       UnlockDisplay(dpy);
 234       SyncHandle();
 235       TRACE("AuthConnection... return False");
 236       return False;
 237    }
 238    UnlockDisplay(dpy);
 239    SyncHandle();
 240    TRACE("AuthConnection... return True");
 241    return True;
 242 }
 243
 244 Bool
 245 XAppleDRICreateSurface(dpy, screen, drawable, client_id, key, uid)
 246      Display *dpy;
 247      int screen;
 248      Drawable drawable;
 249      unsigned int client_id;
 250      unsigned int *key;
 251      unsigned int *uid;
 252 {
 253    XExtDisplayInfo *info = find_display(dpy);
 254    xAppleDRICreateSurfaceReply rep;
 255    xAppleDRICreateSurfaceReq *req;
 256
 257    TRACE("CreateSurface...");
 258    AppleDRICheckExtension(dpy, info, False);
 259
 260    LockDisplay(dpy);
 261    GetReq(AppleDRICreateSurface, req);
 262    req->reqType = info->codes->major_opcode;
 263    req->driReqType = X_AppleDRICreateSurface;
 264    req->screen = screen;
 265    req->drawable = drawable;
 266    req->client_id = client_id;
 267    rep.key_0 = rep.key_1 = rep.uid = 0;
 268    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse) || !rep.key_0) {
 269       UnlockDisplay(dpy);
 270       SyncHandle();
 271       TRACE("CreateSurface... return False");
 272       return False;
 273    }
 274    key[0] = rep.key_0;
 275    key[1] = rep.key_1;
 276    *uid = rep.uid;
 277    UnlockDisplay(dpy);
 278    SyncHandle();
 279    TRACE("CreateSurface... return True");
 280    return True;
 281 }
 282
 283 Bool
 284 XAppleDRIDestroySurface(dpy, screen, drawable)
 285      Display *dpy;
 286      int screen;
 287      Drawable drawable;
 288 {
 289    XExtDisplayInfo *info = find_display(dpy);
 290    xAppleDRIDestroySurfaceReq *req;
 291
 292    TRACE("DestroySurface...");
 293    AppleDRICheckExtension(dpy, info, False);
 294
 295    LockDisplay(dpy);
 296    GetReq(AppleDRIDestroySurface, req);
 297    req->reqType = info->codes->major_opcode;
 298    req->driReqType = X_AppleDRIDestroySurface;
 299    req->screen = screen;
 300    req->drawable = drawable;
 301    UnlockDisplay(dpy);
 302    SyncHandle();
 303    TRACE("DestroySurface... return True");
 304    return True;
 305 }
 306
 307 Bool
 308 XAppleDRICreateSharedBuffer(Display * dpy, int screen, Drawable drawable,
 309                             Bool doubleSwap, char *path, size_t pathlen,
 310                             int *width, int *height)
 311 {
 312    XExtDisplayInfo *info = find_display(dpy);
 313    xAppleDRICreateSharedBufferReq *req;
 314    xAppleDRICreateSharedBufferReply rep;
 315
 316    AppleDRICheckExtension(dpy, info, False);
 317
 318    LockDisplay(dpy);
 319    GetReq(AppleDRICreateSharedBuffer, req);
 320    req->reqType = info->codes->major_opcode;
 321    req->driReqType = X_AppleDRICreateSharedBuffer;
 322    req->screen = screen;
 323    req->drawable = drawable;
 324    req->doubleSwap = doubleSwap;
 325
 326
 327    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 328       puts("REPLY ERROR");
 329
 330       UnlockDisplay(dpy);
 331       SyncHandle();
 332       return False;
 333    }
 334
 335    /* printf("rep.stringLength %d\n", (int) rep.stringLength); */
 336
 337    if (rep.stringLength > 0 && rep.stringLength <= pathlen) {
 338       _XReadPad(dpy, path, rep.stringLength);
 339
 340       /* printf("path: %s\n", path); */
 341
 342       *width = rep.width;
 343       *height = rep.height;
 344
 345       UnlockDisplay(dpy);
 346       SyncHandle();
 347       return True;
 348    }
 349
 350    UnlockDisplay(dpy);
 351    SyncHandle();
 352
 353    return False;
 354 }
 355
 356 Bool
 357 XAppleDRISwapBuffers(Display * dpy, int screen, Drawable drawable)
 358 {
 359    XExtDisplayInfo *info = find_display(dpy);
 360    xAppleDRISwapBuffersReq *req;
 361
 362    AppleDRICheckExtension(dpy, info, False);
 363
 364    LockDisplay(dpy);
 365    GetReq(AppleDRISwapBuffers, req);
 366    req->reqType = info->codes->major_opcode;
 367    req->driReqType = X_AppleDRISwapBuffers;
 368    req->screen = screen;
 369    req->drawable = drawable;
 370    UnlockDisplay(dpy);
 371    SyncHandle();
 372
 373    return True;
 374 }
 375
 376 Bool
 377 XAppleDRICreatePixmap(Display * dpy, int screen, Drawable drawable,
 378                       int *width, int *height, int *pitch, int *bpp,
 379                       size_t * size, char *bufname, size_t bufnamesize)
 380 {
 381    XExtDisplayInfo *info = find_display(dpy);
 382    xAppleDRICreatePixmapReq *req;
 383    xAppleDRICreatePixmapReply rep;
 384
 385    AppleDRICheckExtension(dpy, info, False);
 386
 387    LockDisplay(dpy);
 388    GetReq(AppleDRICreatePixmap, req);
 389    req->reqType = info->codes->major_opcode;
 390    req->driReqType = X_AppleDRICreatePixmap;
 391    req->screen = screen;
 392    req->drawable = drawable;
 393
 394    if (!_XReply(dpy, (xReply *) & rep, 0, xFalse)) {
 395       UnlockDisplay(dpy);
 396       SyncHandle();
 397       return False;
 398    }
 399
 400    /*
 401       printf("rep.stringLength %d\n", (int) rep.stringLength);
 402     */
 403
 404    if (rep.stringLength > 0 && rep.stringLength <= bufnamesize) {
 405       _XReadPad(dpy, bufname, rep.stringLength);
 406
 407       /* printf("path: %s\n", bufname); */
 408
 409       *width = rep.width;
 410       *height = rep.height;
 411       *pitch = rep.pitch;
 412       *bpp = rep.bpp;
 413       *size = rep.size;
 414
 415       UnlockDisplay(dpy);
 416       SyncHandle();
 417       return True;
 418    }
 419    else if (rep.stringLength > 0) {
 420       _XEatData(dpy, rep.stringLength);
 421    }
 422
 423    UnlockDisplay(dpy);
 424    SyncHandle();
 425
 426    return True;
 427 }
 428
 429 /*
 430  * Call it a drawable, because we really don't know what it is
 431  * until it reaches the server, and we should keep that in mind.
 432  */
 433 Bool
 434 XAppleDRIDestroyPixmap(Display * dpy, Pixmap drawable)
 435 {
 436    XExtDisplayInfo *info = find_display(dpy);
 437    xAppleDRIDestroyPixmapReq *req;
 438
 439    AppleDRICheckExtension(dpy, info, False);
 440
 441    LockDisplay(dpy);
 442    GetReq(AppleDRIDestroyPixmap, req);
 443    req->reqType = info->codes->major_opcode;
 444    req->driReqType = X_AppleDRIDestroyPixmap;
 445    req->drawable = drawable;
 446    UnlockDisplay(dpy);
 447    SyncHandle();
 448
 449    return True;
 450 }