[Wayland] Direct scanout (#744)

* wayland/surface: Put buffer reference on heap

Currently a buffer use count always reaches zero before it is replaced.
This is due to the fact that at the point a new buffer is attached, the
last potential user releases it (the stage) since the currently
displayed frame has a composited copy of the buffer.

This may however change, if a buffer is scanned out directly, meaning it
should not be released until the page flip callback is invoked.

Prepare for this by making the buffer reference a heap allocated struct,
enabling us to keep a pointer to it longer than the buffer is attached.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=47002bf0cd9983cb5e45121d566d203baef71103

* drm-buffer/gbm: Support both surface and standalone buffers

Surface buffers are created with meta_drm_buffer_new_acquire(), taking a
gbm_surface acquiring the gbm itself, and meta_drm_buffer_new_take()
that takes over ownership of a passed gbm_bo.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=282aada13a5d744dd29eedf3255b6a9f6d0e370c

* window/x11: Use G_DECLARE_DERIVABLE_TYPE()

This removes the MetaWindowX11::priv pointer. It is replaced with a
meta_window_x11_get_private() helper function, and another method to get
the client rect without going through MetaWindowX11Private.

* surface-actor-x11: Move window related unredirect logic to MetaWindowX11

Better to have the relevant object figure out whether it is a good
position to be unredirectable other than the actor, which should be
responsible for being composited.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=5dad87cfb9058a0be96d9ec1a530e09a6d418a6e

* clutter/actor: Add semi-private API to check for transitions

Transitions are used for animating actors when e.g. going from/to
fullscreen, and the like. We need to know such things when deciding
whether to avoid compositing a window actor, so make add API visible to
mutter that checks whether there are any transitions active.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=bc178b711ffbd8db0b7cfecefb6f67edf4e0254f

* wayland: Make MetaWaylandBufferRef reference counted

So that we can have a more dynamic ownership.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=f36120757f4de3eead9245335bc497c596ed88df

* wayland/buffer-ref: Add helpers for use count tracking

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=f8ee974628504e5ca917cf03a9effdd810629332

* cogl/onscreen: Add API to scanout a buffer directly

Instead of always swapping buffers and flipping the back buffer, make it
possible to scan out a provided buffer directly without swapping any EGL
buffers.

A buffer is passed as an object implementing the empty CoglScanout
interface. It is only possible to do this in the native backend; and the
interface is implemented by MetaDrmBufferGbm. When directly scanned out,
instead of calling gbm_surface_lock_front_buffer() to get the gbm_bo and
fbid, get it directly from the MetaDrmBufferGbm, and use that to create
the page flip KMS update.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=3da8c1bfdc1fa486111c1e1dff363fb931612468

* clutter/view: Make it possible to assign a temporary direct scanout

Make it possible to cause the next frame to scan out directly from the
passed CoglScannout. This makes it possible to completely bypass
compositing for the following frame.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=753066598ff83fa9bdbd1be23d1e22663ae59297

* renderer/native: Add API to get primary GPU

Will be used when acquiring scanouts from Wayland buffers.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=3dd8861fbf51183fd69106f55095d444cd37cc34

* onscreen/native: Add API to check whether buffer is scanout compatible

While this is fairly incomplete, as to check things fully we need to use
TEST_ONLY in atomic to try out a complete assignment on the device, but
this works well enough for legacy non-modifier cases.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=b9fe9c736a3b7ef298bda5f785938275805a47f0

* wayland/dma-buf: Don't advertise modifier support by default

Advertising support for modifiers means we will most likely not not be
able to scan out client buffers directly, meaning it just as likely that
we won't be able to scan out even fullscreen windows without atomic KMS.

When we have atomic support, we should advertise support for modifiers
if atomic is used to drive the CRTCs, as we by then can check whether we
can scan out directly, place in an overlay plane, etc.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=cb05b164140dc6934ff5a00cb4354a5dbf4593ef

* wayland/dma-buf: Handle getting dma-buf from detached buffer handle

We might still have a MetaWaylandBuffer for a wl_buffer that was
destroyed. Handle trying to fetch the MetaWaylandDmaBufBuffer from such
a buffer gracefully.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=4b1805c3065eea293aefb1e3d1dc0ba685bcc1fc

* wayland: Add API to acquire a CoglScanout from a surface

This will check whether the current backing buffer is compatible with
the primary plane of the passed CoglOnscreen. Since this will extend the
time before a buffer is released, the MetaWaylandBufferRef is swapped
and orphaned if a new buffer is committed before the previous one was
released. It'll eventually be released, usually by the next page flip
callback.

Currently implemented for EGLImage and DMA-BUF buffer types.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=ff7a42b8bc25c24d3e0fc0a277b1d628f5ea599a

* util: Move MetaLater to its own file

While at it, fix some style inconsistencies, for now use a single
singleton struct instead of multiple static variables, and
other non-functional cleanups. Semantically, there is no changes
introduced.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=d682cdb078f281b03084e3e0d7ab40d3ea382c1f

* display: Initialize MetaCompositor in two steps

MetaCompositor is the place in muffin that manages the higher level
state of compositing, such as handling what happens before and after
paint. In order for other units that depend on having a compositor
instance active, but should be initialized before the X11 implementation
of MetaCompositor registers as a X11 compositing manager, split the
initialization of compositing into two steps:

 1) Instantiate the object - only construct the instance, making it
    possible for users to start listening to signals etc
 2) Manage - this e.g. establishes the compositor as the X11 compositing
    manager and similar things.

