va_dri.c 17.9 KB
Newer Older
root's avatar
root committed
1 2 3 4 5
/* $XFree86: xc/lib/GL/dri/XF86dri.c,v 1.13 2002/10/30 12:51:25 alanh Exp $ */
/**************************************************************************

Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
Copyright 2000 VA Linux Systems, Inc.
6
Copyright 2007 Intel Corporation
root's avatar
root committed
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
All Rights Reserved.

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, sub license, 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 NON-INFRINGEMENT.
IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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.

**************************************************************************/

/*
 * Authors:
 *   Kevin E. Martin <martin@valinux.com>
 *   Jens Owen <jens@tungstengraphics.com>
 *   Rickard E. (Rik) Faith <faith@valinux.com>
 *
 */

/* THIS IS NOT AN X CONSORTIUM STANDARD */

#define NEED_REPLIES
#include <X11/Xlibint.h>
#include <X11/extensions/Xext.h>
#include <X11/extensions/extutil.h>
45
#include "va_dristr.h"
root's avatar
root committed
46 47 48

#define PUBLIC

49 50 51
static XExtensionInfo _va_dri_info_data;
static XExtensionInfo *va_dri_info = &_va_dri_info_data;
static char va_dri_extension_name[] = VA_DRINAME;
root's avatar
root committed
52

53 54
#define VA_DRICheckExtension(dpy,i,val) \
  XextCheckExtension (dpy, i, va_dri_extension_name, val)
root's avatar
root committed
55 56 57 58 59 60 61 62

/*****************************************************************************
 *                                                                           *
 *			   private utility routines                          *
 *                                                                           *
 *****************************************************************************/

static int close_display(Display *dpy, XExtCodes *extCodes);
63
static /* const */ XExtensionHooks va_dri_extension_hooks = {
root's avatar
root committed
64 65 66 67 68 69 70 71 72 73 74 75 76
    NULL,				/* create_gc */
    NULL,				/* copy_gc */
    NULL,				/* flush_gc */
    NULL,				/* free_gc */
    NULL,				/* create_font */
    NULL,				/* free_font */
    close_display,			/* close_display */
    NULL,				/* wire_to_event */
    NULL,				/* event_to_wire */
    NULL,				/* error */
    NULL,				/* error_string */
};

77 78 79
static XEXT_GENERATE_FIND_DISPLAY (find_display, va_dri_info, 
				   va_dri_extension_name, 
				   &va_dri_extension_hooks, 
root's avatar
root committed
80 81
				   0, NULL)

82
static XEXT_GENERATE_CLOSE_DISPLAY (close_display, va_dri_info)
root's avatar
root committed
83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98


/*****************************************************************************
 *                                                                           *
 *		    public XFree86-DRI Extension routines                    *
 *                                                                           *
 *****************************************************************************/

#if 0
#include <stdio.h>
#define TRACE(msg)  fprintf(stderr,"XF86DRI%s\n", msg);
#else
#define TRACE(msg)
#endif


99
PUBLIC Bool VA_DRIQueryExtension (dpy, event_basep, error_basep)
root's avatar
root committed
100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
    Display *dpy;
    int *event_basep, *error_basep;
{
    XExtDisplayInfo *info = find_display (dpy);

    TRACE("QueryExtension...");
    if (XextHasExtension(info)) {
	*event_basep = info->codes->first_event;
	*error_basep = info->codes->first_error;
        TRACE("QueryExtension... return True");
	return True;
    } else {
        TRACE("QueryExtension... return False");
	return False;
    }
}

117
PUBLIC Bool VA_DRIQueryVersion(dpy, majorVersion, minorVersion, patchVersion)
root's avatar
root committed
118 119 120 121 122 123
    Display* dpy;
    int* majorVersion; 
    int* minorVersion;
    int* patchVersion;
{
    XExtDisplayInfo *info = find_display (dpy);
124 125
    xVA_DRIQueryVersionReply rep;
    xVA_DRIQueryVersionReq *req;
root's avatar
root committed
126 127

    TRACE("QueryVersion...");
128
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
129 130

    LockDisplay(dpy);
131
    GetReq(VA_DRIQueryVersion, req);
root's avatar
root committed
132
    req->reqType = info->codes->major_opcode;
133
    req->driReqType = X_VA_DRIQueryVersion;
root's avatar
root committed
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("QueryVersion... return False");
	return False;
    }
    *majorVersion = rep.majorVersion;
    *minorVersion = rep.minorVersion;
    *patchVersion = rep.patchVersion;
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("QueryVersion... return True");
    return True;
}

