From 3be28b4e8f75190d30e311f0e69da714cac62cc5 Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Thu, 21 Jul 2022 14:53:18 +0200 Subject: Change license to ISC, change style, improve makefile MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- src/libgamma_native_method.pyx | 682 ----------------------------------------- 1 file changed, 682 deletions(-) delete mode 100644 src/libgamma_native_method.pyx (limited to 'src/libgamma_native_method.pyx') diff --git a/src/libgamma_native_method.pyx b/src/libgamma_native_method.pyx deleted file mode 100644 index 1550caf..0000000 --- a/src/libgamma_native_method.pyx +++ /dev/null @@ -1,682 +0,0 @@ -# -*- python -*- -''' -pylibgamma — Python 3 wrapper for libgamma -Copyright © 2014 Mattias Andrée (maandree@member.fsf.org) - -This library is free software: you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation, either version 3 of the License, or -(at your option) any later version. - -This library is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with this library. If not, see . -''' - -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 = 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 = (item.red) - green = (item.green) - blue = (item.blue) - return (int(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 = this - cdef libgamma_gamma_ramps8_t* item = 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 = this - cdef uint8_t* ramp = address - return int(ramp[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 = this - cdef uint8_t* ramp = address - ramp[index] = 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 = 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 = (item.red) - green = (item.green) - blue = (item.blue) - return (int(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 = this - cdef libgamma_gamma_ramps16_t* item = 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 = this - cdef uint16_t* ramp = address - return int(ramp[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 = this - cdef uint16_t* ramp = address - ramp[index] = 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 = 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 = (item.red) - green = (item.green) - blue = (item.blue) - return (int(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 = this - cdef libgamma_gamma_ramps32_t* item = 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 = this - cdef uint32_t* ramp = address - return int(ramp[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 = this - cdef uint32_t* ramp = address - ramp[index] = 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 = 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 = (item.red) - green = (item.green) - blue = (item.blue) - return (int(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 = this - cdef libgamma_gamma_ramps64_t* item = 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 = this - cdef uint64_t* ramp = address - return int(ramp[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 = this - cdef uint64_t* ramp = address - ramp[index] = 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 = 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 = (item.red) - green = (item.green) - blue = (item.blue) - return (int(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 = this - cdef libgamma_gamma_rampsf_t* item = 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 = this - cdef float* ramp = address - return float(ramp[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 = this - cdef float* ramp = address - ramp[index] = 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 = 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 = (item.red) - green = (item.green) - blue = (item.blue) - return (int(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 = this - cdef libgamma_gamma_rampsd_t* item = 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 = this - cdef double* ramp = address - return float(ramp[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 = this - cdef double* ramp = address - ramp[index] = value - -- cgit v1.2.3-70-g09d2