/* See LICENSE file for copyright and license details. */
#define IN_LIBGAMMA_X_RANDR
#include "common.h"
/**
* Get the gamma ramp size of a CRTC
*
* @param this Instance of a data structure to fill with the information about the CRTC
* @param crtc The state of the CRTC whose information should be read
* @return Non-zero on error
*/
static int
get_gamma_ramp_size(libgamma_crtc_information_t *restrict out, libgamma_crtc_state_t *restrict crtc)
{
xcb_connection_t *restrict connection = crtc->partition->site->data;
xcb_randr_crtc_t *restrict crtc_id = crtc->data;
xcb_randr_get_crtc_gamma_size_cookie_t cookie;
xcb_randr_get_crtc_gamma_size_reply_t *restrict reply;
xcb_generic_error_t *error;
/* Query gamma ramp size */
out->gamma_size_error = 0;
cookie = xcb_randr_get_crtc_gamma_size(connection, *crtc_id);
reply = xcb_randr_get_crtc_gamma_size_reply(connection, cookie, &error);
if (error) {
out->gamma_size_error = libgamma_x_randr_internal_translate_error(error->error_code,
LIBGAMMA_GAMMA_RAMPS_SIZE_QUERY_FAILED, 1);
return out->gamma_size_error;
}
/* Sanity check gamma ramp size */
if (reply->size < 2)
out->gamma_size_error = LIBGAMMA_SINGLETON_GAMMA_RAMP;
/* Store gamma ramp size */
out->red_gamma_size = out->green_gamma_size = out->blue_gamma_size = reply->size;
/* Release resources and return successfulnes */
free(reply);
return out->gamma_size_error;
}
/**
* Read information from the CRTC's output
*
* @param out Instance of a data structure to fill with the information about the CRTC
* @param output The CRTC's output information
* @return Non-zero if at least on error occured
*/
static int
read_output_data(libgamma_crtc_information_t *restrict out, xcb_randr_get_output_info_reply_t *restrict output)
{
switch (output->connection) {
case XCB_RANDR_CONNECTION_CONNECTED:
/* We have a monitor connected, report that and store information that is provided to us */
out->active = 1;
out->width_mm = output->mm_width;
out->height_mm = output->mm_height;
switch (output->subpixel_order) {
#define X(CONST, NAME, RENDER_SUFFIX)\
case XCB_RENDER_SUB_PIXEL_##RENDER_SUFFIX:\
out->subpixel_order = CONST;\
break;
LIST_SUBPIXEL_ORDERS(X)
#undef X
default:
out->subpixel_order_error = LIBGAMMA_SUBPIXEL_ORDER_NOT_RECOGNISED;
break;
}
return 0;
case XCB_RANDR_CONNECTION_UNKNOWN:
/* If we do know whether a monitor is connected report that and assume it is not */
out->active_error = LIBGAMMA_STATE_UNKNOWN;
/* fall through */
default:
/* If no monitor is connected, report that on fails that require it */
out->width_mm_error = LIBGAMMA_NOT_CONNECTED;
out->height_mm_error = LIBGAMMA_NOT_CONNECTED;
out->subpixel_order_error = LIBGAMMA_NOT_CONNECTED;
/* And store that we are not connected */
out->active = 0;
/* This fuction only failed if we could not figure out whether a monitor is connected */
return output->connection != XCB_RANDR_CONNECTION_UNKNOWN ? 0 : -1;
}
}
/**
* Determine the connector type from the connector name
*
* @param this The CRTC information to use and extend
* @param Non-zero on error
*/
static int
get_connector_type(libgamma_crtc_information_t *restrict this)
{
/* Since we require the name of the output of get the type of the connected,
copy any reported error on the output's name to the connector's type,
and report failure if there was an error */
if ((this->connector_type_error = this->connector_name_error))
return -1;
#define __select(name, type)\
do {\
if (strstr(this->connector_name, name "-") == this->connector_name) {\
this->connector_type = LIBGAMMA_CONNECTOR_TYPE_##type;\
return 0;\
}\
} while (0)
/* Check begin on the name of the output to find out what type the connector is of */
__select ("None", Unknown);
__select ("VGA", VGA);
__select ("DVI-I", DVII);
__select ("DVI-D", DVID);
__select ("DVI-A", DVIA);
__select ("DVI", DVI);
__select ("Composite", Composite);
__select ("S-Video", SVIDEO);
__select ("Component", Component);
__select ("LFP", LFP);
__select ("Proprietary", Unknown);
__select ("HDMI", HDMI);
__select ("DisplayPort", DisplayPort);
#undef __select
/* If there was no matching output name pattern report that and exit with an error */
this->connector_name_error = LIBGAMMA_CONNECTOR_TYPE_NOT_RECOGNISED;
return -1;
}
/**
* Get the output name of a CRTC
*
* @param this Instance of a data structure to fill with the information about the CRTC
* @param output The CRTC's output's information
* @return Non-zero on error
*/
static int
get_output_name(libgamma_crtc_information_t *restrict out, xcb_randr_get_output_info_reply_t *restrict output)
{
char *restrict store;
uint8_t *restrict name;
uint16_t length;
size_t i;
/* Get the name of the output and the length of that name */
name = xcb_randr_get_output_info_name(output);
length = output->name_len; /* There is no NUL-termination */
if (!name)
return out->connector_name_error = LIBGAMMA_REPLY_VALUE_EXTRACTION_FAILED;
/* Allocate a memory area for a NUL-terminated copy of the name */
store = out->connector_name = malloc(((size_t)length + 1) * sizeof(char));
if (!store) {
out->connector_name_error = errno;
return -1;
}
/* char is guaranteed to be (u)int_least8_t, but it is only guaranteed to be (u)int8_t
* on POSIX, so to be truly portable we will not assume that char is (u)int8_t */
for (i = 0; i < (size_t)length; i++)
store[i] = (char)name[i];
store[length] = '\0';
return 0;
}
/**
* Get the Extended Display Information Data of the monitor connected to the connector of a CRTC
*
* @param out Instance of a data structure to fill with the information about the CRTC
* @param crtc The state of the CRTC whose information should be read
* @param output The CRTC's output
* @return Non-zero on error
*/
static int
get_edid(libgamma_crtc_information_t *restrict out, libgamma_crtc_state_t *restrict crtc, xcb_randr_output_t output)
{
xcb_connection_t *restrict connection = crtc->partition->site->data;
xcb_randr_list_output_properties_cookie_t prop_cookie;
xcb_randr_list_output_properties_reply_t *restrict prop_reply;
xcb_atom_t *atoms;
xcb_atom_t *atoms_end;
xcb_generic_error_t *error;
xcb_get_atom_name_cookie_t atom_name_cookie;
xcb_get_atom_name_reply_t *restrict atom_name_reply;
char *restrict atom_name;
int atom_name_len;
xcb_randr_get_output_property_cookie_t atom_cookie;
xcb_randr_get_output_property_reply_t *restrict atom_reply;
unsigned char* restrict atom_data;
int length;
/* Acquire a list of all properties of the output */
prop_cookie = xcb_randr_list_output_properties(connection, output);
prop_reply = xcb_randr_list_output_properties_reply(connection, prop_cookie, &error);
if (error)
return out->edid_error = libgamma_x_randr_internal_translate_error(error->error_code, LIBGAMMA_LIST_PROPERTIES_FAILED, 1);
/* Extract the properties form the data structure that holds them, */
atoms = xcb_randr_list_output_properties_atoms(prop_reply);
/* and get the last one so that we can iterate over them nicely */
atoms_end = atoms + xcb_randr_list_output_properties_atoms_length(prop_reply);
if (!atoms) {
free(prop_reply);
return out->edid_error = LIBGAMMA_REPLY_VALUE_EXTRACTION_FAILED;
}
/* For each property */
for (; atoms != atoms_end; atoms++) {
/* Acquire the atom name */
atom_name_cookie = xcb_get_atom_name(connection, *atoms);
atom_name_reply = xcb_get_atom_name_reply(connection, atom_name_cookie, &error);
if (error)
continue;
/* Extract the atom name from the data structure that holds it */
atom_name = xcb_get_atom_name_name(atom_name_reply);
/* As well as the length of the name; it is not NUL-termianted */
atom_name_len = xcb_get_atom_name_name_length(atom_name_reply);
if (/* Check for errors */
!atom_name || /* atom_name_len < 1 || */
/* Check that the length is the expected length for the EDID property */
atom_name_len != 4 ||
/* Check that the property is the EDID property */
atom_name[0] != 'E' || atom_name[1] != 'D' || atom_name[2] != 'I' || atom_name[3] != 'D') {
free(atom_name_reply);
continue;
}
/* Acquire the property's value, we know that it is either 128 or 256 byte long */
atom_cookie = xcb_randr_get_output_property(connection, output, *atoms, XCB_GET_PROPERTY_TYPE_ANY, 0, 256, 0, 0);
atom_reply = xcb_randr_get_output_property_reply(connection, atom_cookie, &error);
/* (*) EDID version 1.0 through 1.4 define it as 128 bytes long,
* but version 2.0 define it as 256 bytes long. However,
* version 2.0 is rare(?) and has been deprecated and replaced
* by version 1.3 (I guess that is with a new version epoch,
* but I do not know.) */
if (error) {
free(atom_name_reply);
free(prop_reply);
return out->edid_error = LIBGAMMA_PROPERTY_VALUE_QUERY_FAILED;
}
/* Extract the property's value */
atom_data = xcb_randr_get_output_property_data(atom_reply);
/* and its actual length */
length = xcb_randr_get_output_property_data_length(atom_reply);
if (!atom_data || length < 1) {
free(atom_reply);
free(atom_name_reply);
free(prop_reply);
return out->edid_error = LIBGAMMA_REPLY_VALUE_EXTRACTION_FAILED;
}
/* Store the EDID */
out->edid_length = (size_t)length;
out->edid = malloc((size_t)length * sizeof(unsigned char));
if (!out->edid)
out->edid_error = errno;
else
memcpy(out->edid, atom_data, (size_t)length * sizeof(unsigned char));
/* Release resouces */
free(atom_reply);
free(atom_name_reply);
free(prop_reply);
return out->edid_error;
}
return out->edid_error = LIBGAMMA_EDID_NOT_FOUND;
}
/**
* Read information about a CRTC
*
* @param this Instance of a data structure to fill with the information about the CRTC
* @param crtc The state of the CRTC whose information should be read
* @param fields OR:ed identifiers for the information about the CRTC that should be read
* @return Zero on success, -1 on error; on error refer to the error reports in `this`
*/
int
libgamma_x_randr_get_crtc_information(libgamma_crtc_information_t *restrict this,
libgamma_crtc_state_t *restrict crtc, int32_t fields)
{
#define _E(FIELD) ((fields & FIELD) ? LIBGAMMA_CRTC_INFO_NOT_SUPPORTED : 0)
int e = 0;
xcb_randr_get_output_info_reply_t *restrict output_info = NULL;
xcb_randr_output_t output;
int free_edid, free_name;
xcb_connection_t *restrict connection;
libgamma_x_randr_partition_data_t *restrict screen_data;
size_t output_index;
xcb_randr_get_output_info_cookie_t cookie;
xcb_generic_error_t *error;
/* Wipe all error indicators */
memset(this, 0, sizeof(libgamma_crtc_information_t));
/* We need to free the EDID after us if it is not explicitly requested */
free_edid = !(fields & LIBGAMMA_CRTC_INFO_EDID);
/* We need to free the output's name after us if it is not explicitly requested */
free_name = !(fields & LIBGAMMA_CRTC_INFO_CONNECTOR_NAME);
/* Jump if the output information is not required */
if (!(fields & (LIBGAMMA_CRTC_INFO_MACRO_ACTIVE | LIBGAMMA_CRTC_INFO_MACRO_CONNECTOR)))
goto cont;
/* Get connector and connector information */
connection = crtc->partition->site->data;
screen_data = crtc->partition->data;
output_index = screen_data->crtc_to_output[crtc->crtc];
/* `SIZE_MAX` is used for CRTC:s that misses mapping to its output (should not happen),
* because `SIZE_MAX - 1` is the highest theoretical possible value */
if (output_index == SIZE_MAX) {
e |= this->edid_error = this->gamma_error = this->width_mm_edid_error
= this->height_mm_edid_error = this->connector_type_error
= this->connector_name_error = this->subpixel_order_error
= this->width_mm_error = this->height_mm_error
= this->active_error = LIBGAMMA_CONNECTOR_UNKNOWN;
goto cont;
}
/* Get the output */
output = screen_data->outputs[output_index];
/* Query output information */
cookie = xcb_randr_get_output_info(connection, output, screen_data->config_timestamp);
output_info = xcb_randr_get_output_info_reply(connection, cookie, &error);
if (error) {
e |= this->edid_error = this->gamma_error = this->width_mm_edid_error
= this->height_mm_edid_error = this->connector_type_error
= this->connector_name_error = this->subpixel_order_error
= this->width_mm_error = this->height_mm_error
= this->active_error = LIBGAMMA_OUTPUT_INFORMATION_QUERY_FAILED;
goto cont;
}
/* Get connector name */
e |= get_output_name(this, output_info);
/* Get connector type */
if (fields & LIBGAMMA_CRTC_INFO_CONNECTOR_TYPE)
e |= get_connector_type(this);
/* Get additional output data, excluding EDID */
e |= read_output_data(this, output_info);
if (fields & LIBGAMMA_CRTC_INFO_MACRO_VIEWPORT)
e |= this->width_mm_error | this->height_mm_error;
e |= (fields & LIBGAMMA_CRTC_INFO_SUBPIXEL_ORDER) ? this->subpixel_order_error : 0;
/* If we do not want any EDID information, jump */
if (!(fields & LIBGAMMA_CRTC_INFO_MACRO_EDID))
goto cont;
/* If there is not monitor that report error in EDID related fields */
if (!this->active) {
e |= this->edid_error = this->gamma_error = this->width_mm_edid_error
= this->height_mm_edid_error = LIBGAMMA_NOT_CONNECTED;
goto cont;
}
/* Get EDID */
e |= get_edid(this, crtc, output);
if (!this->edid) {
this->gamma_error = this->width_mm_edid_error = this->height_mm_edid_error = this->edid_error;
goto cont;
}
/* Parse EDID */
if ((fields & (LIBGAMMA_CRTC_INFO_MACRO_EDID ^ LIBGAMMA_CRTC_INFO_EDID)))
e |= libgamma_internal_parse_edid(this, fields);
cont:
/* Get gamma ramp size */
e |= (fields & LIBGAMMA_CRTC_INFO_GAMMA_SIZE) ? get_gamma_ramp_size(this, crtc) : 0;
/* Store gamma ramp depth. */
this->gamma_depth = 16;
/* X RandR does not support quering gamma ramp support. */
e |= this->gamma_support_error = _E(LIBGAMMA_CRTC_INFO_GAMMA_SUPPORT);
/* Free the EDID after us */
if (free_edid) {
free(this->edid);
this->edid = NULL;
}
/* Free the output name after us */
if (free_name) {
free(this->connector_name);
this->connector_name = NULL;
}
free(output_info);
return e ? -1 : 0;
#undef _E
}
