[PATCH weston v3 07/36] libweston: introduce weston_output::head_list

Pekka Paalanen ppaalanen at gmail.com
Tue Oct 31 11:48:17 UTC 2017


From: Pekka Paalanen <pekka.paalanen at collabora.co.uk>

The intention is that in the future backends will dynamically allocate
weston_heads based on the resources they have. The lifetime of a
weston_head will be independent of the lifetime of a weston_output it
may be attached to. Backends allocate objects derived from weston_head,
like they currently do for weston_output. Backend will choose when to
destroy a weston_head.

For clone mode, struct weston_output gains head_list member, which is
the list of attached heads that will all show the same framebuffer.
Since heads are growing out of weston_output, management functions are
added.

Detaching a head from an enabled output is allowed to accommodate
disappearing heads. Attaching a head to an enabled output is disallowed
because it may need hardware reconfiguration and testing, and so
requires a weston_output_enable() call.

As a temporary measure, we have one weston_head embedded in
weston_output, so that backends can be migrated individually to the new
allocation scheme.

Signed-off-by: Pekka Paalanen <pekka.paalanen at collabora.co.uk>
---
 libweston/compositor.c | 216 +++++++++++++++++++++++++++++++++++++++----------
 libweston/compositor.h |   7 +-
 2 files changed, 181 insertions(+), 42 deletions(-)

diff --git a/libweston/compositor.c b/libweston/compositor.c
index d96c96d4..1cc5050a 100644
--- a/libweston/compositor.c
+++ b/libweston/compositor.c
@@ -160,13 +160,12 @@ weston_mode_switch_finish(struct weston_output *output,
 	if (!mode_changed && !scale_changed)
 		return;
 
-	head = &output->head;
-
 	/* notify clients of the changes */
-	weston_mode_switch_send_events(head, mode_changed, scale_changed);
+	wl_list_for_each(head, &output->head_list, output_link)
+		weston_mode_switch_send_events(head,
+					       mode_changed, scale_changed);
 }
 
-
 static void
 weston_compositor_reflow_outputs(struct weston_compositor *compositor,
 				struct weston_output *resized_output, int delta_width);
@@ -362,12 +361,13 @@ weston_presentation_feedback_present(
 	struct wl_resource *o;
 	uint64_t secs;
 
-	head = &output->head;
-	wl_resource_for_each(o, &head->resource_list) {
-		if (wl_resource_get_client(o) != client)
-			continue;
+	wl_list_for_each(head, &output->head_list, output_link) {
+		wl_resource_for_each(o, &head->resource_list) {
+			if (wl_resource_get_client(o) != client)
+				continue;
 
-		wp_presentation_feedback_send_sync_output(feedback->resource, o);
+			wp_presentation_feedback_send_sync_output(feedback->resource, o);
+		}
 	}
 
 	secs = ts->tv_sec;
@@ -988,6 +988,7 @@ weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask)
 	uint32_t left = es->output_mask & different;
 	uint32_t output_bit;
 	struct weston_output *output;
+	struct weston_head *head;
 
 	es->output_mask = mask;
 	if (es->resource == NULL)
@@ -1000,9 +1001,11 @@ weston_surface_update_output_mask(struct weston_surface *es, uint32_t mask)
 		if (!(output_bit & different))
 			continue;
 
-		weston_surface_send_enter_leave(es, &output->head,
-						output_bit & entered,
-						output_bit & left);
+		wl_list_for_each(head, &output->head_list, output_link) {
+			weston_surface_send_enter_leave(es, head,
+							output_bit & entered,
+							output_bit & left);
+		}
 	}
 }
 
@@ -4386,6 +4389,98 @@ weston_head_from_resource(struct wl_resource *resource)
 	return wl_resource_get_user_data(resource);
 }
 