This will enable us to put compositing dependent scattered global
variables into a MetaCompositor owned object.

For now, compositor management is internally done by calling a new
`meta_compositor_do_manage()`, as right now we can't change the API of
`meta_compositor_manage()` as it is public. For the next version, manual
management of compositing will removed from the public API, and only
managed internally.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=dc4fe780f790c8fbd3624a7e75fd25c9a3918d0b

* later: Make MetaCompositor the owner of the MetaLaters state

Since the order of destruction during MetaDisplay tear down is a bit
unordered, there are pieces that try to destruct its compositing
dependent pieces (i.e. queued MetaLater callbacks) after MetaCompositor
has been cleaned up, meaning we need to put some slightly awkward NULL
checks to avoid crashing.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=2e7d02f1ce8cb8eba15968c7facd815a7ce43080

* later: Listen to MetaCompositor signal instead of clutter

We need to coordinate with MetaCompositor during pre-paint so that we
have control over whether MetaLater callbacks happen first, or the
MetaCompositor pre-paint logic.

In order to do so, make MetaLater listen to a new signal "pre-paint" on
MetaCompositor, that is called MetaCompositors own pre-paint handling.

This fixes an issue where the top window actor was calculated after the
MetaCompositor pre-paint handling, meaning the top actor being painted
was out-of-date.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=b51c468c0facc3be5df597a6fe0c8c35b95a1fff

* compositor: Add support for direct scanout of Wayland surfaces

Try to bypass compositing if there is a fullscreen toplevel window with
a buffer compatible with the primary plane of the monitor it is
fullscreen on. Only non-mirrored is currently supported; as well as
fullscreened on a single monitor. It should be possible to extend with
more cases, but this starts small.

It does this by introducing a new MetaCompositor sub type
MetaCompositorNative specific to the native backend, which derives from
MetaCompositorServer, containing functionality only relevant for when
running on top of the native backend.

Original Mutter commit: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/798/diffs?commit_id=65a6c4c361b7dad10b19f9bcabdcf7b576d7daa0

* debian: update symbols for libmuffin0

* Fix build

* Fix build

* wayland/dma-buf: Handle failing to import scanout DMA buffer

* Use custom page flip function when retrying failed flips

When using its EGLStream-based presentation path with the proprietary NVIDIA
driver, mutter will use a different function to process page flips -
custom_egl_stream_page_flip.  If that fails due to an EBUSY error, it will
attempt to retry the flip.  However, when retrying, it unconditionally uses the
libdrm-based path. In practice, this causes a segfault when attempting to
access plane_assignments->fb_id, since plane_assignments will be NULL in the
EGLStream case.

This patch has muffin also use the custom page flip function when retrying the
failed flip.

* backends: force enable modifiers on tagged devices

Some devices can't scanout to linear buffers directly as the hw is not
capable of eg rendering into a linear depth buffer.
Add code to force kms-modifiers on udev taged devices.

* add missing systemd-dev dependency

* compositor/native: fix parent class

Author: Sunderland93

clutter/clutter/clutter-actor.c

@@ -20020,6 +20020,23 @@ clutter_actor_get_transition (ClutterActor *self,
   return clos->transition;
 }
 
