/* See LICENSE file for copyright and license details. */
#ifndef TYPES_OUTPUT_H
#define TYPES_OUTPUT_H

#include <stddef.h>

#include <libgamma.h>

#include "types-ramps.h"
#include "types-filter.h"

#ifndef GCC_ONLY
# if defined(__GNUC__) && !defined(__clang__)
#  define GCC_ONLY(...) __VA_ARGS__
# else
#  define GCC_ONLY(...) /* nothing */
# endif
#endif

/**
 * Copy the ramp sizes
 * 
 * This macro supports both `struct output`
 * and `struct gamma_ramps`
 * 
 * @param  dest  The destination
 * @param  src   The source
 */
#define COPY_RAMP_SIZES(dest, src)         \
  ((dest)->red_size   = (src)->red_size,   \
   (dest)->green_size = (src)->green_size, \
   (dest)->blue_size  = (src)->blue_size)

/**
 * Colour spaces
 */
enum colourspace {
	/**
	 * Unknown
	 */
	COLOURSPACE_UNKNOWN = 0,

	/**
	 * sRGB with explicit gamut
	 */
	COLOURSPACE_SRGB = 1,

	/**
	 * sRGB without explicit gamut
	 */
	COLOURSPACE_SRGB_SANS_GAMUT = 2,

	/**
	 * RGB (but not sRGB) with known gamut
	 */
	COLOURSPACE_RGB = 3,

	/**
	 * RGB (but not sRGB) without known gamut
	 */
	COLOURSPACE_RGB_SANS_GAMUT = 4,

	/**
	 * Non-RGB multicolour
	 */
	COLOURSPACE_NON_RGB = 5,

	/**
	 * Greyscale or monochrome
	 */
	COLOURSPACE_GREY = 6
};

/**
 * Information about an output
 */
struct output {
	/**
	 * -2: double
	 * -1: float
	 *  8: uint8_t
	 * 16: uint16_t
	 * 32: uint32_t
	 * 64: uint64_t
	 */
	signed depth;

	/**
	 * Whether gamma ramps are supported
	 */
	enum libgamma_decision supported;

	/**
	 * Whether the name is the EDID
	 */
	int name_is_edid;

	/**
	 * The monitor's colour space
	 */
	enum colourspace colourspace;

	/**
	 * The x-value (CIE xyY) of the monitor's
	 * red colour, multiplied by 1024
	 */
	unsigned red_x;

	/**
	 * The y-value (CIE xyY) of the monitor's
	 * red colour, multiplied by 1024
	 */
	unsigned red_y;

	/**
	 * The x-value (CIE xyY) of the monitor's
	 * green colour, multiplied by 1024
	 */
	unsigned green_x;

	/**
	 * The y-value (CIE xyY) of the monitor's
	 * green colour, multiplied by 1024
	 */
	unsigned green_y;

	/**
	 * The x-value (CIE xyY) of the monitor's
	 * blue colour, multiplied by 1024
	 */
	unsigned blue_x;

	/**
	 * The y-value (CIE xyY) of the monitor's
	 * blue colour, multiplied by 1024
	 */
	unsigned blue_y;

	/**
	 * The x-value (CIE xyY) of the monitor's
	 * default white point, multiplied by 1024
	 */
	unsigned white_x;

	/**
	 * The y-value (CIE xyY) of the monitor's
	 * default white point, multiplied by 1024
	 */
	unsigned white_y;

	/**
	 * The number of stops in the red gamma ramp
	 */
	size_t red_size;

	/**
	 * The number of stops in the green gamma ramp
	 */
	size_t green_size;

	/**
	 * The number of stops in the blue gamma ramp
	 */
	size_t blue_size;

	/**
	 * `.red_size + .green_size + .blue_size`
	 * multiplied by the byte-size of each stop
	 */
	size_t ramps_size;

	/**
	 * The name of the output, will be its EDID
	 * if available, otherwise it will be the
	 * index of the partition, followed by a dot
	 * and the index of the CRTC within the
	 * partition, or if a name for the connector
	 * is available: the index of the partition
	 * followed by a dot and the name of the
	 * connector
	 */
	char *restrict name;

	/**
	 * The libgamma state for the output
	 */
	struct libgamma_crtc_state *restrict crtc;

	/**
	 * Saved gamma ramps
	 */
	union gamma_ramps saved_ramps;

	/**
	 * The table of all applied filters
	 */
	struct filter *restrict table_filters;

	/**
	 * `.table_sums[i]` is the resulting
	 * adjustment made when all filter
	 * from `.table_filters[0]` up to and
	 * including `.table_filters[i]` has
	 * been applied
	 */
	union gamma_ramps *restrict table_sums;

	/**
	 * The number of elements allocated
	 * for `.table_filters` and for `.table_sums`
	 */
	size_t table_alloc;

	/**
	 * The number of elements stored in
	 * `.table_filters` and in `.table_sums`
	 */
	size_t table_size;
};

/**
 * 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
 */
GCC_ONLY(__attribute__((__nonnull__)))
void output_destroy(struct output *restrict this);

/**
 * 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
 */
GCC_ONLY(__attribute__((__nonnull__(1))))
size_t output_marshal(const struct output *restrict this, void *restrict buf);

/**
 * 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
 */
GCC_ONLY(__attribute__((__nonnull__)))
size_t output_unmarshal(struct output *restrict this, const void *restrict buf);

/**
 * 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
 */
GCC_ONLY(__attribute__((pure, __nonnull__)))
int output_cmp_by_name(const void *restrict a, const void *restrict b);

/**
 * 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
 */
GCC_ONLY(__attribute__((pure, __nonnull__)))
struct output *output_find_by_name(const char *restrict key, struct output *restrict base, size_t n);

#endif