path: root/libgamma-facade.cc

/* See LICENSE file for copyright and license details. */
#include "libgamma-facade.hh"
#include "libgamma-error.hh"
#include <cstdlib>


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<int>
	list_methods(int operation)
	{
		int *methods = (int *)malloc(LIBGAMMA_METHOD_COUNT * sizeof(int));
		size_t n, m, i;
		std::vector<int> rc;

		n = libgamma_list_methods(methods, LIBGAMMA_METHOD_COUNT, operation);
		if (n > LIBGAMMA_METHOD_COUNT) {
			free(methods);
			methods = (int *)malloc(n * sizeof(int));
			m = libgamma_list_methods(methods, n, operation);
			if (m < n)
				n = m;
		}

		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)
	{
		struct libgamma_method_capabilities caps;
		int r = libgamma_method_capabilities(&caps, sizeof(caps), method);
		if (r < 0)
			throw create_error(r);
		*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)
	{
		const 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<uint8_t> *ramps, size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_ramps8 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<uint16_t> *ramps, size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_ramps16 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<uint32_t> *ramps, size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_ramps32 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<uint64_t> *ramps, size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_ramps64 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<float> *ramps, size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_rampsf 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<double> *ramps, size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_rampsd 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<uint8_t> *
	gamma_ramps8_create(size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_ramps8 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<uint8_t>(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<uint16_t> *
	gamma_ramps16_create(size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_ramps16 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<uint16_t>(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<uint32_t> *
	gamma_ramps32_create(size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_ramps32 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<uint32_t>(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<uint64_t> *
	gamma_ramps64_create(size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_ramps64 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<uint64_t>(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<float> *
	gamma_rampsf_create(size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_rampsf 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<float>(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<double> *
	gamma_rampsd_create(size_t red, size_t blue, size_t green)
	{
		struct libgamma_gamma_rampsd 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<double>(ramps.red, ramps.green, ramps.blue, red, green, blue, -2);
	}
}