1298 lines
50 KiB
Cython
1298 lines
50 KiB
Cython
# -*- 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
|