149
PUBLIC Bool VA_DRIQueryDirectRenderingCapable(dpy, screen, isCapable)
root's avatar
root committed
150 151 152 153 154
    Display* dpy;
    int screen;
    Bool* isCapable;
{
    XExtDisplayInfo *info = find_display (dpy);
155 156
    xVA_DRIQueryDirectRenderingCapableReply rep;
    xVA_DRIQueryDirectRenderingCapableReq *req;
root's avatar
root committed
157 158

    TRACE("QueryDirectRenderingCapable...");
159
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
160 161

    LockDisplay(dpy);
162
    GetReq(VA_DRIQueryDirectRenderingCapable, req);
root's avatar
root committed
163
    req->reqType = info->codes->major_opcode;
164
    req->driReqType = X_VA_DRIQueryDirectRenderingCapable;
root's avatar
root committed
165 166 167 168 169 170 171 172 173 174 175 176 177 178
    req->screen = screen;
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("QueryDirectRenderingCapable... return False");
	return False;
    }
    *isCapable = rep.isCapable;
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("QueryDirectRenderingCapable... return True");
    return True;
}

179
PUBLIC Bool VA_DRIOpenConnection(dpy, screen, hSAREA, busIdString)
root's avatar
root committed
180 181 182 183 184 185
    Display* dpy;
    int screen;
    drm_handle_t * hSAREA;
    char **busIdString;
{
    XExtDisplayInfo *info = find_display (dpy);
186 187
    xVA_DRIOpenConnectionReply rep;
    xVA_DRIOpenConnectionReq *req;
root's avatar
root committed
188 189

    TRACE("OpenConnection...");
190
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
191 192

    LockDisplay(dpy);
193
    GetReq(VA_DRIOpenConnection, req);
root's avatar
root committed
194
    req->reqType = info->codes->major_opcode;
195
    req->driReqType = X_VA_DRIOpenConnection;
root's avatar
root committed
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
    req->screen = screen;
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("OpenConnection... return False");
	return False;
    }

    *hSAREA = rep.hSAREALow;
    if (sizeof(drm_handle_t) == 8) {
       int shift = 32; /* var to prevent warning on next line */
       *hSAREA |= ((drm_handle_t) rep.hSAREAHigh) << shift;
    }

    if (rep.length) {
        if (!(*busIdString = (char *)Xcalloc(rep.busIdStringLength + 1, 1))) {
            _XEatData(dpy, ((rep.busIdStringLength+3) & ~3));
            UnlockDisplay(dpy);
            SyncHandle();
            TRACE("OpenConnection... return False");
            return False;
        }
	_XReadPad(dpy, *busIdString, rep.busIdStringLength);
    } else {
        *busIdString = NULL;
    }
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("OpenConnection... return True");
    return True;
}

228
PUBLIC Bool VA_DRIAuthConnection(dpy, screen, magic)
root's avatar
root committed
229 230 231 232 233
    Display* dpy;
    int screen;
    drm_magic_t magic;
{
    XExtDisplayInfo *info = find_display (dpy);
234 235
    xVA_DRIAuthConnectionReq *req;
    xVA_DRIAuthConnectionReply rep;
root's avatar
root committed
236 237

    TRACE("AuthConnection...");
238
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
239 240

    LockDisplay(dpy);
241
    GetReq(VA_DRIAuthConnection, req);
root's avatar
root committed
242
    req->reqType = info->codes->major_opcode;
243
    req->driReqType = X_VA_DRIAuthConnection;
root's avatar
root committed
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
    req->screen = screen;
    req->magic = magic;
    rep.authenticated = 0;
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse) || !rep.authenticated) {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("AuthConnection... return False");
	return False;
    }
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("AuthConnection... return True");
    return True;
}

