Daniel van Vugt has proposed merging ~vanvugt/ubuntu/+source/mutter:fix-lp1763892-bionic into ~ubuntu-desktop/ubuntu/+source/mutter:ubuntu/bionic.
Commit message: 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 Requested reviews: Ubuntu Desktop (ubuntu-desktop) Related bugs: Bug #1763892 in mutter (Ubuntu): "144Hz/120Hz monitor but mutter seems to cap rendering at 60FPS" https://bugs.launchpad.net/ubuntu/+source/mutter/+bug/1763892 For more details, see: https://code.launchpad.net/~vanvugt/ubuntu/+source/mutter/+git/mutter/+merge/364362 -- Your team Ubuntu Desktop is requested to review the proposed merge of ~vanvugt/ubuntu/+source/mutter:fix-lp1763892-bionic into ~ubuntu-desktop/ubuntu/+source/mutter:ubuntu/bionic.
diff --git a/debian/changelog b/debian/changelog index 9044a2f..15cbb38 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,3 +1,12 @@ +mutter (3.28.3+git20190124-0ubuntu18.04.2) 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 <daniel.van.v...@canonical.com> Wed, 13 Mar 2019 15:34:01 +0800 + mutter (3.28.3+git20190124-0ubuntu18.04.1) bionic; urgency=medium * New upstream git snapshot based on 3.28.3 plus commits up to 4af8d9d47 diff --git a/debian/libmutter-2-0.symbols b/debian/libmutter-2-0.symbols index 1489074..d64bcdb 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.2 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 <daniel.van.v...@canonical.com> -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 <daniel.van.v...@canonical.com> +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 (¶ms[0], G_TYPE_POINTER); + g_value_set_pointer (¶ms[0], flip_closure); + g_value_init (¶ms[1], G_TYPE_OBJECT); + g_value_set_object (¶ms[1], gpu_kms); +- g_closure_invoke (flip_closure, NULL, 2, params, NULL); ++ g_value_init (¶ms[2], G_TYPE_OBJECT); ++ g_value_set_object (¶ms[2], crtc); ++ g_value_init (¶ms[3], G_TYPE_INT64); ++ g_value_set_int64 (¶ms[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 <daniel.van.v...@canonical.com> +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
-- ubuntu-desktop mailing list ubuntu-desktop@lists.ubuntu.com https://lists.ubuntu.com/mailman/listinfo/ubuntu-desktop
