From 1fdaa473e0b54d2d8819da0a477dbaeed913e76f Mon Sep 17 00:00:00 2001 From: Mattias Andrée Date: Thu, 21 Jul 2022 18:11:44 +0200 Subject: Change style MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Mattias Andrée --- libgamma-facade.cc | 881 +++++++++++++++++++++++++++-------------------------- 1 file changed, 447 insertions(+), 434 deletions(-) (limited to 'libgamma-facade.cc') diff --git a/libgamma-facade.cc b/libgamma-facade.cc index 9d74d6f..dfb07f3 100644 --- a/libgamma-facade.cc +++ b/libgamma-facade.cc @@ -1,443 +1,456 @@ /* See LICENSE file for copyright and license details. */ #include "libgamma-facade.hh" - #include "libgamma-error.hh" - #include namespace libgamma { - /** - * 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 Array of methods. - */ - std::vector list_methods(int operation) - { - int* methods = (int*)malloc(LIBGAMMA_METHOD_COUNT * sizeof(int)); - size_t n, i; - std::vector rc; - - n = libgamma_list_methods(methods, LIBGAMMA_METHOD_COUNT, operation); - if (n > LIBGAMMA_METHOD_COUNT) - { - free(methods); - methods = (int*)malloc(n * sizeof(int)); - libgamma_list_methods(methods, n, operation); - } - - for (i = 0; i < n; i++) - rc.push_back(methods[i]); - - free(methods); - return rc; - } - - /** - * 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. - */ - int is_method_available(int method) - { - return libgamma_is_method_available(method); - } - - /** - * Return the capabilities of an adjustment method. - * - * @param output The data structure to fill with the method's capabilities, - * @param method The adjustment method (display server and protocol). - */ - void method_capabilities(MethodCapabilities* output, int method) - { - libgamma_method_capabilities_t caps; - libgamma_method_capabilities(&caps, method); - *output = MethodCapabilities(&caps); - } - - /** - * Return the default site for an adjustment method. - * - * @param method The adjustment method (display server and protocol.) - * @return The default site, `nullptr` if it cannot be determined or if - * multiple sites are not supported by the adjustment method. - */ - std::string* method_default_site(int method) - { - char* cstr = libgamma_method_default_site(method); - if (cstr == nullptr) - return nullptr; - return new std::string(cstr); - } - - /** - * 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. `nullptr` if there is none, that is, if - * the method does not support multiple sites. - * This value should not be `free`:d. - */ - std::string* method_default_site_variable(int method) - { - const char* cstr = libgamma_method_default_site_variable(method); - if (cstr == nullptr) - return nullptr; - return new std::string(cstr); - } - - - /** - * Convert a raw representation of an EDID to a lowercase hexadecimal representation. - * - * @param edid The EDID in raw representation. - * @param length The length of `edid`. - * @return The EDID in lowercase hexadecimal representation. - */ - std::string behex_edid(const unsigned char* edid, size_t length) - { - return behex_edid_lowercase(edid, length); - } - - /** - * Convert a raw representation of an EDID to a lowercase hexadecimal representation. - * - * @param edid The EDID in raw representation. - * @param length The length of `edid`. - * @return The EDID in lowercase hexadecimal representation. - */ - std::string behex_edid_lowercase(const unsigned char* edid, size_t length) - { - char* cstr = libgamma_behex_edid_lowercase(edid, length); - std::string rc = std::string(cstr); - free(cstr); - return rc; - } - - /** - * Convert a raw representation of an EDID to an uppercase hexadecimal representation. - * - * @param edid The EDID in raw representation. - * @param length The length of `edid`. - * @return The EDID in uppercase hexadecimal representation. - */ - std::string behex_edid_uppercase(const unsigned char* edid, size_t length) - { - char* cstr = libgamma_behex_edid_uppercase(edid, length); - std::string rc = std::string(cstr); - free(cstr); - return rc; - } - - /** - * Convert an hexadecimal representation of an EDID to a raw representation. - * - * @param edid The EDID in hexadecimal representation. - * @return The EDID in raw representation, it will be half the length - * of `edid` (the input value). - */ - unsigned char* unhex_edid(const std::string edid) - { - const char* cstr = edid.c_str(); - return libgamma_unhex_edid(cstr); - } - - - /** - * Initialise a gamma ramp in the proper way that allows all adjustment - * methods to read from and write to it without causing segmentation violation. - * - * @param ramps The gamma ramp to initialise. - * @param red The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - */ - void gamma_ramps8_initialise(GammaRamps* ramps, size_t red, size_t blue, size_t green) - { - libgamma_gamma_ramps8_t native; - int r; - native.red_size = ramps->red.size = red; - native.green_size = ramps->green.size = green; - native.blue_size = ramps->blue.size = blue; - ramps->depth = 8; - r = libgamma_gamma_ramps8_initialise(&native); - if (r != 0) - throw create_error(r); - ramps->red.ramp = native.red; - ramps->green.ramp = native.green; - ramps->blue.ramp = native.blue; - } - - /** - * Initialise a gamma ramp in the proper way that allows all adjustment - * methods to read from and write to it without causing segmentation violation. - * - * @param ramps The gamma ramp to initialise. - * @param red The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - */ - void gamma_ramps16_initialise(GammaRamps* ramps, size_t red, size_t blue, size_t green) - { - libgamma_gamma_ramps16_t native; - int r; - native.red_size = ramps->red.size = red; - native.green_size = ramps->green.size = green; - native.blue_size = ramps->blue.size = blue; - ramps->depth = 16; - r = libgamma_gamma_ramps16_initialise(&native); - if (r != 0) - throw create_error(r); - ramps->red.ramp = native.red; - ramps->green.ramp = native.green; - ramps->blue.ramp = native.blue; - } - - /** - * Initialise a gamma ramp in the proper way that allows all adjustment - * methods to read from and write to it without causing segmentation violation. - * - * @param ramps The gamma ramp to initialise. - * @param red The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - */ - void gamma_ramps32_initialise(GammaRamps* ramps, size_t red, size_t blue, size_t green) - { - libgamma_gamma_ramps32_t native; - int r; - native.red_size = ramps->red.size = red; - native.green_size = ramps->green.size = green; - native.blue_size = ramps->blue.size = blue; - ramps->depth = 32; - r = libgamma_gamma_ramps32_initialise(&native); - if (r != 0) - throw create_error(r); - ramps->red.ramp = native.red; - ramps->green.ramp = native.green; - ramps->blue.ramp = native.blue; - } - - /** - * Initialise a gamma ramp in the proper way that allows all adjustment - * methods to read from and write to it without causing segmentation violation. - * - * @param ramps The gamma ramp to initialise. - * @param red The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - */ - void gamma_ramps64_initialise(GammaRamps* ramps, size_t red, size_t blue, size_t green) - { - libgamma_gamma_ramps64_t native; - int r; - native.red_size = ramps->red.size = red; - native.green_size = ramps->green.size = green; - native.blue_size = ramps->blue.size = blue; - ramps->depth = 64; - r = libgamma_gamma_ramps64_initialise(&native); - if (r != 0) - throw create_error(r); - ramps->red.ramp = native.red; - ramps->green.ramp = native.green; - ramps->blue.ramp = native.blue; - } - - /** - * Initialise a gamma ramp in the proper way that allows all adjustment - * methods to read from and write to it without causing segmentation violation. - * - * @param ramps The gamma ramp to initialise. - * @param red The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - */ - void gamma_rampsf_initialise(GammaRamps* ramps, size_t red, size_t blue, size_t green) - { - libgamma_gamma_rampsf_t native; - int r; - native.red_size = ramps->red.size = red; - native.green_size = ramps->green.size = green; - native.blue_size = ramps->blue.size = blue; - ramps->depth = -1; - r = libgamma_gamma_rampsf_initialise(&native); - if (r != 0) - throw create_error(r); - ramps->red.ramp = native.red; - ramps->green.ramp = native.green; - ramps->blue.ramp = native.blue; - } - - /** - * Initialise a gamma ramp in the proper way that allows all adjustment - * methods to read from and write to it without causing segmentation violation. - * - * @param ramps The gamma ramp to initialise. - * @param red The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - */ - void gamma_rampsd_initialise(GammaRamps* ramps, size_t red, size_t blue, size_t green) - { - libgamma_gamma_rampsd_t native; - int r; - native.red_size = ramps->red.size = red; - native.green_size = ramps->green.size = green; - native.blue_size = ramps->blue.size = blue; - ramps->depth = -2; - r = libgamma_gamma_rampsd_initialise(&native); - if (r != 0) - throw create_error(r); - ramps->red.ramp = native.red; - ramps->green.ramp = native.green; - ramps->blue.ramp = native.blue; - } - - - /** - * 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 The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - * @return The gamma ramp. - */ - GammaRamps* gamma_ramps8_create(size_t red, size_t blue, size_t green) - { - libgamma_gamma_ramps8_t ramps; - int r; - ramps.red_size = red; - ramps.green_size = green; - ramps.blue_size = blue; - r = libgamma_gamma_ramps8_initialise(&ramps); - if (r != 0) - throw create_error(r); - return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, 8); - } - - /** - * 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 The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - * @return The gamma ramp. - */ - GammaRamps* gamma_ramps16_create(size_t red, size_t blue, size_t green) - { - libgamma_gamma_ramps16_t ramps; - int r; - ramps.red_size = red; - ramps.green_size = green; - ramps.blue_size = blue; - r = libgamma_gamma_ramps16_initialise(&ramps); - if (r != 0) - throw create_error(r); - return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, 16); - } - - /** - * 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 The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - * @return The gamma ramp. - */ - GammaRamps* gamma_ramps32_create(size_t red, size_t blue, size_t green) - { - libgamma_gamma_ramps32_t ramps; - int r; - ramps.red_size = red; - ramps.green_size = green; - ramps.blue_size = blue; - r = libgamma_gamma_ramps32_initialise(&ramps); - if (r != 0) - throw create_error(r); - return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, 32); - } - - /** - * 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 The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - * @return The gamma ramp. - */ - GammaRamps* gamma_ramps64_create(size_t red, size_t blue, size_t green) - { - libgamma_gamma_ramps64_t ramps; - int r; - ramps.red_size = red; - ramps.green_size = green; - ramps.blue_size = blue; - r = libgamma_gamma_ramps64_initialise(&ramps); - if (r != 0) - throw create_error(r); - return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, 64); - } - - /** - * 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 The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - * @return The gamma ramp. - */ - GammaRamps* gamma_rampsf_create(size_t red, size_t blue, size_t green) - { - libgamma_gamma_rampsf_t ramps; - int r; - ramps.red_size = red; - ramps.green_size = green; - ramps.blue_size = blue; - r = libgamma_gamma_rampsf_initialise(&ramps); - if (r != 0) - throw create_error(r); - return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, -1); - } - - /** - * 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 The size of the gamma ramp for the red channel. - * @param green The size of the gamma ramp for the green channel. - * @param blue The size of the gamma ramp for the blue channel. - * @return The gamma ramp. - */ - GammaRamps* gamma_rampsd_create(size_t red, size_t blue, size_t green) - { - libgamma_gamma_rampsd_t ramps; - int r; - ramps.red_size = red; - ramps.green_size = green; - ramps.blue_size = blue; - r = libgamma_gamma_rampsd_initialise(&ramps); - if (r != 0) - throw create_error(r); - return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, -2); - } - -} + /** + * 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 Array of methods + */ + std::vector + list_methods(int operation) + { + int *methods = (int*)malloc(LIBGAMMA_METHOD_COUNT * sizeof(int)); + size_t n, i; + std::vector rc; + + n = libgamma_list_methods(methods, LIBGAMMA_METHOD_COUNT, operation); + if (n > LIBGAMMA_METHOD_COUNT) { + free(methods); + methods = (int*)malloc(n * sizeof(int)); + libgamma_list_methods(methods, n, operation); + } + + for (i = 0; i < n; i++) + rc.push_back(methods[i]); + + free(methods); + return rc; + } + + /** + * 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 + */ + int + is_method_available(int method) + { + return libgamma_is_method_available(method); + } + + /** + * Return the capabilities of an adjustment method + * + * @param output The data structure to fill with the method's capabilities + * @param method The adjustment method (display server and protocol) + */ + void + method_capabilities(MethodCapabilities *output, int method) + { + libgamma_method_capabilities_t caps; + libgamma_method_capabilities(&caps, method); + *output = MethodCapabilities(&caps); + } + + /** + * Return the default site for an adjustment method + * + * @param method The adjustment method (display server and protocol) + * @return The default site, `nullptr` if it cannot be determined or if + * multiple sites are not supported by the adjustment method + */ + std::string * + method_default_site(int method) + { + char *cstr = libgamma_method_default_site(method); + if (cstr == nullptr) + return nullptr; + return new std::string(cstr); + } + + /** + * 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. `nullptr` if there is none, that is, if + * the method does not support multiple sites. + * This value should not be `free`:d. + */ + std::string * + method_default_site_variable(int method) + { + const char *cstr = libgamma_method_default_site_variable(method); + if (cstr == nullptr) + return nullptr; + return new std::string(cstr); + } + + /** + * Convert a raw representation of an EDID to a lowercase hexadecimal representation + * + * @param edid The EDID in raw representation + * @param length The length of `edid` + * @return The EDID in lowercase hexadecimal representation + */ + std::string + behex_edid(const unsigned char *edid, size_t length) + { + return behex_edid_lowercase(edid, length); + } + + /** + * Convert a raw representation of an EDID to a lowercase hexadecimal representation + * + * @param edid The EDID in raw representation + * @param length The length of `edid` + * @return The EDID in lowercase hexadecimal representation + */ + std::string + behex_edid_lowercase(const unsigned char *edid, size_t length) + { + char *cstr = libgamma_behex_edid_lowercase(edid, length); + std::string rc = std::string(cstr); + free(cstr); + return rc; + } + + /** + * Convert a raw representation of an EDID to an uppercase hexadecimal representation + * + * @param edid The EDID in raw representation + * @param length The length of `edid` + * @return The EDID in uppercase hexadecimal representation + */ + std::string + behex_edid_uppercase(const unsigned char *edid, size_t length) + { + char *cstr = libgamma_behex_edid_uppercase(edid, length); + std::string rc = std::string(cstr); + free(cstr); + return rc; + } + /** + * Convert an hexadecimal representation of an EDID to a raw representation + * + * @param edid The EDID in hexadecimal representation + * @return The EDID in raw representation, it will be half the length + * of `edid` (the input value) + */ + unsigned char * + unhex_edid(const std::string edid) + { + const char *cstr = edid.c_str(); + return libgamma_unhex_edid(cstr); + } + + /** + * Initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param ramps The gamma ramp to initialise + * @param red The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + */ + void + gamma_ramps8_initialise(GammaRamps *ramps, size_t red, size_t blue, size_t green) + { + libgamma_gamma_ramps8_t native; + int r; + native.red_size = ramps->red.size = red; + native.green_size = ramps->green.size = green; + native.blue_size = ramps->blue.size = blue; + ramps->depth = 8; + r = libgamma_gamma_ramps8_initialise(&native); + if (r) + throw create_error(r); + ramps->red.ramp = native.red; + ramps->green.ramp = native.green; + ramps->blue.ramp = native.blue; + } + + /** + * Initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param ramps The gamma ramp to initialise + * @param red The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + */ + void + gamma_ramps16_initialise(GammaRamps *ramps, size_t red, size_t blue, size_t green) + { + libgamma_gamma_ramps16_t native; + int r; + native.red_size = ramps->red.size = red; + native.green_size = ramps->green.size = green; + native.blue_size = ramps->blue.size = blue; + ramps->depth = 16; + r = libgamma_gamma_ramps16_initialise(&native); + if (r) + throw create_error(r); + ramps->red.ramp = native.red; + ramps->green.ramp = native.green; + ramps->blue.ramp = native.blue; + } + + /** + * Initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param ramps The gamma ramp to initialise + * @param red The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + */ + void + gamma_ramps32_initialise(GammaRamps *ramps, size_t red, size_t blue, size_t green) + { + libgamma_gamma_ramps32_t native; + int r; + native.red_size = ramps->red.size = red; + native.green_size = ramps->green.size = green; + native.blue_size = ramps->blue.size = blue; + ramps->depth = 32; + r = libgamma_gamma_ramps32_initialise(&native); + if (r) + throw create_error(r); + ramps->red.ramp = native.red; + ramps->green.ramp = native.green; + ramps->blue.ramp = native.blue; + } + + /** + * Initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param ramps The gamma ramp to initialise + * @param red The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + */ + void + gamma_ramps64_initialise(GammaRamps *ramps, size_t red, size_t blue, size_t green) + { + libgamma_gamma_ramps64_t native; + int r; + native.red_size = ramps->red.size = red; + native.green_size = ramps->green.size = green; + native.blue_size = ramps->blue.size = blue; + ramps->depth = 64; + r = libgamma_gamma_ramps64_initialise(&native); + if (r) + throw create_error(r); + ramps->red.ramp = native.red; + ramps->green.ramp = native.green; + ramps->blue.ramp = native.blue; + } + + /** + * Initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation. + * + * @param ramps The gamma ramp to initialise. + * @param red The size of the gamma ramp for the red channel. + * @param green The size of the gamma ramp for the green channel. + * @param blue The size of the gamma ramp for the blue channel. + */ + void + gamma_rampsf_initialise(GammaRamps *ramps, size_t red, size_t blue, size_t green) + { + libgamma_gamma_rampsf_t native; + int r; + native.red_size = ramps->red.size = red; + native.green_size = ramps->green.size = green; + native.blue_size = ramps->blue.size = blue; + ramps->depth = -1; + r = libgamma_gamma_rampsf_initialise(&native); + if (r) + throw create_error(r); + ramps->red.ramp = native.red; + ramps->green.ramp = native.green; + ramps->blue.ramp = native.blue; + } + + /** + * Initialise a gamma ramp in the proper way that allows all adjustment + * methods to read from and write to it without causing segmentation violation + * + * @param ramps The gamma ramp to initialise + * @param red The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + */ + void + gamma_rampsd_initialise(GammaRamps *ramps, size_t red, size_t blue, size_t green) + { + libgamma_gamma_rampsd_t native; + int r; + native.red_size = ramps->red.size = red; + native.green_size = ramps->green.size = green; + native.blue_size = ramps->blue.size = blue; + ramps->depth = -2; + r = libgamma_gamma_rampsd_initialise(&native); + if (r) + throw create_error(r); + ramps->red.ramp = native.red; + ramps->green.ramp = native.green; + ramps->blue.ramp = native.blue; + } + + /** + * 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 The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + * @return The gamma ramp + */ + GammaRamps * + gamma_ramps8_create(size_t red, size_t blue, size_t green) + { + libgamma_gamma_ramps8_t ramps; + int r; + ramps.red_size = red; + ramps.green_size = green; + ramps.blue_size = blue; + r = libgamma_gamma_ramps8_initialise(&ramps); + if (r) + throw create_error(r); + return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, 8); + } + + /** + * 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 The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + * @return The gamma ramp + */ + GammaRamps * + gamma_ramps16_create(size_t red, size_t blue, size_t green) + { + libgamma_gamma_ramps16_t ramps; + int r; + ramps.red_size = red; + ramps.green_size = green; + ramps.blue_size = blue; + r = libgamma_gamma_ramps16_initialise(&ramps); + if (r) + throw create_error(r); + return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, 16); + } + + /** + * 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 The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + * @return The gamma ramp + */ + GammaRamps * + gamma_ramps32_create(size_t red, size_t blue, size_t green) + { + libgamma_gamma_ramps32_t ramps; + int r; + ramps.red_size = red; + ramps.green_size = green; + ramps.blue_size = blue; + r = libgamma_gamma_ramps32_initialise(&ramps); + if (r) + throw create_error(r); + return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, 32); + } + + /** + * 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 The size of the gamma ramp for the red channel + * @param green The size of the gamma ramp for the green channel + * @param blue The size of the gamma ramp for the blue channel + * @return The gamma ramp + */ + GammaRamps * + gamma_ramps64_create(size_t red, size_t blue, size_t green) + { + libgamma_gamma_ramps64_t ramps; + int r; + ramps.red_size = red; + ramps.green_size = green; + ramps.blue_size = blue; + r = libgamma_gamma_ramps64_initialise(&ramps); + if (r) + throw create_error(r); + return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, 64); + } + + /** + * 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 The size of the gamma ramp for the red channel. + * @param green The size of the gamma ramp for the green channel. + * @param blue The size of the gamma ramp for the blue channel. + * @return The gamma ramp. + */ + GammaRamps * + gamma_rampsf_create(size_t red, size_t blue, size_t green) + { + libgamma_gamma_rampsf_t ramps; + int r; + ramps.red_size = red; + ramps.green_size = green; + ramps.blue_size = blue; + r = libgamma_gamma_rampsf_initialise(&ramps); + if (r) + throw create_error(r); + return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, -1); + } + + /** + * 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 The size of the gamma ramp for the red channel. + * @param green The size of the gamma ramp for the green channel. + * @param blue The size of the gamma ramp for the blue channel. + * @return The gamma ramp. + */ + GammaRamps * + gamma_rampsd_create(size_t red, size_t blue, size_t green) + { + libgamma_gamma_rampsd_t ramps; + int r; + ramps.red_size = red; + ramps.green_size = green; + ramps.blue_size = blue; + r = libgamma_gamma_rampsd_initialise(&ramps); + if (r) + throw create_error(r); + return new GammaRamps(ramps.red, ramps.green, ramps.blue, red, green, blue, -2); + } +} -- cgit v1.2.3-70-g09d2