开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
XF86VMode.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：38k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

XF86VMode.c：源码内容
  1. /* $XConsortium: XF86VMode.c /main/2 1995/11/14 18:17:58 kaleb $ */
  2. /* $XFree86: xc/lib/Xxf86vm/XF86VMode.c,v 3.32 2001/07/25 15:04:54 dawes Exp $ */
  3. /*
  5. Copyright (c) 1995  Kaleb S. KEITHLEY
  7. Permission is hereby granted, free of charge, to any person obtaining
  8. a copy of this software and associated documentation files (the
  9. "Software"), to deal in the Software without restriction, including
  10. without limitation the rights to use, copy, modify, merge, publish,
  11. distribute, sublicense, and/or sell copies of the Software, and to
  12. permit persons to whom the Software is furnished to do so, subject to
  13. the following conditions:
  15. The above copyright notice and this permission notice shall be
  16. included in all copies or substantial portions of the Software.
  18. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19. EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20. MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21. IN NO EVENT SHALL Kaleb S. KEITHLEY BE LIABLE FOR ANY CLAIM, DAMAGES 
  22. OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  23. ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24. OTHER DEALINGS IN THE SOFTWARE.
  26. Except as contained in this notice, the name of Kaleb S. KEITHLEY 
  27. shall not be used in advertising or otherwise to promote the sale, use 
  28. or other dealings in this Software without prior written authorization
  29. from Kaleb S. KEITHLEY.
  31. */
  32. /* $XConsortium: XF86VMode.c /main/4 1996/01/16 07:52:25 kaleb CHECKEDOUT $ */
  34. /* THIS IS NOT AN X CONSORTIUM STANDARD */
  36. #define NEED_EVENTS
  37. #define NEED_REPLIES
  38. #ifndef XBUILD_IN_CLIENT
  39. #include <X11/Xlibint.h>
  40. #include "xf86vmstr.h"
  41. #include <X11/extensions/Xext.h>
  42. #include "extutil.h"
  43. #else
  44. #include "lib/X11/Xlibint.h"
  45. #include "include/extensions/xf86vmstr.h"
  46. #include "include/extensions/Xext.h"
  47. #include "include/extensions/extutil.h"
  48. #endif
  50. #ifdef DEBUG
  51. #include <stdio.h>
  52. #endif
  54. #ifndef MODE_BAD
  55. #define MODE_BAD 255
  56. #endif
  58. static XExtensionInfo _xf86vidmode_info_data;
  59. static XExtensionInfo *xf86vidmode_info = &_xf86vidmode_info_data;
  60. static char *xf86vidmode_extension_name = XF86VIDMODENAME;
  62. #define XF86VidModeCheckExtension(dpy,i,val) 
  63.   XextCheckExtension (dpy, i, xf86vidmode_extension_name, val)
  65. /*****************************************************************************
  66.  *                                                                           *
  67.  *    private utility routines                          *
  68.  *                                                                           *
  69.  *****************************************************************************/
  71. static XEXT_CLOSE_DISPLAY_PROTO(close_display);
  72. static /* const */ XExtensionHooks xf86vidmode_extension_hooks = {
  73.     NULL, /* create_gc */
  74.     NULL, /* copy_gc */
  75.     NULL, /* flush_gc */
  76.     NULL, /* free_gc */
  77.     NULL, /* create_font */
  78.     NULL, /* free_font */
  79.     close_display, /* close_display */
  80.     NULL, /* wire_to_event */
  81.     NULL, /* event_to_wire */
  82.     NULL, /* error */
  83.     NULL, /* error_string */
  84. };
  86. static XEXT_GENERATE_FIND_DISPLAY (find_display, xf86vidmode_info, 
  87.    xf86vidmode_extension_name, 
  88.    &xf86vidmode_extension_hooks, 
  89.    0, NULL)
  91. static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xf86vidmode_info)
  94. /*****************************************************************************
  95.  *                                                                           *
  96.  *     public XFree86-VidMode Extension routines                *
  97.  *                                                                           *
  98.  *****************************************************************************/
  100. Bool
  101. SDL_NAME(XF86VidModeQueryExtension) (dpy, event_basep, error_basep)
  102.     Display *dpy;
  103.     int *event_basep, *error_basep;
  104. {
  105.     XExtDisplayInfo *info = find_display (dpy);
  107.     if (XextHasExtension(info)) {
  108. *event_basep = info->codes->first_event;
  109. *error_basep = info->codes->first_error;
  110. return True;
  111.     } else {
  112. return False;
  113.     }
  114. }
  116. Bool
  117. SDL_NAME(XF86VidModeQueryVersion)(dpy, majorVersion, minorVersion)
  118.     Display* dpy;
  119.     int* majorVersion; 
  120.     int* minorVersion;
  121. {
  122.     XExtDisplayInfo *info = find_display (dpy);
  123.     xXF86VidModeQueryVersionReply rep;
  124.     xXF86VidModeQueryVersionReq *req;
  126.     XF86VidModeCheckExtension (dpy, info, False);
  128.     LockDisplay(dpy);
  129.     GetReq(XF86VidModeQueryVersion, req);
  130.     req->reqType = info->codes->major_opcode;
  131.     req->xf86vidmodeReqType = X_XF86VidModeQueryVersion;
  132.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  133. UnlockDisplay(dpy);
  134. SyncHandle();
  135. return False;
  136.     }
  137.     *majorVersion = rep.majorVersion;
  138.     *minorVersion = rep.minorVersion;
  139.     UnlockDisplay(dpy);
  140.     SyncHandle();
  141.     if (*majorVersion >= 2)
  142. SDL_NAME(XF86VidModeSetClientVersion)(dpy);
  143.     return True;
  144. }
  146. Bool
  147. SDL_NAME(XF86VidModeSetClientVersion)(Display *dpy)
  148. {
  149.     XExtDisplayInfo *info = find_display(dpy);
  150.     xXF86VidModeSetClientVersionReq *req;
  152.     XF86VidModeCheckExtension(dpy, info, False);
  154.     LockDisplay(dpy);
  155.     GetReq(XF86VidModeSetClientVersion, req);
  156.     req->reqType = info->codes->major_opcode;
  157.     req->xf86vidmodeReqType = X_XF86VidModeSetClientVersion;
  158.     req->major = XF86VIDMODE_MAJOR_VERSION;
  159.     req->minor = XF86VIDMODE_MINOR_VERSION;
  160.     UnlockDisplay(dpy);
  161.     SyncHandle();
  162.     return True;
  163. }
  165. Bool
  166. SDL_NAME(XF86VidModeSetGamma)(Display *dpy, int screen, SDL_NAME(XF86VidModeGamma) *Gamma)
  167. {
  168.     XExtDisplayInfo *info = find_display(dpy);
  169.     xXF86VidModeSetGammaReq *req;
  171.     XF86VidModeCheckExtension(dpy, info, False);
  173.     LockDisplay(dpy);
  174.     GetReq(XF86VidModeSetGamma, req);
  175.     req->reqType = info->codes->major_opcode;
  176.     req->xf86vidmodeReqType = X_XF86VidModeSetGamma;
  177.     req->screen = screen;
  178.     req->red = (CARD32)(Gamma->red * 10000.);
  179.     req->green = (CARD32)(Gamma->green * 10000.);
  180.     req->blue = (CARD32)(Gamma->blue * 10000.);
  181.     UnlockDisplay(dpy);
  182.     SyncHandle();
  183.     return True;
  184. }
  186. Bool
  187. SDL_NAME(XF86VidModeGetGamma)(Display *dpy, int screen, SDL_NAME(XF86VidModeGamma) *Gamma)
  188. {
  189.     XExtDisplayInfo *info = find_display (dpy);
  190.     xXF86VidModeGetGammaReply rep;
  191.     xXF86VidModeGetGammaReq *req;
  193.     XF86VidModeCheckExtension (dpy, info, False);
  195.     LockDisplay(dpy);
  196.     GetReq(XF86VidModeGetGamma, req);
  197.     req->reqType = info->codes->major_opcode;
  198.     req->xf86vidmodeReqType = X_XF86VidModeGetGamma;
  199.     req->screen = screen;
  200.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  201. UnlockDisplay(dpy);
  202. SyncHandle();
  203. return False;
  204.     }
  205.     Gamma->red = ((float)rep.red) / 10000.;
  206.     Gamma->green = ((float)rep.green) / 10000.;
  207.     Gamma->blue = ((float)rep.blue) / 10000.;
  208.     UnlockDisplay(dpy);
  209.     SyncHandle();
  210.     return True;
  211. }
  213. Bool
  214. SDL_NAME(XF86VidModeGetModeLine)(dpy, screen, dotclock, modeline)
  215.     Display* dpy;
  216.     int screen;
  217.     int* dotclock; 
  218.     SDL_NAME(XF86VidModeModeLine)* modeline;
  219. {
  220.     XExtDisplayInfo *info = find_display (dpy);
  221.     xXF86VidModeGetModeLineReply rep;
  222.     xXF86OldVidModeGetModeLineReply oldrep;
  223.     xXF86VidModeGetModeLineReq *req;
  224.     int majorVersion, minorVersion;
  226.     XF86VidModeCheckExtension (dpy, info, False);
  227.     SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
  229.     LockDisplay(dpy);
  230.     GetReq(XF86VidModeGetModeLine, req);
  231.     req->reqType = info->codes->major_opcode;
  232.     req->xf86vidmodeReqType = X_XF86VidModeGetModeLine;
  233.     req->screen = screen;
  234.     
  235.     if (majorVersion < 2) {
  236. if (!_XReply(dpy, (xReply *)&oldrep, 
  237.             (SIZEOF(xXF86OldVidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
  238.     UnlockDisplay(dpy);
  239.     SyncHandle();
  240.     return False;
  241. }
  242. *dotclock = oldrep.dotclock;
  243. modeline->hdisplay   = oldrep.hdisplay;
  244. modeline->hsyncstart = oldrep.hsyncstart;
  245. modeline->hsyncend   = oldrep.hsyncend;
  246. modeline->htotal     = oldrep.htotal;
  247. modeline->hskew      = 0;
  248. modeline->vdisplay   = oldrep.vdisplay;
  249. modeline->vsyncstart = oldrep.vsyncstart;
  250. modeline->vsyncend   = oldrep.vsyncend;
  251. modeline->vtotal     = oldrep.vtotal;
  252. modeline->flags      = oldrep.flags;
  253. modeline->privsize   = oldrep.privsize;
  254.     } else {
  255. if (!_XReply(dpy, (xReply *)&rep, 
  256.             (SIZEOF(xXF86VidModeGetModeLineReply) - SIZEOF(xReply)) >> 2, xFalse)) {
  257.     UnlockDisplay(dpy);
  258.     SyncHandle();
  259.     return False;
  260. }
  261. *dotclock = rep.dotclock;
  262. modeline->hdisplay   = rep.hdisplay;
  263. modeline->hsyncstart = rep.hsyncstart;
  264. modeline->hsyncend   = rep.hsyncend;
  265. modeline->htotal     = rep.htotal;
  266. modeline->hskew      = rep.hskew;
  267. modeline->vdisplay   = rep.vdisplay;
  268. modeline->vsyncstart = rep.vsyncstart;
  269. modeline->vsyncend   = rep.vsyncend;
  270. modeline->vtotal     = rep.vtotal;
  271. modeline->flags      = rep.flags;
  272. modeline->privsize   = rep.privsize;
  273.     }
  274.     
  275.     if (modeline->privsize > 0) {
  276. if (!(modeline->private = Xcalloc(modeline->privsize, sizeof(INT32)))) {
  277.     _XEatData(dpy, (modeline->privsize) * sizeof(INT32));
  278.     Xfree(modeline->private);
  279.     return False;
  280. }
  281. _XRead(dpy, (char*)modeline->private, modeline->privsize * sizeof(INT32));
  282.     } else {
  283. modeline->private = NULL;
  284.     }
  285.     UnlockDisplay(dpy);
  286.     SyncHandle();
  287.     return True;
  288. }
  290. Bool
  291. SDL_NAME(XF86VidModeGetAllModeLines)(dpy, screen, modecount, modelinesPtr)
  292.     Display* dpy;
  293.     int screen;
  294.     int* modecount; 
  295.     SDL_NAME(XF86VidModeModeInfo) ***modelinesPtr;
  296. {
  297.     XExtDisplayInfo *info = find_display (dpy);
  298.     xXF86VidModeGetAllModeLinesReply rep;
  299.     xXF86VidModeGetAllModeLinesReq *req;
  300.     SDL_NAME(XF86VidModeModeInfo) *mdinfptr, **modelines;
  301.     xXF86VidModeModeInfo xmdline;
  302.     xXF86OldVidModeModeInfo oldxmdline;
  303.     int i;
  304.     int majorVersion, minorVersion;
  305.     Bool protocolBug = False;
  307.     XF86VidModeCheckExtension (dpy, info, False);
  309.     /*
  310.      * Note: There was a bug in the protocol implementation in versions
  311.      * 0.x with x < 8 (the .private field wasn't being passed over the wire).
  312.      * Check the server's version, and accept the old format if appropriate.
  313.      */
  315.     SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
  316.     if (majorVersion == 0 && minorVersion < 8) {
  317. protocolBug = True;
  318. #ifdef DEBUG
  319. fprintf(stderr, "XF86VidModeGetAllModeLines: Warning: Xserver is"
  320. "running an old version (%d.%d)n", majorVersion,
  321. minorVersion);
  322. #endif
  323.     }
  324.     
  325.     LockDisplay(dpy);
  326.     GetReq(XF86VidModeGetAllModeLines, req);
  327.     req->reqType = info->codes->major_opcode;
  328.     req->xf86vidmodeReqType = X_XF86VidModeGetAllModeLines;
  329.     req->screen = screen;
  330.     if (!_XReply(dpy, (xReply *)&rep, 
  331.         (SIZEOF(xXF86VidModeGetAllModeLinesReply) - SIZEOF(xReply)) >> 2, xFalse)) {
  332.         UnlockDisplay(dpy);
  333. SyncHandle();
  334. return False;
  335.     }
  337.     *modecount = rep.modecount;
  339.     if (!(modelines = (SDL_NAME(XF86VidModeModeInfo) **) Xcalloc(rep.modecount,
  340.                                           sizeof(SDL_NAME(XF86VidModeModeInfo) *)
  341.                                           +sizeof(SDL_NAME(XF86VidModeModeInfo))))) {
  342. if (majorVersion < 2)
  343.             _XEatData(dpy, (rep.modecount) * sizeof(xXF86OldVidModeModeInfo));
  344. else
  345.             _XEatData(dpy, (rep.modecount) * sizeof(xXF86VidModeModeInfo));
  346.         Xfree(modelines);
  347.         return False;
  348.     }
  349.     mdinfptr = (SDL_NAME(XF86VidModeModeInfo) *) (
  350.     (char *) modelines
  351.     + rep.modecount*sizeof(SDL_NAME(XF86VidModeModeInfo) *)
  352.     );
  354.     for (i = 0; i < rep.modecount; i++) {
  355.         modelines[i] = mdinfptr++;
  356. if (majorVersion < 2) {
  357.             _XRead(dpy, (char*)&oldxmdline, sizeof(xXF86OldVidModeModeInfo));
  358.     modelines[i]->dotclock   = oldxmdline.dotclock;
  359.     modelines[i]->hdisplay   = oldxmdline.hdisplay;
  360.     modelines[i]->hsyncstart = oldxmdline.hsyncstart;
  361.     modelines[i]->hsyncend   = oldxmdline.hsyncend;
  362.     modelines[i]->htotal     = oldxmdline.htotal;
  363.     modelines[i]->hskew      = 0;
  364.     modelines[i]->vdisplay   = oldxmdline.vdisplay;
  365.     modelines[i]->vsyncstart = oldxmdline.vsyncstart;
  366.     modelines[i]->vsyncend   = oldxmdline.vsyncend;
  367.     modelines[i]->vtotal     = oldxmdline.vtotal;
  368.     modelines[i]->flags      = oldxmdline.flags;
  369.     if (protocolBug) {
  370. modelines[i]->privsize = 0;
  371. modelines[i]->private = NULL;
  372.     } else {
  373. modelines[i]->privsize   = oldxmdline.privsize;
  374. if (oldxmdline.privsize > 0) {
  375.             if (!(modelines[i]->private =
  376.     Xcalloc(oldxmdline.privsize, sizeof(INT32)))) {
  377. _XEatData(dpy, (oldxmdline.privsize) * sizeof(INT32));
  378. Xfree(modelines[i]->private);
  379.     } else {
  380. _XRead(dpy, (char*)modelines[i]->private,
  381.      oldxmdline.privsize * sizeof(INT32));
  382.     }
  383. } else {
  384.   modelines[i]->private = NULL;
  385. }
  386.     }
  387. } else {
  388.             _XRead(dpy, (char*)&xmdline, sizeof(xXF86VidModeModeInfo));
  389.     modelines[i]->dotclock   = xmdline.dotclock;
  390.     modelines[i]->hdisplay   = xmdline.hdisplay;
  391.     modelines[i]->hsyncstart = xmdline.hsyncstart;
  392.     modelines[i]->hsyncend   = xmdline.hsyncend;
  393.     modelines[i]->htotal     = xmdline.htotal;
  394.     modelines[i]->hskew      = xmdline.hskew;
  395.     modelines[i]->vdisplay   = xmdline.vdisplay;
  396.     modelines[i]->vsyncstart = xmdline.vsyncstart;
  397.     modelines[i]->vsyncend   = xmdline.vsyncend;
  398.     modelines[i]->vtotal     = xmdline.vtotal;
  399.     modelines[i]->flags      = xmdline.flags;
  400.     if (protocolBug) {
  401. modelines[i]->privsize = 0;
  402. modelines[i]->private = NULL;
  403.     } else {
  404. modelines[i]->privsize   = xmdline.privsize;
  405. if (xmdline.privsize > 0) {
  406.     if (!(modelines[i]->private =
  407.     Xcalloc(xmdline.privsize, sizeof(INT32)))) {
  408. _XEatData(dpy, (xmdline.privsize) * sizeof(INT32));
  409. Xfree(modelines[i]->private);
  410.     } else {
  411. _XRead(dpy, (char*)modelines[i]->private,
  412.      xmdline.privsize * sizeof(INT32));
  413.     }
  414. } else {
  415.     modelines[i]->private = NULL;
  416. }
  417.     }
  418. }
  419.     }
  420.     *modelinesPtr = modelines;
  421.     UnlockDisplay(dpy);
  422.     SyncHandle();
  423.     return True;
  424. }
  426. /*
  427.  * GetReq replacement for use with VidMode protocols earlier than 2.0
  428.  */
  429. #if !defined(UNIXCPP) || defined(ANSICPP)
  430. #define GetOldReq(name, oldname, req) 
  431.         WORD64ALIGN
  432. if ((dpy->bufptr + SIZEOF(x##oldname##Req)) > dpy->bufmax)
  433. _XFlush(dpy);
  434. req = (x##oldname##Req *)(dpy->last_req = dpy->bufptr);
  435. req->reqType = X_##name;
  436. req->length = (SIZEOF(x##oldname##Req))>>2;
  437. dpy->bufptr += SIZEOF(x##oldname##Req);
  438. dpy->request++
  440. #else  /* non-ANSI C uses empty comment instead of "##" for token concatenation */
  441. #define GetOldReq(name, oldname, req) 
  442.         WORD64ALIGN
  443. if ((dpy->bufptr + SIZEOF(x/**/oldname/**/Req)) > dpy->bufmax)
  444. _XFlush(dpy);
  445. req = (x/**/oldname/**/Req *)(dpy->last_req = dpy->bufptr);
  446. req->reqType = X_/**/name;
  447. req->length = (SIZEOF(x/**/oldname/**/Req))>>2;
  448. dpy->bufptr += SIZEOF(x/**/oldname/**/Req);
  449. dpy->request++
  450. #endif
  452. Bool
  453. SDL_NAME(XF86VidModeAddModeLine) (dpy, screen, newmodeline, aftermodeline)
  454.     Display *dpy;
  455.     int screen;
  456.     SDL_NAME(XF86VidModeModeInfo)* newmodeline;
  457.     SDL_NAME(XF86VidModeModeInfo)* aftermodeline;
  458. {
  459.     XExtDisplayInfo *info = find_display (dpy);
  460.     xXF86VidModeAddModeLineReq *req;
  461.     xXF86OldVidModeAddModeLineReq *oldreq;
  462.     int majorVersion, minorVersion;
  464.     XF86VidModeCheckExtension (dpy, info, False);
  465.     SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
  467.     LockDisplay(dpy);
  468.     if (majorVersion < 2) {
  469. GetOldReq(XF86VidModeAddModeLine, XF86OldVidModeAddModeLine, oldreq);
  470. oldreq->reqType = info->codes->major_opcode;
  471. oldreq->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
  472. oldreq->screen = screen;
  473. oldreq->dotclock = newmodeline->dotclock;
  474. oldreq->hdisplay = newmodeline->hdisplay;
  475. oldreq->hsyncstart = newmodeline->hsyncstart;
  476. oldreq->hsyncend = newmodeline->hsyncend;
  477. oldreq->htotal = newmodeline->htotal;
  478. oldreq->vdisplay = newmodeline->vdisplay;
  479. oldreq->vsyncstart = newmodeline->vsyncstart;
  480. oldreq->vsyncend = newmodeline->vsyncend;
  481. oldreq->vtotal = newmodeline->vtotal;
  482. oldreq->flags = newmodeline->flags;
  483. oldreq->privsize = newmodeline->privsize;
  484. if (aftermodeline != NULL) {
  485.     oldreq->after_dotclock = aftermodeline->dotclock;
  486.     oldreq->after_hdisplay = aftermodeline->hdisplay;
  487.     oldreq->after_hsyncstart = aftermodeline->hsyncstart;
  488.     oldreq->after_hsyncend = aftermodeline->hsyncend;
  489.     oldreq->after_htotal = aftermodeline->htotal;
  490.     oldreq->after_vdisplay = aftermodeline->vdisplay;
  491.     oldreq->after_vsyncstart = aftermodeline->vsyncstart;
  492.     oldreq->after_vsyncend = aftermodeline->vsyncend;
  493.     oldreq->after_vtotal = aftermodeline->vtotal;
  494.     oldreq->after_flags = aftermodeline->flags;
  495. } else {
  496.     oldreq->after_dotclock = 0;
  497.     oldreq->after_hdisplay = 0;
  498.     oldreq->after_hsyncstart = 0;
  499.     oldreq->after_hsyncend = 0;
  500.     oldreq->after_htotal = 0;
  501.     oldreq->after_vdisplay = 0;
  502.     oldreq->after_vsyncstart = 0;
  503.     oldreq->after_vsyncend = 0;
  504.     oldreq->after_vtotal = 0;
  505.     oldreq->after_flags = 0;
  506. }
  507. if (newmodeline->privsize) {
  508.     oldreq->length += newmodeline->privsize;
  509.     Data32(dpy, (long *) newmodeline->private,
  510.        newmodeline->privsize * sizeof(INT32));
  511. }
  512.     } else {
  513. GetReq(XF86VidModeAddModeLine, req);
  514. req->reqType = info->codes->major_opcode;
  515. req->xf86vidmodeReqType = X_XF86VidModeAddModeLine;
  516. req->screen = screen;
  517. req->dotclock = newmodeline->dotclock;
  518. req->hdisplay = newmodeline->hdisplay;
  519. req->hsyncstart = newmodeline->hsyncstart;
  520. req->hsyncend = newmodeline->hsyncend;
  521. req->htotal = newmodeline->htotal;
  522. req->hskew = newmodeline->hskew;
  523. req->vdisplay = newmodeline->vdisplay;
  524. req->vsyncstart = newmodeline->vsyncstart;
  525. req->vsyncend = newmodeline->vsyncend;
  526. req->vtotal = newmodeline->vtotal;
  527. req->flags = newmodeline->flags;
  528. req->privsize = newmodeline->privsize;
  529. if (aftermodeline != NULL) {
  530.     req->after_dotclock = aftermodeline->dotclock;
  531.     req->after_hdisplay = aftermodeline->hdisplay;
  532.     req->after_hsyncstart = aftermodeline->hsyncstart;
  533.     req->after_hsyncend = aftermodeline->hsyncend;
  534.     req->after_htotal = aftermodeline->htotal;
  535.     req->after_hskew = aftermodeline->hskew;
  536.     req->after_vdisplay = aftermodeline->vdisplay;
  537.     req->after_vsyncstart = aftermodeline->vsyncstart;
  538.     req->after_vsyncend = aftermodeline->vsyncend;
  539.     req->after_vtotal = aftermodeline->vtotal;
  540.     req->after_flags = aftermodeline->flags;
  541. } else {
  542.     req->after_dotclock = 0;
  543.     req->after_hdisplay = 0;
  544.     req->after_hsyncstart = 0;
  545.     req->after_hsyncend = 0;
  546.     req->after_htotal = 0;
  547.     req->after_hskew = 0;
  548.     req->after_vdisplay = 0;
  549.     req->after_vsyncstart = 0;
  550.     req->after_vsyncend = 0;
  551.     req->after_vtotal = 0;
  552.     req->after_flags = 0;
  553. }
  554. if (newmodeline->privsize) {
  555.     req->length += newmodeline->privsize;
  556.     Data32(dpy, (long *) newmodeline->private,
  557.        newmodeline->privsize * sizeof(INT32));
  558. }
  559.     }
  560.     UnlockDisplay(dpy);
  561.     SyncHandle();
  562.     return True;
  563. }
  565. Bool
  566. SDL_NAME(XF86VidModeDeleteModeLine) (dpy, screen, modeline)
  567.     Display *dpy;
  568.     int screen;
  569.     SDL_NAME(XF86VidModeModeInfo)* modeline;
  570. {
  571.     XExtDisplayInfo *info = find_display (dpy);
  572.     xXF86VidModeDeleteModeLineReq *req;
  573.     xXF86OldVidModeDeleteModeLineReq *oldreq;
  574.     int majorVersion, minorVersion;
  576.     XF86VidModeCheckExtension (dpy, info, 0);
  577.     SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
  579.     LockDisplay(dpy);
  580.     if (majorVersion < 2) {
  581. GetOldReq(XF86VidModeDeleteModeLine, XF86OldVidModeDeleteModeLine, oldreq);
  582. oldreq->reqType = info->codes->major_opcode;
  583. oldreq->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
  584. oldreq->screen = screen;
  585. oldreq->dotclock = modeline->dotclock;
  586. oldreq->hdisplay = modeline->hdisplay;
  587. oldreq->hsyncstart = modeline->hsyncstart;
  588. oldreq->hsyncend = modeline->hsyncend;
  589. oldreq->htotal = modeline->htotal;
  590. oldreq->vdisplay = modeline->vdisplay;
  591. oldreq->vsyncstart = modeline->vsyncstart;
  592. oldreq->vsyncend = modeline->vsyncend;
  593. oldreq->vtotal = modeline->vtotal;
  594. oldreq->flags = modeline->flags;
  595. oldreq->privsize = modeline->privsize;
  596. if (modeline->privsize) {
  597.     oldreq->length += modeline->privsize;
  598.     Data32(dpy, (long *) modeline->private,
  599.        modeline->privsize * sizeof(INT32));
  600. }
  601.     } else {
  602. GetReq(XF86VidModeDeleteModeLine, req);
  603. req->reqType = info->codes->major_opcode;
  604. req->xf86vidmodeReqType = X_XF86VidModeDeleteModeLine;
  605. req->screen = screen;
  606. req->dotclock = modeline->dotclock;
  607. req->hdisplay = modeline->hdisplay;
  608. req->hsyncstart = modeline->hsyncstart;
  609. req->hsyncend = modeline->hsyncend;
  610. req->htotal = modeline->htotal;
  611. req->hskew = modeline->hskew;
  612. req->vdisplay = modeline->vdisplay;
  613. req->vsyncstart = modeline->vsyncstart;
  614. req->vsyncend = modeline->vsyncend;
  615. req->vtotal = modeline->vtotal;
  616. req->flags = modeline->flags;
  617. req->privsize = modeline->privsize;
  618. if (modeline->privsize) {
  619.     req->length += modeline->privsize;
  620.     Data32(dpy, (long *) modeline->private,
  621.        modeline->privsize * sizeof(INT32));
  622. }
  623.     }
  624.     UnlockDisplay(dpy);
  625.     SyncHandle();
  626.     return True;
  627. }
  629. Bool
  630. SDL_NAME(XF86VidModeModModeLine) (dpy, screen, modeline)
  631.     Display *dpy;
  632.     int screen;
  633.     SDL_NAME(XF86VidModeModeLine)* modeline;
  634. {
  635.     XExtDisplayInfo *info = find_display (dpy);
  636.     xXF86VidModeModModeLineReq *req;
  637.     xXF86OldVidModeModModeLineReq *oldreq;
  638.     int majorVersion, minorVersion;
  640.     XF86VidModeCheckExtension (dpy, info, 0);
  641.     SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
  643.     LockDisplay(dpy);
  644.     if (majorVersion < 2) {
  645. GetOldReq(XF86VidModeModModeLine, XF86OldVidModeModModeLine, oldreq);
  646. oldreq->reqType = info->codes->major_opcode;
  647. oldreq->xf86vidmodeReqType = X_XF86VidModeModModeLine;
  648. oldreq->screen = screen;
  649. oldreq->hdisplay = modeline->hdisplay;
  650. oldreq->hsyncstart = modeline->hsyncstart;
  651. oldreq->hsyncend = modeline->hsyncend;
  652. oldreq->htotal = modeline->htotal;
  653. oldreq->vdisplay = modeline->vdisplay;
  654. oldreq->vsyncstart = modeline->vsyncstart;
  655. oldreq->vsyncend = modeline->vsyncend;
  656. oldreq->vtotal = modeline->vtotal;
  657. oldreq->flags = modeline->flags;
  658. oldreq->privsize = modeline->privsize;
  659. if (modeline->privsize) {
  660.     oldreq->length += modeline->privsize;
  661.     Data32(dpy, (long *) modeline->private,
  662.        modeline->privsize * sizeof(INT32));
  663. }
  664.     } else {
  665. GetReq(XF86VidModeModModeLine, req);
  666. req->reqType = info->codes->major_opcode;
  667. req->xf86vidmodeReqType = X_XF86VidModeModModeLine;
  668. req->screen = screen;
  669. req->hdisplay = modeline->hdisplay;
  670. req->hsyncstart = modeline->hsyncstart;
  671. req->hsyncend = modeline->hsyncend;
  672. req->htotal = modeline->htotal;
  673. req->hskew = modeline->hskew;
  674. req->vdisplay = modeline->vdisplay;
  675. req->vsyncstart = modeline->vsyncstart;
  676. req->vsyncend = modeline->vsyncend;
  677. req->vtotal = modeline->vtotal;
  678. req->flags = modeline->flags;
  679. req->privsize = modeline->privsize;
  680. if (modeline->privsize) {
  681.     req->length += modeline->privsize;
  682.     Data32(dpy, (long *) modeline->private,
  683.        modeline->privsize * sizeof(INT32));
  684. }
  685.     }
  686.     UnlockDisplay(dpy);
  687.     SyncHandle();
  688.     return True;
  689. }
  691. Status
  692. SDL_NAME(XF86VidModeValidateModeLine) (dpy, screen, modeline)
  693.     Display *dpy;
  694.     int screen;
  695.     SDL_NAME(XF86VidModeModeInfo)* modeline;
  696. {
  697.     XExtDisplayInfo *info = find_display (dpy);
  698.     xXF86VidModeValidateModeLineReq *req;
  699.     xXF86OldVidModeValidateModeLineReq *oldreq;
  700.     xXF86VidModeValidateModeLineReply rep;
  701.     int majorVersion, minorVersion;
  703.     XF86VidModeCheckExtension (dpy, info, 0);
  704.     SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
  706.     LockDisplay(dpy);
  708.     if (majorVersion < 2) {
  709. GetOldReq(XF86VidModeValidateModeLine, XF86OldVidModeValidateModeLine, oldreq);
  710. oldreq->reqType = info->codes->major_opcode;
  711. oldreq->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
  712. oldreq->screen = screen;
  713. oldreq->dotclock = modeline->dotclock;
  714. oldreq->hdisplay = modeline->hdisplay;
  715. oldreq->hsyncstart = modeline->hsyncstart;
  716. oldreq->hsyncend = modeline->hsyncend;
  717. oldreq->htotal = modeline->htotal;
  718. oldreq->vdisplay = modeline->vdisplay;
  719. oldreq->vsyncstart = modeline->vsyncstart;
  720. oldreq->vsyncend = modeline->vsyncend;
  721. oldreq->vtotal = modeline->vtotal;
  722. oldreq->flags = modeline->flags;
  723. oldreq->privsize = modeline->privsize;
  724. if (modeline->privsize) {
  725.     oldreq->length += modeline->privsize;
  726.     Data32(dpy, (long *) modeline->private,
  727.        modeline->privsize * sizeof(INT32));
  728. }
  729.     } else {
  730. GetReq(XF86VidModeValidateModeLine, req);
  731. req->reqType = info->codes->major_opcode;
  732. req->xf86vidmodeReqType = X_XF86VidModeValidateModeLine;
  733. req->screen = screen;
  734. req->dotclock = modeline->dotclock;
  735. req->hdisplay = modeline->hdisplay;
  736. req->hsyncstart = modeline->hsyncstart;
  737. req->hsyncend = modeline->hsyncend;
  738. req->htotal = modeline->htotal;
  739. req->hskew = modeline->hskew;
  740. req->vdisplay = modeline->vdisplay;
  741. req->vsyncstart = modeline->vsyncstart;
  742. req->vsyncend = modeline->vsyncend;
  743. req->vtotal = modeline->vtotal;
  744. req->flags = modeline->flags;
  745. req->privsize = modeline->privsize;
  746. if (modeline->privsize) {
  747.     req->length += modeline->privsize;
  748.     Data32(dpy, (long *) modeline->private,
  749.        modeline->privsize * sizeof(INT32));
  750. }
  751.     }
  752.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  753. UnlockDisplay(dpy);
  754. SyncHandle();
  755. return MODE_BAD;
  756.     }
  757.     UnlockDisplay(dpy);
  758.     SyncHandle();
  759.     return rep.status;
  760. }
  762. Bool
  763. SDL_NAME(XF86VidModeSwitchMode)(dpy, screen, zoom)
  764.     Display* dpy;
  765.     int screen;
  766.     int zoom;
  767. {
  768.     XExtDisplayInfo *info = find_display (dpy);
  769.     xXF86VidModeSwitchModeReq *req;
  771.     XF86VidModeCheckExtension (dpy, info, False);
  773.     LockDisplay(dpy);
  774.     GetReq(XF86VidModeSwitchMode, req);
  775.     req->reqType = info->codes->major_opcode;
  776.     req->xf86vidmodeReqType = X_XF86VidModeSwitchMode;
  777.     req->screen = screen;
  778.     req->zoom = zoom;
  779.     UnlockDisplay(dpy);
  780.     SyncHandle();
  781.     return True;
  782. }
  783.     
  784. Bool
  785. SDL_NAME(XF86VidModeSwitchToMode)(dpy, screen, modeline)
  786.     Display* dpy;
  787.     int screen;
  788.     SDL_NAME(XF86VidModeModeInfo)* modeline;
  789. {
  790.     XExtDisplayInfo *info = find_display (dpy);
  791.     xXF86VidModeSwitchToModeReq *req;
  792.     xXF86OldVidModeSwitchToModeReq *oldreq;
  793.     int majorVersion, minorVersion;
  794.     Bool protocolBug = False;
  796.     XF86VidModeCheckExtension (dpy, info, False);
  798.     /*
  799.      * Note: There was a bug in the protocol implementation in versions
  800.      * 0.x with x < 8 (the .private field wasn't expected to be sent over
  801.      * the wire).  Check the server's version, and accept the old format
  802.      * if appropriate.
  803.      */
  805.     SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
  806.     if (majorVersion == 0 && minorVersion < 8) {
  807. protocolBug = True;
  808. #ifdef DEBUG
  809. fprintf(stderr, "XF86VidModeSwitchToMode: Warning: Xserver is"
  810. "running an old version (%d.%d)n", majorVersion,
  811. minorVersion);
  812. #endif
  813.     }
  814.     
  815.     LockDisplay(dpy);
  816.     if (majorVersion < 2) {
  817. GetOldReq(XF86VidModeSwitchToMode, XF86OldVidModeSwitchToMode, oldreq);
  818. oldreq->reqType = info->codes->major_opcode;
  819. oldreq->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
  820. oldreq->screen = screen;
  821. oldreq->dotclock = modeline->dotclock;
  822. oldreq->hdisplay = modeline->hdisplay;
  823. oldreq->hsyncstart = modeline->hsyncstart;
  824. oldreq->hsyncend = modeline->hsyncend;
  825. oldreq->htotal = modeline->htotal;
  826. oldreq->vdisplay = modeline->vdisplay;
  827. oldreq->vsyncstart = modeline->vsyncstart;
  828. oldreq->vsyncend = modeline->vsyncend;
  829. oldreq->vtotal = modeline->vtotal;
  830. oldreq->flags = modeline->flags;
  831. if (protocolBug) {
  832.     oldreq->privsize = 0;
  833. } else {
  834.     oldreq->privsize = modeline->privsize;
  835.     if (modeline->privsize) {
  836. oldreq->length += modeline->privsize;
  837. Data32(dpy, (long *) modeline->private,
  838.            modeline->privsize * sizeof(INT32));
  839.     }
  840. }
  841.     } else {
  842. GetReq(XF86VidModeSwitchToMode, req);
  843. req->reqType = info->codes->major_opcode;
  844. req->xf86vidmodeReqType = X_XF86VidModeSwitchToMode;
  845. req->screen = screen;
  846. req->dotclock = modeline->dotclock;
  847. req->hdisplay = modeline->hdisplay;
  848. req->hsyncstart = modeline->hsyncstart;
  849. req->hsyncend = modeline->hsyncend;
  850. req->htotal = modeline->htotal;
  851. req->hskew = modeline->hskew;
  852. req->vdisplay = modeline->vdisplay;
  853. req->vsyncstart = modeline->vsyncstart;
  854. req->vsyncend = modeline->vsyncend;
  855. req->vtotal = modeline->vtotal;
  856. req->flags = modeline->flags;
  857. if (protocolBug) {
  858.     req->privsize = 0;
  859. } else {
  860.     req->privsize = modeline->privsize;
  861.     if (modeline->privsize) {
  862. req->length += modeline->privsize;
  863. Data32(dpy, (long *) modeline->private,
  864.            modeline->privsize * sizeof(INT32));
  865.     }
  866. }
  867.     }
  868.     UnlockDisplay(dpy);
  869.     SyncHandle();
  870.     return True;
  871. }
  872.     
  873. Bool
  874. SDL_NAME(XF86VidModeLockModeSwitch)(dpy, screen, lock)
  875.     Display* dpy;
  876.     int screen;
  877.     int lock;
  878. {
  879.     XExtDisplayInfo *info = find_display (dpy);
  880.     xXF86VidModeLockModeSwitchReq *req;
  882.     XF86VidModeCheckExtension (dpy, info, False);
  884.     LockDisplay(dpy);
  885.     GetReq(XF86VidModeLockModeSwitch, req);
  886.     req->reqType = info->codes->major_opcode;
  887.     req->xf86vidmodeReqType = X_XF86VidModeLockModeSwitch;
  888.     req->screen = screen;
  889.     req->lock = lock;
  890.     UnlockDisplay(dpy);
  891.     SyncHandle();
  892.     return True;
  893. }
  894.     
  895. Bool
  896. SDL_NAME(XF86VidModeGetMonitor)(dpy, screen, monitor)
  897.     Display* dpy;
  898.     int screen;
  899.     SDL_NAME(XF86VidModeMonitor)* monitor;
  900. {
  901.     XExtDisplayInfo *info = find_display (dpy);
  902.     xXF86VidModeGetMonitorReply rep;
  903.     xXF86VidModeGetMonitorReq *req;
  904.     CARD32 syncrange;
  905.     int i;
  907.     XF86VidModeCheckExtension (dpy, info, False);
  909.     LockDisplay(dpy);
  910.     GetReq(XF86VidModeGetMonitor, req);
  911.     req->reqType = info->codes->major_opcode;
  912.     req->xf86vidmodeReqType = X_XF86VidModeGetMonitor;
  913.     req->screen = screen;
  914.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  915. UnlockDisplay(dpy);
  916. SyncHandle();
  917. return False;
  918.     }
  919.     monitor->nhsync = rep.nhsync;
  920.     monitor->nvsync = rep.nvsync;
  921. #if 0
  922.     monitor->bandwidth = (float)rep.bandwidth / 1e6;
  923. #endif
  924.     if (rep.vendorLength) {
  925. if (!(monitor->vendor = (char *)Xcalloc(rep.vendorLength + 1, 1))) {
  926.     _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
  927.       ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
  928.     return False;
  929. }
  930.     } else {
  931. monitor->vendor = NULL;
  932.     }
  933.     if (rep.modelLength) {
  934. if (!(monitor->model = Xcalloc(rep.modelLength + 1, 1))) {
  935.     _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
  936.       ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
  937.     if (monitor->vendor)
  938. Xfree(monitor->vendor);
  939.     return False;
  940. }
  941.     } else {
  942. monitor->model = NULL;
  943.     }
  944.     if (!(monitor->hsync = Xcalloc(rep.nhsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) {
  945. _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
  946.   ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
  948. if (monitor->vendor)
  949.     Xfree(monitor->vendor);
  950. if (monitor->model)
  951.     Xfree(monitor->model);
  952. return False;
  953.     }
  954.     if (!(monitor->vsync = Xcalloc(rep.nvsync, sizeof(SDL_NAME(XF86VidModeSyncRange))))) {
  955. _XEatData(dpy, (rep.nhsync + rep.nvsync) * 4 +
  956.   ((rep.vendorLength+3) & ~3) + ((rep.modelLength+3) & ~3));
  957. if (monitor->vendor)
  958.     Xfree(monitor->vendor);
  959. if (monitor->model)
  960.     Xfree(monitor->model);
  961. Xfree(monitor->hsync);
  962. return False;
  963.     }
  964.     for (i = 0; i < rep.nhsync; i++) {
  965. _XRead(dpy, (char *)&syncrange, 4);
  966. monitor->hsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
  967. monitor->hsync[i].hi = (float)(syncrange >> 16) / 100.0;
  968.     }
  969.     for (i = 0; i < rep.nvsync; i++) {
  970. _XRead(dpy, (char *)&syncrange, 4);
  971. monitor->vsync[i].lo = (float)(syncrange & 0xFFFF) / 100.0;
  972. monitor->vsync[i].hi = (float)(syncrange >> 16) / 100.0;
  973.     }
  974.     if (rep.vendorLength)
  975. _XReadPad(dpy, monitor->vendor, rep.vendorLength);
  976.     else
  977. monitor->vendor = "";
  978.     if (rep.modelLength)
  979. _XReadPad(dpy, monitor->model, rep.modelLength);
  980.     else
  981. monitor->model = "";
  983.     UnlockDisplay(dpy);
  984.     SyncHandle();
  985.     return True;
  986. }
  988. Bool
  989. SDL_NAME(XF86VidModeGetViewPort)(dpy, screen, x, y)
  990.     Display* dpy;
  991.     int screen;
  992.     int *x, *y;
  993. {
  994.     XExtDisplayInfo *info = find_display (dpy);
  995.     xXF86VidModeGetViewPortReply rep;
  996.     xXF86VidModeGetViewPortReq *req;
  997.     int majorVersion, minorVersion;
  998.     Bool protocolBug = False;
  1000.     XF86VidModeCheckExtension (dpy, info, False);
  1002.     /*
  1003.      * Note: There was a bug in the protocol implementation in versions
  1004.      * 0.x with x < 8 (no reply was sent, so the client would hang)
  1005.      * Check the server's version, and don't wait for a reply with older
  1006.      * versions.
  1007.      */
  1009.     SDL_NAME(XF86VidModeQueryVersion)(dpy, &majorVersion, &minorVersion);
  1010.     if (majorVersion == 0 && minorVersion < 8) {
  1011. protocolBug = True;
  1012. #ifdef DEBUG
  1013. fprintf(stderr, "XF86VidModeGetViewPort: Warning: Xserver is"
  1014. "running an old version (%d.%d)n", majorVersion,
  1015. minorVersion);
  1016. #endif
  1017.     }
  1018.     LockDisplay(dpy);
  1019.     GetReq(XF86VidModeGetViewPort, req);
  1020.     req->reqType = info->codes->major_opcode;
  1021.     req->xf86vidmodeReqType = X_XF86VidModeGetViewPort;
  1022.     req->screen = screen;
  1023.     if (protocolBug) {
  1024. *x = 0;
  1025. *y = 0;
  1026.     } else {
  1027. if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  1028.     UnlockDisplay(dpy);
  1029.     SyncHandle();
  1030.     return False;
  1031. }
  1032. *x = rep.x;
  1033. *y = rep.y;
  1034.     }
  1036.     UnlockDisplay(dpy);
  1037.     SyncHandle();
  1038.     return True;
  1039. }
  1041. Bool
  1042. SDL_NAME(XF86VidModeSetViewPort)(dpy, screen, x, y)
  1043.     Display* dpy;
  1044.     int screen;
  1045.     int x, y;
  1046. {
  1047.     XExtDisplayInfo *info = find_display (dpy);
  1048.     xXF86VidModeSetViewPortReq *req;
  1050.     XF86VidModeCheckExtension (dpy, info, False);
  1052.     LockDisplay(dpy);
  1053.     GetReq(XF86VidModeSetViewPort, req);
  1054.     req->reqType = info->codes->major_opcode;
  1055.     req->xf86vidmodeReqType = X_XF86VidModeSetViewPort;
  1056.     req->screen = screen;
  1057.     req->x = x;
  1058.     req->y = y;
  1060.     UnlockDisplay(dpy);
  1061.     SyncHandle();
  1062.     return True;
  1063. }
  1065. Bool
  1066. SDL_NAME(XF86VidModeGetDotClocks)(dpy, screen,
  1067.     flagsPtr, numclocksPtr, maxclocksPtr, clocksPtr)
  1068.     Display* dpy;
  1069.     int screen;
  1070.     int *flagsPtr, *numclocksPtr, *maxclocksPtr, *clocksPtr[]; 
  1071. {
  1072.     XExtDisplayInfo *info = find_display (dpy);
  1073.     xXF86VidModeGetDotClocksReply rep;
  1074.     xXF86VidModeGetDotClocksReq *req;
  1075.     int i, *dotclocks;
  1076.     CARD32 dotclk;
  1078.     XF86VidModeCheckExtension (dpy, info, False);
  1080.     LockDisplay(dpy);
  1081.     GetReq(XF86VidModeGetDotClocks, req);
  1082.     req->reqType = info->codes->major_opcode;
  1083.     req->xf86vidmodeReqType = X_XF86VidModeGetDotClocks;
  1084.     req->screen = screen;
  1085.     if (!_XReply(dpy, (xReply *)&rep, 
  1086.         (SIZEOF(xXF86VidModeGetDotClocksReply) - SIZEOF(xReply)) >> 2, xFalse))
  1087.     {
  1088.         UnlockDisplay(dpy);
  1089.         SyncHandle();
  1090.         return False;
  1091.     }
  1092.     *numclocksPtr = rep.clocks;
  1093.     *maxclocksPtr = rep.maxclocks;
  1094.     *flagsPtr     = rep.flags;
  1096.     if (!(dotclocks = (int*) Xcalloc(rep.clocks, sizeof(int)))) {
  1097.         _XEatData(dpy, (rep.clocks) * 4);
  1098.         Xfree(dotclocks);
  1099.         return False;
  1100.     }
  1102.     for (i = 0; i < rep.clocks; i++) {
  1103.         _XRead(dpy, (char*)&dotclk, 4);
  1104. dotclocks[i] = dotclk;
  1105.     }
  1106.     *clocksPtr = dotclocks;
  1107.     UnlockDisplay(dpy);
  1108.     SyncHandle();
  1109.     return True;
  1110. }
  1112. Bool
  1113. SDL_NAME(XF86VidModeSetGammaRamp) (
  1114.     Display *dpy,
  1115.     int screen,
  1116.     int size,
  1117.     unsigned short *red,
  1118.     unsigned short *green,
  1119.     unsigned short *blue
  1120. )
  1121. {
  1122.     int length = (size + 1) & ~1;
  1123.     XExtDisplayInfo *info = find_display (dpy);
  1124.     xXF86VidModeSetGammaRampReq *req;
  1126.     XF86VidModeCheckExtension (dpy, info, False);
  1127.     LockDisplay(dpy);
  1128.     GetReq(XF86VidModeSetGammaRamp, req);
  1129.     req->reqType = info->codes->major_opcode;
  1130.     req->xf86vidmodeReqType = X_XF86VidModeSetGammaRamp;
  1131.     req->screen = screen;
  1132.     req->length += (length >> 1) * 3;
  1133.     req->size = size;
  1134.     _XSend(dpy, (char*)red, size * 2);
  1135.     _XSend(dpy, (char*)green, size * 2);
  1136.     _XSend(dpy, (char*)blue, size * 2);
  1137.     UnlockDisplay(dpy);
  1138.     SyncHandle();
  1139.     return True;
  1140. }
  1143. Bool
  1144. SDL_NAME(XF86VidModeGetGammaRamp) (
  1145.     Display *dpy,
  1146.     int screen,
  1147.     int size,
  1148.     unsigned short *red,
  1149.     unsigned short *green,
  1150.     unsigned short *blue
  1151. )
  1152. {
  1153.     XExtDisplayInfo *info = find_display (dpy);
  1154.     xXF86VidModeGetGammaRampReq *req;
  1155.     xXF86VidModeGetGammaRampReply rep;
  1156.   
  1157.     XF86VidModeCheckExtension (dpy, info, False);
  1159.     LockDisplay(dpy);
  1160.     GetReq(XF86VidModeGetGammaRamp, req);
  1161.     req->reqType = info->codes->major_opcode;
  1162.     req->xf86vidmodeReqType = X_XF86VidModeGetGammaRamp;
  1163.     req->screen = screen;
  1164.     req->size = size;
  1165.     if (!_XReply (dpy, (xReply *) &rep, 0, xFalse)) {
  1166.         UnlockDisplay (dpy);
  1167.         SyncHandle ();
  1168.         return False;
  1169.     }
  1170.     if(rep.size) {
  1171. _XRead(dpy, (char*)red, rep.size << 1);
  1172. _XRead(dpy, (char*)green, rep.size << 1);
  1173. _XRead(dpy, (char*)blue, rep.size << 1);
  1174.     }
  1176.     UnlockDisplay(dpy);
  1177.     SyncHandle();
  1178.     return True;
  1179. }
  1181. Bool SDL_NAME(XF86VidModeGetGammaRampSize)(
  1182.     Display *dpy,
  1183.     int screen,
  1184.     int *size
  1185. )
  1186. {
  1187.     XExtDisplayInfo *info = find_display (dpy);
  1188.     xXF86VidModeGetGammaRampSizeReq *req;
  1189.     xXF86VidModeGetGammaRampSizeReply rep;
  1190.   
  1191.     *size = 0;
  1193.     XF86VidModeCheckExtension (dpy, info, False);
  1195.     LockDisplay(dpy);
  1196.     GetReq(XF86VidModeGetGammaRampSize, req);
  1197.     req->reqType = info->codes->major_opcode;
  1198.     req->xf86vidmodeReqType = X_XF86VidModeGetGammaRampSize;
  1199.     req->screen = screen;
  1200.     if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
  1201.         UnlockDisplay (dpy);
  1202.         SyncHandle ();
  1203.         return False; 
  1204.     }
  1205.     *size = rep.size;
  1206.     UnlockDisplay(dpy);
  1207.     SyncHandle();
  1208.     return True;
  1209. }