+/**
+ * clutter_actor_has_transitions: (skip)
+ */
+gboolean
+clutter_actor_has_transitions (ClutterActor *self)
+{
+  const ClutterAnimationInfo *info;
+
+  g_return_val_if_fail (CLUTTER_IS_ACTOR (self), FALSE);
+
+  info = _clutter_actor_get_animation_info_or_defaults (self);
+  if (info->transitions == NULL)
+    return FALSE;
+
+  return g_hash_table_size (info->transitions) > 0;
+}
+
 /**
  * clutter_actor_save_easing_state:
  * @self: a #ClutterActor

clutter/clutter/clutter-muffin.h

@@ -75,6 +75,10 @@ void clutter_stage_thaw_updates (ClutterStage *stage);
 CLUTTER_EXPORT
 void clutter_stage_update_resource_scales (ClutterStage *stage);
 
+CLUTTER_EXPORT
+void clutter_stage_view_assign_next_scanout (ClutterStageView *stage_view,
+                                             CoglScanout      *scanout);
+
 CLUTTER_EXPORT
 gboolean clutter_actor_has_damage (ClutterActor *actor);
 
@@ -83,6 +87,10 @@ void clutter_stage_get_device_coords (ClutterStage         *stage,
                                       ClutterInputDevice   *device,
                                       ClutterEventSequence *sequence,
                                       graphene_point_t     *coords);
+
+CLUTTER_EXPORT
+gboolean clutter_actor_has_transitions (ClutterActor *actor);
+
 #undef __CLUTTER_H_INSIDE__
 
 #endif /* __CLUTTER_MUFFIN_H__ */

clutter/clutter/clutter-stage-view-private.h

