[arch-commits] Commit in mutter/trunk (216.patch 318.patch PKGBUILD)

Jan Steffens heftig at archlinux.org
Thu Jan 3 16:46:45 UTC 2019


    Date: Thursday, January 3, 2019 @ 16:46:45
  Author: heftig
Revision: 342905

3.30.2-2: Support Wayland with more than 60Hz

Added:
  mutter/trunk/216.patch
  mutter/trunk/318.patch
Modified:
  mutter/trunk/PKGBUILD

-----------+
 216.patch |  125 +++++++++++++++++
 318.patch |  420 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 PKGBUILD  |   13 +
 3 files changed, 554 insertions(+), 4 deletions(-)

Added: 216.patch
===================================================================
--- 216.patch	                        (rev 0)
+++ 216.patch	2019-01-03 16:46:45 UTC (rev 342905)
@@ -0,0 +1,125 @@
+From ab03f010df7b78854433093030f08a81c059aa26 Mon Sep 17 00:00:00 2001
+From: Daniel van Vugt <daniel.van.vugt at canonical.com>
+Date: Mon, 23 Jul 2018 16:28:56 +0800
+Subject: [PATCH] cogl-winsys-glx: Fix frame notification race/leak
+
+If a second `set_{sync,complete}_pending` was queued before the idle
+handler had flushed the first then one of them would be forgotten.
+It would stay queued forever and never emitted as a notification.
+
+This could happen repeatedly causing a slow leak. But worse still,
+clutter-stage-cogl would then have pending_swaps permanently stuck above
+zero preventing the presentation timing logic from being used.
+
+The problem was that CoglBool can only count to one pending notification,
+so we just change that to an integer and count properly.
+---
+ cogl/cogl/winsys/cogl-winsys-glx.c | 58 +++++++++++++++---------------
+ 1 file changed, 29 insertions(+), 29 deletions(-)
+
+diff --git a/cogl/cogl/winsys/cogl-winsys-glx.c b/cogl/cogl/winsys/cogl-winsys-glx.c
+index 012c712bd..2cf6e95fc 100644
+--- a/cogl/cogl/winsys/cogl-winsys-glx.c
++++ b/cogl/cogl/winsys/cogl-winsys-glx.c
+@@ -99,9 +99,9 @@ typedef struct _CoglOnscreenGLX
+   CoglOnscreenXlib _parent;
+   GLXDrawable glxwin;
+   uint32_t last_swap_vsync_counter;
+-  CoglBool pending_sync_notify;
+-  CoglBool pending_complete_notify;
+-  CoglBool pending_resize_notify;
++  uint32_t pending_sync_notify;
++  uint32_t pending_complete_notify;
++  uint32_t pending_resize_notify;
+ 
+   GThread *swap_wait_thread;
+   GQueue *swap_wait_queue;
+@@ -347,35 +347,35 @@ flush_pending_notifications_cb (void *data,
+     {
+       CoglOnscreen *onscreen = COGL_ONSCREEN (framebuffer);
+       CoglOnscreenGLX *glx_onscreen = onscreen->winsys;
+-      CoglBool pending_sync_notify = glx_onscreen->pending_sync_notify;
+-      CoglBool pending_complete_notify = glx_onscreen->pending_complete_notify;
+ 
+-      /* If swap_region is called then notifying the sync event could
+-       * potentially immediately queue a subsequent pending notify so
+-       * we need to clear the flag before invoking the callback */
+-      glx_onscreen->pending_sync_notify = FALSE;
+-      glx_onscreen->pending_complete_notify = FALSE;
+-
+-      if (pending_sync_notify)
++      while (glx_onscreen->pending_sync_notify > 0 ||
++             glx_onscreen->pending_complete_notify > 0 ||
++             glx_onscreen->pending_resize_notify > 0)
+         {
+-          CoglFrameInfo *info = g_queue_peek_head (&onscreen->pending_frame_infos);
+-
+-          _cogl_onscreen_notify_frame_sync (onscreen, info);
+-        }
++          if (glx_onscreen->pending_sync_notify > 0)
++            {
++              CoglFrameInfo *info =
++                g_queue_peek_head (&onscreen->pending_frame_infos);
+ 
+-      if (pending_complete_notify)
+-        {
+-          CoglFrameInfo *info = g_queue_pop_head (&onscreen->pending_frame_infos);
++              _cogl_onscreen_notify_frame_sync (onscreen, info);
++              glx_onscreen->pending_sync_notify--;
++            }
+ 
+-          _cogl_onscreen_notify_complete (onscreen, info);
++          if (glx_onscreen->pending_complete_notify > 0)
++            {
++              CoglFrameInfo *info =
++                g_queue_pop_head (&onscreen->pending_frame_infos);
+ 
+-          cogl_object_unref (info);
+-        }
++              _cogl_onscreen_notify_complete (onscreen, info);
++              cogl_object_unref (info);
++              glx_onscreen->pending_complete_notify--;
++            }
+ 
+-      if (glx_onscreen->pending_resize_notify)
+-        {
+-          _cogl_onscreen_notify_resize (onscreen);
+-          glx_onscreen->pending_resize_notify = FALSE;
++          if (glx_onscreen->pending_resize_notify > 0)
++            {
++              _cogl_onscreen_notify_resize (onscreen);
++              glx_onscreen->pending_resize_notify--;
++            }
+         }
+     }
+ }
+@@ -417,7 +417,7 @@ set_sync_pending (CoglOnscreen *onscreen)
+                                       NULL);
+     }
+ 
+-  glx_onscreen->pending_sync_notify = TRUE;
++  glx_onscreen->pending_sync_notify++;
+ }
+ 
+ static void
+@@ -440,7 +440,7 @@ set_complete_pending (CoglOnscreen *onscreen)
+                                       NULL);
+     }
+ 
+-  glx_onscreen->pending_complete_notify = TRUE;
++  glx_onscreen->pending_complete_notify++;
+ }
+ 
+ static void
+@@ -533,7 +533,7 @@ notify_resize (CoglContext *context,
+                                       NULL);
+     }
+ 
+-  glx_onscreen->pending_resize_notify = TRUE;
++  glx_onscreen->pending_resize_notify++;
+ 
+   if (!xlib_onscreen->is_foreign_xwin)
+     {
+-- 
+2.18.1
+

Added: 318.patch
===================================================================
--- 318.patch	                        (rev 0)
+++ 318.patch	2019-01-03 16:46:45 UTC (rev 342905)
@@ -0,0 +1,420 @@
+From d20697ff5972b363679597372d1a98ff3074085c Mon Sep 17 00:00:00 2001
+From: Daniel van Vugt <daniel.van.vugt at canonical.com>
+Date: Wed, 27 Jun 2018 17:19:27 +0800
+Subject: [PATCH 1/2] 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).
+Note however that we also need !73 to land in order to fully realize
+multiple monitors running at full speed.
+---
+ src/Makefile.am                            | 25 +++++++-
+ src/backends/native/meta-gpu-kms.c         | 69 ++++++++++++++++++++--
+ src/backends/native/meta-gpu-kms.h         |  3 +
+ src/backends/native/meta-renderer-native.c | 38 +++++++++++-
+ src/meta-marshal.list                      |  1 +
+ 5 files changed, 128 insertions(+), 8 deletions(-)
+ create mode 100644 src/meta-marshal.list
+
+diff --git a/src/Makefile.am b/src/Makefile.am
+index 811e2b86b..56d539836 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
+@@ -677,6 +679,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	\
+@@ -690,7 +693,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
+@@ -786,3 +792,20 @@ endef
+ 	$(AM_V_GEN)$(WAYLAND_SCANNER) server-header $< $@
+ %-server-protocol.h : $(WAYLAND_EGLSTREAM_DATADIR)/%.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 c3c5d0d68..26c759031 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;
+ 
+@@ -165,18 +169,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);
+ }
+ 
+@@ -216,6 +228,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;
+@@ -223,7 +236,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;
+@@ -263,6 +277,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,
+@@ -296,6 +311,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,
+@@ -306,8 +338,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);
+ }
+ 
+@@ -380,6 +416,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)
+@@ -679,6 +726,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)
+@@ -806,6 +864,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 5f77f191a..3e3f45c7e 100644
+--- a/src/backends/native/meta-gpu-kms.h
++++ b/src/backends/native/meta-gpu-kms.h
+@@ -73,6 +73,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);
+@@ -89,6 +91,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 f58e6b3e0..b192c3641 100644
+--- a/src/backends/native/meta-renderer-native.c
++++ b/src/backends/native/meta-renderer-native.c
+@@ -62,6 +62,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"
+ 
+@@ -1159,6 +1160,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);
+@@ -1169,6 +1172,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)
+     {
+@@ -1299,7 +1320,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,
+@@ -1542,7 +1565,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.
+@@ -2687,6 +2710,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)
+ {
+@@ -2715,6 +2747,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.18.1
+
+
+From 1b3109809167c17bfa8713ce906c95e66d2c042f Mon Sep 17 00:00:00 2001
+From: Daniel van Vugt <daniel.van.vugt at canonical.com>
+Date: Tue, 10 Jul 2018 17:46:02 +0800
+Subject: [PATCH 2/2] 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.
+
+https://bugzilla.gnome.org/show_bug.cgi?id=781296
+---
+ src/backends/native/meta-renderer-native.c | 15 +++++++++++++--
+ 1 file changed, 13 insertions(+), 2 deletions(-)
+
+diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c
+index b192c3641..929e9ca90 100644
+--- a/src/backends/native/meta-renderer-native.c
++++ b/src/backends/native/meta-renderer-native.c
+@@ -2005,6 +2005,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,
+@@ -2639,8 +2646,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.18.1
+

Modified: PKGBUILD
===================================================================
--- PKGBUILD	2019-01-03 15:47:27 UTC (rev 342904)
+++ PKGBUILD	2019-01-03 16:46:45 UTC (rev 342905)
@@ -4,7 +4,7 @@
 
 pkgname=mutter
 pkgver=3.30.2
-pkgrel=1
+pkgrel=2
 pkgdesc="A window manager for GNOME"
 url="https://gitlab.gnome.org/GNOME/mutter"
 arch=(x86_64)
@@ -16,10 +16,11 @@
 groups=(gnome)
 _commit=bcd6103c44ff74ebffd1737b8e0f3a952b83bd54  # tags/3.30.2^0
 source=("git+https://gitlab.gnome.org/GNOME/mutter.git#commit=$_commit"
-        https://gitlab.gnome.org/vanvugt/mutter/commit/fc02b040f3b750b0513f812813351c09795950f6.patch
+        216.patch 318.patch
         startup-notification.patch)
 sha256sums=('SKIP'
-            'dffa2ca19281b9fa5a81bf80bd46a8eae78325c7e1f8b2a25c33945aa7cc0903'
+            '1ae59343f3f5838babdfe1400962bb315d8b49189deb05bb516966b922cd26a5'
+            'd4dcffa9c407e60e321670caaa44dcd6e2bfda7221d73ec4145a985c825a43b3'
             '00d5e77c94e83e1987cc443ed7c47303aa33367ce912b2f665bcd34f88890a17')
 
 pkgver() {
@@ -31,8 +32,12 @@
   cd $pkgname
 
   # https://gitlab.gnome.org/GNOME/mutter/merge_requests/216
-  git apply -3 ../fc02b040f3b750b0513f812813351c09795950f6.patch
+  git apply -3 ../216.patch
 
+  # https://gitlab.gnome.org/GNOME/mutter/merge_requests/318
+  git apply -3 ../318.patch
+
+  # https://bugzilla.gnome.org/show_bug.cgi?id=768531
   # https://bugs.archlinux.org/task/51940
   # As of 2018-05-08: Still needed, according to fmuellner
   git apply -3 ../startup-notification.patch


More information about the arch-commits mailing list