Merge ~vanvugt/ubuntu/+source/mutter:fix-lp1763892-bionic into ~ubuntu-desktop/ubuntu/+source/mutter:ubuntu/bionic

[Daniel van Vugt]

Remove 60 FPS limitation, thus supporting high frame rates

For Xorg the only fix required was to remove the spurious patch:

  clutter-Smooth-out-master-clock-to-smooth-visuals.patch

which had the effect of imposing a 60 FPS limitation. That patch
never landed upstream.

For Wayland you need both the above fix and the introduction of
hardware vsync support which was upstreamed in mutter 3.32 and is
backported to 3.28 in two commits/patches:

  lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch
  lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch

https://bugs.launchpad.net/bugs/1763892

[Marco Trevisan (Treviño) (3v1n0)]

Do you have the upstream merge proposal for the backport branch too?

However, being this something upstream too, LGTM.

We we can include this in the next SRU round.

review: Approve

[Daniel van Vugt (vanvugt)]

> Do you have the upstream merge proposal for the backport branch too?

The upstream upstream link is https://gitlab.gnome.org/GNOME/mutter/merge_requests/171 and the backport branch is https://gitlab.gnome.org/vanvugt/mutter/commits/add-vsync-3.28 . But I have stopped creating MRs for backport branches in cases like this where I only want to generate a web page/patch for it because it annoyed Jonas and he asked me to stop.

In cases where an upstream backport is desired then I would create another MR. But since this is arguably an enhancement for hardware enablement I feel like it wouldn't qualify for a proper upstream backport.

[Daniel van Vugt (vanvugt)]

It looks like this might be held up because the previous version is held up (bug 1811900)

[Daniel van Vugt (vanvugt)]

I guess there are probably conflicts here now. Although LP isn't saying so.

[Daniel van Vugt (vanvugt)]

Conflict fixed.

[Marco Trevisan (Treviño) (3v1n0)]

See the inline diff for the added-symbol.
I'd like to have a SRU upload without it since we don't need to use anywhere else

[Daniel van Vugt (vanvugt)]

Sorry I keep forgetting to save my inline comments. This is from a few hours ago...

[Marco Trevisan (Treviño) (3v1n0)]

I've merged this one in https://code.launchpad.net/~3v1n0/ubuntu/+source/mutter/+git/mutter/+merge/366676

So I guess we can close this.

review: Approve

[Daniel van Vugt (vanvugt)]

OK then.

[Daniel van Vugt (vanvugt)]

Hmm, I don't see any close or reject option (any more). I can only delete the MP. So I will wait for the above to land first and then will permanently delete this one.

