diff options
Diffstat (limited to 'libgamma_native_method.pyx')
| -rw-r--r-- | libgamma_native_method.pyx | 616 |
1 files changed, 616 insertions, 0 deletions
diff --git a/libgamma_native_method.pyx b/libgamma_native_method.pyx new file mode 100644 index 0000000..96eee7c --- /dev/null +++ b/libgamma_native_method.pyx @@ -0,0 +1,616 @@ +# -*- python -*- +# See LICENSE file for copyright and license details. +cimport cython + +from libc.stdint cimport * +from libc.stdlib cimport malloc +from libc.stddef cimport size_t +from libc.errno cimport errno + + +cdef extern from "include-libgamma.h": + 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 int libgamma_gamma_ramps8_initialise(libgamma_gamma_ramps8_t *this) nogil +''' +Initialise a gamma ramp in the proper way that allows all adjustment +methods to read from and write to it without causing segmentation violation + +The input must have `red_size`, `green_size` and `blue_size` +set to the sizes of the gamma ramps that should be allocated + +@param this The gamma ramps +@return Zero on success, -1 on allocation error, `errno` will be set accordingly +''' + +cdef extern void libgamma_gamma_ramps8_free(libgamma_gamma_ramps8_t *this) nogil +''' +Release resources that are held by a gamma ramp strcuture that +has been allocated by `libgamma_gamma_ramps8_initialise` or +otherwise initialises in the proper manner, as well as release +the pointer to the structure + +@param this The gamma ramps +''' + +cdef extern int libgamma_gamma_ramps16_initialise(libgamma_gamma_ramps16_t *this) nogil +''' +Initialise a gamma ramp in the proper way that allows all adjustment +methods to read from and write to it without causing segmentation violation + +The input must have `red_size`, `green_size` and `blue_size` +set to the sizes of the gamma ramps that should be allocated + +@param this The gamma ramps +@return Zero on success, -1 on allocation error, `errno` will be set accordingly +''' + +cdef extern void libgamma_gamma_ramps16_free(libgamma_gamma_ramps16_t *this) nogil +''' +Release resources that are held by a gamma ramp strcuture that +has been allocated by `libgamma_gamma_ramps16_initialise` or +otherwise initialises in the proper manner, as well as release +the pointer to the structure + +@param this The gamma ramps +''' + +cdef extern int libgamma_gamma_ramps32_initialise(libgamma_gamma_ramps32_t *this) nogil +''' +Initialise a gamma ramp in the proper way that allows all adjustment +methods to read from and write to it without causing segmentation violation + +The input must have `red_size`, `green_size` and `blue_size` +set to the sizes of the gamma ramps that should be allocated + +@param this The gamma ramps +@return Zero on success, -1 on allocation error, `errno` will be set accordingly +''' + +cdef extern void libgamma_gamma_ramps32_free(libgamma_gamma_ramps32_t *this) nogil +''' +Release resources that are held by a gamma ramp strcuture that +has been allocated by `libgamma_gamma_ramps32_initialise` or +otherwise initialises in the proper manner, as well as release +the pointer to the structure + +@param this The gamma ramps +''' + +cdef extern int libgamma_gamma_ramps64_initialise(libgamma_gamma_ramps64_t *this) nogil +''' +Initialise a gamma ramp in the proper way that allows all adjustment +methods to read from and write to it without causing segmentation violation + +The input must have `red_size`, `green_size` and `blue_size` +set to the sizes of the gamma ramps that should be allocated + +@param this The gamma ramps +@return Zero on success, -1 on allocation error, `errno` will be set accordingly +''' + +cdef extern void libgamma_gamma_ramps64_free(libgamma_gamma_ramps64_t *this) nogil +''' +Release resources that are held by a gamma ramp strcuture that +has been allocated by `libgamma_gamma_ramps64_initialise` or +otherwise initialises in the proper manner, as well as release +the pointer to the structure + +@param this The gamma ramps +''' + +cdef extern int libgamma_gamma_rampsf_initialise(libgamma_gamma_rampsf_t *this) nogil +''' +Initialise a gamma ramp in the proper way that allows all adjustment +methods to read from and write to it without causing segmentation violation + +The input must have `red_size`, `green_size` and `blue_size` +set to the sizes of the gamma ramps that should be allocated + +@param this The gamma ramps +@return Zero on success, -1 on allocation error, `errno` will be set accordingly +''' + +cdef extern void libgamma_gamma_rampsf_free(libgamma_gamma_rampsf_t *this) nogil +''' +Release resources that are held by a gamma ramp strcuture that +has been allocated by `libgamma_gamma_rampsf_initialise` or +otherwise initialises in the proper manner, as well as release +the pointer to the structure + +@param this The gamma ramps +''' + +cdef extern int libgamma_gamma_rampsd_initialise(libgamma_gamma_rampsd_t *this) nogil +''' +Initialise a gamma ramp in the proper way that allows all adjustment +methods to read from and write to it without causing segmentation violation + +The input must have `red_size`, `green_size` and `blue_size` +set to the sizes of the gamma ramps that should be allocated + +@param this The gamma ramps +@return Zero on success, -1 on allocation error, `errno` will be set accordingly +''' + +cdef extern void libgamma_gamma_rampsd_free(libgamma_gamma_rampsd_t *this) nogil +''' +Release resources that are held by a gamma ramp strcuture that +has been allocated by `libgamma_gamma_rampsd_initialise` or +otherwise initialises in the proper manner, as well as release +the pointer to the structure + +@param this The gamma ramps +''' + + +def libgamma_native_gamma_ramps8_create(red_size : int, green_size : int, blue_size : int): + ''' + Create a gamma ramp in the proper way that allows all adjustment methods + to read from and write to it without causing segmentation violation + + @param red_size The size of the gamma ramp for the red channel + @param green_size The size of the gamma ramp for the green channel + @param blue_size The size of the gamma ramp for the blue channel + @return :(int){4}|int The tuple that describes the created data, `errno` on failure: + Element 1: The address of the gamma ramp structure + Element 2: The address of the gamma ramp for the red channel + Element 3: The address of the gamma ramp for the green channel + Element 4: The address of the gamma ramp for the blue channel + ''' + cdef void *allocation = malloc(sizeof(libgamma_gamma_ramps8_t)) + cdef libgamma_gamma_ramps8_t *item = <libgamma_gamma_ramps8_t *>allocation + cdef size_t red, green, blue + if item is NULL: + return int(errno) + item.red_size = red_size + item.green_size = green_size + item.blue_size = blue_size + if libgamma_gamma_ramps8_initialise(item) < 0: + return int(errno) + red = <size_t><void *>(item.red) + green = <size_t><void *>(item.green) + blue = <size_t><void *>(item.blue) + return (int(<size_t>allocation), int(red), int(green), int(blue)) + + +def libgamma_native_gamma_ramps8_free(this : int): + ''' + Release resources that are held by a gamma ramp strcuture that + has been allocated by `libgamma_native_gamma_ramps8_create` or + otherwise created in the proper manner, as well as release the + pointer to the structure + + @param this The gamma ramps + ''' + cdef void *address = <void *><size_t>this + cdef libgamma_gamma_ramps8_t *item = <libgamma_gamma_ramps8_t *>address + libgamma_gamma_ramps8_free(item) + + +def libgamma_native_gamma_ramps8_get(this : int, index : int) -> int: + ''' + Read a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @return The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef uint8_t *ramp = <uint8_t *>address + return int(ramp[<size_t>index]) + + +def libgamma_native_gamma_ramps8_set(this : int, index : int, value : int): + ''' + Modify a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @param value The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef uint8_t *ramp = <uint8_t *>address + ramp[<size_t>index] = <uint8_t>value + + +def libgamma_native_gamma_ramps16_create(red_size : int, green_size : int, blue_size : int): + ''' + Create a gamma ramp in the proper way that allows all adjustment methods + to read from and write to it without causing segmentation violation + + @param red_size The size of the gamma ramp for the red channel + @param green_size The size of the gamma ramp for the green channel + @param blue_size The size of the gamma ramp for the blue channel + @return :(int){4}|int The tuple that describes the created data, `errno` on failure: + Element 1: The address of the gamma ramp structure + Element 2: The address of the gamma ramp for the red channel + Element 3: The address of the gamma ramp for the green channel + Element 4: The address of the gamma ramp for the blue channel + ''' + cdef void *allocation = malloc(sizeof(libgamma_gamma_ramps16_t)) + cdef libgamma_gamma_ramps16_t *item = <libgamma_gamma_ramps16_t *>allocation + cdef size_t red, green, blue + if item is NULL: + return int(errno) + item.red_size = red_size + item.green_size = green_size + item.blue_size = blue_size + if libgamma_gamma_ramps16_initialise(item) < 0: + return int(errno) + red = <size_t><void *>(item.red) + green = <size_t><void *>(item.green) + blue = <size_t><void *>(item.blue) + return (int(<size_t>allocation), int(red), int(green), int(blue)) + + +def libgamma_native_gamma_ramps16_free(this : int): + ''' + Release resources that are held by a gamma ramp strcuture that + has been allocated by `libgamma_native_gamma_ramps16_create` or + otherwise created in the proper manner, as well as release the + pointer to the structure + + @param this The gamma ramps + ''' + cdef void *address = <void*><size_t>this + cdef libgamma_gamma_ramps16_t *item = <libgamma_gamma_ramps16_t *>address + libgamma_gamma_ramps16_free(item) + + +def libgamma_native_gamma_ramps16_get(this : int, index : int) -> int: + ''' + Read a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @return The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef uint16_t *ramp = <uint16_t *>address + return int(ramp[<size_t>index]) + + +def libgamma_native_gamma_ramps16_set(this : int, index : int, value : int): + ''' + Modify a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @param value The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef uint16_t *ramp = <uint16_t *>address + ramp[<size_t>index] = <uint16_t>value + + +def libgamma_native_gamma_ramps32_create(red_size : int, green_size : int, blue_size : int): + ''' + Create a gamma ramp in the proper way that allows all adjustment methods + to read from and write to it without causing segmentation violation + + @param red_size The size of the gamma ramp for the red channel + @param green_size The size of the gamma ramp for the green channel + @param blue_size The size of the gamma ramp for the blue channel + @return :(int){4}|int The tuple that describes the created data, `errno` on failure: + Element 1: The address of the gamma ramp structure + Element 2: The address of the gamma ramp for the red channel + Element 3: The address of the gamma ramp for the green channel + Element 4: The address of the gamma ramp for the blue channel + ''' + cdef void *allocation = malloc(sizeof(libgamma_gamma_ramps32_t)) + cdef libgamma_gamma_ramps32_t *item = <libgamma_gamma_ramps32_t *>allocation + cdef size_t red, green, blue + if item is NULL: + return int(errno) + item.red_size = red_size + item.green_size = green_size + item.blue_size = blue_size + if libgamma_gamma_ramps32_initialise(item) < 0: + return int(errno) + red = <size_t><void *>(item.red) + green = <size_t><void *>(item.green) + blue = <size_t><void *>(item.blue) + return (int(<size_t>allocation), int(red), int(green), int(blue)) + + +def libgamma_native_gamma_ramps32_free(this : int): + ''' + Release resources that are held by a gamma ramp strcuture that + has been allocated by `libgamma_native_gamma_ramps32_create` or + otherwise created in the proper manner, as well as release the + pointer to the structure + + @param this The gamma ramps + ''' + cdef void *address = <void *><size_t>this + cdef libgamma_gamma_ramps32_t *item = <libgamma_gamma_ramps32_t *>address + libgamma_gamma_ramps32_free(item) + + +def libgamma_native_gamma_ramps32_get(this : int, index : int) -> int: + ''' + Read a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @return The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef uint32_t *ramp = <uint32_t *>address + return int(ramp[<size_t>index]) + + +def libgamma_native_gamma_ramps32_set(this : int, index : int, value : int): + ''' + Modify a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @param value The value of the gamma ramp stop + ''' + cdef void *address = <void*><size_t>this + cdef uint32_t *ramp = <uint32_t *>address + ramp[<size_t>index] = <uint32_t>value + + +def libgamma_native_gamma_ramps64_create(red_size : int, green_size : int, blue_size : int): + ''' + Create a gamma ramp in the proper way that allows all adjustment methods + to read from and write to it without causing segmentation violation + + @param red_size The size of the gamma ramp for the red channel + @param green_size The size of the gamma ramp for the green channel + @param blue_size The size of the gamma ramp for the blue channel + @return :(int){4}|int The tuple that describes the created data, `errno` on failure: + Element 1: The address of the gamma ramp structure + Element 2: The address of the gamma ramp for the red channel + Element 3: The address of the gamma ramp for the green channel + Element 4: The address of the gamma ramp for the blue channel + ''' + cdef void *allocation = malloc(sizeof(libgamma_gamma_ramps64_t)) + cdef libgamma_gamma_ramps64_t *item = <libgamma_gamma_ramps64_t *>allocation + cdef size_t red, green, blue + if item is NULL: + return int(errno) + item.red_size = red_size + item.green_size = green_size + item.blue_size = blue_size + if libgamma_gamma_ramps64_initialise(item) < 0: + return int(errno) + red = <size_t><void *>(item.red) + green = <size_t><void *>(item.green) + blue = <size_t><void *>(item.blue) + return (int(<size_t>allocation), int(red), int(green), int(blue)) + + +def libgamma_native_gamma_ramps64_free(this : int): + ''' + Release resources that are held by a gamma ramp strcuture that + has been allocated by `libgamma_native_gamma_ramps64_create` or + otherwise created in the proper manner, as well as release the + pointer to the structure + + @param this The gamma ramps + ''' + cdef void *address = <void *><size_t>this + cdef libgamma_gamma_ramps64_t *item = <libgamma_gamma_ramps64_t *>address + libgamma_gamma_ramps64_free(item) + + +def libgamma_native_gamma_ramps64_get(this : int, index : int) -> int: + ''' + Read a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @return The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef uint64_t *ramp = <uint64_t *>address + return int(ramp[<size_t>index]) + + +def libgamma_native_gamma_ramps64_set(this : int, index : int, value : int): + ''' + Modify a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @param value The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef uint64_t *ramp = <uint64_t *>address + ramp[<size_t>index] = <uint64_t>value + + +def libgamma_native_gamma_rampsf_create(red_size : int, green_size : int, blue_size : int): + ''' + Create a gamma ramp in the proper way that allows all adjustment methods + to read from and write to it without causing segmentation violation + + @param red_size The size of the gamma ramp for the red channel + @param green_size The size of the gamma ramp for the green channel + @param blue_size The size of the gamma ramp for the blue channel + @return :(int){4}|int The tuple that describes the created data, `errno` on failure: + Element 1: The address of the gamma ramp structure + Element 2: The address of the gamma ramp for the red channel + Element 3: The address of the gamma ramp for the green channel + Element 4: The address of the gamma ramp for the blue channel + ''' + cdef void *allocation = malloc(sizeof(libgamma_gamma_rampsf_t)) + cdef libgamma_gamma_rampsf_t *item = <libgamma_gamma_rampsf_t *>allocation + cdef size_t red, green, blue + if item is NULL: + return int(errno) + item.red_size = red_size + item.green_size = green_size + item.blue_size = blue_size + if libgamma_gamma_rampsf_initialise(item) < 0: + return int(errno) + red = <size_t><void *>(item.red) + green = <size_t><void *>(item.green) + blue = <size_t><void *>(item.blue) + return (int(<size_t>allocation), int(red), int(green), int(blue)) + + +def libgamma_native_gamma_rampsf_free(this : int): + ''' + Release resources that are held by a gamma ramp strcuture that + has been allocated by `libgamma_native_gamma_rampsf_create` or + otherwise created in the proper manner, as well as release the + pointer to the structure + + @param this The gamma ramps + ''' + cdef void *address = <void *><size_t>this + cdef libgamma_gamma_rampsf_t *item = <libgamma_gamma_rampsf_t *>address + libgamma_gamma_rampsf_free(item) + + +def libgamma_native_gamma_rampsf_get(this : int, index : int) -> float: + ''' + Read a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @return The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef float *ramp = <float *>address + return float(ramp[<size_t>index]) + + +def libgamma_native_gamma_rampsf_set(this : int, index : int, value : float): + ''' + Modify a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @param value The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef float *ramp = <float *>address + ramp[<size_t>index] = <float>value + + +def libgamma_native_gamma_rampsd_create(red_size : int, green_size : int, blue_size : int): + ''' + Create a gamma ramp in the proper way that allows all adjustment + methods to read from and write to it without causing segmentation violation + + @param red_size The size of the gamma ramp for the red channel + @param green_size The size of the gamma ramp for the green channel + @param blue_size The size of the gamma ramp for the blue channel + @return :(int){4}|int The tuple that describes the created data, `errno` on failure: + Element 1: The address of the gamma ramp structure + Element 2: The address of the gamma ramp for the red channel + Element 3: The address of the gamma ramp for the green channel + Element 4: The address of the gamma ramp for the blue channel + ''' + cdef void *allocation = malloc(sizeof(libgamma_gamma_rampsd_t)) + cdef libgamma_gamma_rampsd_t *item = <libgamma_gamma_rampsd_t *>allocation + cdef size_t red, green, blue + if item is NULL: + return int(errno) + item.red_size = red_size + item.green_size = green_size + item.blue_size = blue_size + if libgamma_gamma_rampsd_initialise(item) < 0: + return int(errno) + red = <size_t><void *>(item.red) + green = <size_t><void *>(item.green) + blue = <size_t><void *>(item.blue) + return (int(<size_t>allocation), int(red), int(green), int(blue)) + + +def libgamma_native_gamma_rampsd_free(this : int): + ''' + Release resources that are held by a gamma ramp strcuture that + has been allocated by `libgamma_native_gamma_rampsd_create` or + otherwise created in the proper manner, as well as release the + pointer to the structure + + @param this The gamma ramps + ''' + cdef void *address = <void *><size_t>this + cdef libgamma_gamma_rampsd_t *item = <libgamma_gamma_rampsd_t *>address + libgamma_gamma_rampsd_free(item) + + +def libgamma_native_gamma_rampsd_get(this : int, index : int) -> float: + ''' + Read a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @return The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef double *ramp = <double *>address + return float(ramp[<size_t>index]) + + +def libgamma_native_gamma_rampsd_set(this : int, index : int, value : float): + ''' + Modify a stop in a gamma ramp + + @param this The gamma ramp + @param index The index of the gamma ramp stop + @param value The value of the gamma ramp stop + ''' + cdef void *address = <void *><size_t>this + cdef double *ramp = <double *>address + ramp[<size_t>index] = <double>value |