259
PUBLIC Bool VA_DRICloseConnection(dpy, screen)
root's avatar
root committed
260 261 262 263
    Display* dpy;
    int screen;
{
    XExtDisplayInfo *info = find_display (dpy);
264
    xVA_DRICloseConnectionReq *req;
root's avatar
root committed
265 266 267

    TRACE("CloseConnection...");

268
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
269 270

    LockDisplay(dpy);
271
    GetReq(VA_DRICloseConnection, req);
root's avatar
root committed
272
    req->reqType = info->codes->major_opcode;
273
    req->driReqType = X_VA_DRICloseConnection;
root's avatar
root committed
274 275 276 277 278 279 280
    req->screen = screen;
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("CloseConnection... return True");
    return True;
}

281
PUBLIC Bool VA_DRIGetClientDriverName(dpy, screen, ddxDriverMajorVersion, 
root's avatar
root committed
282 283 284 285 286 287 288 289 290
	ddxDriverMinorVersion, ddxDriverPatchVersion, clientDriverName)
    Display* dpy;
    int screen;
    int* ddxDriverMajorVersion;
    int* ddxDriverMinorVersion;
    int* ddxDriverPatchVersion;
    char** clientDriverName;
{
    XExtDisplayInfo *info = find_display (dpy);
291 292
    xVA_DRIGetClientDriverNameReply rep;
    xVA_DRIGetClientDriverNameReq *req;
root's avatar
root committed
293 294

    TRACE("GetClientDriverName...");
295
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
296 297

    LockDisplay(dpy);
298
    GetReq(VA_DRIGetClientDriverName, req);
root's avatar
root committed
299
    req->reqType = info->codes->major_opcode;
300
    req->driReqType = X_VA_DRIGetClientDriverName;
root's avatar
root committed
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
    req->screen = screen;
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("GetClientDriverName... return False");
	return False;
    }

    *ddxDriverMajorVersion = rep.ddxDriverMajorVersion;
    *ddxDriverMinorVersion = rep.ddxDriverMinorVersion;
    *ddxDriverPatchVersion = rep.ddxDriverPatchVersion;

    if (rep.length) {
        if (!(*clientDriverName = (char *)Xcalloc(rep.clientDriverNameLength + 1, 1))) {
            _XEatData(dpy, ((rep.clientDriverNameLength+3) & ~3));
            UnlockDisplay(dpy);
            SyncHandle();
            TRACE("GetClientDriverName... return False");
            return False;
        }
	_XReadPad(dpy, *clientDriverName, rep.clientDriverNameLength);
    } else {
        *clientDriverName = NULL;
    }
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("GetClientDriverName... return True");
    return True;
}

331
PUBLIC Bool VA_DRICreateContextWithConfig(dpy, screen, configID, context,
root's avatar
root committed
332 333 334 335 336 337 338 339
	hHWContext)
    Display* dpy;
    int screen;
    int configID;
    XID* context;
    drm_context_t * hHWContext;
{
    XExtDisplayInfo *info = find_display (dpy);
340 341
    xVA_DRICreateContextReply rep;
    xVA_DRICreateContextReq *req;
root's avatar
root committed
342 343

    TRACE("CreateContext...");
344
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
345 346

    LockDisplay(dpy);
347
    GetReq(VA_DRICreateContext, req);
root's avatar
root committed
348
    req->reqType = info->codes->major_opcode;
349
    req->driReqType = X_VA_DRICreateContext;
root's avatar
root committed
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
    req->visual = configID;
    req->screen = screen;
    *context = XAllocID(dpy);
    req->context = *context;
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("CreateContext... return False");
	return False;
    }
    *hHWContext = rep.hHWContext;
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("CreateContext... return True");
    return True;
}

367
PUBLIC Bool VA_DRICreateContext(dpy, screen, visual, context, hHWContext)
root's avatar
root committed
368 369 370 371 372 373
    Display* dpy;
    int screen;
    Visual* visual;
    XID* context;
    drm_context_t * hHWContext;
{
374
    return VA_DRICreateContextWithConfig( dpy, screen, visual->visualid,
root's avatar
root committed
375 376 377
					   context, hHWContext );
}

378
PUBLIC Bool VA_DRIDestroyContext( __DRInativeDisplay * ndpy, int screen, 
root's avatar
root committed
379 380 381 382
    __DRIid context )
{
    Display * const dpy = (Display *) ndpy;
    XExtDisplayInfo *info = find_display (dpy);
383
    xVA_DRIDestroyContextReq *req;
root's avatar
root committed
384 385

    TRACE("DestroyContext...");
386
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
387 388

    LockDisplay(dpy);
389
    GetReq(VA_DRIDestroyContext, req);
root's avatar
root committed
390
    req->reqType = info->codes->major_opcode;
391
    req->driReqType = X_VA_DRIDestroyContext;
root's avatar
root committed
392 393 394 395 396 397 398 399
    req->screen = screen;
    req->context = context;
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("DestroyContext... return True");
    return True;
}