+/** Initialize a pre-allocated weston_head
+ *
+ * \param head The head to initialize.
+ *
+ * The head will be safe to attach, detach and release.
+ *
+ * \memberof weston_head
+ * \internal
+ */
+static void
+weston_head_init(struct weston_head *head)
+{
+	/* Add some (in)sane defaults which can be used
+	 * for checking if an output was properly configured
+	 */
+	memset(head, 0, sizeof *head);
+
+	wl_list_init(&head->output_link);
+	wl_list_init(&head->resource_list);
+}
+
+/** Attach a head to an inactive output
+ *
+ * \param output The output to attach to.
+ * \param head The head that is not yet attached.
+ * \return 0 on success, -1 on failure.
+ *
+ * Attaches the given head to the output. All heads of an output are clones
+ * and share the resolution and timings.
+ *
+ * Cloning heads this way uses less resources than creating an output for
+ * each head, but is not always possible due to environment, driver and hardware
+ * limitations.
+ *
+ * On failure, the head remains unattached. Success of this function does not
+ * guarantee the output configuration is actually valid. The final checks are
+ * made on weston_output_enable().
+ *
+ * \memberof weston_output
+ */
+static int
+weston_output_attach_head(struct weston_output *output,
+			  struct weston_head *head)
+{
+	if (output->enabled)
+		return -1;
+
+	if (!wl_list_empty(&head->output_link))
+		return -1;
+
+	/* XXX: no support for multi-head yet */
+	if (!wl_list_empty(&output->head_list))
+		return -1;
+
+	head->output = output;
+	wl_list_insert(output->head_list.prev, &head->output_link);
+
+	return 0;
+}
+
+/** Detach a head from its output
+ *
+ * \param head The head to detach.
+ *
+ * It is safe to detach a non-attached head.
+ *
+ * \memberof weston_head
+ */
+static void
+weston_head_detach(struct weston_head *head)
+{
+	wl_list_remove(&head->output_link);
+	wl_list_init(&head->output_link);
+	head->output = NULL;
+}
+
+/** Destroy a head
+ *
+ * \param head The head to be released.
+ *
+ * Destroys the head. The caller is responsible for freeing the memory pointed
+ * to by \c head.
+ *
+ * \memberof weston_head
+ * \internal
+ */
+static void
+weston_head_release(struct weston_head *head)
+{
+	weston_head_detach(head);
+}
+
 /** Store monitor make, model and serial number
  *
  * \param head The head to modify.
@@ -4581,8 +4676,9 @@ weston_output_init_geometry(struct weston_output *output, int x, int y)
 WL_EXPORT void
 weston_output_move(struct weston_output *output, int x, int y)
 {
-	struct weston_head *head = &output->head;
+	struct weston_head *head;
 	struct wl_resource *resource;
+	int ver;
 
 	output->move_x = x - output->x;
 	output->move_y = y - output->y;
@@ -4598,19 +4694,22 @@ weston_output_move(struct weston_output *output, int x, int y)
 	wl_signal_emit(&output->compositor->output_moved_signal, output);
 
 	/* Notify clients of the change for output position. */
-	wl_resource_for_each(resource, &head->resource_list) {
-		wl_output_send_geometry(resource,
-					output->x,
-					output->y,
-					head->mm_width,
-					head->mm_height,
-					head->subpixel,
-					head->make,
-					head->model,
-					output->transform);
-
-		if (wl_resource_get_version(resource) >= WL_OUTPUT_DONE_SINCE_VERSION)
-			wl_output_send_done(resource);
+	wl_list_for_each(head, &output->head_list, output_link) {
+		wl_resource_for_each(resource, &head->resource_list) {
+			wl_output_send_geometry(resource,
+						output->x,
+						output->y,
+						head->mm_width,
+						head->mm_height,
+						head->subpixel,
+						head->make,
+						head->model,
+						output->transform);
+
+			ver = wl_resource_get_version(resource);
+			if (ver >= WL_OUTPUT_DONE_SINCE_VERSION)
+				wl_output_send_done(resource);
+		}
 	}
 }
 