@@ -54,11 +54,12 @@ const cairo_region_t * clutter_stage_view_peek_redraw_clip (ClutterStageView *vi
 
 cairo_region_t * clutter_stage_view_take_redraw_clip (ClutterStageView *view);
 
-
 void clutter_stage_view_transform_rect_to_onscreen (ClutterStageView            *view,
                                                     const cairo_rectangle_int_t *src_rect,
                                                     int                          dst_width,
                                                     int                          dst_height,
                                                     cairo_rectangle_int_t       *dst_rect);
 
+CoglScanout * clutter_stage_view_take_scanout (ClutterStageView *view);
+
 #endif /* __CLUTTER_STAGE_VIEW_PRIVATE_H__ */

clutter/clutter/clutter-stage-view.c

@@ -25,6 +25,8 @@
 
 #include "clutter/clutter-damage-history.h"
 #include "clutter/clutter-private.h"
+#include "clutter/clutter-muffin.h"
+#include "cogl/cogl.h"
 
 enum
 {
@@ -64,6 +66,8 @@ typedef struct _ClutterStageViewPrivate
     CoglOffscreen *framebuffer;
   } shadow;
 
+  CoglScanout *next_scanout;
+
   gboolean has_redraw_clip;
   cairo_region_t *redraw_clip;
 
@@ -923,6 +927,25 @@ clutter_stage_default_get_offscreen_transformation_matrix (ClutterStageView *vie
   cogl_matrix_init_identity (matrix);
 }
 
+void
+clutter_stage_view_assign_next_scanout (ClutterStageView *view,
+                                        CoglScanout      *scanout)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+
+  g_set_object (&priv->next_scanout, scanout);
+}
+
+CoglScanout *
+clutter_stage_view_take_scanout (ClutterStageView *view)
+{
+  ClutterStageViewPrivate *priv =
+    clutter_stage_view_get_instance_private (view);
+
+  return g_steal_pointer (&priv->next_scanout);
+}
+
 static void
 clutter_stage_view_get_property (GObject    *object,
                                  guint       prop_id,

clutter/clutter/cogl/clutter-stage-cogl.c

@@ -793,6 +793,20 @@ clutter_stage_cogl_redraw_view (ClutterStageWindow *stage_window,
   return res;
 }
 
+static void
+clutter_stage_cogl_scanout_view (ClutterStageCogl *stage_cogl,
+                                 ClutterStageView *view,
+                                 CoglScanout      *scanout)
+{
+  CoglFramebuffer *framebuffer = clutter_stage_view_get_framebuffer (view);
+  CoglOnscreen *onscreen;
+
+  g_return_if_fail (cogl_is_onscreen (framebuffer));
+
+  onscreen = COGL_ONSCREEN (framebuffer);
+  cogl_onscreen_direct_scanout (onscreen, scanout);
+}
+
 static void
 clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
 {
@@ -820,11 +834,23 @@ clutter_stage_cogl_redraw (ClutterStageWindow *stage_window)
   for (l = _clutter_stage_window_get_views (stage_window); l; l = l->next)
     {
       ClutterStageView *view = l->data;
+      g_autoptr (CoglScanout) scanout = NULL;
 
       if (!clutter_stage_view_has_redraw_clip (view))
         continue;
 
-      swap_event |= clutter_stage_cogl_redraw_view (stage_window, view);
+      scanout = clutter_stage_view_take_scanout (view);
+      if (scanout)
+        {
+          clutter_stage_cogl_scanout_view (stage_cogl,
+                                           view,
+                                           scanout);
+          swap_event = TRUE;
+        }
+      else
+        {
+          swap_event |= clutter_stage_cogl_redraw_view (stage_window, view);
+        }
     }
 
   if (has_redraw_clip)

cogl/cogl/cogl-onscreen.c

@@ -405,6 +405,27 @@ cogl_onscreen_get_buffer_age (CoglOnscreen *onscreen)
   return winsys->onscreen_get_buffer_age (onscreen);
 }
 
+void
+cogl_onscreen_direct_scanout (CoglOnscreen *onscreen,
+                              CoglScanout  *scanout)
+{
+  CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
+  const CoglWinsysVtable *winsys;
+  CoglFrameInfo *info;
+
+  g_return_if_fail (framebuffer->type == COGL_FRAMEBUFFER_TYPE_ONSCREEN);
+  g_return_if_fail (_cogl_winsys_has_feature (COGL_WINSYS_FEATURE_SYNC_AND_COMPLETE_EVENT));
+
+  info = _cogl_frame_info_new ();
+  info->frame_counter = onscreen->frame_counter;
+  g_queue_push_tail (&onscreen->pending_frame_infos, info);
+
+  winsys = _cogl_framebuffer_get_winsys (framebuffer);
+  winsys->onscreen_direct_scanout (onscreen, scanout);
+
+  onscreen->frame_counter++;
+}
+
 #ifdef COGL_HAS_X11_SUPPORT
 uint32_t
 cogl_x11_onscreen_get_window_xid (CoglOnscreen *onscreen)

cogl/cogl/cogl-onscreen.h

@@ -50,6 +50,8 @@ G_BEGIN_DECLS
 typedef struct _CoglOnscreen CoglOnscreen;
 #define COGL_ONSCREEN(X) ((CoglOnscreen *)(X))
 
+typedef struct _CoglScanout CoglScanout;
+
 /**
  * cogl_onscreen_get_gtype:
  *
@@ -284,6 +286,13 @@ cogl_onscreen_swap_buffers_with_damage (CoglOnscreen *onscreen,
                                         const int *rectangles,
                                         int n_rectangles);
 
+/**
+ * cogl_onscreen_direct_scanout: (skip)
+ */
+COGL_EXPORT void
+cogl_onscreen_direct_scanout (CoglOnscreen *onscreen,
+                              CoglScanout  *scanout);
+
 /**
  * cogl_onscreen_swap_region:
  * @onscreen: A #CoglOnscreen framebuffer

cogl/cogl/cogl-scanout.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2019 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "cogl-config.h"
+
+#include "cogl-scanout.h"
+
+G_DEFINE_INTERFACE (CoglScanout, cogl_scanout, G_TYPE_OBJECT)
+
+static void
+cogl_scanout_default_init (CoglScanoutInterface *iface)
+{
+}

cogl/cogl/cogl-scanout.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2019 Red Hat Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef COGL_SCANOUT_H
+#define COGL_SCANOUT_H
+
+#include "cogl/cogl-types.h"
+
+#include <glib-object.h>
+
+#define COGL_TYPE_SCANOUT (cogl_scanout_get_type ())
+COGL_EXPORT
+G_DECLARE_INTERFACE (CoglScanout, cogl_scanout,
+                     COGL, SCANOUT, GObject)
+
+struct _CoglScanoutInterface
+{
+    GTypeInterface parent_iface;
+};
+
+#endif /* COGL_SCANOUT_H */

cogl/cogl/cogl.h

@@ -122,6 +122,7 @@
 #include <cogl/cogl-fence.h>
 #include <cogl/cogl-glib-source.h>
 #include <cogl/cogl-trace.h>
+#include <cogl/cogl-scanout.h>
 /* XXX: This will definitly go away once all the Clutter winsys
  * code has been migrated down into Cogl! */
 #include <cogl/deprecated/cogl-clutter.h>