diff options
Diffstat (limited to 'libgamma_native_facade.pyx')
| -rw-r--r-- | libgamma_native_facade.pyx | 1297 |
1 files changed, 1297 insertions, 0 deletions
diff --git a/libgamma_native_facade.pyx b/libgamma_native_facade.pyx new file mode 100644 index 0000000..19da8b1 --- /dev/null +++ b/libgamma_native_facade.pyx @@ -0,0 +1,1297 @@ +# -*- python -*- +# See LICENSE file for copyright and license details. +cimport cython + +from libc.stddef cimport size_t +from libc.stdlib cimport malloc, free +from libc.stdint cimport int32_t, uint8_t, uint16_t, uint32_t, uint64_t +from libc.errno cimport errno + + +ctypedef int libgamma_subpixel_order_t +ctypedef int libgamma_connector_type_t + +cdef extern from "include-libgamma.h": + + ctypedef struct libgamma_method_capabilities_t: + # Capabilities of adjustment methods + + int32_t crtc_information + # OR of the CRTC information fields in `libgamma_crtc_information_t` + # that may (but can fail) be read successfully + + unsigned default_site_known # : 1 + # Whether the default site is known, if true the site is integrated + # to the system or can be determined using environment variables + + unsigned multiple_sites # : 1 + # Whether the adjustment method supports multiple sites rather + # than just the default site + + unsigned multiple_partitions # : 1 + # Whether the adjustment method supports multiple partitions + # per site + + unsigned multiple_crtcs # : 1 + # Whether the adjustment method supports multiple CRTC:s + # per partition per site + + unsigned partitions_are_graphics_cards # : 1 + # Whether the partition to graphics card is a bijection + + unsigned site_restore # : 1 + # Whether the adjustment method supports `libgamma_site_restore` + + unsigned partition_restore # : 1 + # Whether the adjustment method supports `libgamma_partition_restore` + + unsigned crtc_restore # : 1 + # Whether the adjustment method supports `libgamma_crtc_restore` + + unsigned identical_gamma_sizes # : 1 + # Whether the `red_gamma_size`, `green_gamma_size` and `blue_gamma_size` + # fields in `libgamma_crtc_information_t` will always have the same + # values as each other for the adjustment method + + unsigned fixed_gamma_size # : 1 + # Whether the `red_gamma_size`, `green_gamma_size` and `blue_gamma_size` + # fields in `libgamma_crtc_information_t` will always be filled with the + # same value for the adjustment method + + unsigned fixed_gamma_depth # : 1 + # Whether the `gamma_depth` field in `libgamma_crtc_information_t` + # will always be filled with the same value for the adjustment method + + unsigned real # : 1 + # Whether the adjustment method will actually perform adjustments + + unsigned fake # : 1 + # Whether the adjustment method is implement using a translation layer + + ctypedef struct libgamma_site_state_t: + # Site state + # + # On operating systems that integrate a graphical environment + # there is usually just one site. However, one systems with + # pluggable graphics, like Unix-like systems such as GNU/Linux + # and the BSD:s, there can usually be any (feasible) number of + # sites. In X.org parlance they are called displays. + + void *data + # Adjustment method implementation specific data. + # You as a user of this library should not touch this. + + int method + # This field specifies, for the methods if this library, + # which adjustment method (display server and protocol) + # is used to adjust the gamma ramps + + char *site + # The site identifier. It can either be `NULL` or a string. + # `NULL` indicates the default site. On systems like the + # Unix-like systems, where the graphics are pluggable, this + # is usually resolved by an environment variable, such as + # "DISPLAY" for X.org. + + size_t partitions_available + # The number of partitions that is available on this site. + # Probably the majority of display server only one partition + # per site. However, X.org can, and traditional used to have + # on multi-headed environments, multiple partitions per site. + # In X.org partitions are called 'screens'. It is not to be + # confused with monitor. A screen is a collection of monitors, + # and the mapping from monitors to screens is a surjection. + # On hardware-level adjustment methods, such as Direct + # Rendering Manager, a partition is a graphics card. + + ctypedef struct libgamma_partition_state_t: + # Partition state + # + # Probably the majority of display server only one partition + # per site. However, X.org can, and traditional used to have + # on multi-headed environments, multiple partitions per site. + # In X.org partitions are called 'screens'. It is not to be + # confused with monitor. A screen is a collection of monitors, + # and the mapping from monitors to screens is a surjection. + # On hardware-level adjustment methods, such as Direct + # Rendering Manager, a partition is a graphics card. + + void *data + # Adjustment method implementation specific data. + # You as a user of this library should not touch this. + + libgamma_site_state_t* site + # The site this partition belongs to + + size_t partition + # The index of the partition + + size_t crtcs_available + # The number of CRTC:s that are available under this + # partition. Note that the CRTC:s are not necessarily + # online. + + ctypedef struct libgamma_crtc_state_t: + # Cathode ray tube controller state + # + # The CRTC controls the gamma ramps for the + # monitor that is plugged in to the connector + # that the CRTC belongs to + + void* data + # Adjustment method implementation specific data. + # You as a user of this library should not touch this. + + libgamma_partition_state_t* partition + # The partition this CRTC belongs to + + size_t crtc + # The index of the CRTC within its partition + + ctypedef struct libgamma_crtc_information_t: + # Cathode ray tube controller information data structure + + unsigned char *edid + # The Extended Display Identification Data associated with + # the attached monitor. This is raw byte array that is usually + # 128 bytes long. It is not NUL-terminate, rather its length + # is stored in `edid_length`. + + size_t edid_length + # The length of `edid` + + int edid_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + size_t width_mm + # The phyical width, in millimetres, of the viewport of the + # attached monitor, as reported by the adjustment method. This + # value may be incorrect, which is a known issue with the X + # server where it is the result of the X server attempting + # the estimate the size on its own. + # Zero means that its is not applicable, which is the case + # for projectors. + + int width_mm_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + size_t height_mm + # The phyical height, in millimetres, of the viewport of the + # attached monitor, as reported by the adjustment method. This + # value may be incorrect, which is a known issue with the X + # server where it is the result of the X server attempting + # the estimate the size on its own. + # Zero means that its is not applicable, which is the case + # for projectors. + + int height_mm_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + size_t width_mm_edid + # The phyical width, in millimetres, of the viewport of the + # attached monitor, as reported by it the monitor's Extended + # Display Information Data. This value can only contain whole + # centimetres, which means that the result is always zero + # modulus ten. However, this could change with revisions of + # the EDID structure. + # Zero means that its is not applicable, which is the case + # for projectors. + + int width_mm_edid_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + size_t height_mm_edid + # The phyical height, in millimetres, of the viewport of the + # attached monitor, as reported by it the monitor's Extended + # Display Information Data. This value can only contain whole + # centimetres, which means that the result is always zero + # modulus ten. However, this could change with revisions of + # the EDID structure. + # Zero means that its is not applicable, which is the case + # for projectors. + + int height_mm_edid_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + size_t red_gamma_size + # The size of the encoding axis of the red gamma ramp + + size_t green_gamma_size + # The size of the encoding axis of the green gamma ramp + + size_t blue_gamma_size + # The size of the encoding axis of the blue gamma ramp + + int gamma_size_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + signed gamma_depth + # The bit-depth of the value axes of gamma ramps, + # -1 for single precision floating point, and -2 for + # double precision floating point + + int gamma_depth_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + int gamma_support + # Non-zero gamma ramp adjustments are supported + + int gamma_support_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + libgamma_subpixel_order_t subpixel_order + # The layout of the subpixels. + # You cannot count on this value --- especially for CRT:s --- + # but it is provided anyway as a means of distinguishing monitors. + + int subpixel_order_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library. + + int active + # Whether there is a monitors connected to the CRTC + + int active_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + char *connector_name + # The name of the connector as designated by the display + # server or as give by this library in case the display + # server lacks this feature + + int connector_name_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + libgamma_connector_type_t connector_type + # The type of the connector that is associated with the CRTC + + int connector_type_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + float gamma_red + # The gamma characteristics of the monitor as reported + # in its Extended Display Information Data. The value + # holds the value for the red channel. If you do not have + # and more accurate measurement of the gamma for the + # monitor this could be used to give a rought gamma + # correction; simply divide the value with 2.2 and use + # the result for the red channel in the gamma correction. + + float gamma_green + # The gamma characteristics of the monitor as reported + # in its Extended Display Information Data. The value + # holds the value for the green channel. If you do not have + # and more accurate measurement of the gamma for the + # monitor this could be used to give a rought gamma + # correction; simply divide the value with 2.2 and use + # the result for the green channel in the gamma correction. + + float gamma_blue + # The gamma characteristics of the monitor as reported + # in its Extended Display Information Data. The value + # holds the value for the blue channel. If you do not have + # and more accurate measurement of the gamma for the + # monitor this could be used to give a rought gamma + # correction; simply divide the value with 2.2 and use + # the result for the blue channel in the gamma correction. + + int gamma_error + # Zero on success, positive it holds the value `errno` had + # when the reading failed, otherwise (negative) the value + # of an error identifier provided by this library + + ctypedef struct libgamma_gamma_ramps8_t: + # Gamma ramp structure for 8-bit gamma ramps + size_t red_size # The size of `red` + size_t green_size # The size of `green` + size_t blue_size # The size of `blue` + uint8_t *red # The gamma ramp for the red channel + uint8_t *green # The gamma ramp for the green channel + uint8_t *blue # The gamma ramp for the blue channel + + ctypedef struct libgamma_gamma_ramps16_t: + # Gamma ramp structure for 16-bit gamma ramps + size_t red_size # The size of `red` + size_t green_size # The size of `green` + size_t blue_size # The size of `blue` + uint16_t *red # The gamma ramp for the red channel + uint16_t *green # The gamma ramp for the green channel + uint16_t *blue # The gamma ramp for the blue channel + + ctypedef struct libgamma_gamma_ramps32_t: + # Gamma ramp structure for 32-bit gamma ramps + size_t red_size # The size of `red` + size_t green_size # The size of `green` + size_t blue_size # The size of `blue` + uint32_t *red # The gamma ramp for the red channel + uint32_t *green # The gamma ramp for the green channel + uint32_t *blue # The gamma ramp for the blue channel + + ctypedef struct libgamma_gamma_ramps64_t: + # Gamma ramp structure for 64-bit gamma ramps + size_t red_size # The size of `red` + size_t green_size # The size of `green` + size_t blue_size # The size of `blue` + uint64_t *red # The gamma ramp for the red channel + uint64_t *green # The gamma ramp for the green channel + uint64_t *blue # The gamma ramp for the blue channel + + ctypedef struct libgamma_gamma_rampsf_t: + # Gamma ramp structure for `float` gamma ramps + size_t red_size # The size of `red` + size_t green_size # The size of `green` + size_t blue_size # The size of `blue` + float *red # The gamma ramp for the red channel + float *green # The gamma ramp for the green channel + float *blue # The gamma ramp for the blue channel + + ctypedef struct libgamma_gamma_rampsd_t: + # Gamma ramp structure for `double` gamma ramps + size_t red_size # The size of `red` + size_t green_size # The size of `green` + size_t blue_size # The size of `blue` + double *red # The gamma ramp for the red channel + double *green # The gamma ramp for the green channel + double *blue # The gamma ramp for the blue channel + + +cdef extern size_t libgamma_list_methods(int *methods, size_t buf_size, int operation) nogil +''' +List available adjustment methods by their order of preference based on the environment + +@param methods Output array of methods, should be able to hold `LIBGAMMA_METHOD_COUNT` elements +@param buf_size The number of elements that fits in `methods`, it should be `LIBGAMMA_METHOD_COUNT`, + This is used to avoid writing outside the output buffer if this library adds new + adjustment methods without the users of the library recompiling +@param operation Allowed values: + 0: Methods that the environment suggests will work, excluding fake + 1: Methods that the environment suggests will work, including fake + 2: All real non-fake methods + 3: All real methods + 4: All methods + Other values invoke undefined behaviour +@return The number of element that have been stored in `methods`, or should + have been stored if the buffer was large enough +''' + + +cdef extern int libgamma_is_method_available(int method) nogil +''' +Check whether an adjustment method is available, non-existing (invalid) methods will be +identified as not available under the rationale that the library may be out of date + +@param method The adjustment method +@return Whether the adjustment method is available +''' + + +cdef extern void libgamma_method_capabilities(libgamma_method_capabilities_t *this, int method) nogil +''' +Return the capabilities of an adjustment method + +@param this The data structure to fill with the method's capabilities +@param method The adjustment method (display server and protocol) +''' + + +cdef extern char *libgamma_method_default_site(int method) nogil +''' +Return the default site for an adjustment method + +@param method The adjustment method (display server and protocol) +@return The default site, `NULL` if it cannot be determined or + if multiple sites are not supported by the adjustment + method. This value should not be `free`:d +''' + + +cdef extern const char *libgamma_method_default_site_variable(int method) nogil +''' +Return the default variable that determines +the default site for an adjustment method + +@param method The adjustment method (display server and protocol) +@return The environ variables that is used to determine the + default site. `NULL` if there is none, that is, if + the method does not support multiple sites. + This value should not be `free`:d. +''' + + +cdef extern int libgamma_site_initialise(libgamma_site_state_t *this, int method, char *site) nogil +''' +Initialise an allocated site state + +@param this The site state to initialise +@param method The adjustment method (display server and protocol) +@param site The site identifier, unless it is `NULL` it must a + `free`:able. One the state is destroyed the library + will attempt to free it. There you should not free + it yourself, and it must not be a string constant + or allocate on the stack. Note however that it will + not be `free`:d if this function fails. +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern void libgamma_site_free(libgamma_site_state_t *this) nogil +''' +Release all resources held by a site state +and free the site state pointer + +@param this The site state +''' + + +cdef extern int libgamma_site_restore(libgamma_site_state_t *this) nogil +''' +Restore the gamma ramps all CRTC:s with a site to the system settings + +@param this The site state +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_partition_initialise(libgamma_partition_state_t *this, libgamma_site_state_t* site, size_t partition) nogil +''' +Initialise an allocated partition state + +@param this The partition state to initialise +@param site The site state for the site that the partition belongs to. +@param partition The index of the partition within the site +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern void libgamma_partition_free(libgamma_partition_state_t *this) nogil +''' +Release all resources held by a partition state +and free the partition state pointer + +@param this The partition state +''' + + +cdef extern int libgamma_partition_restore(libgamma_partition_state_t *this) nogil +''' +Restore the gamma ramps all CRTC:s with a partition to the system settings + +@param this The partition state +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_initialise(libgamma_crtc_state_t *this, libgamma_partition_state_t *partition, size_t crtc) nogil +''' +Initialise an allocated CRTC state + +@param this The CRTC state to initialise +@param partition The partition state for the partition that the CRTC belongs to +@param crtc The index of the CRTC within the partition +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern void libgamma_crtc_free(libgamma_crtc_state_t *this) nogil +''' +Release all resources held by a CRTC state +and free the CRTC state pointer + +@param this The CRTC state +''' + + +cdef extern int libgamma_crtc_restore(libgamma_crtc_state_t *this) nogil +''' +Restore the gamma ramps for a CRTC to the system settings for that CRTC + +@param this The CRTC state +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_get_crtc_information(libgamma_crtc_information_t *this, libgamma_crtc_state_t *crtc, int32_t fields) nogil +''' +Read information about a CRTC + +@param this Instance of a data structure to fill with the information about the CRTC +@param crtc The state of the CRTC whose information should be read +@param fields OR:ed identifiers for the information about the CRTC that should be read +@return Zero on success, -1 on error; on error refer to the error reports in `this` +''' + + +cdef extern void libgamma_crtc_information_destroy(libgamma_crtc_information_t *this) nogil +''' +Release all resources in an information data structure for a CRTC + +@param this The CRTC information +''' + + +cdef extern int libgamma_crtc_get_gamma_ramps8(libgamma_crtc_state_t *this, libgamma_gamma_ramps8_t *ramps) nogil +''' +Get the current gamma ramps for a CRTC, 8-bit gamma-depth version + +@param this The CRTC state +@param ramps The gamma ramps to fill with the current values +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_set_gamma_ramps8(libgamma_crtc_state_t *this, libgamma_gamma_ramps8_t ramps) nogil +''' +Set the gamma ramps for a CRTC, 8-bit gamma-depth version + +@param this The CRTC state +@param ramps The gamma ramps to apply +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_get_gamma_ramps16(libgamma_crtc_state_t *this, libgamma_gamma_ramps16_t *ramps) nogil +''' +Get the current gamma ramps for a CRTC, 16-bit gamma-depth version + +@param this The CRTC state +@param ramps The gamma ramps to fill with the current values +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_set_gamma_ramps16(libgamma_crtc_state_t *this, libgamma_gamma_ramps16_t ramps) nogil +''' +Set the gamma ramps for a CRTC, 16-bit gamma-depth version + +@param this The CRTC state +@param ramps The gamma ramps to apply +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_get_gamma_ramps32(libgamma_crtc_state_t *this, libgamma_gamma_ramps32_t *ramps) nogil +''' +Get the current gamma ramps for a CRTC, 32-bit gamma-depth version + +@param this The CRTC state +@param ramps The gamma ramps to fill with the current values +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_set_gamma_ramps32(libgamma_crtc_state_t *this, libgamma_gamma_ramps32_t ramps) nogil +''' +Set the gamma ramps for a CRTC, 32-bit gamma-depth version + +@param this The CRTC state +@param ramps The gamma ramps to apply +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_get_gamma_ramps64(libgamma_crtc_state_t *this, libgamma_gamma_ramps64_t *ramps) nogil +''' +Get the current gamma ramps for a CRTC, 64-bit gamma-depth version + +@param this The CRTC state +@param ramps The gamma ramps to fill with the current values +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_set_gamma_ramps64(libgamma_crtc_state_t *this, libgamma_gamma_ramps64_t ramps) nogil +''' +Set the gamma ramps for a CRTC, 64-bit gamma-depth version + +@param this The CRTC state +@param ramps The gamma ramps to apply +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_get_gamma_rampsf(libgamma_crtc_state_t *this, libgamma_gamma_rampsf_t *ramps) nogil +''' +Get the current gamma ramps for a CRTC, `float` version + +@param this The CRTC state +@param ramps The gamma ramps to fill with the current values +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_set_gamma_rampsf(libgamma_crtc_state_t *this, libgamma_gamma_rampsf_t ramps) nogil +''' +Set the gamma ramps for a CRTC, `float` version + +@param this The CRTC state +@param ramps The gamma ramps to apply +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + + +cdef extern int libgamma_crtc_get_gamma_rampsd(libgamma_crtc_state_t *this, libgamma_gamma_rampsd_t *ramps) nogil +''' +Get the current gamma ramps for a CRTC, `double` version + +@param this The CRTC state +@param ramps The gamma ramps to fill with the current values +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +cdef extern int libgamma_crtc_set_gamma_rampsd(libgamma_crtc_state_t *this, libgamma_gamma_rampsd_t ramps) nogil +''' +Set the gamma ramps for a CRTC, `double` version + +@param this The CRTC state +@param ramps The gamma ramps to apply +@return Zero on success, otherwise (negative) the value of an + error identifier provided by this library +''' + + +def libgamma_native_list_methods(operation : int) -> list: + ''' + List available adjustment methods by their order of preference based on the environment + + @param operation Allowed values: + 0: Methods that the environment suggests will work, excluding fake + 1: Methods that the environment suggests will work, including fake + 2: All real non-fake methods + 3: All real methods + 4: All methods + Other values invoke undefined behaviour + @return :list<int> A list of available adjustment methods + ''' + cdef int *methods + cdef size_t buf_size + cdef size_t r + buf_size = 6 + methods = <int *>malloc(buf_size * sizeof(size_t)) + if methods == NULL: + raise MemoryError() + r = libgamma_list_methods(methods, buf_size, operation) + if r > buf_size: + buf_size = r + free(methods) + methods = <int *>malloc(buf_size * sizeof(size_t)) + if methods == NULL: + raise MemoryError() + libgamma_list_methods(methods, buf_size, operation) + rc = [] + for i in range(r): + rc.append(methods[i]) + free(methods) + return rc + + +def libgamma_native_is_method_available(method : int) -> int: + ''' + Check whether an adjustment method is available, non-existing (invalid) methods will be + identified as not available under the rationale that the library may be out of date + + @param method The adjustment method + @return Whether the adjustment method is available + ''' + return int(libgamma_is_method_available(<int>method)) + + +def libgamma_native_method_capabilities(method : int) -> tuple: + ''' + Return the capabilities of an adjustment method + + @param method The adjustment method (display server and protocol) + @return :(int, int) Input parameters for `MethodCapabilities.__init__` + ''' + cdef libgamma_method_capabilities_t caps + libgamma_method_capabilities(&caps, <int>method) + booleans = 0 + crtc_information = int(caps.crtc_information) + booleans |= (0 if caps.default_site_known == 0 else 1) << 0 + booleans |= (0 if caps.multiple_sites == 0 else 1) << 1 + booleans |= (0 if caps.multiple_partitions == 0 else 1) << 2 + booleans |= (0 if caps.multiple_crtcs == 0 else 1) << 3 + booleans |= (0 if caps.partitions_are_graphics_cards == 0 else 1) << 4 + booleans |= (0 if caps.site_restore == 0 else 1) << 5 + booleans |= (0 if caps.partition_restore == 0 else 1) << 6 + booleans |= (0 if caps.crtc_restore == 0 else 1) << 7 + booleans |= (0 if caps.identical_gamma_sizes == 0 else 1) << 8 + booleans |= (0 if caps.fixed_gamma_size == 0 else 1) << 9 + booleans |= (0 if caps.fixed_gamma_depth == 0 else 1) << 10 + booleans |= (0 if caps.real == 0 else 1) << 11 + booleans |= (0 if caps.fake == 0 else 1) << 12 + return (crtc_information, booleans) + + +def libgamma_native_method_default_site(method : int) -> str: + ''' + Return the default site for an adjustment method + + @param method The adjustment method (display server and protocol) + @return The default site, `None` if it cannot be determined or + if multiple sites are not supported by the adjustment + method + ''' + cdef char *var + cdef bytes bs + var = libgamma_method_default_site(<int>method) + if var is NULL: + return None + bs = var + return bs.decode('utf-8', 'strict') + + +def libgamma_native_method_default_site_variable(method : int) -> str: + ''' + Return the default variable that determines + the default site for an adjustment method + + @param method The adjustment method (display server and protocol) + @return The environ variables that is used to determine the + default site. `None` if there is none, that is, if + the method does not support multiple sites. + ''' + cdef const char *var + cdef bytes bs + var = libgamma_method_default_site_variable(<int>method) + if var is NULL: + return None + bs = var + return bs.decode('utf-8', 'strict') + + +def libgamma_native_site_create(method : int, site : str) -> tuple: + ''' + Create an allocated site state + + @param method The adjustment method (display server and protocol) + @param site The site identifier, unless it is `NULL` it must a + `free`:able. One the state is destroyed the library + will attempt to free it. There you should not free + it yourself, and it must not be a string constant + or allocate on the stack. Note however that it will + not be `free`:d if this function fails. + @return :(site:int, partitions:int) First value: The created site, zero on error + Second value: The number of partitions in the site, + on error: the value of the error identifier + provided by this library or `errno` + ''' + cdef libgamma_site_state_t *this + cdef char *site_ + cdef size_t this_address + this = <libgamma_site_state_t *>malloc(sizeof(libgamma_site_state_t)) + if this is NULL: + raise MemoryError() + this_address = <size_t><void *>this + site_ = NULL + if site is not None: + site_bs = site.encode('utf-8') + bytes([0]) + site_ = <char *>malloc(len(site_bs) * sizeof(char)) + if site_ is None: + free(this) + raise MemoryError() + for i in range(len(site_bs)): + site_[i] = <char>(site_bs[i]) + r = int(libgamma_site_initialise(this, <int>method, site_)) + if not r == 0: + libgamma_site_free(this) + return (0, int(errno) if r == -1 else r) + return (int(this_address), int(this.partitions_available)) + + +def libgamma_native_site_free(this : int): + ''' + Release all resources held by a site state + and free the CRTC state pointer + + @param this The site state + ''' + cdef size_t this_address + cdef libgamma_site_state_t *this_ + this_address = <size_t>this + this_ = <libgamma_site_state_t *><void *>this_address + libgamma_site_free(this_) + + +def libgamma_native_site_restore(this : int) -> int: + ''' + Restore the gamma ramps all CRTC:s with a site to the system settings + + @param this The site state + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef libgamma_site_state_t *this_ + this_address = <size_t>this + this_ = <libgamma_site_state_t *><void *>this_address + r = int(libgamma_site_restore(this_)) + return int(errno) if r == -1 else r + + +def libgamma_native_partition_create(site : int, partition : int) -> tuple: + ''' + Create an allocated partition state + + @param site The site state for the site that the partition belongs to + @param partition The index of the partition within the site + @return :(site:int, partitions:int) First value: The created partition, zero on error + Second value: The number of CRTC:s in the partition, + on error: the value of the error identifier + provided by this library or `errno` + ''' + cdef libgamma_partition_state_t *this + cdef libgamma_site_state_t *site_ + cdef size_t this_address + cdef size_t site_address + site_address = <size_t>site + site_ = <libgamma_site_state_t *><void *>site_address + this = <libgamma_partition_state_t *>malloc(sizeof(libgamma_partition_state_t)) + if this is NULL: + raise MemoryError() + this_address = <size_t><void *>this + r = int(libgamma_partition_initialise(this, site_, <size_t>partition)) + if not r == 0: + libgamma_partition_free(this) + return (0, int(errno) if r == -1 else r) + return (int(this_address), int(this.crtcs_available)) + + +def libgamma_native_partition_free(this : int): + ''' + Release all resources held by a partition state + and free the partition state pointer + + @param this The partition state + ''' + cdef size_t this_address + cdef libgamma_partition_state_t *this_ + this_address = <size_t>this + this_ = <libgamma_partition_state_t *><void *>this_address + libgamma_partition_free(this_) + + +def libgamma_native_partition_restore(this : int) -> int: + ''' + Restore the gamma ramps all CRTC:s with a partition to the system settings + + @param this The partition state + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef libgamma_partition_state_t *this_ + this_address = <size_t>this + this_ = <libgamma_partition_state_t *><void *>this_address + r = int(libgamma_partition_restore(this_)) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_create(partition : int, crtc : int) -> tuple: + ''' + Create an allocated CRTC state + + @param partition The partition state for the partition that the CRTC belongs to. + @param crtc The index of the CRTC within the partition + @return :(int, int) First value: The created CRTC, zero on error + Second value: Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef libgamma_crtc_state_t *this + cdef libgamma_partition_state_t *partition_ + cdef size_t this_address + cdef size_t partition_address + partition_address = <size_t>partition + partition_ = <libgamma_partition_state_t *><void *>partition_address + this = <libgamma_crtc_state_t *>malloc(sizeof(libgamma_crtc_state_t)) + if this is NULL: + raise MemoryError() + this_address = <size_t><void *>this + r = int(libgamma_crtc_initialise(this, partition_, <size_t>crtc)) + if not r == 0: + libgamma_crtc_free(this) + return (0, int(errno) if r == -1 else r) + return (int(this_address), 0) + + +def libgamma_native_crtc_free(this : int): + ''' + Release all resources held by a CRTC state + and free the CRTC state pointer + + @param this The CRTC state + ''' + cdef size_t this_address + cdef libgamma_crtc_state_t *this_ + this_address = <size_t>this + this_ = <libgamma_crtc_state_t *><void *>this_address + libgamma_crtc_free(this_) + + +def libgamma_native_crtc_restore(this : int) -> int: + ''' + Restore the gamma ramps for a CRTC to the system settings for that CRTC + + @param this The CRTC state + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef libgamma_crtc_state_t *this_ + this_address = <size_t>this + this_ = <libgamma_crtc_state_t *><void *>this_address + r = int(libgamma_crtc_restore(this_)) + return int(errno) if r == -1 else r + + +def libgamma_native_get_crtc_information(crtc : int, fields : int) -> tuple: + ''' + Read information about a CRTC + + @param crtc The state of the CRTC whose information should be read + @param field OR:ed identifiers for the information about the CRTC that should be read + @return :(list, :int) First value: Input parametrs for `CRTCInformation.__init__` + Second value: Zero on success, -1 on error; on error refer to + the error reports in the return + ''' + cdef libgamma_crtc_information_t info + cdef size_t crtc_address + cdef libgamma_crtc_state_t *crtc_ + cdef bytes bs + crtc_address = <size_t>crtc + crtc_ = <libgamma_crtc_state_t *><void *>crtc_address + r = int(libgamma_get_crtc_information(&info, crtc_, <int32_t>fields)) + rc = [] + connector_name = None + if info.connector_name is not NULL: + bs = info.connector_name + connector_name = bs.decode('utf-8', 'strict') + edid = None + if info.edid is not NULL: + bs = info.edid[:info.edid_length] + edid = bs + rc.append(edid) + rc.append(int(info.edid_error)) + rc.append(int(info.width_mm)) + rc.append(int(info.width_mm_error)) + rc.append(int(info.height_mm)) + rc.append(int(info.height_mm_error)) + rc.append(int(info.width_mm_edid)) + rc.append(int(info.width_mm_edid_error)) + rc.append(int(info.height_mm_edid)) + rc.append(int(info.height_mm_edid_error)) + rc.append(int(info.red_gamma_size)) + rc.append(int(info.green_gamma_size)) + rc.append(int(info.blue_gamma_size)) + rc.append(int(info.gamma_size_error)) + rc.append(int(info.gamma_depth)) + rc.append(int(info.gamma_depth_error)) + rc.append(int(info.gamma_support)) + rc.append(int(info.gamma_support_error)) + rc.append(int(info.subpixel_order)) + rc.append(int(info.subpixel_order_error)) + rc.append(int(info.active)) + rc.append(int(info.active_error)) + rc.append(connector_name) + rc.append(int(info.connector_name_error)) + rc.append(int(info.connector_type)) + rc.append(int(info.connector_type_error)) + rc.append(float(info.gamma_red)) + rc.append(float(info.gamma_green)) + rc.append(float(info.gamma_blue)) + rc.append(int(info.gamma_error)) + libgamma_crtc_information_destroy(&info) + return (rc, r) + + +def libgamma_native_crtc_get_gamma_ramps8(this : int, ramps : int) -> int: + ''' + Get the current gamma ramps for a CRTC, 8-bit gamma-depth version + + @param this The CRTC state + @param ramps The gamma ramps to fill with the current values + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_ramps8_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_ramps8_t *><void *>ramps_address + r = int(libgamma_crtc_get_gamma_ramps8(this_, ramps_)) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_set_gamma_ramps8(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, 8-bit gamma-depth version + + @param this The CRTC state + @param ramps The gamma ramps to apply + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_ramps8_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_ramps8_t *><void *>ramps_address + r = int(libgamma_crtc_set_gamma_ramps8(this_, ramps_[0])) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_get_gamma_ramps16(this : int, ramps : int) -> int: + ''' + Get the current gamma ramps for a CRTC, 16-bit gamma-depth version + + @param this The CRTC state + @param ramps The gamma ramps to fill with the current values + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_ramps16_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_ramps16_t *><void *>ramps_address + r = int(libgamma_crtc_get_gamma_ramps16(this_, ramps_)) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_set_gamma_ramps16(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, 16-bit gamma-depth version + + @param this The CRTC state + @param ramps The gamma ramps to apply + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_ramps16_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_ramps16_t *><void *>ramps_address + r = int(libgamma_crtc_set_gamma_ramps16(this_, ramps_[0])) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_get_gamma_ramps32(this : int, ramps : int) -> int: + ''' + Get the current gamma ramps for a CRTC, 32-bit gamma-depth version + + @param this The CRTC state + @param ramps The gamma ramps to fill with the current values + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_ramps32_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_ramps32_t *><void *>ramps_address + r = int(libgamma_crtc_get_gamma_ramps32(this_, ramps_)) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_set_gamma_ramps32(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, 32-bit gamma-depth version + + @param this The CRTC state + @param ramps The gamma ramps to apply + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_ramps32_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_ramps32_t *><void *>ramps_address + r = int(libgamma_crtc_set_gamma_ramps32(this_, ramps_[0])) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_get_gamma_ramps64(this : int, ramps : int) -> int: + ''' + Get the current gamma ramps for a CRTC, 64-bit gamma-depth version + + @param this The CRTC state + @param ramps The gamma ramps to fill with the current values + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_ramps64_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_ramps64_t *><void *>ramps_address + r = int(libgamma_crtc_get_gamma_ramps64(this_, ramps_)) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_set_gamma_ramps64(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, 64-bit gamma-depth version + + @param this The CRTC state + @param ramps The gamma ramps to apply + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t * this_ + cdef libgamma_gamma_ramps64_t * ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_ramps64_t *><void *>ramps_address + r = int(libgamma_crtc_set_gamma_ramps64(this_, ramps_[0])) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_get_gamma_rampsf(this : int, ramps : int) -> int: + ''' + Get the current gamma ramps for a CRTC, `float` version + + @param this The CRTC state + @param ramps The gamma ramps to fill with the current values + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_rampsf_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_rampsf_t *><void *>ramps_address + r = int(libgamma_crtc_get_gamma_rampsf(this_, ramps_)) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_set_gamma_rampsf(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, `float` version + + @param this The CRTC state + @param ramps The gamma ramps to apply + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_rampsf_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_rampsf_t *><void *>ramps_address + r = int(libgamma_crtc_set_gamma_rampsf(this_, ramps_[0])) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_get_gamma_rampsd(this : int, ramps : int) -> int: + ''' + Get the current gamma ramps for a CRTC, `double` version + + @param this The CRTC state + @param ramps The gamma ramps to fill with the current values + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_rampsd_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_rampsd_t *><void *>ramps_address + r = int(libgamma_crtc_get_gamma_rampsd(this_, ramps_)) + return int(errno) if r == -1 else r + + +def libgamma_native_crtc_set_gamma_rampsd(this : int, ramps : int) -> int: + ''' + Set the gamma ramps for a CRTC, `double` version + + @param this The CRTC state + @param ramps The gamma ramps to apply + @return Zero on success, otherwise the value of an error + identifier provided by this library or `errno` + ''' + cdef size_t this_address + cdef size_t ramps_address + cdef libgamma_crtc_state_t *this_ + cdef libgamma_gamma_rampsd_t *ramps_ + this_address = <size_t>this + ramps_address = <size_t>ramps + this_ = <libgamma_crtc_state_t *><void *>this_address + ramps_ = <libgamma_gamma_rampsd_t *><void *>ramps_address + r = int(libgamma_crtc_set_gamma_rampsd(this_, ramps_[0])) + return int(errno) if r == -1 else r |