types-output.c

/* See LICENSE file for copyright and license details. */
#include "types-output.h"
#include "util.h"

#include <stdlib.h>
#include <string.h>


/**
 * Free all resources allocated to an output.
 * The allocation of `output` itself is not freed,
 * nor is its the libgamma destroyed.
 * 
 * @param  this  The output
 */
void
output_destroy(struct output *restrict this)
{
	size_t i;

	if (this->supported != LIBGAMMA_NO) {
		switch (this->depth) {
		case 8:
			libgamma_gamma_ramps8_destroy(&this->saved_ramps.u8);
			for (i = 0; i < this->table_size; i++)
				libgamma_gamma_ramps8_destroy(&this->table_sums[i].u8);
			break;

		case 16:
			libgamma_gamma_ramps16_destroy(&this->saved_ramps.u16);
			for (i = 0; i < this->table_size; i++)
				libgamma_gamma_ramps16_destroy(&this->table_sums[i].u16);
			break;

		case 32:
			libgamma_gamma_ramps32_destroy(&this->saved_ramps.u32);
			for (i = 0; i < this->table_size; i++)
				libgamma_gamma_ramps32_destroy(&this->table_sums[i].u32);
			break;

		case 64:
			libgamma_gamma_ramps64_destroy(&this->saved_ramps.u64);
			for (i = 0; i < this->table_size; i++)
				libgamma_gamma_ramps64_destroy(&this->table_sums[i].u64);
			break;

		case -1:
			libgamma_gamma_rampsf_destroy(&this->saved_ramps.f);
			for (i = 0; i < this->table_size; i++)
				libgamma_gamma_rampsf_destroy(&this->table_sums[i].f);
			break;

		case -2:
			libgamma_gamma_rampsd_destroy(&this->saved_ramps.d);
			for (i = 0; i < this->table_size; i++)
				libgamma_gamma_rampsd_destroy(&this->table_sums[i].d);
			break;

		default:
			break; /* impossible */
		}
	}

	for (i = 0; i < this->table_size; i++)
		filter_destroy(&this->table_filters[i]);

	free(this->table_filters);
	free(this->table_sums);
	free(this->name);
}


#if defined(__clang__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wcast-align"
#endif


/**
 * Marshal an output
 * 
 * @param   this  The output
 * @param   buf   Output buffer for the marshalled output,
 *                `NULL` just measure how large the buffers
 *                needs to be
 * @return        The number of marshalled byte
 */
size_t
output_marshal(const struct output *restrict this, void *restrict buf)
{
	size_t off = 0, i, n;
	char *bs = buf;

	if (bs)
		*(signed *)&bs[off] = this->depth;
	off += sizeof(signed);

	if (bs)
		*(size_t *)&bs[off] = this->red_size;
	off += sizeof(size_t);

	if (bs)
		*(size_t *)&bs[off] = this->green_size;
	off += sizeof(size_t);

	if (bs)
		*(size_t *)&bs[off] = this->blue_size;
	off += sizeof(size_t);

	if (bs)
		*(size_t *)&bs[off] = this->ramps_size;
	off += sizeof(size_t);

	if (bs)
		*(enum libgamma_decision *)&bs[off] = this->supported;
	off += sizeof(enum libgamma_decision);

	if (bs)
		*(enum colourspace *)&bs[off] = this->colourspace;
	off += sizeof(enum colourspace);

	if (bs)
		*(int *)&bs[off] = this->name_is_edid;
	off += sizeof(int);

	if (bs)
		*(unsigned *)&bs[off] = this->red_x;
	off += sizeof(unsigned);

	if (bs)
		*(unsigned *)&bs[off] = this->red_y;
	off += sizeof(unsigned);

	if (bs)
		*(unsigned *)&bs[off] = this->green_x;
	off += sizeof(unsigned);

	if (bs)
		*(unsigned *)&bs[off] = this->green_y;
	off += sizeof(unsigned);

	if (bs)
		*(unsigned *)&bs[off] = this->blue_x;
	off += sizeof(unsigned);

	if (bs)
		*(unsigned *)&bs[off] = this->blue_y;
	off += sizeof(unsigned);

	if (bs)
		*(unsigned *)&bs[off] = this->white_x;
	off += sizeof(unsigned);

	if (bs)
		*(unsigned *)&bs[off] = this->white_y;
	off += sizeof(unsigned);

	n = strlen(this->name) + 1;
	if (bs)
		memcpy(&bs[off], this->name, n);
	off += n;

	off += gamma_ramps_marshal(&(this->saved_ramps), bs ? &bs[off] : NULL, this->ramps_size);

	if (bs)
		*(size_t *)&bs[off] = this->table_size;
	off += sizeof(size_t);

	for (i = 0; i < this->table_size; i++) {
		off +=      filter_marshal(this->table_filters + i, bs ? &bs[off] : NULL, this->ramps_size);
		off += gamma_ramps_marshal(this->table_sums    + i, bs ? &bs[off] : NULL, this->ramps_size);
	}

	return off;
}