400
PUBLIC Bool VA_DRICreateDrawable( __DRInativeDisplay * ndpy, int screen, 
root's avatar
root committed
401 402 403 404
    __DRIid drawable, drm_drawable_t * hHWDrawable )
{
    Display * const dpy = (Display *) ndpy;
    XExtDisplayInfo *info = find_display (dpy);
405 406
    xVA_DRICreateDrawableReply rep;
    xVA_DRICreateDrawableReq *req;
root's avatar
root committed
407 408

    TRACE("CreateDrawable...");
409
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
410 411

    LockDisplay(dpy);
412
    GetReq(VA_DRICreateDrawable, req);
root's avatar
root committed
413
    req->reqType = info->codes->major_opcode;
414
    req->driReqType = X_VA_DRICreateDrawable;
root's avatar
root committed
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
    req->screen = screen;
    req->drawable = drawable;
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("CreateDrawable... return False");
	return False;
    }
    *hHWDrawable = rep.hHWDrawable;
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("CreateDrawable... return True");
    return True;
}

430
PUBLIC Bool VA_DRIDestroyDrawable( __DRInativeDisplay * ndpy, int screen,
root's avatar
root committed
431 432 433 434
    __DRIid drawable )
{
    Display * const dpy = (Display *) ndpy;
    XExtDisplayInfo *info = find_display (dpy);
435
    xVA_DRIDestroyDrawableReq *req;
root's avatar
root committed
436 437

    TRACE("DestroyDrawable...");
438
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
439 440

    LockDisplay(dpy);
441
    GetReq(VA_DRIDestroyDrawable, req);
root's avatar
root committed
442
    req->reqType = info->codes->major_opcode;
443
    req->driReqType = X_VA_DRIDestroyDrawable;
root's avatar
root committed
444 445 446 447 448 449 450 451
    req->screen = screen;
    req->drawable = drawable;
    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("DestroyDrawable... return True");
    return True;
}

452
PUBLIC Bool VA_DRIGetDrawableInfo(Display* dpy, int screen, Drawable drawable,
root's avatar
root committed
453 454 455 456 457 458 459
    unsigned int* index, unsigned int* stamp,
    int* X, int* Y, int* W, int* H,
    int* numClipRects, drm_clip_rect_t ** pClipRects,
    int* backX, int* backY,
    int* numBackClipRects, drm_clip_rect_t ** pBackClipRects )
{
    XExtDisplayInfo *info = find_display (dpy);
460 461
    xVA_DRIGetDrawableInfoReply rep;
    xVA_DRIGetDrawableInfoReq *req;
root's avatar
root committed
462 463 464
    int total_rects;

    TRACE("GetDrawableInfo...");
465
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
466 467

    LockDisplay(dpy);
468
    GetReq(VA_DRIGetDrawableInfo, req);
root's avatar
root committed
469
    req->reqType = info->codes->major_opcode;
470
    req->driReqType = X_VA_DRIGetDrawableInfo;
root's avatar
root committed
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
    req->screen = screen;
    req->drawable = drawable;

    if (!_XReply(dpy, (xReply *)&rep, 1, xFalse)) 
    {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("GetDrawableInfo... return False");
	return False;
    }
    *index = rep.drawableTableIndex;
    *stamp = rep.drawableTableStamp;
    *X = (int)rep.drawableX;
    *Y = (int)rep.drawableY;
    *W = (int)rep.drawableWidth;
    *H = (int)rep.drawableHeight;
    *numClipRects = rep.numClipRects;
    total_rects = *numClipRects;

    *backX = rep.backX;
    *backY = rep.backY;
    *numBackClipRects = rep.numBackClipRects;
    total_rects += *numBackClipRects;

#if 0
    /* Because of the fix in Xserver/GL/dri/xf86dri.c, this check breaks
     * backwards compatibility (Because of the >> 2 shift) but the fix
     * enables multi-threaded apps to work.
     */
500
    if (rep.length !=  ((((SIZEOF(xVA_DRIGetDrawableInfoReply) - 
root's avatar
root committed
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
		       SIZEOF(xGenericReply) + 
		       total_rects * sizeof(drm_clip_rect_t)) + 3) & ~3) >> 2)) {
        _XEatData(dpy, rep.length);
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("GetDrawableInfo... return False");
        return False;
    }
#endif

    if (*numClipRects) {
       int len = sizeof(drm_clip_rect_t) * (*numClipRects);

       *pClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
       if (*pClipRects) 
	  _XRead(dpy, (char*)*pClipRects, len);
    } else {
        *pClipRects = NULL;
    }

    if (*numBackClipRects) {
       int len = sizeof(drm_clip_rect_t) * (*numBackClipRects);

       *pBackClipRects = (drm_clip_rect_t *)Xcalloc(len, 1);
       if (*pBackClipRects) 
	  _XRead(dpy, (char*)*pBackClipRects, len);
    } else {
        *pBackClipRects = NULL;
    }

    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("GetDrawableInfo... return True");
    return True;
}