@@ -4650,11 +4749,11 @@ weston_compositor_add_output(struct weston_compositor *compositor,
 	wl_list_insert(compositor->output_list.prev, &output->link);
 	output->enabled = true;
 
-	head = &output->head;
-	head->output = output;
-	head->global = wl_global_create(compositor->wl_display,
-					&wl_output_interface, 3,
-					head, bind_output);
+	wl_list_for_each(head, &output->head_list, output_link) {
+		head->global = wl_global_create(compositor->wl_display,
+						&wl_output_interface, 3,
+						head, bind_output);
+	}
 
 	wl_signal_emit(&compositor->output_created_signal, output);
 
@@ -4747,11 +4846,12 @@ weston_compositor_remove_output(struct weston_output *output)
 	wl_signal_emit(&compositor->output_destroyed_signal, output);
 	wl_signal_emit(&output->destroy_signal, output);
 
-	head = &output->head;
-	wl_global_destroy(head->global);
-	head->global = NULL;
-	wl_resource_for_each(resource, &head->resource_list) {
-		wl_resource_set_destructor(resource, NULL);
+	wl_list_for_each(head, &output->head_list, output_link) {
+		wl_global_destroy(head->global);
+		head->global = NULL;
+
+		wl_resource_for_each(resource, &head->resource_list)
+			wl_resource_set_destructor(resource, NULL);
 	}
 
 	compositor->output_id_pool &= ~(1u << output->id);
@@ -4829,19 +4929,19 @@ weston_output_init(struct weston_output *output,
 		   struct weston_compositor *compositor,
 		   const char *name)
 {
-	struct weston_head *head = &output->head;
-
 	output->compositor = compositor;
 	output->destroying = 0;
 	output->name = strdup(name);
 	wl_list_init(&output->link);
 	output->enabled = false;
 
+	wl_list_init(&output->head_list);
+
+	weston_head_init(&output->head);
+
 	/* Add some (in)sane defaults which can be used
 	 * for checking if an output was properly configured
 	 */
-	head->mm_width = 0;
-	head->mm_height = 0;
 	output->scale = 0;
 	/* Can't use -1 on uint32_t and 0 is valid enum value */
 	output->transform = UINT32_MAX;
@@ -4915,6 +5015,7 @@ weston_output_enable(struct weston_output *output)
 	struct weston_compositor *c = output->compositor;
 	struct weston_output *iterator;
 	int x = 0, y = 0;
+	int ret;
 
 	if (output->enabled) {
 		weston_log("Error: attempt to enable an enabled output '%s'\n",
@@ -4948,9 +5049,14 @@ weston_output_enable(struct weston_output *output)
 	wl_signal_init(&output->frame_signal);
 	wl_signal_init(&output->destroy_signal);
 	wl_list_init(&output->animation_list);
-	wl_list_init(&output->head.resource_list);
 	wl_list_init(&output->feedback_list);
 
+	/* XXX: Temporary until all backends are converted. */
+	if (wl_list_empty(&output->head_list)) {
+		ret = weston_output_attach_head(output, &output->head);
+		assert(ret == 0);
+	}
+
 	/* Enable the output (set up the crtc or create a
 	 * window representing the output, set up the
 	 * renderer, etc)
@@ -5042,6 +5148,8 @@ weston_pending_output_coldplug(struct weston_compositor *compositor)
 WL_EXPORT void
 weston_output_release(struct weston_output *output)
 {
+	struct weston_head *head;
+
 	output->destroying = 1;
 
 	if (output->enabled)
@@ -5050,9 +5158,35 @@ weston_output_release(struct weston_output *output)
 	pixman_region32_fini(&output->region);
 	pixman_region32_fini(&output->previous_damage);
 	wl_list_remove(&output->link);
+
+	while (!wl_list_empty(&output->head_list)) {
+		head = weston_output_get_first_head(output);
+		weston_head_detach(head);
+	}
+
+	weston_head_release(&output->head);
+
 	free(output->name);
 }
 
+/** When you need a head...
+ *
+ * This function is a hack, used until all code has been converted to become
+ * multi-head aware.
+ *
+ * \param output The weston_output whose head to get.
+ * \return The first head in the output's list.
+ */
+WL_EXPORT struct weston_head *
+weston_output_get_first_head(struct weston_output *output)
+{
+	if (wl_list_empty(&output->head_list))
+		return NULL;
+
+	return container_of(output->head_list.next,
+			    struct weston_head, output_link);
+}
+
 static void
 destroy_viewport(struct wl_resource *resource)
 {
diff --git a/libweston/compositor.h b/libweston/compositor.h
index f56fc2a3..47aacbc8 100644
--- a/libweston/compositor.h
+++ b/libweston/compositor.h
@@ -153,6 +153,7 @@ enum dpms_enum {
  */
 struct weston_head {
 	struct weston_output *output;	/**< the output driving this head */
+	struct wl_list output_link;	/**< in weston_output::head_list */
 
 	struct wl_list resource_list;	/**< wl_output protocol objects */
 	struct wl_global *global;	/**< wl_output global */
@@ -225,7 +226,8 @@ struct weston_output {
 	struct weston_mode *original_mode;
 	struct wl_list mode_list;
 
-	struct weston_head head;
+	struct weston_head head; /**< head for unconverted backends */
+	struct wl_list head_list; /**< List of driven weston_heads */
 
 	void (*start_repaint_loop)(struct weston_output *output);
 	int (*repaint)(struct weston_output *output,
@@ -1978,6 +1980,9 @@ weston_pending_output_coldplug(struct weston_compositor *compositor);
 struct weston_head *
 weston_head_from_resource(struct wl_resource *resource);
 
+struct weston_head *
+weston_output_get_first_head(struct weston_output *output);
+
 #ifdef  __cplusplus
 }
 #endif
-- 
2.13.6



More information about the wayland-devel mailing list