kc3-lang/angle/src/third_party/libXNVCtrl/NVCtrl.c

• Show log

  Commit

• Hash : cc068e93
  Author :
  Date : 2016-02-29T16:37:04
  

  Add DisplayGL::getDriverVersion and implementation on Linux NVIDIA
  
  Some GPU driver bug workarounds should be active only for specific
  driver version ranges. This adds NVIDIA Linux driver detection using
  the XNVCtrl X11 extension.
  
  BUG=590870
  
  Change-Id: I8cbf692a0c8a6da7473169f29d720bdc2d07663d
  Reviewed-on: https://chromium-review.googlesource.com/329637
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/third_party/libXNVCtrl/NVCtrl.c

• /*
   * Copyright (c) 2008 NVIDIA, Corporation
   *
   * 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, sublicense, 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 NONINFRINGEMENT.  IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS 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.
   */
  
  /*
   * Make sure that XTHREADS is defined, so that the
   * LockDisplay/UnlockDisplay macros are expanded properly and the
   * libXNVCtrl library properly protects the Display connection.
   */
  
  #if !defined(XTHREADS)
  #define XTHREADS
  #endif /* XTHREADS */
  
  #define NEED_EVENTS
  #define NEED_REPLIES
  #include <stdint.h>
  #include <stdlib.h>
  #include <X11/Xlibint.h>
  #include <X11/Xutil.h>
  #include <X11/extensions/Xext.h>
  #include <X11/extensions/extutil.h>
  #include "NVCtrlLib.h"
  #include "nv_control.h"
  
  #define NVCTRL_EXT_EXISTS              1
  #define NVCTRL_EXT_NEED_TARGET_SWAP    2
  #define NVCTRL_EXT_64_BIT_ATTRIBUTES   4
  #define NVCTRL_EXT_NEED_CHECK          (1 << (sizeof(XPointer) - 1))
  
  static XExtensionInfo _nvctrl_ext_info_data;
  static XExtensionInfo *nvctrl_ext_info = &_nvctrl_ext_info_data;
  static const char *nvctrl_extension_name = NV_CONTROL_NAME;
  
  #define XNVCTRLCheckExtension(dpy,i,val) \
    XextCheckExtension (dpy, i, nvctrl_extension_name, val)
  #define XNVCTRLSimpleCheckExtension(dpy,i) \
    XextSimpleCheckExtension (dpy, i, nvctrl_extension_name)
  
  static int close_display();
  static uintptr_t version_flags(Display *dpy, XExtDisplayInfo *info);
  static Bool wire_to_event();
  static /* const */ XExtensionHooks nvctrl_extension_hooks = {
      NULL,                               /* create_gc */
      NULL,                               /* copy_gc */
      NULL,                               /* flush_gc */
      NULL,                               /* free_gc */
      NULL,                               /* create_font */
      NULL,                               /* free_font */
      close_display,                      /* close_display */
      wire_to_event,                      /* wire_to_event */
      NULL,                               /* event_to_wire */
      NULL,                               /* error */
      NULL,                               /* error_string */
  };
  
  static XEXT_GENERATE_FIND_DISPLAY (find_display, nvctrl_ext_info,
                                     nvctrl_extension_name,
                                     &nvctrl_extension_hooks,
                                     NV_CONTROL_EVENTS,
                                     (XPointer)NVCTRL_EXT_NEED_CHECK)
  
  static XEXT_GENERATE_CLOSE_DISPLAY (close_display, nvctrl_ext_info)
  
  /*
   * NV-CONTROL versions 1.8 and 1.9 pack the target_type and target_id
   * fields in reversed order.  In order to talk to one of these servers,
   * we need to swap these fields.
   */
  
  static void XNVCTRLCheckTargetData(Display *dpy, XExtDisplayInfo *info,
                                     int *target_type, int *target_id)
  {
      uintptr_t flags = version_flags(dpy, info);
  
      /* We need to swap the target_type and target_id */
      if (flags & NVCTRL_EXT_NEED_TARGET_SWAP) {
          int tmp;
          tmp = *target_type;
          *target_type = *target_id;
          *target_id = tmp;
      }
  }
  
  
  Bool XNVCTRLQueryExtension (
      Display *dpy,
      int *event_basep,
      int *error_basep
  ){
      XExtDisplayInfo *info = find_display (dpy);
  
      if (XextHasExtension(info)) {
          if (event_basep) *event_basep = info->codes->first_event;
          if (error_basep) *error_basep = info->codes->first_error;
          return True;
      } else {
          return False;
      }
  }
  
  /*
   * Retrieve any cached flags that depend on the version of the NV-CONTROL
   * extension.
   */
  
  static uintptr_t version_flags(Display *dpy, XExtDisplayInfo *info)
  {
      uintptr_t data = (uintptr_t)info->data;
  
      /* If necessary, determine the NV-CONTROL version */
      if (data & NVCTRL_EXT_NEED_CHECK) {
          int major, minor;
          data = 0;
          if (XNVCTRLQueryVersion(dpy, &major, &minor)) {
              data |= NVCTRL_EXT_EXISTS;
              if (major == 1 && (minor == 8 || minor == 9)) {
                  data |= NVCTRL_EXT_NEED_TARGET_SWAP;
              }
              if ((major > 1) || ((major == 1) && (minor > 20))) {
                  data |= NVCTRL_EXT_64_BIT_ATTRIBUTES;
              }
          }
  
          info->data = (XPointer)data;
      }
  
      return data;
  }
  
  Bool XNVCTRLQueryVersion (
      Display *dpy,
      int *major,
      int *minor
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlQueryExtensionReply rep;
      xnvCtrlQueryExtensionReq   *req;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      LockDisplay (dpy);
      GetReq (nvCtrlQueryExtension, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryExtension;
      if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      if (major) *major = rep.major;
      if (minor) *minor = rep.minor;
      UnlockDisplay (dpy);
      SyncHandle ();
      return True;
  }
  
  
  Bool XNVCTRLIsNvScreen (
      Display *dpy,
      int screen
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlIsNvReply rep;
      xnvCtrlIsNvReq   *req;
      Bool isnv;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      LockDisplay (dpy);
      GetReq (nvCtrlIsNv, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlIsNv;
      req->screen = screen;
      if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      isnv = rep.isnv;
      UnlockDisplay (dpy);
      SyncHandle ();
      return isnv;
  }
  
  
  Bool XNVCTRLQueryTargetCount (
      Display *dpy,
      int target_type,
      int *value
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlQueryTargetCountReply  rep;
      xnvCtrlQueryTargetCountReq   *req;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      LockDisplay (dpy);
      GetReq (nvCtrlQueryTargetCount, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryTargetCount;
      req->target_type = target_type;
      if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      if (value) *value = rep.count;
      UnlockDisplay (dpy);
      SyncHandle ();
      return True;
  }
  
  
  void XNVCTRLSetTargetAttribute (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      int value
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlSetAttributeReq *req;
  
      XNVCTRLSimpleCheckExtension (dpy, info);
      XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
  
      LockDisplay (dpy);
      GetReq (nvCtrlSetAttribute, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlSetAttribute;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      req->value = value;
      UnlockDisplay (dpy);
      SyncHandle ();
  }
  
  void XNVCTRLSetAttribute (
      Display *dpy,
      int screen,
      unsigned int display_mask,
      unsigned int attribute,
      int value
  ){
      XNVCTRLSetTargetAttribute (dpy, NV_CTRL_TARGET_TYPE_X_SCREEN, screen,
                                 display_mask, attribute, value);
  }
  
  
  Bool XNVCTRLSetTargetAttributeAndGetStatus (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      int value
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlSetAttributeAndGetStatusReq *req;
      xnvCtrlSetAttributeAndGetStatusReply rep;
      Bool success;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      LockDisplay (dpy);
      GetReq (nvCtrlSetAttributeAndGetStatus, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlSetAttributeAndGetStatus;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      req->value = value;
      if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      UnlockDisplay (dpy);
      SyncHandle ();
      
      success = rep.flags;
      return success;
  }
  
  Bool XNVCTRLSetAttributeAndGetStatus (
      Display *dpy,
      int screen,
      unsigned int display_mask,
      unsigned int attribute,
      int value
  ){
      return XNVCTRLSetTargetAttributeAndGetStatus(dpy,
                                                   NV_CTRL_TARGET_TYPE_X_SCREEN,
                                                   screen, display_mask,
                                                   attribute, value);
  }
  
  
  Bool XNVCTRLQueryTargetAttribute (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      int *value
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlQueryAttributeReply rep;
      xnvCtrlQueryAttributeReq   *req;
      Bool exists;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
      XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
  
      LockDisplay (dpy);
      GetReq (nvCtrlQueryAttribute, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryAttribute;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      exists = rep.flags;
      if (exists && value) *value = rep.value;
      UnlockDisplay (dpy);
      SyncHandle ();
      return exists;
  }
  
  Bool XNVCTRLQueryAttribute (
      Display *dpy,
      int screen,
      unsigned int display_mask,
      unsigned int attribute,
      int *value
  ){
      return XNVCTRLQueryTargetAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
                                         screen, display_mask, attribute, value);
  }
  
  
  Bool XNVCTRLQueryTargetAttribute64 (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      int64_t *value
  ){
      XExtDisplayInfo *info = find_display(dpy);
      xnvCtrlQueryAttribute64Reply rep;
      xnvCtrlQueryAttributeReq *req;
      Bool exists;
  
      if (!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension(dpy, info, False);
      XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
  
      LockDisplay(dpy);
      GetReq(nvCtrlQueryAttribute, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryAttribute64;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) {
          UnlockDisplay(dpy);
          SyncHandle();
          return False;
      }
      exists = rep.flags;
      if (exists && value) *value = rep.value_64;
      UnlockDisplay(dpy);
      SyncHandle();
      return exists;
  }
  
  
  Bool XNVCTRLQueryTargetStringAttribute (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      char **ptr
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlQueryStringAttributeReply rep;
      xnvCtrlQueryStringAttributeReq   *req;
      Bool exists;
      int length, numbytes, slop;
  
      if (!ptr) return False;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
      XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
  
      LockDisplay (dpy);
      GetReq (nvCtrlQueryStringAttribute, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryStringAttribute;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      length = rep.length;
      numbytes = rep.n;
      slop = numbytes & 3;
      exists = rep.flags;
      if (exists) {
          *ptr = (char *) Xmalloc(numbytes);
      }
      if (!exists || !*ptr) {
          _XEatData(dpy, length);
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      } else {
          _XRead(dpy, (char *) *ptr, numbytes);
          if (slop) _XEatData(dpy, 4-slop);
      }
      UnlockDisplay (dpy);
      SyncHandle ();
      return exists;
  }
  
  Bool XNVCTRLQueryStringAttribute (
      Display *dpy,
      int screen,
      unsigned int display_mask,
      unsigned int attribute,
      char **ptr
  ){
      return XNVCTRLQueryTargetStringAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
                                               screen, display_mask,
                                               attribute, ptr);
  }
  
  
  Bool XNVCTRLSetTargetStringAttribute (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      char *ptr
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlSetStringAttributeReq *req;
      xnvCtrlSetStringAttributeReply rep;
      int size;
      Bool success;
      
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      size = strlen(ptr)+1;
  
      LockDisplay (dpy);
      GetReq (nvCtrlSetStringAttribute, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlSetStringAttribute;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      req->length += ((size + 3) & ~3) >> 2;
      req->num_bytes = size;
      Data(dpy, ptr, size);
      
      if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      UnlockDisplay (dpy);
      SyncHandle ();
      
      success = rep.flags;
      return success;
  }
  
  Bool XNVCTRLSetStringAttribute (
      Display *dpy,
      int screen,
      unsigned int display_mask,
      unsigned int attribute,
      char *ptr
  ){
      return XNVCTRLSetTargetStringAttribute(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
                                             screen, display_mask,
                                             attribute, ptr);
  }
  
  
  static Bool XNVCTRLQueryValidTargetAttributeValues32 (
      Display *dpy,
      XExtDisplayInfo *info,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,                                 
      NVCTRLAttributeValidValuesRec *values
  ){
      xnvCtrlQueryValidAttributeValuesReply rep;
      xnvCtrlQueryValidAttributeValuesReq   *req;
      Bool exists;
  
      LockDisplay (dpy);
      GetReq (nvCtrlQueryValidAttributeValues, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryValidAttributeValues;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      exists = rep.flags;
      if (exists) {
          values->type = rep.attr_type;
          if (rep.attr_type == ATTRIBUTE_TYPE_RANGE) {
              values->u.range.min = rep.min;
              values->u.range.max = rep.max;
          }
          if (rep.attr_type == ATTRIBUTE_TYPE_INT_BITS) {
              values->u.bits.ints = rep.bits;
          }
          values->permissions = rep.perms;
      }
      UnlockDisplay (dpy);
      SyncHandle ();
      return exists;
  }
  
  
  Bool XNVCTRLQueryValidTargetStringAttributeValues (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      NVCTRLAttributeValidValuesRec *values
  ){
      XExtDisplayInfo *info = find_display(dpy);
      Bool exists;
      xnvCtrlQueryValidAttributeValuesReply rep;
      xnvCtrlQueryValidAttributeValuesReq   *req;
  
      if (!values) return False;
  
      if (!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension(dpy, info, False);
  
      LockDisplay(dpy);
      GetReq (nvCtrlQueryValidAttributeValues, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryValidStringAttributeValues;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      if (!_XReply(dpy, (xReply *)&rep, 0, xTrue)) {
          UnlockDisplay(dpy);
          SyncHandle();
          return False;
      }
      exists = rep.flags;
      if (exists) {
          values->type = rep.attr_type;
          values->permissions = rep.perms;
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return exists;
  }
  
  
  static Bool XNVCTRLQueryValidTargetAttributeValues64 (
      Display *dpy,
      XExtDisplayInfo *info,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      NVCTRLAttributeValidValuesRec *values
  ){
      xnvCtrlQueryValidAttributeValues64Reply rep;
      xnvCtrlQueryValidAttributeValuesReq *req;
      Bool exists;
  
      LockDisplay(dpy);
      GetReq(nvCtrlQueryValidAttributeValues, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryValidAttributeValues64;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      if (!_XReply(dpy, (xReply *)&rep,
                   sz_xnvCtrlQueryValidAttributeValues64Reply_extra,
                   xTrue)) {
          UnlockDisplay(dpy);
          SyncHandle();
          return False;
      }
      exists = rep.flags;
      if (exists) {
          values->type = rep.attr_type;
          if (rep.attr_type == ATTRIBUTE_TYPE_RANGE) {
              values->u.range.min = rep.min_64;
              values->u.range.max = rep.max_64;
          }
          if (rep.attr_type == ATTRIBUTE_TYPE_INT_BITS) {
              values->u.bits.ints = rep.bits_64;
          }
          values->permissions = rep.perms;
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return exists;
  }
  
  Bool XNVCTRLQueryValidTargetAttributeValues (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      NVCTRLAttributeValidValuesRec *values
  ){
      XExtDisplayInfo *info = find_display(dpy);
      Bool exists;
      uintptr_t flags;
  
      if (!values) return False;
  
      if (!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension(dpy, info, False);
      XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
  
      flags = version_flags(dpy,info);
  
      if (!(flags & NVCTRL_EXT_EXISTS))
          return False;
  
      if (flags & NVCTRL_EXT_64_BIT_ATTRIBUTES) {
          exists = XNVCTRLQueryValidTargetAttributeValues64(dpy, info,
                                                            target_type,
                                                            target_id,
                                                            display_mask,
                                                            attribute,
                                                            values);
      } else {
          exists = XNVCTRLQueryValidTargetAttributeValues32(dpy, info,
                                                            target_type,
                                                            target_id,
                                                            display_mask,
                                                            attribute,
                                                            values);
      }
      return exists;
  }
  
  
  Bool XNVCTRLQueryValidAttributeValues (
      Display *dpy,
      int screen,
      unsigned int display_mask,
      unsigned int attribute,
      NVCTRLAttributeValidValuesRec *values
  ){
      return XNVCTRLQueryValidTargetAttributeValues(dpy,
                                                    NV_CTRL_TARGET_TYPE_X_SCREEN,
                                                    screen, display_mask,
                                                    attribute, values);
  }
  
  
  static Bool QueryAttributePermissionsInternal (
      Display *dpy,
      unsigned int attribute,
      NVCTRLAttributePermissionsRec *permissions,
      unsigned int reqType
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlQueryAttributePermissionsReply rep;
      xnvCtrlQueryAttributePermissionsReq *req;
      Bool exists;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      LockDisplay(dpy);
      GetReq(nvCtrlQueryAttributePermissions, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = reqType;
      req->attribute = attribute;
      if (!_XReply (dpy, (xReply *) &rep, 0, xTrue)) {
          UnlockDisplay (dpy);
          SyncHandle();
          return False;
      }
      exists = rep.flags;
      if (exists && permissions) {
          permissions->type = rep.attr_type;
          permissions->permissions = rep.perms;
      }
      UnlockDisplay(dpy);
      SyncHandle();
      return exists;
  }
  
  
  Bool XNVCTRLQueryAttributePermissions (
      Display *dpy,
      unsigned int attribute,
      NVCTRLAttributePermissionsRec *permissions
  ){
      return QueryAttributePermissionsInternal(dpy,
                                               attribute,
                                               permissions,
                                               X_nvCtrlQueryAttributePermissions);
  }
  
  
  Bool XNVCTRLQueryStringAttributePermissions (
      Display *dpy,
      unsigned int attribute,
      NVCTRLAttributePermissionsRec *permissions
  ){
      return QueryAttributePermissionsInternal(dpy,
                                               attribute,
                                               permissions,
                                               X_nvCtrlQueryStringAttributePermissions);
  }
  
  
  Bool XNVCTRLQueryBinaryDataAttributePermissions (
      Display *dpy,
      unsigned int attribute,
      NVCTRLAttributePermissionsRec *permissions
  ){
      return QueryAttributePermissionsInternal(dpy,
                                               attribute,
                                               permissions,
                                               X_nvCtrlQueryBinaryDataAttributePermissions);
  }
  
  
  Bool XNVCTRLQueryStringOperationAttributePermissions (
      Display *dpy,
      unsigned int attribute,
      NVCTRLAttributePermissionsRec *permissions
  ){
      return QueryAttributePermissionsInternal(dpy,
                                               attribute,
                                               permissions,
                                               X_nvCtrlQueryStringOperationAttributePermissions);
  }
  
  
  void XNVCTRLSetGvoColorConversion (
      Display *dpy,
      int screen,
      float colorMatrix[3][3],
      float colorOffset[3],
      float colorScale[3]
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlSetGvoColorConversionReq *req;
  
      XNVCTRLSimpleCheckExtension (dpy, info);
  
      LockDisplay (dpy);
      GetReq (nvCtrlSetGvoColorConversion, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlSetGvoColorConversion;
      req->screen = screen;
  
      req->cscMatrix_y_r = colorMatrix[0][0];
      req->cscMatrix_y_g = colorMatrix[0][1];
      req->cscMatrix_y_b = colorMatrix[0][2];
  
      req->cscMatrix_cr_r = colorMatrix[1][0];
      req->cscMatrix_cr_g = colorMatrix[1][1];
      req->cscMatrix_cr_b = colorMatrix[1][2];
  
      req->cscMatrix_cb_r = colorMatrix[2][0];
      req->cscMatrix_cb_g = colorMatrix[2][1];
      req->cscMatrix_cb_b = colorMatrix[2][2];
  
      req->cscOffset_y  = colorOffset[0];
      req->cscOffset_cr = colorOffset[1];
      req->cscOffset_cb = colorOffset[2];
  
      req->cscScale_y  = colorScale[0];
      req->cscScale_cr = colorScale[1];
      req->cscScale_cb = colorScale[2];
  
      UnlockDisplay (dpy);
      SyncHandle ();
  }
  
  
  Bool XNVCTRLQueryGvoColorConversion (
      Display *dpy,
      int screen,
      float colorMatrix[3][3],
      float colorOffset[3],
      float colorScale[3]
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlQueryGvoColorConversionReply rep;
      xnvCtrlQueryGvoColorConversionReq *req;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      LockDisplay (dpy);
  
      GetReq (nvCtrlQueryGvoColorConversion, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryGvoColorConversion;
      req->screen = screen;
  
      if (!_XReply(dpy, (xReply *) &rep, 0, xFalse)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
  
      _XRead(dpy, (char *)(colorMatrix), 36);
      _XRead(dpy, (char *)(colorOffset), 12);
      _XRead(dpy, (char *)(colorScale), 12);
  
      UnlockDisplay (dpy);
      SyncHandle ();
  
      return True;
  }
  
  
  Bool XNVCtrlSelectTargetNotify (
      Display *dpy,
      int target_type,
      int target_id,
      int notify_type,
      Bool onoff
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlSelectTargetNotifyReq *req;
  
      if(!XextHasExtension (info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      LockDisplay (dpy);
      GetReq (nvCtrlSelectTargetNotify, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlSelectTargetNotify;
      req->target_type = target_type;
      req->target_id = target_id;
      req->notifyType = notify_type;
      req->onoff = onoff;
      UnlockDisplay (dpy);
      SyncHandle ();
  
      return True;
  }
  
  
  Bool XNVCtrlSelectNotify (
      Display *dpy,
      int screen,
      int type,
      Bool onoff
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlSelectNotifyReq *req;
  
      if(!XextHasExtension (info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
  
      LockDisplay (dpy);
      GetReq (nvCtrlSelectNotify, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlSelectNotify;
      req->screen = screen;
      req->notifyType = type;
      req->onoff = onoff;
      UnlockDisplay (dpy);
      SyncHandle ();
  
      return True;
  }
  
  Bool XNVCTRLQueryTargetBinaryData (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      unsigned char **ptr,
      int *len
  ){
      XExtDisplayInfo *info = find_display (dpy);
      xnvCtrlQueryBinaryDataReply rep;
      xnvCtrlQueryBinaryDataReq   *req;
      Bool exists;
      int length, numbytes, slop;
  
      if (!ptr) return False;
  
      if(!XextHasExtension(info))
          return False;
  
      XNVCTRLCheckExtension (dpy, info, False);
      XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
  
      LockDisplay (dpy);
      GetReq (nvCtrlQueryBinaryData, req);
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlQueryBinaryData;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
      if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      }
      length = rep.length;
      numbytes = rep.n;
      slop = numbytes & 3;
      exists = rep.flags;
      if (exists) {
          *ptr = (unsigned char *) Xmalloc(numbytes);
      }
      if (!exists || !*ptr) {
          _XEatData(dpy, length);
          UnlockDisplay (dpy);
          SyncHandle ();
          return False;
      } else {
          _XRead(dpy, (char *) *ptr, numbytes);
          if (slop) _XEatData(dpy, 4-slop);
      }
      if (len) *len = numbytes;
      UnlockDisplay (dpy);
      SyncHandle ();
      return exists;
  }
  
  Bool XNVCTRLQueryBinaryData (
      Display *dpy,
      int screen,
      unsigned int display_mask,
      unsigned int attribute,
      unsigned char **ptr,
      int *len
  ){
      return XNVCTRLQueryTargetBinaryData(dpy, NV_CTRL_TARGET_TYPE_X_SCREEN,
                                          screen, display_mask,
                                          attribute, ptr, len);
  }
  
  Bool XNVCTRLStringOperation (
      Display *dpy,
      int target_type,
      int target_id,
      unsigned int display_mask,
      unsigned int attribute,
      char *pIn,
      char **ppOut
  ) {
      XExtDisplayInfo *info = find_display(dpy);
      xnvCtrlStringOperationReq *req;
      xnvCtrlStringOperationReply rep;
      Bool ret;
      int inSize, outSize, length, slop;
  
      if (!XextHasExtension(info))
          return False;
      
      if (!ppOut)
          return False;
  
      *ppOut = NULL;
      
      XNVCTRLCheckExtension(dpy, info, False);
      XNVCTRLCheckTargetData(dpy, info, &target_type, &target_id);
      
      if (pIn) {
          inSize = strlen(pIn) + 1;
      } else {
          inSize = 0;
      }
      
      LockDisplay(dpy);
      GetReq(nvCtrlStringOperation, req);
      
      req->reqType = info->codes->major_opcode;
      req->nvReqType = X_nvCtrlStringOperation;
      req->target_type = target_type;
      req->target_id = target_id;
      req->display_mask = display_mask;
      req->attribute = attribute;
  
      req->length += ((inSize + 3) & ~3) >> 2;
      req->num_bytes = inSize;
      
      if (pIn) {
          Data(dpy, pIn, inSize);
      }
      
      if (!_XReply (dpy, (xReply *) &rep, 0, False)) {
          UnlockDisplay(dpy);
          SyncHandle();
          return False;
      }
      
      length = rep.length;
      outSize = rep.num_bytes;
      slop = outSize & 3;
  
      if (outSize) *ppOut = (char *) Xmalloc(outSize);
      
      if (!*ppOut) {
          _XEatData(dpy, length);
      } else {
          _XRead(dpy, (char *) *ppOut, outSize);
          if (slop) _XEatData(dpy, 4-slop);
      }
      
      ret = rep.ret;
      
      UnlockDisplay(dpy);
      SyncHandle();
      
      return ret;
  }
  
  
  static Bool wire_to_event (Display *dpy, XEvent *host, xEvent *wire)
  {
      XExtDisplayInfo *info = find_display (dpy);
      XNVCtrlEvent *re;
      xnvctrlEvent *event;
      XNVCtrlEventTarget *reTarget;
      xnvctrlEventTarget *eventTarget;
      XNVCtrlEventTargetAvailability *reTargetAvailability;
      XNVCtrlStringEventTarget *reTargetString;
      XNVCtrlBinaryEventTarget *reTargetBinary;
  
      XNVCTRLCheckExtension (dpy, info, False);
      
      switch ((wire->u.u.type & 0x7F) - info->codes->first_event) {
      case ATTRIBUTE_CHANGED_EVENT:
          re = (XNVCtrlEvent *) host;
          event = (xnvctrlEvent *) wire;
          re->attribute_changed.type = event->u.u.type & 0x7F;
          re->attribute_changed.serial =
              _XSetLastRequestRead(dpy, (xGenericReply*) event);
          re->attribute_changed.send_event = ((event->u.u.type & 0x80) != 0);
          re->attribute_changed.display = dpy;
          re->attribute_changed.time = event->u.attribute_changed.time;
          re->attribute_changed.screen = event->u.attribute_changed.screen;
          re->attribute_changed.display_mask =
              event->u.attribute_changed.display_mask;
          re->attribute_changed.attribute = event->u.attribute_changed.attribute;
          re->attribute_changed.value = event->u.attribute_changed.value;
          break;
      case TARGET_ATTRIBUTE_CHANGED_EVENT:
          reTarget = (XNVCtrlEventTarget *) host;
          eventTarget = (xnvctrlEventTarget *) wire;
          reTarget->attribute_changed.type = eventTarget->u.u.type & 0x7F;
          reTarget->attribute_changed.serial =
              _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
          reTarget->attribute_changed.send_event =
              ((eventTarget->u.u.type & 0x80) != 0);
          reTarget->attribute_changed.display = dpy;
          reTarget->attribute_changed.time =
              eventTarget->u.attribute_changed.time;
          reTarget->attribute_changed.target_type =
              eventTarget->u.attribute_changed.target_type;
          reTarget->attribute_changed.target_id =
              eventTarget->u.attribute_changed.target_id;
          reTarget->attribute_changed.display_mask =
              eventTarget->u.attribute_changed.display_mask;
          reTarget->attribute_changed.attribute =
              eventTarget->u.attribute_changed.attribute;
          reTarget->attribute_changed.value =
              eventTarget->u.attribute_changed.value;
          break;
      case TARGET_ATTRIBUTE_AVAILABILITY_CHANGED_EVENT:
          reTargetAvailability = (XNVCtrlEventTargetAvailability *) host;
          eventTarget = (xnvctrlEventTarget *) wire;
          reTargetAvailability->attribute_changed.type =
              eventTarget->u.u.type & 0x7F;
          reTargetAvailability->attribute_changed.serial =
              _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
          reTargetAvailability->attribute_changed.send_event =
              ((eventTarget->u.u.type & 0x80) != 0);
          reTargetAvailability->attribute_changed.display = dpy;
          reTargetAvailability->attribute_changed.time =
              eventTarget->u.availability_changed.time;
          reTargetAvailability->attribute_changed.target_type =
              eventTarget->u.availability_changed.target_type;
          reTargetAvailability->attribute_changed.target_id =
              eventTarget->u.availability_changed.target_id;
          reTargetAvailability->attribute_changed.display_mask =
              eventTarget->u.availability_changed.display_mask;
          reTargetAvailability->attribute_changed.attribute =
              eventTarget->u.availability_changed.attribute;
          reTargetAvailability->attribute_changed.availability =
              eventTarget->u.availability_changed.availability;
          reTargetAvailability->attribute_changed.value =
              eventTarget->u.availability_changed.value;
          break;
      case TARGET_STRING_ATTRIBUTE_CHANGED_EVENT:
          reTargetString = (XNVCtrlStringEventTarget *) host;
          eventTarget = (xnvctrlEventTarget *) wire;
          reTargetString->attribute_changed.type = eventTarget->u.u.type & 0x7F;
          reTargetString->attribute_changed.serial =
              _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
          reTargetString->attribute_changed.send_event =
              ((eventTarget->u.u.type & 0x80) != 0);
          reTargetString->attribute_changed.display = dpy;
          reTargetString->attribute_changed.time =
              eventTarget->u.attribute_changed.time;
          reTargetString->attribute_changed.target_type =
              eventTarget->u.attribute_changed.target_type;
          reTargetString->attribute_changed.target_id =
              eventTarget->u.attribute_changed.target_id;
          reTargetString->attribute_changed.display_mask =
              eventTarget->u.attribute_changed.display_mask;
          reTargetString->attribute_changed.attribute =
              eventTarget->u.attribute_changed.attribute;
          break;
      case TARGET_BINARY_ATTRIBUTE_CHANGED_EVENT:
          reTargetBinary = (XNVCtrlBinaryEventTarget *) host;
          eventTarget = (xnvctrlEventTarget *) wire;
          reTargetBinary->attribute_changed.type = eventTarget->u.u.type & 0x7F;
          reTargetBinary->attribute_changed.serial =
              _XSetLastRequestRead(dpy, (xGenericReply*) eventTarget);
          reTargetBinary->attribute_changed.send_event =
              ((eventTarget->u.u.type & 0x80) != 0);
          reTargetBinary->attribute_changed.display = dpy;
          reTargetBinary->attribute_changed.time =
              eventTarget->u.attribute_changed.time;
          reTargetBinary->attribute_changed.target_type =
              eventTarget->u.attribute_changed.target_type;
          reTargetBinary->attribute_changed.target_id =
              eventTarget->u.attribute_changed.target_id;
          reTargetBinary->attribute_changed.display_mask =
              eventTarget->u.attribute_changed.display_mask;
          reTargetBinary->attribute_changed.attribute =
              eventTarget->u.attribute_changed.attribute;
          break;
  
      default:
          return False;
      }
  
      return True;
  }
  
  

Download