537
PUBLIC Bool VA_DRIGetDeviceInfo(dpy, screen, hFrameBuffer, 
root's avatar
root committed
538 539 540 541 542 543 544 545 546 547 548
	fbOrigin, fbSize, fbStride, devPrivateSize, pDevPrivate)
    Display* dpy;
    int screen;
    drm_handle_t * hFrameBuffer;
    int* fbOrigin;
    int* fbSize;
    int* fbStride;
    int* devPrivateSize;
    void** pDevPrivate;
{
    XExtDisplayInfo *info = find_display (dpy);
549 550
    xVA_DRIGetDeviceInfoReply rep;
    xVA_DRIGetDeviceInfoReq *req;
root's avatar
root committed
551 552

    TRACE("GetDeviceInfo...");
553
    VA_DRICheckExtension (dpy, info, False);
root's avatar
root committed
554 555

    LockDisplay(dpy);
556
    GetReq(VA_DRIGetDeviceInfo, req);
root's avatar
root committed
557
    req->reqType = info->codes->major_opcode;
558
    req->driReqType = X_VA_DRIGetDeviceInfo;
root's avatar
root committed
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
    req->screen = screen;
    if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
	UnlockDisplay(dpy);
	SyncHandle();
        TRACE("GetDeviceInfo... return False");
	return False;
    }

    *hFrameBuffer = rep.hFrameBufferLow;
    if (sizeof(drm_handle_t) == 8) {
       int shift = 32; /* var to prevent warning on next line */
       *hFrameBuffer |= ((drm_handle_t) rep.hFrameBufferHigh) << shift;
    }

    *fbOrigin = rep.framebufferOrigin;
    *fbSize = rep.framebufferSize;
    *fbStride = rep.framebufferStride;
    *devPrivateSize = rep.devPrivateSize;

    if (rep.length) {
        if (!(*pDevPrivate = (void *)Xcalloc(rep.devPrivateSize, 1))) {
            _XEatData(dpy, ((rep.devPrivateSize+3) & ~3));
            UnlockDisplay(dpy);
            SyncHandle();
            TRACE("GetDeviceInfo... return False");
            return False;
        }
	_XRead(dpy, (char*)*pDevPrivate, rep.devPrivateSize);
    } else {
        *pDevPrivate = NULL;
    }

    UnlockDisplay(dpy);
    SyncHandle();
    TRACE("GetDeviceInfo... return True");
    return True;
}

597
PUBLIC Bool VA_DRIOpenFullScreen(dpy, screen, drawable)
root's avatar
root committed
598 599 600 601 602 603 604 605 606 607 608 609
    Display* dpy;
    int screen;
    Drawable drawable;
{
    /* This function and the underlying X protocol are deprecated.
     */
    (void) dpy;
    (void) screen;
    (void) drawable;
    return False;
}

610
PUBLIC Bool VA_DRICloseFullScreen(dpy, screen, drawable)
root's avatar
root committed
611 612 613 614 615 616 617 618 619 620 621
    Display* dpy;
    int screen;
    Drawable drawable;
{
    /* This function and the underlying X protocol are deprecated.
     */
    (void) dpy;
    (void) screen;
    (void) drawable;
    return True;
}
622 623 624

#undef TRACE