mirror of
https://gitlab.freedesktop.org/wayland/weston
synced 2024-09-06 18:05:39 +00:00
![Pekka Paalanen](/assets/img/avatar_default.png)
This introduces a new convention of checking through the compositor destroy listener if the plugin is already initialized. If the plugin is already initialized, then the plugin entry function succeeds as a no-op. This makes it safe to load the same plugin multiple times in a running compositor. Currently module loading functions return failure if a plugin is already loaded, but that will change in the future. Therefore we need this other method of ensuring we do not double-initialize a plugin which would lead to list corruptions the very least. All plugins are converted to use the new helper, except: - those that do not have a destroy listener already, and - hmi-controller which does the same open-coded as the common code pattern did not fit there. Plugins should always have a compositor destroy listener registered since they very least allocate a struct to hold their data. Hence omissions are highlighted in code. Backends do not need this because weston_compositor_load_backend() already protects against double-init. GL-renderer does not export a standard module init function so cannot be initialized the usual way and therefore is not vulnerable to double-init. Signed-off-by: Pekka Paalanen <pekka.paalanen@collabora.com>
589 lines
16 KiB
C
589 lines
16 KiB
C
/*
|
|
* Copyright © 2013 Richard Hughes
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial
|
|
* portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <colord.h>
|
|
|
|
#include <libweston/libweston.h>
|
|
#include "weston.h"
|
|
#include "cms-helper.h"
|
|
#include "shared/helpers.h"
|
|
|
|
struct cms_colord {
|
|
struct weston_compositor *ec;
|
|
CdClient *client;
|
|
GHashTable *devices; /* key = device-id, value = cms_output */
|
|
GHashTable *pnp_ids; /* key = pnp-id, value = vendor */
|
|
gchar *pnp_ids_data;
|
|
GMainLoop *loop;
|
|
GThread *thread;
|
|
GList *pending;
|
|
GMutex pending_mutex;
|
|
struct wl_event_source *source;
|
|
int readfd;
|
|
int writefd;
|
|
struct wl_listener destroy_listener;
|
|
struct wl_listener output_created_listener;
|
|
};
|
|
|
|
struct cms_output {
|
|
CdDevice *device;
|
|
guint32 backlight_value;
|
|
struct cms_colord *cms;
|
|
struct weston_color_profile *p;
|
|
struct weston_output *o;
|
|
struct wl_listener destroy_listener;
|
|
};
|
|
|
|
static gint
|
|
colord_idle_find_output_cb(gconstpointer a, gconstpointer b)
|
|
{
|
|
struct cms_output *ocms = (struct cms_output *) a;
|
|
struct weston_output *o = (struct weston_output *) b;
|
|
return ocms->o == o ? 0 : -1;
|
|
}
|
|
|
|
static void
|
|
colord_idle_cancel_for_output(struct cms_colord *cms, struct weston_output *o)
|
|
{
|
|
GList *l;
|
|
|
|
/* cancel and remove any helpers that match the output */
|
|
g_mutex_lock(&cms->pending_mutex);
|
|
l = g_list_find_custom (cms->pending, o, colord_idle_find_output_cb);
|
|
if (l) {
|
|
struct cms_output *ocms = l->data;
|
|
cms->pending = g_list_remove (cms->pending, ocms);
|
|
}
|
|
g_mutex_unlock(&cms->pending_mutex);
|
|
}
|
|
|
|
static bool
|
|
edid_value_valid(const char *str)
|
|
{
|
|
if (str == NULL)
|
|
return false;
|
|
if (str[0] == '\0')
|
|
return false;
|
|
if (strcmp(str, "unknown") == 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
static gchar *
|
|
get_output_id(struct cms_colord *cms, struct weston_output *o)
|
|
{
|
|
struct weston_head *head;
|
|
const gchar *tmp;
|
|
GString *device_id;
|
|
|
|
/* XXX: What to do with multiple heads?
|
|
* This is potentially unstable, if head configuration is changed
|
|
* while the output is enabled. */
|
|
head = weston_output_get_first_head(o);
|
|
|
|
if (wl_list_length(&o->head_list) > 1) {
|
|
weston_log("colord: WARNING: multiple heads are not supported (output %s).\n",
|
|
o->name);
|
|
}
|
|
|
|
/* see https://github.com/hughsie/colord/blob/master/doc/device-and-profile-naming-spec.txt
|
|
* for format and allowed values */
|
|
device_id = g_string_new("xrandr");
|
|
if (edid_value_valid(head->make)) {
|
|
tmp = g_hash_table_lookup(cms->pnp_ids, head->make);
|
|
if (tmp == NULL)
|
|
tmp = head->make;
|
|
g_string_append_printf(device_id, "-%s", tmp);
|
|
}
|
|
if (edid_value_valid(head->model))
|
|
g_string_append_printf(device_id, "-%s", head->model);
|
|
if (edid_value_valid(head->serial_number))
|
|
g_string_append_printf(device_id, "-%s", head->serial_number);
|
|
|
|
/* no EDID data, so use fallback */
|
|
if (strcmp(device_id->str, "xrandr") == 0)
|
|
g_string_append_printf(device_id, "-drm-%i", o->id);
|
|
|
|
return g_string_free(device_id, FALSE);
|
|
}
|
|
|
|
static void
|
|
update_device_with_profile_in_idle(struct cms_output *ocms)
|
|
{
|
|
gboolean signal_write = FALSE;
|
|
ssize_t rc;
|
|
struct cms_colord *cms = ocms->cms;
|
|
|
|
colord_idle_cancel_for_output(cms, ocms->o);
|
|
g_mutex_lock(&cms->pending_mutex);
|
|
if (cms->pending == NULL)
|
|
signal_write = TRUE;
|
|
cms->pending = g_list_prepend(cms->pending, ocms);
|
|
g_mutex_unlock(&cms->pending_mutex);
|
|
|
|
/* signal we've got updates to do */
|
|
if (signal_write) {
|
|
gchar tmp = '\0';
|
|
rc = write(cms->writefd, &tmp, 1);
|
|
if (rc == 0)
|
|
weston_log("colord: failed to write to pending fd\n");
|
|
}
|
|
}
|
|
|
|
static void
|
|
colord_update_output_from_device (struct cms_output *ocms)
|
|
{
|
|
CdProfile *profile;
|
|
const gchar *tmp;
|
|
gboolean ret;
|
|
GError *error = NULL;
|
|
gint percentage;
|
|
|
|
/* old profile is no longer valid */
|
|
weston_cms_destroy_profile(ocms->p);
|
|
ocms->p = NULL;
|
|
|
|
ret = cd_device_connect_sync(ocms->device, NULL, &error);
|
|
if (!ret) {
|
|
weston_log("colord: failed to connect to device %s: %s\n",
|
|
cd_device_get_object_path (ocms->device),
|
|
error->message);
|
|
g_error_free(error);
|
|
goto out;
|
|
}
|
|
profile = cd_device_get_default_profile(ocms->device);
|
|
if (!profile) {
|
|
weston_log("colord: no assigned color profile for %s\n",
|
|
cd_device_get_id (ocms->device));
|
|
goto out;
|
|
}
|
|
ret = cd_profile_connect_sync(profile, NULL, &error);
|
|
if (!ret) {
|
|
weston_log("colord: failed to connect to profile %s: %s\n",
|
|
cd_profile_get_object_path (profile),
|
|
error->message);
|
|
g_error_free(error);
|
|
goto out;
|
|
}
|
|
|
|
/* get the calibration brightness level (only set for some profiles) */
|
|
tmp = cd_profile_get_metadata_item(profile, CD_PROFILE_METADATA_SCREEN_BRIGHTNESS);
|
|
if (tmp != NULL) {
|
|
percentage = atoi(tmp);
|
|
if (percentage > 0 && percentage <= 100)
|
|
ocms->backlight_value = percentage * 255 / 100;
|
|
}
|
|
|
|
ocms->p = weston_cms_load_profile(cd_profile_get_filename(profile));
|
|
if (ocms->p == NULL) {
|
|
weston_log("colord: warning failed to load profile %s: %s\n",
|
|
cd_profile_get_object_path (profile),
|
|
error->message);
|
|
g_error_free(error);
|
|
goto out;
|
|
}
|
|
out:
|
|
update_device_with_profile_in_idle(ocms);
|
|
}
|
|
|
|
static void
|
|
colord_device_changed_cb(CdDevice *device, struct cms_output *ocms)
|
|
{
|
|
weston_log("colord: device %s changed, update output\n",
|
|
cd_device_get_object_path (ocms->device));
|
|
colord_update_output_from_device(ocms);
|
|
}
|
|
|
|
static void
|
|
colord_notifier_output_destroy(struct wl_listener *listener, void *data)
|
|
{
|
|
struct cms_output *ocms =
|
|
container_of(listener, struct cms_output, destroy_listener);
|
|
struct weston_output *o = (struct weston_output *) data;
|
|
struct cms_colord *cms = ocms->cms;
|
|
gchar *device_id;
|
|
|
|
device_id = get_output_id(cms, o);
|
|
g_hash_table_remove (cms->devices, device_id);
|
|
g_free (device_id);
|
|
}
|
|
|
|
static void
|
|
colord_output_created(struct cms_colord *cms, struct weston_output *o)
|
|
{
|
|
struct weston_head *head;
|
|
CdDevice *device;
|
|
const gchar *tmp;
|
|
gchar *device_id;
|
|
GError *error = NULL;
|
|
GHashTable *device_props;
|
|
struct cms_output *ocms;
|
|
|
|
/* XXX: What to do with multiple heads? */
|
|
head = weston_output_get_first_head(o);
|
|
|
|
/* create device */
|
|
device_id = get_output_id(cms, o);
|
|
weston_log("colord: output added %s\n", device_id);
|
|
device_props = g_hash_table_new_full(g_str_hash, g_str_equal,
|
|
g_free, g_free);
|
|
g_hash_table_insert (device_props,
|
|
g_strdup(CD_DEVICE_PROPERTY_KIND),
|
|
g_strdup(cd_device_kind_to_string (CD_DEVICE_KIND_DISPLAY)));
|
|
g_hash_table_insert (device_props,
|
|
g_strdup(CD_DEVICE_PROPERTY_FORMAT),
|
|
g_strdup("ColorModel.OutputMode.OutputResolution"));
|
|
g_hash_table_insert (device_props,
|
|
g_strdup(CD_DEVICE_PROPERTY_COLORSPACE),
|
|
g_strdup(cd_colorspace_to_string(CD_COLORSPACE_RGB)));
|
|
if (edid_value_valid(head->make)) {
|
|
tmp = g_hash_table_lookup(cms->pnp_ids, head->make);
|
|
if (tmp == NULL)
|
|
tmp = head->make;
|
|
g_hash_table_insert (device_props,
|
|
g_strdup(CD_DEVICE_PROPERTY_VENDOR),
|
|
g_strdup(tmp));
|
|
}
|
|
if (edid_value_valid(head->model)) {
|
|
g_hash_table_insert (device_props,
|
|
g_strdup(CD_DEVICE_PROPERTY_MODEL),
|
|
g_strdup(head->model));
|
|
}
|
|
if (edid_value_valid(head->serial_number)) {
|
|
g_hash_table_insert (device_props,
|
|
g_strdup(CD_DEVICE_PROPERTY_SERIAL),
|
|
g_strdup(head->serial_number));
|
|
}
|
|
if (head->connection_internal) {
|
|
g_hash_table_insert (device_props,
|
|
g_strdup (CD_DEVICE_PROPERTY_EMBEDDED),
|
|
NULL);
|
|
}
|
|
device = cd_client_create_device_sync(cms->client,
|
|
device_id,
|
|
CD_OBJECT_SCOPE_TEMP,
|
|
device_props,
|
|
NULL,
|
|
&error);
|
|
if (g_error_matches (error,
|
|
CD_CLIENT_ERROR,
|
|
CD_CLIENT_ERROR_ALREADY_EXISTS)) {
|
|
g_clear_error(&error);
|
|
device = cd_client_find_device_sync (cms->client,
|
|
device_id,
|
|
NULL,
|
|
&error);
|
|
}
|
|
if (!device) {
|
|
weston_log("colord: failed to create new or "
|
|
"find existing device: %s\n",
|
|
error->message);
|
|
g_error_free(error);
|
|
goto out;
|
|
}
|
|
|
|
/* create object and watch for the output to be destroyed */
|
|
ocms = g_slice_new0(struct cms_output);
|
|
ocms->cms = cms;
|
|
ocms->o = o;
|
|
ocms->device = g_object_ref(device);
|
|
ocms->destroy_listener.notify = colord_notifier_output_destroy;
|
|
wl_signal_add(&o->destroy_signal, &ocms->destroy_listener);
|
|
|
|
/* add to local cache */
|
|
g_hash_table_insert (cms->devices, g_strdup(device_id), ocms);
|
|
g_signal_connect (ocms->device, "changed",
|
|
G_CALLBACK (colord_device_changed_cb), ocms);
|
|
|
|
/* get profiles */
|
|
colord_update_output_from_device (ocms);
|
|
out:
|
|
g_hash_table_unref (device_props);
|
|
if (device)
|
|
g_object_unref (device);
|
|
g_free (device_id);
|
|
}
|
|
|
|
static void
|
|
colord_notifier_output_created(struct wl_listener *listener, void *data)
|
|
{
|
|
struct weston_output *o = (struct weston_output *) data;
|
|
struct cms_colord *cms =
|
|
container_of(listener, struct cms_colord, destroy_listener);
|
|
weston_log("colord: output %s created\n", o->name);
|
|
colord_output_created(cms, o);
|
|
}
|
|
|
|
static gpointer
|
|
colord_run_loop_thread(gpointer data)
|
|
{
|
|
struct cms_colord *cms = (struct cms_colord *) data;
|
|
struct weston_output *o;
|
|
|
|
/* coldplug outputs */
|
|
wl_list_for_each(o, &cms->ec->output_list, link) {
|
|
weston_log("colord: output %s coldplugged\n", o->name);
|
|
colord_output_created(cms, o);
|
|
}
|
|
|
|
g_main_loop_run(cms->loop);
|
|
return NULL;
|
|
}
|
|
|
|
static int
|
|
colord_dispatch_all_pending(int fd, uint32_t mask, void *data)
|
|
{
|
|
gchar tmp;
|
|
GList *l;
|
|
ssize_t rc;
|
|
struct cms_colord *cms = data;
|
|
struct cms_output *ocms;
|
|
|
|
weston_log("colord: dispatching events\n");
|
|
g_mutex_lock(&cms->pending_mutex);
|
|
for (l = cms->pending; l != NULL; l = l->next) {
|
|
ocms = l->data;
|
|
|
|
/* optionally set backlight to calibration value */
|
|
if (ocms->o->set_backlight && ocms->backlight_value != 0) {
|
|
weston_log("colord: profile calibration backlight to %i/255\n",
|
|
ocms->backlight_value);
|
|
ocms->o->set_backlight(ocms->o, ocms->backlight_value);
|
|
}
|
|
|
|
weston_cms_set_color_profile(ocms->o, ocms->p);
|
|
}
|
|
g_list_free (cms->pending);
|
|
cms->pending = NULL;
|
|
g_mutex_unlock(&cms->pending_mutex);
|
|
|
|
/* done */
|
|
rc = read(cms->readfd, &tmp, 1);
|
|
if (rc == 0)
|
|
weston_log("colord: failed to read from pending fd\n");
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
colord_load_pnp_ids(struct cms_colord *cms)
|
|
{
|
|
gboolean ret = FALSE;
|
|
gchar *tmp;
|
|
GError *error = NULL;
|
|
guint i;
|
|
const gchar *pnp_ids_fn[] = { "/usr/share/hwdata/pnp.ids",
|
|
"/usr/share/misc/pnp.ids",
|
|
NULL };
|
|
|
|
/* find and load file */
|
|
for (i = 0; pnp_ids_fn[i] != NULL; i++) {
|
|
if (!g_file_test(pnp_ids_fn[i], G_FILE_TEST_EXISTS))
|
|
continue;
|
|
ret = g_file_get_contents(pnp_ids_fn[i],
|
|
&cms->pnp_ids_data,
|
|
NULL,
|
|
&error);
|
|
if (!ret) {
|
|
weston_log("colord: failed to load %s: %s\n",
|
|
pnp_ids_fn[i], error->message);
|
|
g_error_free(error);
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
if (!ret) {
|
|
weston_log("colord: no pnp.ids found\n");
|
|
return;
|
|
}
|
|
|
|
/* parse fixed offsets into lines */
|
|
tmp = cms->pnp_ids_data;
|
|
for (i = 0; cms->pnp_ids_data[i] != '\0'; i++) {
|
|
if (cms->pnp_ids_data[i] != '\n')
|
|
continue;
|
|
cms->pnp_ids_data[i] = '\0';
|
|
if (tmp[0] && tmp[1] && tmp[2] && tmp[3] == '\t' && tmp[4]) {
|
|
tmp[3] = '\0';
|
|
g_hash_table_insert(cms->pnp_ids, tmp, tmp+4);
|
|
tmp = &cms->pnp_ids_data[i+1];
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
colord_module_destroy(struct cms_colord *cms)
|
|
{
|
|
if (cms->loop) {
|
|
g_main_loop_quit(cms->loop);
|
|
g_main_loop_unref(cms->loop);
|
|
}
|
|
if (cms->thread)
|
|
g_thread_join(cms->thread);
|
|
|
|
/* cms->devices must be destroyed before other resources, as
|
|
* the other resources are needed during output cleanup in
|
|
* cms->devices unref.
|
|
*/
|
|
if (cms->devices)
|
|
g_hash_table_unref(cms->devices);
|
|
if (cms->client)
|
|
g_object_unref(cms->client);
|
|
if (cms->readfd)
|
|
close(cms->readfd);
|
|
if (cms->writefd)
|
|
close(cms->writefd);
|
|
|
|
g_free(cms->pnp_ids_data);
|
|
g_hash_table_unref(cms->pnp_ids);
|
|
|
|
wl_list_remove(&cms->destroy_listener.link);
|
|
free(cms);
|
|
}
|
|
|
|
static void
|
|
colord_notifier_destroy(struct wl_listener *listener, void *data)
|
|
{
|
|
struct cms_colord *cms =
|
|
container_of(listener, struct cms_colord, destroy_listener);
|
|
colord_module_destroy(cms);
|
|
}
|
|
|
|
static void
|
|
colord_cms_output_destroy(gpointer data)
|
|
{
|
|
struct cms_output *ocms = (struct cms_output *) data;
|
|
struct cms_colord *cms = ocms->cms;
|
|
struct weston_output *o = ocms->o;
|
|
gboolean ret;
|
|
gchar *device_id;
|
|
GError *error = NULL;
|
|
|
|
colord_idle_cancel_for_output(cms, o);
|
|
device_id = get_output_id(cms, o);
|
|
weston_log("colord: output unplugged %s\n", device_id);
|
|
|
|
wl_list_remove(&ocms->destroy_listener.link);
|
|
g_signal_handlers_disconnect_by_data(ocms->device, ocms);
|
|
|
|
ret = cd_client_delete_device_sync (cms->client,
|
|
ocms->device,
|
|
NULL,
|
|
&error);
|
|
|
|
if (!ret) {
|
|
weston_log("colord: failed to delete device: %s\n",
|
|
error->message);
|
|
g_error_free(error);
|
|
}
|
|
|
|
g_object_unref(ocms->device);
|
|
g_slice_free(struct cms_output, ocms);
|
|
g_free (device_id);
|
|
}
|
|
|
|
WL_EXPORT int
|
|
wet_module_init(struct weston_compositor *ec,
|
|
int *argc, char *argv[])
|
|
{
|
|
gboolean ret;
|
|
GError *error = NULL;
|
|
int fd[2];
|
|
struct cms_colord *cms;
|
|
struct wl_event_loop *loop;
|
|
|
|
weston_log("colord: initialized\n");
|
|
|
|
/* create local state object */
|
|
cms = zalloc(sizeof *cms);
|
|
if (cms == NULL)
|
|
return -1;
|
|
cms->ec = ec;
|
|
|
|
if (!weston_compositor_add_destroy_listener_once(ec,
|
|
&cms->destroy_listener,
|
|
colord_notifier_destroy)) {
|
|
free(cms);
|
|
return 0;
|
|
}
|
|
|
|
#if !GLIB_CHECK_VERSION(2,36,0)
|
|
g_type_init();
|
|
#endif
|
|
cms->client = cd_client_new();
|
|
ret = cd_client_connect_sync(cms->client, NULL, &error);
|
|
if (!ret) {
|
|
weston_log("colord: failed to contact daemon: %s\n", error->message);
|
|
g_error_free(error);
|
|
colord_module_destroy(cms);
|
|
return -1;
|
|
}
|
|
g_mutex_init(&cms->pending_mutex);
|
|
cms->devices = g_hash_table_new_full(g_str_hash, g_str_equal,
|
|
g_free, colord_cms_output_destroy);
|
|
|
|
/* devices added */
|
|
cms->output_created_listener.notify = colord_notifier_output_created;
|
|
wl_signal_add(&ec->output_created_signal, &cms->output_created_listener);
|
|
|
|
/* add all the PNP IDs */
|
|
cms->pnp_ids = g_hash_table_new_full(g_str_hash,
|
|
g_str_equal,
|
|
NULL,
|
|
NULL);
|
|
colord_load_pnp_ids(cms);
|
|
|
|
/* setup a thread for the GLib callbacks */
|
|
cms->loop = g_main_loop_new(NULL, FALSE);
|
|
cms->thread = g_thread_new("colord CMS main loop",
|
|
colord_run_loop_thread, cms);
|
|
|
|
/* batch device<->profile updates */
|
|
if (pipe2(fd, O_CLOEXEC) == -1) {
|
|
colord_module_destroy(cms);
|
|
return -1;
|
|
}
|
|
cms->readfd = fd[0];
|
|
cms->writefd = fd[1];
|
|
loop = wl_display_get_event_loop(ec->wl_display);
|
|
cms->source = wl_event_loop_add_fd (loop,
|
|
cms->readfd,
|
|
WL_EVENT_READABLE,
|
|
colord_dispatch_all_pending,
|
|
cms);
|
|
if (!cms->source) {
|
|
colord_module_destroy(cms);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|