/**
 * Unmarshal an output
 * 
 * @param   this  Output for the output
 * @param   buf   Buffer with the marshalled output
 * @return        The number of unmarshalled bytes, 0 on error
 */
size_t
output_unmarshal(struct output *restrict this, const void *restrict buf)
{
	size_t off = 0, i, n;
	const char *bs = buf;

	this->crtc = NULL;
	this->name = NULL;

	this->depth = *(const signed *)&bs[off];
	off += sizeof(signed);

	this->red_size = *(const size_t *)&bs[off];
	off += sizeof(size_t);

	this->green_size = *(const size_t *)&bs[off];
	off += sizeof(size_t);

	this->blue_size = *(const size_t *)&bs[off];
	off += sizeof(size_t);

	this->ramps_size = *(const size_t *)&bs[off];
	off += sizeof(size_t);

	this->supported = *(const enum libgamma_decision *)&bs[off];
	off += sizeof(enum libgamma_decision);

	this->colourspace = *(const enum colourspace *)&bs[off];
	off += sizeof(enum colourspace);

	this->name_is_edid = *(const int *)&bs[off];
	off += sizeof(int);

	this->red_x = *(const unsigned *)&bs[off];
	off += sizeof(unsigned);

	this->red_y = *(const unsigned *)&bs[off];
	off += sizeof(unsigned);

	this->green_x = *(const unsigned *)&bs[off];
	off += sizeof(unsigned);

	this->green_y = *(const unsigned *)&bs[off];
	off += sizeof(unsigned);

	this->blue_x = *(const unsigned *)&bs[off];
	off += sizeof(unsigned);

	this->blue_y = *(const unsigned *)&bs[off];
	off += sizeof(unsigned);

	this->white_x = *(const unsigned *)&bs[off];
	off += sizeof(unsigned);

	this->white_y = *(const unsigned *)&bs[off];
	off += sizeof(unsigned);

	n = strlen(&bs[off]) + 1;
	this->name = memdup(&bs[off], n);
	if (this->name == NULL)
		return 0;
	off += n;

	COPY_RAMP_SIZES(&this->saved_ramps.u8, this);
	off += n = gamma_ramps_unmarshal(&this->saved_ramps, &bs[off], this->ramps_size);
	if (n == 0)
		return 0;

	this->table_size = this->table_alloc = *(const size_t*)&bs[off];
	off += sizeof(size_t);
	if (this->table_size > 0) {
		this->table_filters = calloc(this->table_size, sizeof(*this->table_filters));
		if (!this->table_filters)
			return 0;
		this->table_sums = calloc(this->table_size, sizeof(*this->table_sums));
		if (!this->table_sums)
			return 0;
	}

	for (i = 0; i < this->table_size; i++) {
		off += n = filter_unmarshal(&this->table_filters[i], &bs[off], this->ramps_size);
		if (!n)
			return 0;
		COPY_RAMP_SIZES(&this->table_sums[i].u8, this);
		off += n = gamma_ramps_unmarshal(&this->table_sums[i], &bs[off], this->ramps_size);
		if (!n)
			return 0;
	}

	return off;
}


#if defined(__clang__)
# pragma GCC diagnostic pop
#endif


/**
 * Compare to outputs by the names of their respective CRTC:s
 * 
 * @param   a  Return -1 if this one is lower
 * @param   b  Return +1 if this one is higher
 * @return     See description of `a` and `b`,
 *             0 if returned if they are the same
 */
int
output_cmp_by_name(const void *restrict a, const void *restrict b)
{
	const struct output *x = a, *y = b;
	return strcmp(x->name, y->name);
}


/**
 * Find an output by its name
 * 
 * @param   key   The name of the output
 * @param   base  The array of outputs
 * @param   n     The number of elements in `base`
 * @return        Output find in `base`, `NULL` if not found
 */
struct output *
output_find_by_name(const char *restrict key, struct output *restrict base, size_t n)
{
	struct output k;

#if defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wcast-qual"
#endif
	k.name = (char *)key;
#if defined(__GNUC__)
# pragma GCC diagnostic pop
#endif

	return bsearch(&k, base, n, sizeof(*base), output_cmp_by_name);
}