diff --git a/debian/changelog b/debian/changelog
index 99219d6..b728846 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,12 @@
+mutter (3.28.3+git20190124-0ubuntu18.04.3) UNRELEASED; urgency=medium
+
+  * Add support for high frame rate displays (LP: #1763892):
+    - Drop clutter-Smooth-out-master-clock-to-smooth-visuals.patch
+    - Add lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch
+    - Add lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch
+
+ -- Daniel van Vugt <[e-mail]>  Mon, 29 Apr 2019 16:21:54 +0800
+
 mutter (3.28.3+git20190124-0ubuntu18.04.2) bionic; urgency=medium
 
   * control: Add Breaks on budgie-desktop verions broken by this upload.
diff --git a/debian/libmutter-2-0.symbols b/debian/libmutter-2-0.symbols
index 1489074..89b3d01 100644
--- a/debian/libmutter-2-0.symbols
+++ b/debian/libmutter-2-0.symbols
@@ -549,6 +549,7 @@ libmutter-2.so.0 libmutter-2-0 #MINVER#
  meta_gpu_kms_error_quark@Base 3.28.2
  meta_gpu_kms_flip_closure_container_free@Base 3.28.3+git20190124
  meta_gpu_kms_flip_crtc@Base 3.28.2
+ meta_gpu_kms_get_current_time_ns@Base 3.28.3+git20190124-0ubuntu18.04.3
  meta_gpu_kms_get_fd@Base 3.28.2
  meta_gpu_kms_get_file_path@Base 3.28.2
  meta_gpu_kms_get_max_buffer_size@Base 3.28.2
diff --git a/debian/patches/clutter-Smooth-out-master-clock-to-smooth-visuals.patch b/debian/patches/clutter-Smooth-out-master-clock-to-smooth-visuals.patch
 deleted file mode 100644
index 2239837..0000000
--- a/debian/patches/clutter-Smooth-out-master-clock-to-smooth-visuals.patch
+++ /dev/null
@@ -1,225 +0,0 @@
-From: Daniel van Vugt <[e-mail]>
-Date: Fri, 16 Feb 2018 02:50:59 -0600
-Subject: clutter: Smooth out master clock to smooth visuals
-
-Clutter's master clock was jittery because it included errors in cur_tick
-such as dispatch delays due to other sources. Dispatch could also occur up
-to 1ms early since GSource can only be timed to the millisecond. All of this
-could impact the visual smoothness of animations as they are displayed on
-the steady interval of the monitor, but spacially moving in less regular
-steps derived from the dispatch times.
-
-The simple fix is to ignore any jitter in dispatch timing. Try a little
-bit harder to use a precise interval that will better match the display
-hardware, and smoother visuals will follow.
-
-Bug: https://gitlab.gnome.org/GNOME/mutter/issues/25
-Forwarded: https://gitlab.gnome.org/GNOME/mutter/merge_requests/70
----
- clutter/clutter/clutter-master-clock-default.c | 134 +++++++++++++++++--------
- 1 file changed, 93 insertions(+), 41 deletions(-)
-
-diff --git a/clutter/clutter/clutter-master-clock-default.c b/clutter/clutter/clutter-master-clock-default.c
-index 7b2df0d..97b6d13 100644
---- a/clutter/clutter/clutter-master-clock-default.c
-+++ b/clutter/clutter/clutter-master-clock-default.c
-@@ -69,8 +69,10 @@ struct _ClutterMasterClockDefault
-   /* the previous state of the clock, in usecs, used to compute the delta */
-   gint64 prev_tick;
- 
-+  /* the ideal frame interval in usecs (inverse of your max refresh rate) */
-+  gint64 frame_interval;
-+
- #ifdef CLUTTER_ENABLE_DEBUG
--  gint64 frame_budget;
-   gint64 remaining_budget;
- #endif
- 
-@@ -264,6 +266,41 @@ master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
-     }
- }
- 
-+static gint64
-+estimate_next_presentation_time (ClutterMasterClockDefault *master_clock)
-+{
-+  gint64 frame_phase, now, now_phase, undershoot;
-+
-+  /* In future if this was updated from the backend's (maximum) refresh rate
-+   * then that would fix: https://bugzilla.gnome.org/show_bug.cgi?id=781296
-+   */
-+  master_clock->frame_interval = G_USEC_PER_SEC /
-+                                 clutter_get_default_frame_rate ();
-+
-+  now = g_source_get_time (master_clock->source);
-+  now_phase = now % master_clock->frame_interval;
-+
-+  /* To be precise we would like to use:
-+   *   frame_phase = a_recent_hardware_presentation_time % frame_interval;
-+   * where hardware_presentation_time must be using the same clock as
-+   * g_source_get_time. Unfortunately they're different clocks right now
-+   * so we can't.
-+   *   Alternatively, we could replace g_source_get_time in future with the
-+   * current time in the clutter/cogl presentation clock, but that function
-+   * also doesn't exist yet.
-+   *   Until we can get either of those, zero is fine. It just means latency
-+   * will be suboptimal by half a frame on average. We still get maximum
-+   * smoothness this way...
-+   */
-+  frame_phase = 0;
-+
-+  undershoot = frame_phase - now_phase;
-+  if (undershoot < 0)
-+    undershoot += master_clock->frame_interval;
-+
-+  return now + undershoot;
-+}
-+
- /*
-  * master_clock_next_frame_delay:
-  * @master_clock: a #ClutterMasterClock
-@@ -276,7 +313,8 @@ master_clock_reschedule_stage_updates (ClutterMasterClockDefault *master_clock,
- static gint
- master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
- {
--  gint64 now, next;
-+  gint64 now, target_presentation_time, ideal_render_start;  /* timestamps */
-+  gint64 ideal_prerender_time, lateness;  /* deltas */
-   gint swap_delay;
- 
-   if (!master_clock_is_running (master_clock))
-@@ -307,46 +345,45 @@ master_clock_next_frame_delay (ClutterMasterClockDefault *master_clock)
-       return 0;
-     }
- 
--  if (master_clock->prev_tick == 0)
--    {
--      /* If we weren't previously running, then draw the next frame
--       * immediately
--       */
--      CLUTTER_NOTE (SCHEDULER, "draw the first frame immediately");
--      return 0;
--    }
--
--  /* Otherwise, wait at least 1/frame_rate seconds since we last
--   * started a frame
--   */
-   now = g_source_get_time (master_clock->source);
- 
--  next = master_clock->prev_tick;
--
--  /* If time has gone backwards then there's no way of knowing how
--     long we should wait so let's just dispatch immediately */
--  if (now <= next)
-+  /* As first preference, try to carry on smoothly from the previous frame,
-+   * even if that means we start rendering frame 2 before frame 1 has been
-+   * presented. This is why we ignore estimate_next_presentation_time here...
-+   */
-+  target_presentation_time = master_clock->prev_tick +
-+                             master_clock->frame_interval;
-+  ideal_prerender_time = master_clock->frame_interval;
-+  ideal_render_start = target_presentation_time - ideal_prerender_time;
-+  lateness = now - ideal_render_start;
-+
-+  /* If we just woke from idle then try to improve the smoothness of the first
-+   * two frames some more. Otherwise the first frame would appear too old
-+   * relative to the second frame.
-+   */
-+  if (lateness >= master_clock->frame_interval)
-     {
--      CLUTTER_NOTE (SCHEDULER, "Time has gone backwards");
--
--      return 0;
-+      target_presentation_time = estimate_next_presentation_time (master_clock);
-+      ideal_render_start = target_presentation_time - ideal_prerender_time;
-+      lateness = now - ideal_render_start;
-     }
- 
--  next += (1000000L / clutter_get_default_frame_rate ());
--
--  if (next <= now)
-+  if (lateness > 0)
-     {
--      CLUTTER_NOTE (SCHEDULER, "Less than %lu microsecs",
--                    1000000L / (gulong) clutter_get_default_frame_rate ());
--
-+      CLUTTER_NOTE (SCHEDULER, "No wait required. We're already late.");
-       return 0;
-     }
-   else
-     {
--      CLUTTER_NOTE (SCHEDULER, "Waiting %" G_GINT64_FORMAT " msecs",
--                   (next - now) / 1000);
--
--      return (next - now) / 1000;
-+      /* We +1 here to avoid premature dispatches that would otherwise occur
-+       * repeatedly during the 1ms before 'ideal_render_start'. We don't care
-+       * if this makes the final dispatch 1ms late because the smoothing
-+       * algorithm corrects that, and it's much better than attempting to
-+       * render more frames than the hardware can physically display...
-+       */
-+      gint millisec_delay = -lateness / 1000 + 1;
-+      CLUTTER_NOTE (SCHEDULER, "Waiting %dms", millisec_delay);
-+      return millisec_delay;
-     }
- }
- 
-@@ -532,16 +569,34 @@ clutter_clock_dispatch (GSource     *source,
-   ClutterMasterClockDefault *master_clock = clock_source->master_clock;
-   gboolean stages_updated = FALSE;
-   GSList *stages;
--
--  CLUTTER_NOTE (SCHEDULER, "Master clock [tick]");
-+  gint64 smooth_tick;
- 
-   _clutter_threads_acquire_lock ();
- 
-   /* Get the time to use for this frame */
--  master_clock->cur_tick = g_source_get_time (source);
-+  smooth_tick = estimate_next_presentation_time (master_clock);
-+  if (smooth_tick <= master_clock->prev_tick)
-+    {
-+      /* Ordinarily this will never happen. But after we fix bug 781296, it
-+       * could happen in the rare case when the ideal frame_interval changes,
-+       * such as video mode switching or hotplugging monitors. As such it is
-+       * not considered a bug (unless it's happening without mode switching
-+       * or hotplugging).
-+       */
-+      CLUTTER_NOTE (SCHEDULER, "Master clock [tick] was premature (skipped)");
-+      _clutter_threads_release_lock ();
-+      return G_SOURCE_CONTINUE;
-+    }
-+
-+  master_clock->cur_tick = smooth_tick;
-+  if (master_clock->prev_tick)
-+    CLUTTER_NOTE (SCHEDULER, "Master clock [tick] %+ldus",
-+                  (long) (master_clock->cur_tick - master_clock->prev_tick));
-+  else
-+    CLUTTER_NOTE (SCHEDULER, "Master clock [tick] startup");
- 
- #ifdef CLUTTER_ENABLE_DEBUG
--  master_clock->remaining_budget = master_clock->frame_budget;
-+  master_clock->remaining_budget = master_clock->frame_interval;
- #endif
- 
-   /* We need to protect ourselves against stages being destroyed during
-@@ -580,7 +635,7 @@ clutter_clock_dispatch (GSource     *source,
- 
-   _clutter_threads_release_lock ();
- 
--  return TRUE;
-+  return G_SOURCE_CONTINUE;
- }
- 
- static void
-@@ -612,10 +667,7 @@ clutter_master_clock_default_init (ClutterMasterClockDefault *self)
-   self->idle = FALSE;
-   self->ensure_next_iteration = FALSE;
-   self->paused = FALSE;
--
--#ifdef CLUTTER_ENABLE_DEBUG
--  self->frame_budget = G_USEC_PER_SEC / 60;
--#endif
-+  self->frame_interval = G_USEC_PER_SEC / 60; /* Will be refined at runtime */
- 
-   g_source_set_priority (source, CLUTTER_PRIORITY_REDRAW);
-   g_source_set_can_recurse (source, FALSE);
diff --git a/debian/patches/lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch b/debian/patches/lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch
 new file mode 100644
index 0000000..c28b267
--- /dev/null
+++ b/debian/patches/lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch
@@ -0,0 +1,363 @@
+Description: renderer-native: Add hardware presentation timing
+ Add support for getting hardware presentation times from KMS (Wayland
+ sessions). Also implement cogl_get_clock_time which is required to compare
+ and judge the age of presentation timestamps.
+ .
+ For single monitor systems this is straightforward. For multi-monitor
+ systems though we have to choose a display to sync to. The compositor
+ already partially solves this for us in the case of only one display
+ updating because it will only use the subset of monitors that are
+ changing. In the case of multiple monitors consuming the same frame
+ concurrently however, we choose the fastest one (in use at the time).
+ .
+ Patch 1 of 2
+Author: Daniel van Vugt <[e-mail]>
+Origin: https://gitlab.gnome.org/GNOME/mutter/merge_requests/171 via backport branch https://gitlab.gnome.org/vanvugt/mutter/commits/add-vsync-3.28
+Bug: https://bugzilla.gnome.org/show_bug.cgi?id=781296
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1763892
+Forwarded: yes
+Last-Update: 2019-03-13
+
+diff --git a/src/Makefile.am b/src/Makefile.am
+index bcb3505c7..13862e940 100644
+--- a/src/Makefile.am
++++ b/src/Makefile.am
+@@ -51,6 +51,8 @@ mutter_built_sources = \
+ 	$(dbus_login1_built_sources)		\
+ 	meta/meta-enum-types.h			\
+ 	meta-enum-types.c			\
++	meta-marshal.c	        		\
++	meta-marshal.h		        	\
+ 	$(NULL)
+ 
+ if HAVE_REMOTE_DESKTOP
+@@ -653,6 +655,7 @@ EXTRA_DIST +=					\
+ 	libmutter.pc.in				\
+ 	meta-enum-types.h.in			\
+ 	meta-enum-types.c.in			\
++	meta-marshal.list			\
+ 	org.freedesktop.login1.xml		\
+ 	org.gnome.Mutter.DisplayConfig.xml	\
+ 	org.gnome.Mutter.IdleMonitor.xml	\
+@@ -666,7 +669,10 @@ BUILT_SOURCES =					\
+ 	$(libmutterinclude_built_headers)
+ 
+ MUTTER_STAMP_FILES = stamp-meta-enum-types.h
+-CLEANFILES += $(MUTTER_STAMP_FILES)
++CLEANFILES +=					\
++	$(MUTTER_STAMP_FILES)			\
++	meta-marshal.c	        		\
++	meta-marshal.h
+ 
+ meta/meta-enum-types.h: stamp-meta-enum-types.h Makefile
+ 	@true
+@@ -760,3 +766,20 @@ endef
+ 	$(AM_V_GEN)$(WAYLAND_SCANNER) code $< $@
+ %-server-protocol.h : $(srcdir)/wayland/protocol/%.xml
+ 	$(AM_V_GEN)$(WAYLAND_SCANNER) server-header $< $@
++
++meta_marshal_opts = --prefix=meta_marshal --internal
++
++meta-marshal.h: meta-marshal.list
++	$(AM_V_GEN)$(GLIB_GENMARSHAL) \
++		--header \
++		$(meta_marshal_opts) \
++		--output=$@ \
++		$<
++
++meta-marshal.c: meta-marshal.list meta-marshal.h
++	$(AM_V_GEN)$(GLIB_GENMARSHAL) \
++		--include-header=meta-marshal.h \
++		$(meta_marshal_opts) \
++		--body \
++		--output=$@ \
++		$<
+diff --git a/src/backends/native/meta-gpu-kms.c b/src/backends/native/meta-gpu-kms.c
+index 815caf501..e931e70f7 100644
+--- a/src/backends/native/meta-gpu-kms.c
++++ b/src/backends/native/meta-gpu-kms.c
+@@ -27,6 +27,7 @@
+ #include <errno.h>
+ #include <poll.h>
+ #include <string.h>
++#include <time.h>
+ #include <xf86drm.h>
+ #include <xf86drmMode.h>
+ 
+@@ -51,6 +52,7 @@ typedef struct _MetaGpuKmsFlipClosureContainer
+ {
+   GClosure *flip_closure;
+   MetaGpuKms *gpu_kms;
++  MetaCrtc *crtc;
+ } MetaGpuKmsFlipClosureContainer;
+ 
+ struct _MetaGpuKms
+@@ -61,6 +63,8 @@ struct _MetaGpuKms
+   char *file_path;
+   GSource *source;
+ 
++  clockid_t clock_id;
++
+   drmModeConnector **connectors;
+   unsigned int n_connectors;
+ 
+@@ -166,18 +170,26 @@ meta_gpu_kms_apply_crtc_mode (MetaGpuKms *gpu_kms,
+ 
+ static void
+ invoke_flip_closure (GClosure   *flip_closure,
+-                     MetaGpuKms *gpu_kms)
++                     MetaGpuKms *gpu_kms,
++                     MetaCrtc   *crtc,
++                     int64_t     page_flip_time_ns)
+ {
+   GValue params[] = {
+     G_VALUE_INIT,
+-    G_VALUE_INIT
++    G_VALUE_INIT,
++    G_VALUE_INIT,
++    G_VALUE_INIT,
+   };
+ 
+   g_value_init (&params[0], G_TYPE_POINTER);
+   g_value_set_pointer (&params[0], flip_closure);
+   g_value_init (&params[1], G_TYPE_OBJECT);
+   g_value_set_object (&params[1], gpu_kms);
+-  g_closure_invoke (flip_closure, NULL, 2, params, NULL);
++  g_value_init (&params[2], G_TYPE_OBJECT);
++  g_value_set_object (&params[2], crtc);
++  g_value_init (&params[3], G_TYPE_INT64);
++  g_value_set_int64 (&params[3], page_flip_time_ns);
++  g_closure_invoke (flip_closure, NULL, 4, params, NULL);
+   g_closure_unref (flip_closure);
+ }
+ 
+@@ -217,6 +229,7 @@ meta_gpu_kms_is_crtc_active (MetaGpuKms *gpu_kms,
+ 
+ MetaGpuKmsFlipClosureContainer *
+ meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms,
++                                MetaCrtc   *crtc,
+                                 GClosure   *flip_closure)
+ {
+   MetaGpuKmsFlipClosureContainer *closure_container;
+@@ -224,7 +237,8 @@ meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms,
+   closure_container = g_new0 (MetaGpuKmsFlipClosureContainer, 1);
+   *closure_container = (MetaGpuKmsFlipClosureContainer) {
+     .flip_closure = flip_closure,
+-    .gpu_kms = gpu_kms
++    .gpu_kms = gpu_kms,
++    .crtc = crtc
+   };
+ 
+   return closure_container;
+@@ -264,6 +278,7 @@ meta_gpu_kms_flip_crtc (MetaGpuKms *gpu_kms,
+       int kms_fd = meta_gpu_kms_get_fd (gpu_kms);
+ 
+       closure_container = meta_gpu_kms_wrap_flip_closure (gpu_kms,
++                                                          crtc,
+                                                           flip_closure);
+ 
+       ret = drmModePageFlip (kms_fd,
+@@ -297,6 +312,23 @@ meta_gpu_kms_flip_crtc (MetaGpuKms *gpu_kms,
+   return TRUE;
+ }
+ 
++static int64_t
++timespec_to_nanoseconds (const struct timespec *ts)
++{
++  const int64_t one_billion = 1000000000;
++
++  return ((int64_t) ts->tv_sec) * one_billion + ts->tv_nsec;
++}
++
++static int64_t
++timeval_to_nanoseconds (const struct timeval *tv)
++{
++  int64_t usec = ((int64_t) tv->tv_sec) * G_USEC_PER_SEC + tv->tv_usec;
++  int64_t nsec = usec * 1000;
++
++  return nsec;
++}
++
+ static void
+ page_flip_handler (int           fd,
+                    unsigned int  frame,
+@@ -307,8 +339,12 @@ page_flip_handler (int           fd,
+   MetaGpuKmsFlipClosureContainer *closure_container = user_data;
+   GClosure *flip_closure = closure_container->flip_closure;
+   MetaGpuKms *gpu_kms = closure_container->gpu_kms;
++  struct timeval page_flip_time = {sec, usec};
+ 
+-  invoke_flip_closure (flip_closure, gpu_kms);
++  invoke_flip_closure (flip_closure,
++                       gpu_kms,
++                       closure_container->crtc,
++                       timeval_to_nanoseconds (&page_flip_time));
+   meta_gpu_kms_flip_closure_container_free (closure_container);
+ }
+ 
+@@ -381,6 +417,17 @@ meta_gpu_kms_get_file_path (MetaGpuKms *gpu_kms)
+   return gpu_kms->file_path;
+ }
+ 
++int64_t
++meta_gpu_kms_get_current_time_ns (MetaGpuKms *gpu_kms)
++{
++  struct timespec ts;
++
++  if (clock_gettime (gpu_kms->clock_id, &ts))
++    return 0;
++
++  return timespec_to_nanoseconds (&ts);
++}
++
+ void
+ meta_gpu_kms_set_power_save_mode (MetaGpuKms *gpu_kms,
+                                   uint64_t    state)
+@@ -680,6 +727,17 @@ init_crtcs (MetaGpuKms       *gpu_kms,
+   meta_gpu_take_crtcs (gpu, crtcs);
+ }
+ 
++static void
++init_frame_clock (MetaGpuKms *gpu_kms)
++{
++  uint64_t uses_monotonic;
++
++  if (drmGetCap (gpu_kms->fd, DRM_CAP_TIMESTAMP_MONOTONIC, &uses_monotonic) != 0)
++    uses_monotonic = 0;
++
++  gpu_kms->clock_id = uses_monotonic ? CLOCK_MONOTONIC : CLOCK_REALTIME;
++}
++
+ static void
+ init_outputs (MetaGpuKms       *gpu_kms,
+               MetaKmsResources *resources)
+@@ -809,6 +867,7 @@ meta_gpu_kms_read_current (MetaGpu  *gpu,
+   init_modes (gpu_kms, resources.resources);
+   init_crtcs (gpu_kms, &resources);
+   init_outputs (gpu_kms, &resources);
++  init_frame_clock (gpu_kms);
+ 
+   meta_kms_resources_release (&resources);
+ 
+diff --git a/src/backends/native/meta-gpu-kms.h b/src/backends/native/meta-gpu-kms.h
+index 01c3f2c0c..6e7a2e56c 100644
+--- a/src/backends/native/meta-gpu-kms.h
++++ b/src/backends/native/meta-gpu-kms.h
+@@ -81,6 +81,8 @@ int meta_gpu_kms_get_fd (MetaGpuKms *gpu_kms);
+ 
+ const char * meta_gpu_kms_get_file_path (MetaGpuKms *gpu_kms);
+ 
++int64_t meta_gpu_kms_get_current_time_ns (MetaGpuKms *gpu_kms);
++
+ void meta_gpu_kms_get_max_buffer_size (MetaGpuKms *gpu_kms,
+                                        int        *max_width,
+                                        int        *max_height);
+@@ -97,6 +99,7 @@ gboolean meta_drm_mode_equal (const drmModeModeInfo *one,
+ float meta_calculate_drm_mode_refresh_rate (const drmModeModeInfo *mode);
+ 
+ MetaGpuKmsFlipClosureContainer * meta_gpu_kms_wrap_flip_closure (MetaGpuKms *gpu_kms,
++                                                                 MetaCrtc   *crtc,
+                                                                  GClosure   *flip_closure);
+ 
+ void meta_gpu_kms_flip_closure_container_free (MetaGpuKmsFlipClosureContainer *closure_container);
+diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c
+index 470da8845..f6adb3fee 100644
+--- a/src/backends/native/meta-renderer-native.c
++++ b/src/backends/native/meta-renderer-native.c
+@@ -61,6 +61,7 @@
+ #include "backends/native/meta-monitor-manager-kms.h"
+ #include "backends/native/meta-renderer-native.h"
+ #include "backends/native/meta-renderer-native-gles3.h"
++#include "meta-marshal.h"
+ #include "cogl/cogl.h"
+ #include "core/boxes-private.h"
+ 
+@@ -1157,6 +1158,8 @@ meta_onscreen_native_swap_drm_fb (CoglOnscreen *onscreen)
+ static void
+ on_crtc_flipped (GClosure         *closure,
+                  MetaGpuKms       *gpu_kms,
++                 MetaCrtc         *crtc,
++                 int64_t           page_flip_time_ns,
+                  MetaRendererView *view)
+ {
+   ClutterStageView *stage_view = CLUTTER_STAGE_VIEW (view);
+@@ -1167,6 +1170,24 @@ on_crtc_flipped (GClosure         *closure,
+   MetaOnscreenNative *onscreen_native = onscreen_egl->platform;
+   MetaRendererNative *renderer_native = onscreen_native->renderer_native;
+   MetaGpuKms *render_gpu = onscreen_native->render_gpu;
++  CoglFrameInfo *frame_info;
++  float refresh_rate;
++
++  frame_info = g_queue_peek_tail (&onscreen->pending_frame_infos);
++  refresh_rate = crtc && crtc->current_mode ?
++                 crtc->current_mode->refresh_rate :
++                 0.0f;
++
++  /* Only keep the frame info for the fastest CRTC in use, which may not be
++   * the first one to complete a flip. By only telling the compositor about the
++   * fastest monitor(s) we direct it to produce new frames fast enough to
++   * satisfy all monitors.
++   */
++  if (refresh_rate >= frame_info->refresh_rate)
++    {
++      frame_info->presentation_time = page_flip_time_ns;
++      frame_info->refresh_rate = refresh_rate;
++    }
+ 
+   if (gpu_kms != render_gpu)
+     {
+@@ -1297,7 +1318,9 @@ flip_egl_stream (MetaOnscreenNative *onscreen_native,
+     return FALSE;
+ 
+   closure_container =
+-    meta_gpu_kms_wrap_flip_closure (onscreen_native->render_gpu, flip_closure);
++    meta_gpu_kms_wrap_flip_closure (onscreen_native->render_gpu,
++                                    NULL,
++                                    flip_closure);
+ 
+   acquire_attribs = (EGLAttrib[]) {
+     EGL_DRM_FLIP_EVENT_DATA_NV,
+@@ -1540,7 +1563,7 @@ meta_onscreen_native_flip_crtcs (CoglOnscreen *onscreen)
+   flip_closure = g_cclosure_new (G_CALLBACK (on_crtc_flipped),
+                                  g_object_ref (view),
+                                  (GClosureNotify) flip_closure_destroyed);
+-  g_closure_set_marshal (flip_closure, g_cclosure_marshal_VOID__OBJECT);
++  g_closure_set_marshal (flip_closure, meta_marshal_VOID__OBJECT_OBJECT_INT64);
+ 
+   /* Either flip the CRTC's of the monitor info, if we are drawing just part
+    * of the stage, or all of the CRTC's if we are drawing the whole stage.
+@@ -2673,6 +2696,15 @@ meta_renderer_native_create_offscreen (MetaRendererNative    *renderer,
+   return fb;
+ }
+ 
++static int64_t
++meta_renderer_native_get_clock_time (CoglContext *context)
++{
++  CoglRenderer *cogl_renderer = cogl_context_get_renderer (context);
++  MetaGpuKms *gpu_kms = cogl_renderer->custom_winsys_user_data;
++
++  return meta_gpu_kms_get_current_time_ns (gpu_kms);
++}
++
+ static const CoglWinsysVtable *
+ get_native_cogl_winsys_vtable (CoglRenderer *cogl_renderer)
+ {
+@@ -2701,6 +2733,8 @@ get_native_cogl_winsys_vtable (CoglRenderer *cogl_renderer)
+       vtable.onscreen_swap_buffers_with_damage =
+         meta_onscreen_native_swap_buffers_with_damage;
+ 
++      vtable.context_get_clock_time = meta_renderer_native_get_clock_time;
++
+       vtable_inited = TRUE;
+     }
+ 
+diff --git a/src/meta-marshal.list b/src/meta-marshal.list
+new file mode 100644
+index 000000000..c1f4781d2
+--- /dev/null
++++ b/src/meta-marshal.list
+@@ -0,0 +1 @@
++VOID:OBJECT,OBJECT,INT64
+-- 
+2.20.1
+
diff --git a/debian/patches/lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch b/debian/patches/lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch
 new file mode 100644
index 0000000..a80b993
--- /dev/null
+++ b/debian/patches/lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch
@@ -0,0 +1,49 @@
+Description: renderer-native: Advertise _FEATURE_SWAP_THROTTLE
+ Because it is implemented and always on. By advertising this fact
+ the master clock is able to sync to the native refresh rate instead
+ of always using the fallback of 60.00Hz.
+ .
+ Patch 2 of 2
+Author: Daniel van Vugt <[e-mail]>
+Origin: https://gitlab.gnome.org/GNOME/mutter/merge_requests/171 via backport branch https://gitlab.gnome.org/vanvugt/mutter/commits/add-vsync-3.28
+Bug: https://bugzilla.gnome.org/show_bug.cgi?id=781296
+Bug-Ubuntu: https://bugs.launchpad.net/bugs/1763892
+Forwarded: yes
+Last-Update: 2019-03-13
+
+diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c
+index f6adb3fee..fa2e9b7d3 100644
+--- a/src/backends/native/meta-renderer-native.c
++++ b/src/backends/native/meta-renderer-native.c
+@@ -1997,6 +1997,13 @@ meta_renderer_native_init_egl_context (CoglContext *cogl_context,
+                   COGL_WINSYS_FEATURE_MULTIPLE_ONSCREEN,
+                   TRUE);
+ 
++  /* COGL_WINSYS_FEATURE_SWAP_THROTTLE is always true for this renderer
++   * because we have the call to wait_for_pending_flips on every frame.
++   */
++  COGL_FLAGS_SET (cogl_context->winsys_features,
++                  COGL_WINSYS_FEATURE_SWAP_THROTTLE,
++                  TRUE);
++
+ #ifdef HAVE_EGL_DEVICE
+   if (renderer_gpu_data->mode == META_RENDERER_NATIVE_MODE_EGL_DEVICE)
+     COGL_FLAGS_SET (cogl_context->features,
+@@ -2625,8 +2632,12 @@ meta_renderer_native_create_onscreen (MetaRendererNative   *renderer_native,
+     }
+ 
+   onscreen = cogl_onscreen_new (context, width, height);
+-  cogl_onscreen_set_swap_throttled (onscreen,
+-                                    _clutter_get_sync_to_vblank ());
++
++  /* We have wait_for_pending_flips hardcoded, so throttling always. */
++  cogl_onscreen_set_swap_throttled (onscreen, TRUE);
++  if (!_clutter_get_sync_to_vblank ())
++    g_warning ("Request to disable sync-to-vblank is being ignored. "
++               "MetaRendererNative does not support disabling it.");
+ 
+   if (!cogl_framebuffer_allocate (COGL_FRAMEBUFFER (onscreen), error))
+     {
+-- 
+2.20.1
+
diff --git a/debian/patches/series b/debian/patches/series
index 198db5a..5d87807 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1,8 +1,9 @@
 theme-use-gtk_render_icon_suface-to-paint-button-icon.patch
 theme-load-icons-as-Gtk-does-with-fallback-and-RTL-suppor.patch
-clutter-Smooth-out-master-clock-to-smooth-visuals.patch
 clutter-Fix-offscreen-effect-painting-of-clones.patch
 bgo768531_workaround-startup-notifications.patch
+lp1763892-a-renderer-native-Add-hardware-presentation-timing.patch
+lp1763892-b-renderer-native-Advertise-_FEATURE_SWAP_THROTTLE.patch
 debian/synaptics-support.patch
 debian/skip-failing-tests.patch
 debian/skip-failing-tests-325.patch