2022-04-13 08:38:52 +00:00
|
|
|
Author: Daniel van Vugt <daniel.van.vugt@canonical.com>
|
2022-10-27 14:41:22 +00:00
|
|
|
Source: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/1441
|
2023-02-22 06:16:16 +00:00
|
|
|
Editor: Mingi Sung <fiestalake@disroot.org>
|
|
|
|
Commit: a6f23c151c94912c8fc074facd07b0d6aa70f939
|
|
|
|
Last Updated: 2/22/23 (Mutter 43.3-1)
|
2022-04-02 05:32:56 +00:00
|
|
|
---
|
|
|
|
|
|
|
|
Use triple buffering if and when the previous frame is running late.
|
|
|
|
This means the next frame will be dispatched on time instead of also starting
|
|
|
|
late.
|
|
|
|
|
|
|
|
It also triggers a GPU clock boost if deemed necessary by the driver.
|
|
|
|
Although frequency scaling is not required to get a performance gain here
|
|
|
|
because even a fixed frequency GPU will benefit from not over-sleeping anymore.
|
|
|
|
If the previous frame is not running late then we stick to double buffering so
|
|
|
|
there's no latency penalty when the system is able to maintain full frame rate.
|
|
|
|
|
|
|
|
---
|
2021-11-12 08:43:54 +00:00
|
|
|
diff --git a/clutter/clutter/clutter-frame-clock.c b/clutter/clutter/clutter-frame-clock.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index 4d441c364b2f86d601a53a3dc1c46f5a5cd4092d..ee05b36de0973b8cbe99362eb1b76a6f49a8e453 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/clutter/clutter/clutter-frame-clock.c
|
|
|
|
+++ b/clutter/clutter/clutter-frame-clock.c
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -45,6 +45,8 @@ typedef struct _EstimateQueue
|
|
|
|
int next_index;
|
|
|
|
} EstimateQueue;
|
|
|
|
|
|
|
|
+static gboolean triple_buffering_disabled = FALSE;
|
|
|
|
+
|
|
|
|
#define SYNC_DELAY_FALLBACK_FRACTION 0.875
|
|
|
|
|
|
|
|
typedef struct _ClutterFrameListener
|
|
|
|
@@ -65,8 +67,9 @@ typedef enum _ClutterFrameClockState
|
2021-11-12 08:43:54 +00:00
|
|
|
CLUTTER_FRAME_CLOCK_STATE_INIT,
|
|
|
|
CLUTTER_FRAME_CLOCK_STATE_IDLE,
|
|
|
|
CLUTTER_FRAME_CLOCK_STATE_SCHEDULED,
|
|
|
|
- CLUTTER_FRAME_CLOCK_STATE_DISPATCHING,
|
|
|
|
- CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED,
|
|
|
|
+ CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE,
|
|
|
|
+ CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED,
|
|
|
|
+ CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO,
|
|
|
|
} ClutterFrameClockState;
|
|
|
|
|
|
|
|
struct _ClutterFrameClock
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -96,6 +99,8 @@ struct _ClutterFrameClock
|
2021-11-12 08:43:54 +00:00
|
|
|
/* Last KMS buffer submission time. */
|
|
|
|
int64_t last_flip_time_us;
|
|
|
|
|
|
|
|
+ ClutterFrameHint last_flip_hints;
|
|
|
|
+
|
|
|
|
/* Last few durations between dispatch start and buffer swap. */
|
|
|
|
EstimateQueue dispatch_to_swap_us;
|
|
|
|
/* Last few durations between buffer swap and GPU rendering finish. */
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -228,6 +233,12 @@ void
|
2022-04-02 05:32:56 +00:00
|
|
|
clutter_frame_clock_notify_presented (ClutterFrameClock *frame_clock,
|
|
|
|
ClutterFrameInfo *frame_info)
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
+#ifdef CLUTTER_ENABLE_DEBUG
|
2022-04-02 05:32:56 +00:00
|
|
|
+ const char *debug_state =
|
|
|
|
+ frame_clock->state == CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO ?
|
|
|
|
+ "Triple buffering" : "Double buffering";
|
2022-10-27 14:41:22 +00:00
|
|
|
+#endif
|
2022-04-02 05:32:56 +00:00
|
|
|
+
|
|
|
|
COGL_TRACE_BEGIN_SCOPED (ClutterFrameClockNotifyPresented,
|
|
|
|
"Frame Clock (presented)");
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -290,7 +301,8 @@ clutter_frame_clock_notify_presented (ClutterFrameClock *frame_clock,
|
2022-04-02 05:32:56 +00:00
|
|
|
frame_info->cpu_time_before_buffer_swap_us;
|
|
|
|
|
|
|
|
CLUTTER_NOTE (FRAME_TIMINGS,
|
|
|
|
- "dispatch2swap %ld µs, swap2render %ld µs, swap2flip %ld µs",
|
|
|
|
+ "%s: dispatch2swap %ld µs, swap2render %ld µs, swap2flip %ld µs",
|
|
|
|
+ debug_state,
|
|
|
|
dispatch_to_swap_us,
|
|
|
|
swap_to_rendering_done_us,
|
|
|
|
swap_to_flip_us);
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -304,6 +316,10 @@ clutter_frame_clock_notify_presented (ClutterFrameClock *frame_clock,
|
2022-04-02 05:32:56 +00:00
|
|
|
|
|
|
|
frame_clock->got_measurements_last_frame = TRUE;
|
|
|
|
}
|
|
|
|
+ else
|
|
|
|
+ {
|
|
|
|
+ CLUTTER_NOTE (FRAME_TIMINGS, "%s", debug_state);
|
|
|
|
+ }
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
if (frame_info->refresh_rate > 1.0)
|
2022-04-02 05:32:56 +00:00
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -318,11 +334,18 @@ clutter_frame_clock_notify_presented (ClutterFrameClock *frame_clock,
|
2021-11-12 08:43:54 +00:00
|
|
|
case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
g_warn_if_reached ();
|
|
|
|
break;
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
|
|
|
frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_IDLE;
|
2022-04-02 05:32:56 +00:00
|
|
|
maybe_reschedule_update (frame_clock);
|
|
|
|
break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
|
|
|
|
+ maybe_reschedule_update (frame_clock);
|
2021-11-12 08:43:54 +00:00
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE;
|
2022-04-02 05:32:56 +00:00
|
|
|
+ maybe_reschedule_update (frame_clock);
|
|
|
|
+ break;
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
2022-04-02 05:32:56 +00:00
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -338,11 +361,18 @@ clutter_frame_clock_notify_ready (ClutterFrameClock *frame_clock)
|
2021-11-12 08:43:54 +00:00
|
|
|
case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
g_warn_if_reached ();
|
|
|
|
break;
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
|
|
|
frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_IDLE;
|
|
|
|
maybe_reschedule_update (frame_clock);
|
|
|
|
break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
|
|
|
|
+ maybe_reschedule_update (frame_clock);
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE;
|
|
|
|
+ maybe_reschedule_update (frame_clock);
|
|
|
|
+ break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -354,6 +384,7 @@ clutter_frame_clock_compute_max_render_time_us (ClutterFrameClock *frame_clock)
|
2022-04-02 05:32:56 +00:00
|
|
|
int64_t max_swap_to_rendering_done_us = 0;
|
|
|
|
int64_t max_swap_to_flip_us = 0;
|
|
|
|
int64_t max_render_time_us;
|
|
|
|
+ int buffer_queue_latency_frames = 0;
|
|
|
|
int i;
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
refresh_interval_us = frame_clock->refresh_interval_us;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -376,6 +407,27 @@ clutter_frame_clock_compute_max_render_time_us (ClutterFrameClock *frame_clock)
|
2022-04-02 05:32:56 +00:00
|
|
|
frame_clock->swap_to_flip_us.values[i]);
|
|
|
|
}
|
2021-11-12 08:43:54 +00:00
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
+ switch (frame_clock->state)
|
|
|
|
+ {
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_INIT:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_IDLE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
+ buffer_queue_latency_frames = 0;
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
+ buffer_queue_latency_frames = 1;
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
+ g_warn_if_reached ();
|
|
|
|
+ buffer_queue_latency_frames = 2;
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ max_swap_to_flip_us -= refresh_interval_us * buffer_queue_latency_frames;
|
|
|
|
+ if (max_swap_to_flip_us < 0)
|
|
|
|
+ max_swap_to_flip_us = 0;
|
|
|
|
+
|
|
|
|
/* Max render time shows how early the frame clock needs to be dispatched
|
|
|
|
* to make it to the predicted next presentation time. It is composed of:
|
|
|
|
* - An estimate of duration from dispatch start to buffer swap.
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -392,8 +444,6 @@ clutter_frame_clock_compute_max_render_time_us (ClutterFrameClock *frame_clock)
|
2022-04-02 05:32:56 +00:00
|
|
|
frame_clock->vblank_duration_us +
|
|
|
|
clutter_max_render_time_constant_us;
|
|
|
|
|
|
|
|
- max_render_time_us = CLAMP (max_render_time_us, 0, refresh_interval_us);
|
|
|
|
-
|
|
|
|
return max_render_time_us;
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -563,8 +613,12 @@ clutter_frame_clock_inhibit (ClutterFrameClock *frame_clock)
|
2021-11-12 08:43:54 +00:00
|
|
|
frame_clock->pending_reschedule = TRUE;
|
|
|
|
frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_IDLE;
|
|
|
|
break;
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
+ frame_clock->pending_reschedule = TRUE;
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE;
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -600,11 +654,17 @@ clutter_frame_clock_schedule_update_now (ClutterFrameClock *frame_clock)
|
2021-11-12 08:43:54 +00:00
|
|
|
case CLUTTER_FRAME_CLOCK_STATE_INIT:
|
|
|
|
case CLUTTER_FRAME_CLOCK_STATE_IDLE:
|
|
|
|
next_update_time_us = g_get_monotonic_time ();
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
|
|
|
|
break;
|
|
|
|
case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
return;
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
|
|
|
+ next_update_time_us = g_get_monotonic_time ();
|
|
|
|
+ frame_clock->state =
|
|
|
|
+ CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED;
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
frame_clock->pending_reschedule = TRUE;
|
|
|
|
frame_clock->pending_reschedule_now = TRUE;
|
|
|
|
return;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -613,7 +673,6 @@ clutter_frame_clock_schedule_update_now (ClutterFrameClock *frame_clock)
|
2021-11-12 08:43:54 +00:00
|
|
|
g_warn_if_fail (next_update_time_us != -1);
|
|
|
|
|
|
|
|
g_source_set_ready_time (frame_clock->source, next_update_time_us);
|
|
|
|
- frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
|
|
|
|
frame_clock->is_next_presentation_time_valid = FALSE;
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -632,6 +691,7 @@ clutter_frame_clock_schedule_update (ClutterFrameClock *frame_clock)
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
|
|
|
case CLUTTER_FRAME_CLOCK_STATE_INIT:
|
|
|
|
next_update_time_us = g_get_monotonic_time ();
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
|
|
|
|
break;
|
|
|
|
case CLUTTER_FRAME_CLOCK_STATE_IDLE:
|
|
|
|
calculate_next_update_time_us (frame_clock,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -639,11 +699,28 @@ clutter_frame_clock_schedule_update (ClutterFrameClock *frame_clock)
|
2021-11-12 08:43:54 +00:00
|
|
|
&frame_clock->next_presentation_time_us);
|
|
|
|
frame_clock->is_next_presentation_time_valid =
|
|
|
|
(frame_clock->next_presentation_time_us != 0);
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
|
|
|
|
break;
|
|
|
|
case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
return;
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
2022-04-02 05:32:56 +00:00
|
|
|
+ if (frame_clock->last_flip_hints & CLUTTER_FRAME_HINT_DIRECT_SCANOUT_ATTEMPTED ||
|
|
|
|
+ triple_buffering_disabled)
|
2021-11-12 08:43:54 +00:00
|
|
|
+ {
|
|
|
|
+ /* Force double buffering, disable triple buffering */
|
|
|
|
+ frame_clock->pending_reschedule = TRUE;
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ calculate_next_update_time_us (frame_clock,
|
|
|
|
+ &next_update_time_us,
|
|
|
|
+ &frame_clock->next_presentation_time_us);
|
|
|
|
+ frame_clock->is_next_presentation_time_valid =
|
|
|
|
+ (frame_clock->next_presentation_time_us != 0);
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED;
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
frame_clock->pending_reschedule = TRUE;
|
|
|
|
return;
|
|
|
|
}
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -651,7 +728,6 @@ clutter_frame_clock_schedule_update (ClutterFrameClock *frame_clock)
|
2021-11-12 08:43:54 +00:00
|
|
|
g_warn_if_fail (next_update_time_us != -1);
|
|
|
|
|
|
|
|
g_source_set_ready_time (frame_clock->source, next_update_time_us);
|
|
|
|
- frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -677,7 +753,7 @@ clutter_frame_clock_dispatch (ClutterFrameClock *frame_clock,
|
2021-11-12 08:43:54 +00:00
|
|
|
frame_clock->refresh_interval_us;
|
|
|
|
|
|
|
|
lateness_us = time_us - ideal_dispatch_time_us;
|
|
|
|
- if (lateness_us < 0 || lateness_us >= frame_clock->refresh_interval_us)
|
|
|
|
+ if (lateness_us < 0 || lateness_us >= frame_clock->refresh_interval_us / 4)
|
|
|
|
frame_clock->last_dispatch_lateness_us = 0;
|
|
|
|
else
|
|
|
|
frame_clock->last_dispatch_lateness_us = lateness_us;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -685,7 +761,21 @@ clutter_frame_clock_dispatch (ClutterFrameClock *frame_clock,
|
2021-11-12 08:43:54 +00:00
|
|
|
frame_clock->last_dispatch_time_us = time_us;
|
|
|
|
g_source_set_ready_time (frame_clock->source, -1);
|
|
|
|
|
|
|
|
- frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHING;
|
|
|
|
+ switch (frame_clock->state)
|
|
|
|
+ {
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_INIT:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_IDLE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
+ g_warn_if_reached ();
|
|
|
|
+ return;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE;
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO;
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
|
|
|
|
frame_count = frame_clock->frame_count++;
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -710,25 +800,31 @@ clutter_frame_clock_dispatch (ClutterFrameClock *frame_clock,
|
2021-11-12 08:43:54 +00:00
|
|
|
frame_clock->listener.user_data);
|
|
|
|
COGL_TRACE_END (ClutterFrameClockFrame);
|
|
|
|
|
|
|
|
- switch (frame_clock->state)
|
|
|
|
+ switch (result)
|
|
|
|
{
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_INIT:
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED:
|
|
|
|
- g_warn_if_reached ();
|
|
|
|
+ case CLUTTER_FRAME_RESULT_PENDING_PRESENTED:
|
|
|
|
break;
|
2022-04-02 05:32:56 +00:00
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_IDLE:
|
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
- break;
|
2021-11-12 08:43:54 +00:00
|
|
|
- case CLUTTER_FRAME_CLOCK_STATE_DISPATCHING:
|
|
|
|
- switch (result)
|
|
|
|
+ case CLUTTER_FRAME_RESULT_IDLE:
|
|
|
|
+ /* The frame was aborted; nothing to paint/present */
|
|
|
|
+ switch (frame_clock->state)
|
|
|
|
{
|
|
|
|
- case CLUTTER_FRAME_RESULT_PENDING_PRESENTED:
|
|
|
|
- frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_PENDING_PRESENTED;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_INIT:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_IDLE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
+ g_warn_if_reached ();
|
|
|
|
break;
|
|
|
|
- case CLUTTER_FRAME_RESULT_IDLE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
|
|
|
frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_IDLE;
|
|
|
|
maybe_reschedule_update (frame_clock);
|
|
|
|
break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_SCHEDULED;
|
|
|
|
+ maybe_reschedule_update (frame_clock);
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
+ frame_clock->state = CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE;
|
|
|
|
+ maybe_reschedule_update (frame_clock);
|
|
|
|
+ break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -761,10 +857,12 @@ frame_clock_source_dispatch (GSource *source,
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
-clutter_frame_clock_record_flip_time (ClutterFrameClock *frame_clock,
|
|
|
|
- int64_t flip_time_us)
|
|
|
|
+clutter_frame_clock_record_flip (ClutterFrameClock *frame_clock,
|
|
|
|
+ int64_t flip_time_us,
|
|
|
|
+ ClutterFrameHint hints)
|
|
|
|
{
|
|
|
|
frame_clock->last_flip_time_us = flip_time_us;
|
|
|
|
+ frame_clock->last_flip_hints = hints;
|
|
|
|
}
|
|
|
|
|
|
|
|
GString *
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -895,6 +993,9 @@ clutter_frame_clock_class_init (ClutterFrameClockClass *klass)
|
2022-04-02 05:32:56 +00:00
|
|
|
{
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
|
|
|
|
+ if (!g_strcmp0 (g_getenv ("MUTTER_DEBUG_DISABLE_TRIPLE_BUFFERING"), "1"))
|
|
|
|
+ triple_buffering_disabled = TRUE;
|
|
|
|
+
|
|
|
|
object_class->dispose = clutter_frame_clock_dispose;
|
|
|
|
|
|
|
|
signals[DESTROY] =
|
2021-11-12 08:43:54 +00:00
|
|
|
diff --git a/clutter/clutter/clutter-frame-clock.h b/clutter/clutter/clutter-frame-clock.h
|
2022-04-13 08:38:52 +00:00
|
|
|
index 91e6b3a13039717807b0ebb487afbf49867915eb..d750404d5342bdaba315d2e5dfeba988a6ef1ca0 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/clutter/clutter/clutter-frame-clock.h
|
|
|
|
+++ b/clutter/clutter/clutter-frame-clock.h
|
|
|
|
@@ -34,6 +34,12 @@ typedef enum _ClutterFrameResult
|
|
|
|
CLUTTER_FRAME_RESULT_IDLE,
|
|
|
|
} ClutterFrameResult;
|
|
|
|
|
|
|
|
+typedef enum _ClutterFrameHint
|
|
|
|
+{
|
|
|
|
+ CLUTTER_FRAME_HINT_NONE = 0,
|
|
|
|
+ CLUTTER_FRAME_HINT_DIRECT_SCANOUT_ATTEMPTED = 1 << 0,
|
|
|
|
+} ClutterFrameHint;
|
|
|
|
+
|
|
|
|
#define CLUTTER_TYPE_FRAME_CLOCK (clutter_frame_clock_get_type ())
|
|
|
|
CLUTTER_EXPORT
|
|
|
|
G_DECLARE_FINAL_TYPE (ClutterFrameClock, clutter_frame_clock,
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -90,8 +96,9 @@ void clutter_frame_clock_remove_timeline (ClutterFrameClock *frame_clock,
|
2021-11-12 08:43:54 +00:00
|
|
|
CLUTTER_EXPORT
|
|
|
|
float clutter_frame_clock_get_refresh_rate (ClutterFrameClock *frame_clock);
|
|
|
|
|
|
|
|
-void clutter_frame_clock_record_flip_time (ClutterFrameClock *frame_clock,
|
|
|
|
- int64_t flip_time_us);
|
|
|
|
+void clutter_frame_clock_record_flip (ClutterFrameClock *frame_clock,
|
|
|
|
+ int64_t flip_time_us,
|
|
|
|
+ ClutterFrameHint hints);
|
|
|
|
|
|
|
|
GString * clutter_frame_clock_get_max_render_time_debug_info (ClutterFrameClock *frame_clock);
|
|
|
|
|
|
|
|
diff --git a/clutter/clutter/clutter-frame-private.h b/clutter/clutter/clutter-frame-private.h
|
2022-04-13 08:38:52 +00:00
|
|
|
index e0088564fcd95f5cfb5d807fe4568805ddf8adb4..06581492f58c30f5d4e0ad7b7794e63f61fc614e 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/clutter/clutter/clutter-frame-private.h
|
|
|
|
+++ b/clutter/clutter/clutter-frame-private.h
|
|
|
|
@@ -24,6 +24,7 @@ struct _ClutterFrame
|
|
|
|
{
|
|
|
|
gboolean has_result;
|
|
|
|
ClutterFrameResult result;
|
|
|
|
+ ClutterFrameHint hints;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define CLUTTER_FRAME_INIT ((ClutterFrame) { 0 })
|
|
|
|
diff --git a/clutter/clutter/clutter-frame.c b/clutter/clutter/clutter-frame.c
|
2022-04-13 08:38:52 +00:00
|
|
|
index 3c708da9dc8530a99fa9795e438dce3dc3517543..63ae302af7aaf8fd4b5bd357ac0ed5c2ae5da3cc 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/clutter/clutter/clutter-frame.c
|
|
|
|
+++ b/clutter/clutter/clutter-frame.c
|
|
|
|
@@ -40,3 +40,16 @@ clutter_frame_set_result (ClutterFrame *frame,
|
|
|
|
frame->result = result;
|
|
|
|
frame->has_result = TRUE;
|
|
|
|
}
|
|
|
|
+
|
|
|
|
+void
|
|
|
|
+clutter_frame_set_hint (ClutterFrame *frame,
|
|
|
|
+ ClutterFrameHint hint)
|
|
|
|
+{
|
|
|
|
+ frame->hints |= hint;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+ClutterFrameHint
|
|
|
|
+clutter_frame_get_hints (ClutterFrame *frame)
|
|
|
|
+{
|
|
|
|
+ return frame->hints;
|
|
|
|
+}
|
|
|
|
diff --git a/clutter/clutter/clutter-frame.h b/clutter/clutter/clutter-frame.h
|
2022-04-13 08:38:52 +00:00
|
|
|
index d3608e81ca71dfc5acdccc0111dd0f032025e0d0..06c5f7f28a58d421994036036a2f67d92ce53221 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/clutter/clutter/clutter-frame.h
|
|
|
|
+++ b/clutter/clutter/clutter-frame.h
|
|
|
|
@@ -33,4 +33,11 @@ void clutter_frame_set_result (ClutterFrame *frame,
|
|
|
|
CLUTTER_EXPORT
|
|
|
|
gboolean clutter_frame_has_result (ClutterFrame *frame);
|
|
|
|
|
|
|
|
+CLUTTER_EXPORT
|
|
|
|
+void clutter_frame_set_hint (ClutterFrame *frame,
|
|
|
|
+ ClutterFrameHint hint);
|
|
|
|
+
|
|
|
|
+CLUTTER_EXPORT
|
|
|
|
+ClutterFrameHint clutter_frame_get_hints (ClutterFrame *frame);
|
|
|
|
+
|
|
|
|
#endif /* CLUTTER_FRAME_H */
|
|
|
|
diff --git a/clutter/clutter/clutter-stage-view.c b/clutter/clutter/clutter-stage-view.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index aa98e6a629755ceec86eb2053399911e0c62c4c1..fada3a6103cd7c7506037788365042bdd0b2883f 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/clutter/clutter/clutter-stage-view.c
|
|
|
|
+++ b/clutter/clutter/clutter-stage-view.c
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1252,8 +1252,9 @@ handle_frame_clock_frame (ClutterFrameClock *frame_clock,
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
_clutter_stage_window_redraw_view (stage_window, view, &frame);
|
|
|
|
|
|
|
|
- clutter_frame_clock_record_flip_time (frame_clock,
|
|
|
|
- g_get_monotonic_time ());
|
|
|
|
+ clutter_frame_clock_record_flip (frame_clock,
|
|
|
|
+ g_get_monotonic_time (),
|
|
|
|
+ clutter_frame_get_hints (&frame));
|
|
|
|
|
|
|
|
clutter_stage_emit_after_paint (stage, view);
|
|
|
|
|
|
|
|
diff --git a/cogl/cogl/cogl-onscreen-private.h b/cogl/cogl/cogl-onscreen-private.h
|
2022-04-13 08:38:52 +00:00
|
|
|
index dffe018d2ed7828ae539edcca0cf2396795261dd..e0215f750d861e832b7dd1e78ec99014d37ba785 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/cogl/cogl/cogl-onscreen-private.h
|
|
|
|
+++ b/cogl/cogl/cogl-onscreen-private.h
|
|
|
|
@@ -97,4 +97,7 @@ cogl_onscreen_peek_tail_frame_info (CoglOnscreen *onscreen);
|
|
|
|
COGL_EXPORT CoglFrameInfo *
|
|
|
|
cogl_onscreen_pop_head_frame_info (CoglOnscreen *onscreen);
|
|
|
|
|
|
|
|
+COGL_EXPORT unsigned int
|
|
|
|
+cogl_onscreen_count_pending_frames (CoglOnscreen *onscreen);
|
|
|
|
+
|
|
|
|
#endif /* __COGL_ONSCREEN_PRIVATE_H */
|
|
|
|
diff --git a/cogl/cogl/cogl-onscreen.c b/cogl/cogl/cogl-onscreen.c
|
2022-04-13 08:38:52 +00:00
|
|
|
index ff9e1749a7dd6024f03ed33b42c060b5e9f3eef5..b25b4af4ab7cc2d22fe52463024630657cc8e398 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/cogl/cogl/cogl-onscreen.c
|
|
|
|
+++ b/cogl/cogl/cogl-onscreen.c
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -510,6 +510,14 @@ cogl_onscreen_pop_head_frame_info (CoglOnscreen *onscreen)
|
2021-11-12 08:43:54 +00:00
|
|
|
return g_queue_pop_head (&priv->pending_frame_infos);
|
|
|
|
}
|
|
|
|
|
|
|
|
+unsigned int
|
|
|
|
+cogl_onscreen_count_pending_frames (CoglOnscreen *onscreen)
|
|
|
|
+{
|
|
|
|
+ CoglOnscreenPrivate *priv = cogl_onscreen_get_instance_private (onscreen);
|
|
|
|
+
|
|
|
|
+ return g_queue_get_length (&priv->pending_frame_infos);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
CoglFrameClosure *
|
|
|
|
cogl_onscreen_add_frame_callback (CoglOnscreen *onscreen,
|
|
|
|
CoglFrameCallback callback,
|
|
|
|
diff --git a/src/backends/meta-stage-impl.c b/src/backends/meta-stage-impl.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index ca6f1f44f47a0bf531be440413b94c4f3ce407a6..a4b1c8cd0c0225f181cff41e9b3f35a8d7f7e412 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/src/backends/meta-stage-impl.c
|
|
|
|
+++ b/src/backends/meta-stage-impl.c
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -721,6 +721,8 @@ meta_stage_impl_redraw_view (ClutterStageWindow *stage_window,
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
|
|
|
g_autoptr (GError) error = NULL;
|
|
|
|
|
|
|
|
+ clutter_frame_set_hint (frame, CLUTTER_FRAME_HINT_DIRECT_SCANOUT_ATTEMPTED);
|
|
|
|
+
|
|
|
|
if (meta_stage_impl_scanout_view (stage_impl,
|
|
|
|
stage_view,
|
|
|
|
scanout,
|
2022-04-02 05:32:56 +00:00
|
|
|
diff --git a/src/backends/native/meta-crtc-kms.c b/src/backends/native/meta-crtc-kms.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index 0bfd3f5ad5fe01ac808854185402d7b2c38970ac..3590608ee08ec5ed764bec256fbe74184a70294e 100644
|
2022-04-02 05:32:56 +00:00
|
|
|
--- a/src/backends/native/meta-crtc-kms.c
|
|
|
|
+++ b/src/backends/native/meta-crtc-kms.c
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -394,7 +394,7 @@ meta_crtc_kms_maybe_set_gamma (MetaCrtcKms *crtc_kms,
|
2022-04-02 05:32:56 +00:00
|
|
|
if (!gamma)
|
|
|
|
return;
|
|
|
|
|
|
|
|
- kms_update = meta_kms_ensure_pending_update (kms, kms_device);
|
|
|
|
+ kms_update = meta_kms_ensure_pending_update_for_crtc (kms, kms_crtc);
|
|
|
|
meta_kms_update_set_crtc_gamma (kms_update,
|
2022-04-26 11:39:22 +00:00
|
|
|
kms_crtc,
|
2022-04-02 05:32:56 +00:00
|
|
|
gamma->size,
|
2021-11-12 08:43:54 +00:00
|
|
|
diff --git a/src/backends/native/meta-cursor-renderer-native.c b/src/backends/native/meta-cursor-renderer-native.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index f4b42c56c1ad86df5529dadb792bb0badeaaecac..81ce0c6278d800e3adfdb2dfd0fde6a8b92871fd 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/src/backends/native/meta-cursor-renderer-native.c
|
|
|
|
+++ b/src/backends/native/meta-cursor-renderer-native.c
|
2022-05-03 06:13:42 +00:00
|
|
|
@@ -58,19 +58,6 @@
|
2022-04-26 11:39:22 +00:00
|
|
|
#include "wayland/meta-wayland-buffer.h"
|
2021-11-12 08:43:54 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
-/* When animating a cursor, we usually call drmModeSetCursor2 once per frame.
|
|
|
|
- * Though, testing shows that we need to triple buffer the cursor buffer in
|
|
|
|
- * order to avoid glitches when animating the cursor, at least when running on
|
|
|
|
- * Intel. The reason for this might be (but is not confirmed to be) due to
|
|
|
|
- * the user space gbm_bo cache, making us reuse and overwrite the kernel side
|
|
|
|
- * buffer content before it was scanned out. To avoid this, we keep a user space
|
|
|
|
- * reference to each buffer we set until at least one frame after it was drawn.
|
|
|
|
- * In effect, this means we three active cursor gbm_bo's: one that that just has
|
|
|
|
- * been set, one that was previously set and may or may not have been scanned
|
|
|
|
- * out, and one pending that will be replaced if the cursor sprite changes.
|
|
|
|
- */
|
|
|
|
-#define HW_CURSOR_BUFFER_COUNT 3
|
|
|
|
-
|
|
|
|
static GQuark quark_cursor_sprite = 0;
|
|
|
|
|
|
|
|
typedef struct _CrtcCursorData
|
2022-05-03 06:13:42 +00:00
|
|
|
@@ -104,19 +91,10 @@ typedef struct _MetaCursorRendererNativeGpuData
|
2021-11-12 08:43:54 +00:00
|
|
|
uint64_t cursor_height;
|
|
|
|
} MetaCursorRendererNativeGpuData;
|
|
|
|
|
|
|
|
-typedef enum _MetaCursorBufferState
|
|
|
|
-{
|
|
|
|
- META_CURSOR_BUFFER_STATE_NONE,
|
|
|
|
- META_CURSOR_BUFFER_STATE_SET,
|
|
|
|
- META_CURSOR_BUFFER_STATE_INVALIDATED,
|
|
|
|
-} MetaCursorBufferState;
|
|
|
|
-
|
|
|
|
typedef struct _MetaCursorNativeGpuState
|
|
|
|
{
|
|
|
|
MetaGpu *gpu;
|
|
|
|
- unsigned int active_buffer_idx;
|
|
|
|
- MetaCursorBufferState pending_buffer_state;
|
|
|
|
- MetaDrmBuffer *buffers[HW_CURSOR_BUFFER_COUNT];
|
|
|
|
+ MetaDrmBuffer *buffer;
|
|
|
|
} MetaCursorNativeGpuState;
|
|
|
|
|
|
|
|
typedef struct _MetaCursorNativePrivate
|
2022-05-03 06:13:42 +00:00
|
|
|
@@ -197,44 +175,17 @@ meta_cursor_renderer_native_finalize (GObject *object)
|
2021-11-12 08:43:54 +00:00
|
|
|
G_OBJECT_CLASS (meta_cursor_renderer_native_parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
-static unsigned int
|
|
|
|
-get_pending_cursor_sprite_buffer_index (MetaCursorNativeGpuState *cursor_gpu_state)
|
|
|
|
-{
|
|
|
|
- return (cursor_gpu_state->active_buffer_idx + 1) % HW_CURSOR_BUFFER_COUNT;
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-static MetaDrmBuffer *
|
|
|
|
-get_pending_cursor_sprite_buffer (MetaCursorNativeGpuState *cursor_gpu_state)
|
|
|
|
-{
|
|
|
|
- unsigned int pending_buffer_idx;
|
|
|
|
-
|
|
|
|
- pending_buffer_idx =
|
|
|
|
- get_pending_cursor_sprite_buffer_index (cursor_gpu_state);
|
|
|
|
- return cursor_gpu_state->buffers[pending_buffer_idx];
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-static MetaDrmBuffer *
|
|
|
|
-get_active_cursor_sprite_buffer (MetaCursorNativeGpuState *cursor_gpu_state)
|
|
|
|
-{
|
|
|
|
- return cursor_gpu_state->buffers[cursor_gpu_state->active_buffer_idx];
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
static void
|
|
|
|
-set_pending_cursor_sprite_buffer (MetaCursorSprite *cursor_sprite,
|
|
|
|
- MetaGpuKms *gpu_kms,
|
|
|
|
- MetaDrmBuffer *buffer)
|
|
|
|
+set_cursor_sprite_buffer (MetaCursorSprite *cursor_sprite,
|
|
|
|
+ MetaGpuKms *gpu_kms,
|
|
|
|
+ MetaDrmBuffer *buffer)
|
|
|
|
{
|
|
|
|
MetaCursorNativePrivate *cursor_priv;
|
|
|
|
MetaCursorNativeGpuState *cursor_gpu_state;
|
|
|
|
- unsigned int pending_buffer_idx;
|
|
|
|
|
|
|
|
cursor_priv = ensure_cursor_priv (cursor_sprite);
|
|
|
|
cursor_gpu_state = ensure_cursor_gpu_state (cursor_priv, gpu_kms);
|
|
|
|
-
|
|
|
|
- pending_buffer_idx =
|
|
|
|
- get_pending_cursor_sprite_buffer_index (cursor_gpu_state);
|
|
|
|
- cursor_gpu_state->buffers[pending_buffer_idx] = buffer;
|
|
|
|
- cursor_gpu_state->pending_buffer_state = META_CURSOR_BUFFER_STATE_SET;
|
|
|
|
+ cursor_gpu_state->buffer = buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-05-03 06:13:42 +00:00
|
|
|
@@ -309,10 +260,7 @@ assign_cursor_plane (MetaCursorRendererNative *native,
|
2021-11-12 08:43:54 +00:00
|
|
|
MetaKmsUpdate *kms_update;
|
|
|
|
MetaKmsPlaneAssignment *plane_assignment;
|
|
|
|
|
|
|
|
- if (cursor_gpu_state->pending_buffer_state == META_CURSOR_BUFFER_STATE_SET)
|
|
|
|
- buffer = get_pending_cursor_sprite_buffer (cursor_gpu_state);
|
|
|
|
- else
|
|
|
|
- buffer = get_active_cursor_sprite_buffer (cursor_gpu_state);
|
|
|
|
+ buffer = cursor_gpu_state->buffer;
|
|
|
|
|
|
|
|
kms_crtc = meta_crtc_kms_get_kms_crtc (crtc_kms);
|
|
|
|
kms_device = meta_kms_crtc_get_device (kms_crtc);
|
2022-05-03 06:13:42 +00:00
|
|
|
@@ -341,8 +289,8 @@ assign_cursor_plane (MetaCursorRendererNative *native,
|
2022-04-02 05:32:56 +00:00
|
|
|
flags |= META_KMS_ASSIGN_PLANE_FLAG_FB_UNCHANGED;
|
|
|
|
|
|
|
|
kms_update =
|
|
|
|
- meta_kms_ensure_pending_update (meta_kms_device_get_kms (kms_device),
|
|
|
|
- meta_kms_crtc_get_device (kms_crtc));
|
|
|
|
+ meta_kms_ensure_pending_update_for_crtc (meta_kms_device_get_kms (kms_device),
|
|
|
|
+ kms_crtc);
|
|
|
|
plane_assignment = meta_kms_update_assign_plane (kms_update,
|
|
|
|
kms_crtc,
|
|
|
|
cursor_plane,
|
2022-05-03 06:13:42 +00:00
|
|
|
@@ -363,13 +311,6 @@ assign_cursor_plane (MetaCursorRendererNative *native,
|
2021-11-12 08:43:54 +00:00
|
|
|
native);
|
|
|
|
|
|
|
|
crtc_cursor_data->buffer = buffer;
|
|
|
|
-
|
|
|
|
- if (cursor_gpu_state->pending_buffer_state == META_CURSOR_BUFFER_STATE_SET)
|
|
|
|
- {
|
|
|
|
- cursor_gpu_state->active_buffer_idx =
|
|
|
|
- (cursor_gpu_state->active_buffer_idx + 1) % HW_CURSOR_BUFFER_COUNT;
|
|
|
|
- cursor_gpu_state->pending_buffer_state = META_CURSOR_BUFFER_STATE_NONE;
|
|
|
|
- }
|
|
|
|
}
|
|
|
|
|
|
|
|
static float
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -494,7 +435,7 @@ unset_crtc_cursor (MetaCursorRendererNative *native,
|
2022-04-02 05:32:56 +00:00
|
|
|
MetaKms *kms = meta_kms_device_get_kms (kms_device);
|
|
|
|
MetaKmsUpdate *kms_update;
|
|
|
|
|
|
|
|
- kms_update = meta_kms_ensure_pending_update (kms, kms_device);
|
|
|
|
+ kms_update = meta_kms_ensure_pending_update_for_crtc (kms, kms_crtc);
|
|
|
|
meta_kms_update_unassign_plane (kms_update, kms_crtc, cursor_plane);
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -602,19 +543,7 @@ has_valid_cursor_sprite_buffer (MetaCursorSprite *cursor_sprite,
|
2021-11-12 08:43:54 +00:00
|
|
|
if (!cursor_gpu_state)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
- switch (cursor_gpu_state->pending_buffer_state)
|
|
|
|
- {
|
|
|
|
- case META_CURSOR_BUFFER_STATE_NONE:
|
|
|
|
- return get_active_cursor_sprite_buffer (cursor_gpu_state) != NULL;
|
|
|
|
- case META_CURSOR_BUFFER_STATE_SET:
|
|
|
|
- return TRUE;
|
|
|
|
- case META_CURSOR_BUFFER_STATE_INVALIDATED:
|
|
|
|
- return FALSE;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- g_assert_not_reached ();
|
|
|
|
-
|
|
|
|
- return FALSE;
|
|
|
|
+ return cursor_gpu_state->buffer != NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1119,16 +1048,14 @@ unset_crtc_cursor_renderer_privates (MetaGpu *gpu,
|
2021-11-12 08:43:54 +00:00
|
|
|
static void
|
|
|
|
cursor_gpu_state_free (MetaCursorNativeGpuState *cursor_gpu_state)
|
|
|
|
{
|
|
|
|
- int i;
|
|
|
|
MetaDrmBuffer *active_buffer;
|
|
|
|
|
|
|
|
- active_buffer = get_active_cursor_sprite_buffer (cursor_gpu_state);
|
|
|
|
+ active_buffer = cursor_gpu_state->buffer;
|
|
|
|
if (active_buffer)
|
|
|
|
unset_crtc_cursor_renderer_privates (cursor_gpu_state->gpu,
|
|
|
|
active_buffer);
|
|
|
|
|
|
|
|
- for (i = 0; i < HW_CURSOR_BUFFER_COUNT; i++)
|
|
|
|
- g_clear_object (&cursor_gpu_state->buffers[i]);
|
|
|
|
+ g_clear_object (&cursor_gpu_state->buffer);
|
|
|
|
g_free (cursor_gpu_state);
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1165,14 +1092,7 @@ invalidate_cursor_gpu_state (MetaCursorSprite *cursor_sprite)
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
g_hash_table_iter_init (&iter, cursor_priv->gpu_states);
|
|
|
|
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &cursor_gpu_state))
|
|
|
|
- {
|
|
|
|
- unsigned int pending_buffer_idx;
|
|
|
|
-
|
|
|
|
- pending_buffer_idx = get_pending_cursor_sprite_buffer_index (cursor_gpu_state);
|
|
|
|
- g_clear_object (&cursor_gpu_state->buffers[pending_buffer_idx]);
|
|
|
|
- cursor_gpu_state->pending_buffer_state =
|
|
|
|
- META_CURSOR_BUFFER_STATE_INVALIDATED;
|
|
|
|
- }
|
|
|
|
+ g_clear_object (&cursor_gpu_state->buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1410,35 +1330,7 @@ load_cursor_sprite_gbm_buffer_for_gpu (MetaCursorRendererNative *native,
|
2022-05-03 06:13:42 +00:00
|
|
|
return;
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
|
2022-05-03 06:13:42 +00:00
|
|
|
- set_pending_cursor_sprite_buffer (cursor_sprite, gpu_kms, buffer);
|
|
|
|
-}
|
|
|
|
-
|
2021-11-12 08:43:54 +00:00
|
|
|
-static gboolean
|
|
|
|
-is_cursor_hw_state_valid (MetaCursorSprite *cursor_sprite,
|
|
|
|
- MetaGpuKms *gpu_kms)
|
|
|
|
-{
|
|
|
|
- MetaCursorNativePrivate *cursor_priv;
|
|
|
|
- MetaCursorNativeGpuState *cursor_gpu_state;
|
|
|
|
-
|
|
|
|
- cursor_priv = get_cursor_priv (cursor_sprite);
|
|
|
|
- if (!cursor_priv)
|
|
|
|
- return FALSE;
|
|
|
|
-
|
|
|
|
- cursor_gpu_state = get_cursor_gpu_state (cursor_priv, gpu_kms);
|
|
|
|
- if (!cursor_gpu_state)
|
|
|
|
- return FALSE;
|
|
|
|
-
|
|
|
|
- switch (cursor_gpu_state->pending_buffer_state)
|
|
|
|
- {
|
|
|
|
- case META_CURSOR_BUFFER_STATE_SET:
|
|
|
|
- case META_CURSOR_BUFFER_STATE_NONE:
|
|
|
|
- return TRUE;
|
|
|
|
- case META_CURSOR_BUFFER_STATE_INVALIDATED:
|
|
|
|
- return FALSE;
|
|
|
|
- }
|
|
|
|
-
|
|
|
|
- g_assert_not_reached ();
|
|
|
|
- return FALSE;
|
2022-05-03 06:13:42 +00:00
|
|
|
+ set_cursor_sprite_buffer (cursor_sprite, gpu_kms, buffer);
|
|
|
|
}
|
|
|
|
|
2021-11-12 08:43:54 +00:00
|
|
|
static gboolean
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1605,7 +1497,7 @@ realize_cursor_sprite_from_wl_buffer_for_gpu (MetaCursorRenderer *renderer,
|
2021-11-12 08:43:54 +00:00
|
|
|
if (!cursor_renderer_gpu_data || cursor_renderer_gpu_data->hw_cursor_broken)
|
|
|
|
return;
|
|
|
|
|
|
|
|
- if (is_cursor_hw_state_valid (cursor_sprite, gpu_kms) &&
|
|
|
|
+ if (has_valid_cursor_sprite_buffer (cursor_sprite, gpu_kms) &&
|
|
|
|
is_cursor_scale_and_transform_valid (renderer, cursor_sprite))
|
|
|
|
return;
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1750,8 +1642,8 @@ realize_cursor_sprite_from_wl_buffer_for_gpu (MetaCursorRenderer *renderer,
|
2021-11-12 08:43:54 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
- set_pending_cursor_sprite_buffer (cursor_sprite, gpu_kms,
|
|
|
|
- META_DRM_BUFFER (buffer_gbm));
|
|
|
|
+ set_cursor_sprite_buffer (cursor_sprite, gpu_kms,
|
|
|
|
+ META_DRM_BUFFER (buffer_gbm));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1775,7 +1667,7 @@ realize_cursor_sprite_from_xcursor_for_gpu (MetaCursorRenderer *renderer,
|
2021-11-12 08:43:54 +00:00
|
|
|
if (!cursor_renderer_gpu_data || cursor_renderer_gpu_data->hw_cursor_broken)
|
|
|
|
return;
|
|
|
|
|
|
|
|
- if (is_cursor_hw_state_valid (cursor_sprite, gpu_kms) &&
|
|
|
|
+ if (has_valid_cursor_sprite_buffer (cursor_sprite, gpu_kms) &&
|
|
|
|
is_cursor_scale_and_transform_valid (renderer, cursor_sprite))
|
|
|
|
return;
|
|
|
|
|
|
|
|
diff --git a/src/backends/native/meta-kms-crtc.c b/src/backends/native/meta-kms-crtc.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index ee9e19d2d99ae638347bc2ccdea66ecb83fb0823..0da9a77853f14a7fd606e29aa00e7d9ee5f57289 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/src/backends/native/meta-kms-crtc.c
|
|
|
|
+++ b/src/backends/native/meta-kms-crtc.c
|
|
|
|
@@ -32,6 +32,12 @@ typedef struct _MetaKmsCrtcPropTable
|
|
|
|
MetaKmsProp props[META_KMS_CRTC_N_PROPS];
|
|
|
|
} MetaKmsCrtcPropTable;
|
|
|
|
|
|
|
|
+typedef struct
|
|
|
|
+{
|
|
|
|
+ MetaDrmBuffer *front, *back;
|
|
|
|
+ gboolean back_is_set;
|
|
|
|
+} PlaneState;
|
|
|
|
+
|
|
|
|
struct _MetaKmsCrtc
|
|
|
|
{
|
|
|
|
GObject parent;
|
|
|
|
@@ -44,6 +50,8 @@ struct _MetaKmsCrtc
|
|
|
|
MetaKmsCrtcState current_state;
|
|
|
|
|
|
|
|
MetaKmsCrtcPropTable prop_table;
|
|
|
|
+
|
|
|
|
+ GHashTable *plane_states;
|
|
|
|
};
|
|
|
|
|
|
|
|
G_DEFINE_TYPE (MetaKmsCrtc, meta_kms_crtc, G_TYPE_OBJECT)
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -403,20 +411,91 @@ meta_kms_crtc_new (MetaKmsImplDevice *impl_device,
|
2021-11-12 08:43:54 +00:00
|
|
|
return crtc;
|
|
|
|
}
|
|
|
|
|
|
|
|
+void
|
|
|
|
+meta_kms_crtc_remember_plane_buffer (MetaKmsCrtc *crtc,
|
|
|
|
+ uint32_t plane_id,
|
|
|
|
+ MetaDrmBuffer *buffer)
|
|
|
|
+{
|
|
|
|
+ gpointer key = GUINT_TO_POINTER (plane_id);
|
|
|
|
+ PlaneState *plane_state;
|
|
|
|
+
|
|
|
|
+ plane_state = g_hash_table_lookup (crtc->plane_states, key);
|
|
|
|
+ if (plane_state == NULL)
|
|
|
|
+ {
|
|
|
|
+ plane_state = g_new0 (PlaneState, 1);
|
|
|
|
+ g_hash_table_insert (crtc->plane_states, key, plane_state);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ plane_state->back_is_set = TRUE; /* note buffer may be NULL */
|
|
|
|
+ g_set_object (&plane_state->back, buffer);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void
|
|
|
|
+swap_plane_buffers (gpointer key,
|
|
|
|
+ gpointer value,
|
|
|
|
+ gpointer user_data)
|
|
|
|
+{
|
|
|
|
+ PlaneState *plane_state = value;
|
|
|
|
+
|
|
|
|
+ if (plane_state->back_is_set)
|
|
|
|
+ {
|
|
|
|
+ g_set_object (&plane_state->front, plane_state->back);
|
|
|
|
+ g_clear_object (&plane_state->back);
|
|
|
|
+ plane_state->back_is_set = FALSE;
|
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+void
|
|
|
|
+meta_kms_crtc_on_scanout_started (MetaKmsCrtc *crtc)
|
|
|
|
+{
|
|
|
|
+ g_hash_table_foreach (crtc->plane_states, swap_plane_buffers, NULL);
|
|
|
|
+}
|
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
+void
|
|
|
|
+meta_kms_crtc_release_buffers (MetaKmsCrtc *crtc)
|
|
|
|
+{
|
|
|
|
+ g_hash_table_remove_all (crtc->plane_states);
|
|
|
|
+}
|
|
|
|
+
|
2021-11-12 08:43:54 +00:00
|
|
|
+static void
|
|
|
|
+meta_kms_crtc_dispose (GObject *object)
|
|
|
|
+{
|
|
|
|
+ MetaKmsCrtc *crtc = META_KMS_CRTC (object);
|
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
+ meta_kms_crtc_release_buffers (crtc);
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
|
|
|
+ G_OBJECT_CLASS (meta_kms_crtc_parent_class)->dispose (object);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
static void
|
|
|
|
meta_kms_crtc_finalize (GObject *object)
|
|
|
|
{
|
|
|
|
MetaKmsCrtc *crtc = META_KMS_CRTC (object);
|
|
|
|
|
|
|
|
clear_gamma_state (&crtc->current_state);
|
|
|
|
+ g_hash_table_unref (crtc->plane_states);
|
|
|
|
|
|
|
|
G_OBJECT_CLASS (meta_kms_crtc_parent_class)->finalize (object);
|
|
|
|
}
|
|
|
|
|
|
|
|
+static void
|
|
|
|
+destroy_plane_state (gpointer data)
|
|
|
|
+{
|
|
|
|
+ PlaneState *plane_state = data;
|
|
|
|
+
|
|
|
|
+ g_clear_object (&plane_state->front);
|
|
|
|
+ g_clear_object (&plane_state->back);
|
|
|
|
+ g_free (plane_state);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
static void
|
|
|
|
meta_kms_crtc_init (MetaKmsCrtc *crtc)
|
|
|
|
{
|
|
|
|
crtc->current_state.gamma.size = 0;
|
|
|
|
+ crtc->plane_states = g_hash_table_new_full (NULL,
|
|
|
|
+ NULL,
|
|
|
|
+ NULL,
|
|
|
|
+ destroy_plane_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -424,5 +503,6 @@ meta_kms_crtc_class_init (MetaKmsCrtcClass *klass)
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (klass);
|
|
|
|
|
|
|
|
+ object_class->dispose = meta_kms_crtc_dispose;
|
|
|
|
object_class->finalize = meta_kms_crtc_finalize;
|
|
|
|
}
|
|
|
|
diff --git a/src/backends/native/meta-kms-crtc.h b/src/backends/native/meta-kms-crtc.h
|
2022-04-26 11:39:22 +00:00
|
|
|
index 54801dd96ad4f8e875e79604940bcd1bc2762429..deafeb61e0e548e01604854cbef8e0f5fe77ca99 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/src/backends/native/meta-kms-crtc.h
|
|
|
|
+++ b/src/backends/native/meta-kms-crtc.h
|
|
|
|
@@ -25,6 +25,7 @@
|
|
|
|
#include <xf86drmMode.h>
|
|
|
|
|
|
|
|
#include "backends/native/meta-kms-types.h"
|
|
|
|
+#include "backends/native/meta-drm-buffer.h"
|
2022-04-02 05:32:56 +00:00
|
|
|
#include "core/util-private.h"
|
2021-11-12 08:43:54 +00:00
|
|
|
#include "meta/boxes.h"
|
|
|
|
|
2022-04-26 11:39:22 +00:00
|
|
|
@@ -84,4 +85,12 @@ MetaKmsCrtcGamma * meta_kms_crtc_gamma_new (MetaKmsCrtc *crtc,
|
2021-11-12 08:43:54 +00:00
|
|
|
const uint16_t *green,
|
|
|
|
const uint16_t *blue);
|
|
|
|
|
|
|
|
+void meta_kms_crtc_remember_plane_buffer (MetaKmsCrtc *crtc,
|
|
|
|
+ uint32_t plane_id,
|
|
|
|
+ MetaDrmBuffer *buffer);
|
|
|
|
+
|
|
|
|
+void meta_kms_crtc_on_scanout_started (MetaKmsCrtc *crtc);
|
2022-04-02 05:32:56 +00:00
|
|
|
+
|
|
|
|
+void meta_kms_crtc_release_buffers (MetaKmsCrtc *crtc);
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
|
|
|
#endif /* META_KMS_CRTC_H */
|
|
|
|
diff --git a/src/backends/native/meta-kms-impl-device-atomic.c b/src/backends/native/meta-kms-impl-device-atomic.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index e938e4522c865251544e50748cecdc6f1d214bce..5271cbecf4ff96ab889eec99be51620de55a66ee 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/src/backends/native/meta-kms-impl-device-atomic.c
|
|
|
|
+++ b/src/backends/native/meta-kms-impl-device-atomic.c
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -457,6 +457,7 @@ process_plane_assignment (MetaKmsImplDevice *impl_device,
|
2022-04-02 05:32:56 +00:00
|
|
|
{
|
|
|
|
MetaKmsPlaneAssignment *plane_assignment = update_entry;
|
|
|
|
MetaKmsPlane *plane = plane_assignment->plane;
|
|
|
|
+ MetaKmsUpdateFlag flags = (MetaKmsUpdateFlag) user_data;
|
|
|
|
MetaDrmBuffer *buffer;
|
|
|
|
MetaKmsFbDamage *fb_damage;
|
|
|
|
uint32_t prop_id;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -609,6 +610,12 @@ process_plane_assignment (MetaKmsImplDevice *impl_device,
|
2022-04-02 05:32:56 +00:00
|
|
|
error))
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
+
|
|
|
|
+ if (!(flags & META_KMS_UPDATE_FLAG_TEST_ONLY))
|
|
|
|
+ meta_kms_crtc_remember_plane_buffer (plane_assignment->crtc,
|
|
|
|
+ meta_kms_plane_get_id (plane),
|
|
|
|
+ buffer);
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -986,7 +993,7 @@ meta_kms_impl_device_atomic_process_update (MetaKmsImplDevice *impl_device,
|
2022-04-02 05:32:56 +00:00
|
|
|
req,
|
|
|
|
blob_ids,
|
|
|
|
meta_kms_update_get_plane_assignments (update),
|
|
|
|
- NULL,
|
|
|
|
+ GUINT_TO_POINTER (flags),
|
|
|
|
process_plane_assignment,
|
|
|
|
&error))
|
|
|
|
goto err;
|
|
|
|
diff --git a/src/backends/native/meta-kms-impl-device-simple.c b/src/backends/native/meta-kms-impl-device-simple.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index 648de51c65063bd248ce4f100b8182bbddbde27f..53d76291adca22e668d3c240a02c5f59f4925eee 100644
|
2022-04-02 05:32:56 +00:00
|
|
|
--- a/src/backends/native/meta-kms-impl-device-simple.c
|
|
|
|
+++ b/src/backends/native/meta-kms-impl-device-simple.c
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -486,6 +486,8 @@ process_mode_set (MetaKmsImplDevice *impl_device,
|
2022-04-02 05:32:56 +00:00
|
|
|
return FALSE;
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
2022-04-02 05:32:56 +00:00
|
|
|
|
|
|
|
+ meta_kms_crtc_on_scanout_started (crtc);
|
|
|
|
+
|
|
|
|
if (drm_mode)
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
2022-04-02 05:32:56 +00:00
|
|
|
g_hash_table_replace (impl_device_simple->cached_mode_sets,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -550,7 +552,7 @@ is_timestamp_earlier_than (uint64_t ts1,
|
2022-04-02 05:32:56 +00:00
|
|
|
typedef struct _RetryPageFlipData
|
|
|
|
{
|
|
|
|
MetaKmsCrtc *crtc;
|
|
|
|
- uint32_t fb_id;
|
|
|
|
+ MetaDrmBuffer *fb;
|
|
|
|
MetaKmsPageFlipData *page_flip_data;
|
|
|
|
float refresh_rate;
|
|
|
|
uint64_t retry_time_us;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -563,6 +565,7 @@ retry_page_flip_data_free (RetryPageFlipData *retry_page_flip_data)
|
2022-04-02 05:32:56 +00:00
|
|
|
g_assert (!retry_page_flip_data->page_flip_data);
|
|
|
|
g_clear_pointer (&retry_page_flip_data->custom_page_flip,
|
|
|
|
meta_kms_custom_page_flip_free);
|
|
|
|
+ g_clear_object (&retry_page_flip_data->fb);
|
|
|
|
g_free (retry_page_flip_data);
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -630,16 +633,21 @@ retry_page_flips (gpointer user_data)
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
2022-04-02 05:32:56 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
+ uint32_t fb_id =
|
|
|
|
+ retry_page_flip_data->fb ?
|
|
|
|
+ meta_drm_buffer_get_fb_id (retry_page_flip_data->fb) :
|
|
|
|
+ 0;
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
meta_topic (META_DEBUG_KMS,
|
|
|
|
"[simple] Retrying page flip on CRTC %u (%s) with %u",
|
|
|
|
meta_kms_crtc_get_id (crtc),
|
|
|
|
meta_kms_impl_device_get_path (impl_device),
|
|
|
|
- retry_page_flip_data->fb_id);
|
|
|
|
+ fb_id);
|
|
|
|
|
|
|
|
fd = meta_kms_impl_device_get_fd (impl_device);
|
|
|
|
ret = drmModePageFlip (fd,
|
|
|
|
meta_kms_crtc_get_id (crtc),
|
|
|
|
- retry_page_flip_data->fb_id,
|
|
|
|
+ fb_id,
|
|
|
|
DRM_MODE_PAGE_FLIP_EVENT,
|
|
|
|
retry_page_flip_data->page_flip_data);
|
|
|
|
}
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -726,7 +734,7 @@ retry_page_flips (gpointer user_data)
|
2022-04-02 05:32:56 +00:00
|
|
|
static void
|
|
|
|
schedule_retry_page_flip (MetaKmsImplDeviceSimple *impl_device_simple,
|
|
|
|
MetaKmsCrtc *crtc,
|
|
|
|
- uint32_t fb_id,
|
|
|
|
+ MetaDrmBuffer *fb,
|
|
|
|
float refresh_rate,
|
|
|
|
MetaKmsPageFlipData *page_flip_data,
|
|
|
|
MetaKmsCustomPageFlip *custom_page_flip)
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -741,7 +749,7 @@ schedule_retry_page_flip (MetaKmsImplDeviceSimple *impl_device_simple,
|
2022-04-02 05:32:56 +00:00
|
|
|
retry_page_flip_data = g_new0 (RetryPageFlipData, 1);
|
|
|
|
*retry_page_flip_data = (RetryPageFlipData) {
|
|
|
|
.crtc = crtc,
|
|
|
|
- .fb_id = fb_id,
|
|
|
|
+ .fb = fb ? g_object_ref (fb) : NULL,
|
|
|
|
.page_flip_data = page_flip_data,
|
|
|
|
.refresh_rate = refresh_rate,
|
|
|
|
.retry_time_us = retry_time_us,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -875,6 +883,8 @@ mode_set_fallback (MetaKmsImplDeviceSimple *impl_device_simple,
|
2022-04-02 05:32:56 +00:00
|
|
|
return FALSE;
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
+ meta_kms_crtc_on_scanout_started (crtc);
|
|
|
|
+
|
|
|
|
if (!impl_device_simple->mode_set_fallback_feedback_source)
|
|
|
|
{
|
|
|
|
GSource *source;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -999,20 +1009,20 @@ dispatch_page_flip (MetaKmsImplDevice *impl_device,
|
2022-04-02 05:32:56 +00:00
|
|
|
cached_mode_set = get_cached_mode_set (impl_device_simple, crtc);
|
|
|
|
if (cached_mode_set)
|
|
|
|
{
|
|
|
|
- uint32_t fb_id;
|
|
|
|
+ MetaDrmBuffer *fb;
|
|
|
|
drmModeModeInfo *drm_mode;
|
|
|
|
float refresh_rate;
|
|
|
|
|
|
|
|
if (plane_assignment)
|
|
|
|
- fb_id = meta_drm_buffer_get_fb_id (plane_assignment->buffer);
|
|
|
|
+ fb = plane_assignment->buffer;
|
|
|
|
else
|
|
|
|
- fb_id = 0;
|
|
|
|
+ fb = NULL;
|
|
|
|
drm_mode = cached_mode_set->drm_mode;
|
|
|
|
refresh_rate = meta_calculate_drm_mode_refresh_rate (drm_mode);
|
|
|
|
meta_kms_impl_device_hold_fd (impl_device);
|
|
|
|
schedule_retry_page_flip (impl_device_simple,
|
|
|
|
crtc,
|
|
|
|
- fb_id,
|
|
|
|
+ fb,
|
|
|
|
refresh_rate,
|
|
|
|
page_flip_data,
|
|
|
|
g_steal_pointer (&custom_page_flip));
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1302,7 +1312,7 @@ process_plane_assignment (MetaKmsImplDevice *impl_device,
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
|
|
|
case META_KMS_PLANE_TYPE_PRIMARY:
|
|
|
|
/* Handled as part of the mode-set and page flip. */
|
|
|
|
- return TRUE;
|
|
|
|
+ goto assigned;
|
|
|
|
case META_KMS_PLANE_TYPE_CURSOR:
|
|
|
|
if (!process_cursor_plane_assignment (impl_device, update,
|
|
|
|
plane_assignment,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1316,7 +1326,7 @@ process_plane_assignment (MetaKmsImplDevice *impl_device,
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
- return TRUE;
|
|
|
|
+ goto assigned;
|
|
|
|
}
|
|
|
|
case META_KMS_PLANE_TYPE_OVERLAY:
|
|
|
|
error = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_FAILED,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1329,6 +1339,12 @@ process_plane_assignment (MetaKmsImplDevice *impl_device,
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
g_assert_not_reached ();
|
|
|
|
+
|
|
|
|
+assigned:
|
|
|
|
+ meta_kms_crtc_remember_plane_buffer (plane_assignment->crtc,
|
|
|
|
+ meta_kms_plane_get_id (plane),
|
|
|
|
+ plane_assignment->buffer);
|
|
|
|
+ return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static gboolean
|
2022-04-02 05:32:56 +00:00
|
|
|
diff --git a/src/backends/native/meta-kms-impl-device.c b/src/backends/native/meta-kms-impl-device.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index b1dd321a7f1a9c0b9cfad5e17a4666a7df50822c..c42320a84dca1c3c03027f1ca624cc14495ca696 100644
|
2022-04-02 05:32:56 +00:00
|
|
|
--- a/src/backends/native/meta-kms-impl-device.c
|
|
|
|
+++ b/src/backends/native/meta-kms-impl-device.c
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1206,8 +1206,12 @@ meta_kms_impl_device_init_mode_setting (MetaKmsImplDevice *impl_device,
|
2022-04-02 05:32:56 +00:00
|
|
|
void
|
|
|
|
meta_kms_impl_device_prepare_shutdown (MetaKmsImplDevice *impl_device)
|
|
|
|
{
|
|
|
|
+ MetaKmsImplDevicePrivate *priv =
|
|
|
|
+ meta_kms_impl_device_get_instance_private (impl_device);
|
|
|
|
MetaKmsImplDeviceClass *klass = META_KMS_IMPL_DEVICE_GET_CLASS (impl_device);
|
|
|
|
|
|
|
|
+ g_list_foreach (priv->crtcs, (GFunc) meta_kms_crtc_release_buffers, NULL);
|
|
|
|
+
|
|
|
|
if (klass->prepare_shutdown)
|
|
|
|
klass->prepare_shutdown (impl_device);
|
|
|
|
|
2021-11-12 08:43:54 +00:00
|
|
|
diff --git a/src/backends/native/meta-kms-page-flip.c b/src/backends/native/meta-kms-page-flip.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index c1c29905c6256159ffbc12d574dff4de418a5a74..a6fbaf2f88ca01070dd8dbb0278441376b66c87e 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/src/backends/native/meta-kms-page-flip.c
|
|
|
|
+++ b/src/backends/native/meta-kms-page-flip.c
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -25,6 +25,7 @@
|
2021-11-12 08:43:54 +00:00
|
|
|
#include "backends/native/meta-kms-impl.h"
|
|
|
|
#include "backends/native/meta-kms-private.h"
|
|
|
|
#include "backends/native/meta-kms-update.h"
|
|
|
|
+#include "backends/native/meta-kms-crtc.h"
|
|
|
|
|
|
|
|
typedef struct _MetaKmsPageFlipClosure
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -150,6 +151,8 @@ meta_kms_page_flip_data_flipped (MetaKms *kms,
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
meta_assert_not_in_kms_impl (kms);
|
|
|
|
|
|
|
|
+ meta_kms_crtc_on_scanout_started (page_flip_data->crtc);
|
|
|
|
+
|
|
|
|
for (l = page_flip_data->closures; l; l = l->next)
|
|
|
|
{
|
|
|
|
MetaKmsPageFlipClosure *closure = l->data;
|
2022-04-02 05:32:56 +00:00
|
|
|
diff --git a/src/backends/native/meta-kms-update-private.h b/src/backends/native/meta-kms-update-private.h
|
2022-10-27 14:41:22 +00:00
|
|
|
index 3a648ba0da60488d6d358118ce50b89e8e1c6d8f..cfcf4b0505d5c9c7eef2ed226a79e6454d5a5f03 100644
|
2022-04-02 05:32:56 +00:00
|
|
|
--- a/src/backends/native/meta-kms-update-private.h
|
|
|
|
+++ b/src/backends/native/meta-kms-update-private.h
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -137,6 +137,12 @@ uint64_t meta_kms_update_get_sequence_number (MetaKmsUpdate *update);
|
2022-04-02 05:32:56 +00:00
|
|
|
META_EXPORT_TEST
|
|
|
|
MetaKmsDevice * meta_kms_update_get_device (MetaKmsUpdate *update);
|
|
|
|
|
|
|
|
+gboolean meta_kms_update_includes_crtc (MetaKmsUpdate *update,
|
|
|
|
+ MetaKmsCrtc *crtc);
|
|
|
|
+
|
|
|
|
+void meta_kms_update_include_crtc (MetaKmsUpdate *update,
|
|
|
|
+ MetaKmsCrtc *crtc);
|
|
|
|
+
|
|
|
|
void meta_kms_plane_assignment_set_rotation (MetaKmsPlaneAssignment *plane_assignment,
|
2022-10-27 14:41:22 +00:00
|
|
|
MetaKmsPlaneRotation rotation);
|
2022-04-02 05:32:56 +00:00
|
|
|
|
2021-11-12 08:43:54 +00:00
|
|
|
diff --git a/src/backends/native/meta-kms-update.c b/src/backends/native/meta-kms-update.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index 4c34000ef5d562e28b76a1084901ef3e8cf721b7..cbbf1a0dabe0c3ea2ae453a515f3b381d114bf61 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/src/backends/native/meta-kms-update.c
|
|
|
|
+++ b/src/backends/native/meta-kms-update.c
|
2022-04-26 11:39:22 +00:00
|
|
|
@@ -25,12 +25,14 @@
|
|
|
|
#include "backends/meta-display-config-shared.h"
|
|
|
|
#include "backends/native/meta-kms-connector.h"
|
|
|
|
#include "backends/native/meta-kms-crtc.h"
|
|
|
|
+#include "backends/native/meta-kms-device.h"
|
|
|
|
#include "backends/native/meta-kms-mode-private.h"
|
|
|
|
#include "backends/native/meta-kms-plane.h"
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
struct _MetaKmsUpdate
|
|
|
|
{
|
|
|
|
MetaKmsDevice *device;
|
|
|
|
+ GHashTable *crtcs;
|
|
|
|
|
|
|
|
gboolean is_locked;
|
|
|
|
uint64_t sequence_number;
|
2022-04-26 11:39:22 +00:00
|
|
|
@@ -149,6 +151,7 @@ static void
|
2021-11-12 08:43:54 +00:00
|
|
|
meta_kms_plane_assignment_free (MetaKmsPlaneAssignment *plane_assignment)
|
|
|
|
{
|
|
|
|
g_clear_pointer (&plane_assignment->fb_damage, meta_kms_fb_damage_free);
|
|
|
|
+ g_clear_object (&plane_assignment->buffer);
|
|
|
|
g_free (plane_assignment);
|
|
|
|
}
|
|
|
|
|
2022-04-26 11:39:22 +00:00
|
|
|
@@ -228,7 +231,7 @@ meta_kms_update_assign_plane (MetaKmsUpdate *update,
|
2021-11-12 08:43:54 +00:00
|
|
|
.update = update,
|
|
|
|
.crtc = crtc,
|
|
|
|
.plane = plane,
|
|
|
|
- .buffer = buffer,
|
|
|
|
+ .buffer = g_object_ref (buffer),
|
|
|
|
.src_rect = src_rect,
|
|
|
|
.dst_rect = dst_rect,
|
|
|
|
.flags = flags,
|
2022-04-26 11:39:22 +00:00
|
|
|
@@ -237,6 +240,8 @@ meta_kms_update_assign_plane (MetaKmsUpdate *update,
|
2022-04-02 05:32:56 +00:00
|
|
|
update->plane_assignments = g_list_prepend (update->plane_assignments,
|
|
|
|
plane_assignment);
|
|
|
|
|
2022-04-26 11:39:22 +00:00
|
|
|
+ g_hash_table_add (update->crtcs, crtc);
|
2022-04-02 05:32:56 +00:00
|
|
|
+
|
|
|
|
return plane_assignment;
|
|
|
|
}
|
|
|
|
|
2022-09-14 14:55:57 +00:00
|
|
|
@@ -251,6 +256,8 @@ meta_kms_update_unassign_plane (MetaKmsUpdate *update,
|
|
|
|
g_assert (meta_kms_crtc_get_device (crtc) == update->device);
|
|
|
|
g_assert (meta_kms_plane_get_device (plane) == update->device);
|
|
|
|
|
|
|
|
+ drop_plane_assignment (update, plane, NULL);
|
|
|
|
+
|
|
|
|
plane_assignment = g_new0 (MetaKmsPlaneAssignment, 1);
|
|
|
|
*plane_assignment = (MetaKmsPlaneAssignment) {
|
|
|
|
.update = update,
|
|
|
|
@@ -262,6 +269,8 @@ meta_kms_update_unassign_plane (MetaKmsUpdate *update,
|
2022-04-02 05:32:56 +00:00
|
|
|
update->plane_assignments = g_list_prepend (update->plane_assignments,
|
|
|
|
plane_assignment);
|
|
|
|
|
2022-04-26 11:39:22 +00:00
|
|
|
+ g_hash_table_add (update->crtcs, crtc);
|
2022-04-02 05:32:56 +00:00
|
|
|
+
|
|
|
|
return plane_assignment;
|
|
|
|
}
|
|
|
|
|
2022-09-14 14:55:57 +00:00
|
|
|
@@ -284,6 +293,8 @@ meta_kms_update_mode_set (MetaKmsUpdate *update,
|
2022-04-02 05:32:56 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
update->mode_sets = g_list_prepend (update->mode_sets, mode_set);
|
|
|
|
+
|
2022-04-26 11:39:22 +00:00
|
|
|
+ g_hash_table_add (update->crtcs, crtc);
|
2022-04-02 05:32:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static MetaKmsConnectorUpdate *
|
2022-09-14 14:55:57 +00:00
|
|
|
@@ -292,6 +303,8 @@ ensure_connector_update (MetaKmsUpdate *update,
|
2022-04-26 11:39:22 +00:00
|
|
|
{
|
|
|
|
GList *l;
|
|
|
|
MetaKmsConnectorUpdate *connector_update;
|
|
|
|
+ MetaKmsDevice *device;
|
|
|
|
+ const MetaKmsConnectorState *state;
|
|
|
|
|
|
|
|
for (l = update->connector_updates; l; l = l->next)
|
|
|
|
{
|
2022-09-14 14:55:57 +00:00
|
|
|
@@ -306,6 +319,23 @@ ensure_connector_update (MetaKmsUpdate *update,
|
2022-04-26 11:39:22 +00:00
|
|
|
|
|
|
|
update->connector_updates = g_list_prepend (update->connector_updates,
|
|
|
|
connector_update);
|
|
|
|
+ device = meta_kms_connector_get_device (connector);
|
|
|
|
+ state = meta_kms_connector_get_current_state (connector);
|
|
|
|
+ if (device && state && state->current_crtc_id)
|
|
|
|
+ {
|
|
|
|
+ GList *l;
|
|
|
|
+
|
|
|
|
+ for (l = meta_kms_device_get_crtcs (device); l; l = l->next)
|
|
|
|
+ {
|
|
|
|
+ MetaKmsCrtc *kms_crtc = l->data;
|
|
|
|
+
|
|
|
|
+ if (meta_kms_crtc_get_id (kms_crtc) == state->current_crtc_id)
|
2022-08-03 09:36:52 +00:00
|
|
|
+ {
|
|
|
|
+ g_hash_table_add (update->crtcs, kms_crtc);
|
|
|
|
+ break;
|
|
|
|
+ }
|
2022-04-26 11:39:22 +00:00
|
|
|
+ }
|
|
|
|
+ }
|
|
|
|
|
|
|
|
return connector_update;
|
|
|
|
}
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -416,6 +446,8 @@ meta_kms_update_set_crtc_gamma (MetaKmsUpdate *update,
|
2022-04-02 05:32:56 +00:00
|
|
|
gamma = meta_kms_crtc_gamma_new (crtc, size, red, green, blue);
|
|
|
|
|
|
|
|
update->crtc_gammas = g_list_prepend (update->crtc_gammas, gamma);
|
|
|
|
+
|
2022-04-26 11:39:22 +00:00
|
|
|
+ g_hash_table_add (update->crtcs, crtc);
|
2022-04-02 05:32:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -679,6 +711,20 @@ meta_kms_update_get_device (MetaKmsUpdate *update)
|
2022-04-02 05:32:56 +00:00
|
|
|
return update->device;
|
|
|
|
}
|
|
|
|
|
|
|
|
+gboolean
|
|
|
|
+meta_kms_update_includes_crtc (MetaKmsUpdate *update,
|
|
|
|
+ MetaKmsCrtc *crtc)
|
|
|
|
+{
|
2022-04-26 11:39:22 +00:00
|
|
|
+ return g_hash_table_contains (update->crtcs, crtc);
|
2022-04-02 05:32:56 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+void
|
|
|
|
+meta_kms_update_include_crtc (MetaKmsUpdate *update,
|
|
|
|
+ MetaKmsCrtc *crtc)
|
|
|
|
+{
|
2022-04-26 11:39:22 +00:00
|
|
|
+ g_hash_table_add (update->crtcs, crtc);
|
2022-04-02 05:32:56 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
MetaKmsCustomPageFlip *
|
|
|
|
meta_kms_update_take_custom_page_flip_func (MetaKmsUpdate *update)
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -707,12 +753,15 @@ meta_kms_update_new (MetaKmsDevice *device)
|
2022-04-02 05:32:56 +00:00
|
|
|
update->device = device;
|
|
|
|
update->sequence_number = sequence_number++;
|
|
|
|
|
|
|
|
+ update->crtcs = g_hash_table_new (NULL, NULL);
|
|
|
|
+
|
|
|
|
return update;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
meta_kms_update_free (MetaKmsUpdate *update)
|
|
|
|
{
|
|
|
|
+ g_hash_table_destroy (update->crtcs);
|
|
|
|
g_list_free_full (update->result_listeners,
|
|
|
|
(GDestroyNotify) meta_kms_result_listener_free);
|
|
|
|
g_list_free_full (update->plane_assignments,
|
2021-11-12 08:43:54 +00:00
|
|
|
diff --git a/src/backends/native/meta-kms.c b/src/backends/native/meta-kms.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index 21be532a2fc6060fec047a116c2cee2190118380..b8dba8d0e3f1de236bdcad4e473c104f19e2726c 100644
|
2021-11-12 08:43:54 +00:00
|
|
|
--- a/src/backends/native/meta-kms.c
|
|
|
|
+++ b/src/backends/native/meta-kms.c
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -23,6 +23,7 @@
|
|
|
|
#include "backends/native/meta-kms-private.h"
|
2021-11-12 08:43:54 +00:00
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
#include "backends/native/meta-backend-native.h"
|
|
|
|
+#include "backends/native/meta-kms-crtc.h"
|
|
|
|
#include "backends/native/meta-kms-device-private.h"
|
|
|
|
#include "backends/native/meta-kms-impl.h"
|
|
|
|
#include "backends/native/meta-kms-update-private.h"
|
2022-04-26 11:39:22 +00:00
|
|
|
@@ -177,10 +178,17 @@ struct _MetaKms
|
|
|
|
|
|
|
|
GList *pending_callbacks;
|
|
|
|
guint callback_source_id;
|
|
|
|
+
|
|
|
|
+ gboolean shutting_down;
|
|
|
|
};
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
G_DEFINE_TYPE (MetaKms, meta_kms, G_TYPE_OBJECT)
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
+static MetaKmsFeedback *
|
|
|
|
+meta_kms_post_update_sync (MetaKms *kms,
|
|
|
|
+ MetaKmsUpdate *update,
|
|
|
|
+ MetaKmsUpdateFlag flags);
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
|
|
|
void
|
2022-04-02 05:32:56 +00:00
|
|
|
meta_kms_discard_pending_updates (MetaKms *kms)
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -247,12 +255,105 @@ meta_kms_take_pending_update (MetaKms *kms,
|
2022-04-02 05:32:56 +00:00
|
|
|
return NULL;
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
+MetaKmsUpdate *
|
|
|
|
+meta_kms_ensure_pending_update_for_crtc (MetaKms *kms,
|
|
|
|
+ MetaKmsCrtc *crtc)
|
|
|
|
+{
|
|
|
|
+ MetaKmsUpdate *update;
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
+ update = meta_kms_get_pending_update_for_crtc (kms, crtc);
|
|
|
|
+ if (update == NULL)
|
|
|
|
+ {
|
|
|
|
+ update = meta_kms_update_new (meta_kms_crtc_get_device (crtc));
|
|
|
|
+ meta_kms_update_include_crtc (update, crtc);
|
|
|
|
+ meta_kms_add_pending_update (kms, update);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return update;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static MetaKmsUpdate *
|
|
|
|
+meta_kms_find_compatible_update_for_crtc (MetaKms *kms,
|
|
|
|
+ MetaKmsCrtc *crtc,
|
|
|
|
+ gboolean take)
|
|
|
|
+{
|
|
|
|
+ MetaKmsDevice *device;
|
|
|
|
+ MetaKmsUpdate *update;
|
|
|
|
+ GList *l;
|
|
|
|
+
|
|
|
|
+ for (l = kms->pending_updates; l; l = l->next)
|
|
|
|
+ {
|
|
|
|
+ update = l->data;
|
|
|
|
+ if (meta_kms_update_includes_crtc (update, crtc))
|
|
|
|
+ goto found;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ device = meta_kms_crtc_get_device (crtc);
|
|
|
|
+
|
|
|
|
+ for (l = kms->pending_updates; l; l = l->next)
|
|
|
|
+ {
|
|
|
|
+ update = l->data;
|
|
|
|
+ if (meta_kms_update_get_device (update) == device &&
|
|
|
|
+ meta_kms_update_get_mode_sets (update))
|
|
|
|
+ goto found;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+found:
|
|
|
|
+ if (take)
|
|
|
|
+ kms->pending_updates = g_list_delete_link (kms->pending_updates, l);
|
|
|
|
+ return update;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+MetaKmsUpdate *
|
|
|
|
+meta_kms_get_pending_update_for_crtc (MetaKms *kms,
|
|
|
|
+ MetaKmsCrtc *crtc)
|
|
|
|
+{
|
|
|
|
+ return meta_kms_find_compatible_update_for_crtc (kms, crtc, FALSE);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static MetaKmsUpdate *
|
|
|
|
+meta_kms_take_pending_update_for_crtc (MetaKms *kms,
|
|
|
|
+ MetaKmsCrtc *crtc)
|
|
|
|
+{
|
|
|
|
+ return meta_kms_find_compatible_update_for_crtc (kms, crtc, TRUE);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
MetaKmsFeedback *
|
|
|
|
meta_kms_post_pending_update_sync (MetaKms *kms,
|
|
|
|
MetaKmsDevice *device,
|
|
|
|
MetaKmsUpdateFlag flags)
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
2022-04-02 05:32:56 +00:00
|
|
|
MetaKmsUpdate *update;
|
|
|
|
+
|
|
|
|
+ update = meta_kms_take_pending_update (kms, device);
|
|
|
|
+ if (!update)
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+ return meta_kms_post_update_sync (kms, update, flags);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+MetaKmsFeedback *
|
|
|
|
+meta_kms_post_pending_update_for_crtc_sync (MetaKms *kms,
|
|
|
|
+ MetaKmsCrtc *crtc,
|
|
|
|
+ MetaKmsUpdateFlag flags)
|
|
|
|
+{
|
|
|
|
+ MetaKmsUpdate *update;
|
|
|
|
+
|
|
|
|
+ update = meta_kms_take_pending_update_for_crtc (kms, crtc);
|
|
|
|
+ if (!update)
|
|
|
|
+ return NULL;
|
|
|
|
+
|
|
|
|
+ return meta_kms_post_update_sync (kms, update, flags);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static MetaKmsFeedback *
|
|
|
|
+meta_kms_post_update_sync (MetaKms *kms,
|
|
|
|
+ MetaKmsUpdate *update,
|
|
|
|
+ MetaKmsUpdateFlag flags)
|
|
|
|
+{
|
|
|
|
+ MetaKmsDevice *device = meta_kms_update_get_device (update);
|
|
|
|
MetaKmsFeedback *feedback;
|
|
|
|
GList *result_listeners;
|
|
|
|
GList *l;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -260,10 +361,6 @@ meta_kms_post_pending_update_sync (MetaKms *kms,
|
2022-04-02 05:32:56 +00:00
|
|
|
COGL_TRACE_BEGIN_SCOPED (MetaKmsPostUpdateSync,
|
|
|
|
"KMS (post update)");
|
|
|
|
|
|
|
|
- update = meta_kms_take_pending_update (kms, device);
|
|
|
|
- if (!update)
|
|
|
|
- return NULL;
|
|
|
|
-
|
|
|
|
meta_kms_update_lock (update);
|
|
|
|
|
|
|
|
feedback = meta_kms_device_process_update_sync (device, update, flags);
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -752,10 +849,18 @@ prepare_shutdown_in_impl (MetaKmsImpl *impl,
|
2022-04-26 11:39:22 +00:00
|
|
|
void
|
|
|
|
meta_kms_prepare_shutdown (MetaKms *kms)
|
|
|
|
{
|
|
|
|
+ kms->shutting_down = TRUE;
|
|
|
|
+
|
|
|
|
meta_kms_run_impl_task_sync (kms, prepare_shutdown_in_impl, NULL, NULL);
|
|
|
|
flush_callbacks (kms);
|
|
|
|
}
|
2022-10-27 14:41:22 +00:00
|
|
|
|
|
|
|
+gboolean
|
|
|
|
+meta_kms_is_shutting_down (MetaKms *kms)
|
|
|
|
+{
|
|
|
|
+ return kms->shutting_down;
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
static void
|
|
|
|
meta_kms_finalize (GObject *object)
|
|
|
|
{
|
2022-04-02 05:32:56 +00:00
|
|
|
diff --git a/src/backends/native/meta-kms.h b/src/backends/native/meta-kms.h
|
2022-10-27 14:41:22 +00:00
|
|
|
index bd9fe5ceadc8d4d46a1eabe775a0242bffbf77bf..e8fe2e418d67be4a9f05006493387e7471a85960 100644
|
2022-04-02 05:32:56 +00:00
|
|
|
--- a/src/backends/native/meta-kms.h
|
|
|
|
+++ b/src/backends/native/meta-kms.h
|
|
|
|
@@ -39,9 +39,15 @@ void meta_kms_discard_pending_updates (MetaKms *kms);
|
|
|
|
MetaKmsUpdate * meta_kms_ensure_pending_update (MetaKms *kms,
|
|
|
|
MetaKmsDevice *device);
|
|
|
|
|
|
|
|
+MetaKmsUpdate * meta_kms_ensure_pending_update_for_crtc (MetaKms *kms,
|
|
|
|
+ MetaKmsCrtc *crtc);
|
|
|
|
+
|
|
|
|
MetaKmsUpdate * meta_kms_get_pending_update (MetaKms *kms,
|
|
|
|
MetaKmsDevice *device);
|
|
|
|
|
|
|
|
+MetaKmsUpdate * meta_kms_get_pending_update_for_crtc (MetaKms *kms,
|
|
|
|
+ MetaKmsCrtc *crtc);
|
|
|
|
+
|
|
|
|
MetaKmsFeedback * meta_kms_post_pending_update_sync (MetaKms *kms,
|
|
|
|
MetaKmsDevice *device,
|
|
|
|
MetaKmsUpdateFlag flags);
|
|
|
|
@@ -49,6 +55,10 @@ MetaKmsFeedback * meta_kms_post_pending_update_sync (MetaKms *kms,
|
|
|
|
MetaKmsFeedback * meta_kms_post_test_update_sync (MetaKms *kms,
|
|
|
|
MetaKmsUpdate *update);
|
|
|
|
|
|
|
|
+MetaKmsFeedback * meta_kms_post_pending_update_for_crtc_sync (MetaKms *kms,
|
|
|
|
+ MetaKmsCrtc *device,
|
|
|
|
+ MetaKmsUpdateFlag flags);
|
|
|
|
+
|
|
|
|
void meta_kms_discard_pending_page_flips (MetaKms *kms);
|
|
|
|
|
|
|
|
void meta_kms_notify_modes_set (MetaKms *kms);
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -68,6 +78,8 @@ MetaKmsDevice * meta_kms_create_device (MetaKms *kms,
|
|
|
|
|
|
|
|
void meta_kms_prepare_shutdown (MetaKms *kms);
|
|
|
|
|
|
|
|
+gboolean meta_kms_is_shutting_down (MetaKms *kms);
|
|
|
|
+
|
|
|
|
MetaKms * meta_kms_new (MetaBackend *backend,
|
|
|
|
MetaKmsFlags flags,
|
|
|
|
GError **error);
|
2022-04-02 05:32:56 +00:00
|
|
|
diff --git a/src/backends/native/meta-onscreen-native.c b/src/backends/native/meta-onscreen-native.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index a107a99bb37ea007d67462d07765605bfa0ca7ef..6c8245f8cb47c86fa754308db701b96fbdfbc56e 100644
|
2022-04-02 05:32:56 +00:00
|
|
|
--- a/src/backends/native/meta-onscreen-native.c
|
|
|
|
+++ b/src/backends/native/meta-onscreen-native.c
|
|
|
|
@@ -67,13 +67,12 @@ typedef struct _MetaOnscreenNativeSecondaryGpuState
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
struct {
|
|
|
|
struct gbm_surface *surface;
|
|
|
|
- MetaDrmBuffer *current_fb;
|
2022-04-02 05:32:56 +00:00
|
|
|
- MetaDrmBuffer *next_fb;
|
2021-11-12 08:43:54 +00:00
|
|
|
} gbm;
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
struct {
|
|
|
|
MetaDrmBufferDumb *current_dumb_fb;
|
|
|
|
MetaDrmBufferDumb *dumb_fbs[2];
|
|
|
|
+ MetaDrmBuffer *source_fbs[2];
|
|
|
|
} cpu;
|
|
|
|
|
|
|
|
gboolean noted_primary_gpu_copy_ok;
|
|
|
|
@@ -94,8 +93,8 @@ struct _MetaOnscreenNative
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
struct {
|
|
|
|
struct gbm_surface *surface;
|
|
|
|
- MetaDrmBuffer *current_fb;
|
|
|
|
MetaDrmBuffer *next_fb;
|
2022-04-02 05:32:56 +00:00
|
|
|
+ MetaDrmBuffer *stalled_fb;
|
2021-11-12 08:43:54 +00:00
|
|
|
} gbm;
|
|
|
|
|
|
|
|
#ifdef HAVE_EGL_DEVICE
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -107,69 +106,25 @@ struct _MetaOnscreenNative
|
2021-11-12 08:43:54 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
MetaRendererView *view;
|
|
|
|
+
|
|
|
|
+ unsigned int swaps_pending;
|
|
|
|
+ struct {
|
|
|
|
+ int *rectangles; /* 4 x n_rectangles */
|
|
|
|
+ int n_rectangles;
|
|
|
|
+ } next_post;
|
|
|
|
};
|
|
|
|
|
|
|
|
G_DEFINE_TYPE (MetaOnscreenNative, meta_onscreen_native,
|
|
|
|
COGL_TYPE_ONSCREEN_EGL)
|
|
|
|
|
|
|
|
+static void
|
2022-04-02 05:32:56 +00:00
|
|
|
+try_post_latest_swap (CoglOnscreen *onscreen);
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
|
|
|
static gboolean
|
|
|
|
init_secondary_gpu_state (MetaRendererNative *renderer_native,
|
|
|
|
CoglOnscreen *onscreen,
|
|
|
|
GError **error);
|
|
|
|
|
|
|
|
-static void
|
|
|
|
-swap_secondary_drm_fb (CoglOnscreen *onscreen)
|
|
|
|
-{
|
|
|
|
- MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
- MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state;
|
|
|
|
-
|
|
|
|
- secondary_gpu_state = onscreen_native->secondary_gpu_state;
|
|
|
|
- if (!secondary_gpu_state)
|
|
|
|
- return;
|
|
|
|
-
|
|
|
|
- g_set_object (&secondary_gpu_state->gbm.current_fb,
|
|
|
|
- secondary_gpu_state->gbm.next_fb);
|
|
|
|
- g_clear_object (&secondary_gpu_state->gbm.next_fb);
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-static void
|
|
|
|
-free_current_secondary_bo (CoglOnscreen *onscreen)
|
|
|
|
-{
|
|
|
|
- MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
- MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state;
|
|
|
|
-
|
|
|
|
- secondary_gpu_state = onscreen_native->secondary_gpu_state;
|
|
|
|
- if (!secondary_gpu_state)
|
|
|
|
- return;
|
|
|
|
-
|
|
|
|
- g_clear_object (&secondary_gpu_state->gbm.current_fb);
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-static void
|
|
|
|
-free_current_bo (CoglOnscreen *onscreen)
|
|
|
|
-{
|
|
|
|
- MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
-
|
|
|
|
- g_clear_object (&onscreen_native->gbm.current_fb);
|
|
|
|
- free_current_secondary_bo (onscreen);
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
-static void
|
|
|
|
-meta_onscreen_native_swap_drm_fb (CoglOnscreen *onscreen)
|
|
|
|
-{
|
|
|
|
- MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
-
|
|
|
|
- if (!onscreen_native->gbm.next_fb)
|
|
|
|
- return;
|
|
|
|
-
|
|
|
|
- free_current_bo (onscreen);
|
|
|
|
-
|
|
|
|
- g_set_object (&onscreen_native->gbm.current_fb, onscreen_native->gbm.next_fb);
|
|
|
|
- g_clear_object (&onscreen_native->gbm.next_fb);
|
|
|
|
-
|
|
|
|
- swap_secondary_drm_fb (onscreen);
|
|
|
|
-}
|
|
|
|
-
|
|
|
|
static void
|
|
|
|
maybe_update_frame_info (MetaCrtc *crtc,
|
|
|
|
CoglFrameInfo *frame_info,
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -205,7 +160,7 @@ meta_onscreen_native_notify_frame_complete (CoglOnscreen *onscreen)
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
info = cogl_onscreen_pop_head_frame_info (onscreen);
|
|
|
|
|
|
|
|
- g_assert (!cogl_onscreen_peek_head_frame_info (onscreen));
|
|
|
|
+ g_assert (info);
|
|
|
|
|
|
|
|
_cogl_onscreen_notify_frame_sync (onscreen, info);
|
|
|
|
_cogl_onscreen_notify_complete (onscreen, info);
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -234,7 +189,7 @@ notify_view_crtc_presented (MetaRendererView *view,
|
2021-11-12 08:43:54 +00:00
|
|
|
maybe_update_frame_info (crtc, frame_info, time_us, flags, sequence);
|
|
|
|
|
|
|
|
meta_onscreen_native_notify_frame_complete (onscreen);
|
|
|
|
- meta_onscreen_native_swap_drm_fb (onscreen);
|
2022-04-02 05:32:56 +00:00
|
|
|
+ try_post_latest_swap (onscreen);
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int64_t
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -296,6 +251,7 @@ page_flip_feedback_ready (MetaKmsCrtc *kms_crtc,
|
2021-11-12 08:43:54 +00:00
|
|
|
frame_info->flags |= COGL_FRAME_INFO_FLAG_SYMBOLIC;
|
|
|
|
|
|
|
|
meta_onscreen_native_notify_frame_complete (onscreen);
|
2022-04-02 05:32:56 +00:00
|
|
|
+ try_post_latest_swap (onscreen);
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -345,7 +301,7 @@ page_flip_feedback_discarded (MetaKmsCrtc *kms_crtc,
|
2021-11-12 08:43:54 +00:00
|
|
|
frame_info->flags |= COGL_FRAME_INFO_FLAG_SYMBOLIC;
|
|
|
|
|
|
|
|
meta_onscreen_native_notify_frame_complete (onscreen);
|
|
|
|
- meta_onscreen_native_swap_drm_fb (onscreen);
|
2022-04-02 05:32:56 +00:00
|
|
|
+ try_post_latest_swap (onscreen);
|
2021-11-12 08:43:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const MetaKmsPageFlipListenerVtable page_flip_listener_vtable = {
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -406,18 +362,40 @@ custom_egl_stream_page_flip (gpointer custom_page_flip_data,
|
|
|
|
}
|
|
|
|
#endif /* HAVE_EGL_DEVICE */
|
|
|
|
|
|
|
|
-void
|
|
|
|
-meta_onscreen_native_dummy_power_save_page_flip (CoglOnscreen *onscreen)
|
|
|
|
+static void
|
|
|
|
+drop_stalled_swap (CoglOnscreen *onscreen)
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
2022-04-02 05:32:56 +00:00
|
|
|
+ MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
2021-11-12 08:43:54 +00:00
|
|
|
CoglFrameInfo *frame_info;
|
|
|
|
|
|
|
|
- meta_onscreen_native_swap_drm_fb (onscreen);
|
2022-04-02 05:32:56 +00:00
|
|
|
+ /* Remember we can't compare stalled_fb because it's not used by
|
|
|
|
+ * META_RENDERER_NATIVE_MODE_EGL_DEVICE. So we judge stalled to be whenever
|
|
|
|
+ * swaps_pending > 1.
|
|
|
|
+ */
|
|
|
|
+ if (onscreen_native->swaps_pending <= 1)
|
|
|
|
+ return;
|
|
|
|
+
|
|
|
|
+ onscreen_native->swaps_pending--;
|
|
|
|
+
|
|
|
|
+ g_clear_object (&onscreen_native->gbm.stalled_fb);
|
|
|
|
|
2021-11-12 08:43:54 +00:00
|
|
|
frame_info = cogl_onscreen_peek_tail_frame_info (onscreen);
|
|
|
|
frame_info->flags |= COGL_FRAME_INFO_FLAG_SYMBOLIC;
|
|
|
|
meta_onscreen_native_notify_frame_complete (onscreen);
|
|
|
|
}
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
+void
|
|
|
|
+meta_onscreen_native_dummy_power_save_page_flip (CoglOnscreen *onscreen)
|
|
|
|
+{
|
|
|
|
+ drop_stalled_swap (onscreen);
|
|
|
|
+
|
|
|
|
+ /* If the monitor just woke up and the shell is fully idle (has nothing
|
|
|
|
+ * more to swap) then we just woke to an indefinitely black screen. Let's
|
|
|
|
+ * fix that using the last swap (which is never classified as "stalled").
|
|
|
|
+ */
|
|
|
|
+ try_post_latest_swap (onscreen);
|
|
|
|
+}
|
|
|
|
+
|
2021-11-12 08:43:54 +00:00
|
|
|
static void
|
2022-04-02 05:32:56 +00:00
|
|
|
meta_onscreen_native_flip_crtc (CoglOnscreen *onscreen,
|
|
|
|
MetaRendererView *view,
|
|
|
|
@@ -436,8 +414,7 @@ meta_onscreen_native_flip_crtc (CoglOnscreen *onscreen,
|
|
|
|
MetaKmsDevice *kms_device;
|
2021-11-12 08:43:54 +00:00
|
|
|
MetaKms *kms;
|
|
|
|
MetaKmsUpdate *kms_update;
|
2022-04-02 05:32:56 +00:00
|
|
|
- MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state = NULL;
|
2021-11-12 08:43:54 +00:00
|
|
|
- MetaDrmBuffer *buffer;
|
|
|
|
+ g_autoptr (MetaDrmBuffer) buffer = NULL;
|
|
|
|
MetaKmsPlaneAssignment *plane_assignment;
|
|
|
|
|
|
|
|
COGL_TRACE_BEGIN_SCOPED (MetaOnscreenNativeFlipCrtcs,
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -446,7 +423,7 @@ meta_onscreen_native_flip_crtc (CoglOnscreen *onscreen,
|
|
|
|
gpu_kms = META_GPU_KMS (meta_crtc_get_gpu (crtc));
|
|
|
|
kms_device = meta_gpu_kms_get_kms_device (gpu_kms);
|
2021-11-24 14:38:22 +00:00
|
|
|
kms = meta_kms_device_get_kms (kms_device);
|
2022-04-02 05:32:56 +00:00
|
|
|
- kms_update = meta_kms_ensure_pending_update (kms, kms_device);
|
|
|
|
+ kms_update = meta_kms_ensure_pending_update_for_crtc (kms, kms_crtc);
|
2021-11-24 14:38:22 +00:00
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
g_assert (meta_gpu_kms_is_crtc_active (gpu_kms, crtc));
|
2021-11-24 14:38:22 +00:00
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
@@ -455,15 +432,7 @@ meta_onscreen_native_flip_crtc (CoglOnscreen *onscreen,
|
|
|
|
switch (renderer_gpu_data->mode)
|
|
|
|
{
|
2021-11-12 08:43:54 +00:00
|
|
|
case META_RENDERER_NATIVE_MODE_GBM:
|
2022-04-02 05:32:56 +00:00
|
|
|
- if (gpu_kms == render_gpu)
|
|
|
|
- {
|
2021-11-12 08:43:54 +00:00
|
|
|
- buffer = onscreen_native->gbm.next_fb;
|
2022-04-02 05:32:56 +00:00
|
|
|
- }
|
|
|
|
- else
|
|
|
|
- {
|
|
|
|
- secondary_gpu_state = onscreen_native->secondary_gpu_state;
|
2021-11-12 08:43:54 +00:00
|
|
|
- buffer = secondary_gpu_state->gbm.next_fb;
|
2022-04-02 05:32:56 +00:00
|
|
|
- }
|
|
|
|
+ buffer = g_steal_pointer (&onscreen_native->gbm.next_fb);
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
plane_assignment = meta_crtc_kms_assign_primary_plane (crtc_kms,
|
2022-04-02 05:32:56 +00:00
|
|
|
buffer,
|
2022-09-14 14:55:57 +00:00
|
|
|
@@ -474,6 +443,11 @@ meta_onscreen_native_flip_crtc (CoglOnscreen *onscreen,
|
|
|
|
meta_kms_plane_assignment_set_fb_damage (plane_assignment,
|
|
|
|
rectangles, n_rectangles);
|
|
|
|
}
|
|
|
|
+
|
|
|
|
+ g_object_set_data_full (G_OBJECT (buffer),
|
|
|
|
+ "gbm_surface owner",
|
|
|
|
+ g_object_ref (onscreen),
|
|
|
|
+ (GDestroyNotify) g_object_unref);
|
|
|
|
break;
|
|
|
|
case META_RENDERER_NATIVE_MODE_SURFACELESS:
|
|
|
|
g_assert_not_reached ();
|
|
|
|
@@ -509,7 +483,7 @@ meta_onscreen_native_set_crtc_mode (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
COGL_TRACE_BEGIN_SCOPED (MetaOnscreenNativeSetCrtcModes,
|
|
|
|
"Onscreen (set CRTC modes)");
|
|
|
|
|
|
|
|
- kms_update = meta_kms_ensure_pending_update (kms, kms_device);
|
|
|
|
+ kms_update = meta_kms_ensure_pending_update_for_crtc (kms, kms_crtc);
|
|
|
|
|
|
|
|
switch (renderer_gpu_data->mode)
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -537,13 +511,41 @@ meta_onscreen_native_set_crtc_mode (CoglOnscreen *onscreen,
|
|
|
|
kms_update);
|
2022-04-02 05:32:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
+static void
|
|
|
|
+hold_primary_gpu_fb_for_secondary_gpu_scanout (MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state,
|
|
|
|
+ MetaDrmBuffer *primary_gpu_fb,
|
|
|
|
+ MetaDrmBuffer *secondary_gpu_fb)
|
|
|
|
+{
|
|
|
|
+ if (META_IS_DRM_BUFFER_DUMB (secondary_gpu_fb))
|
|
|
|
+ {
|
|
|
|
+ MetaDrmBufferDumb *dumb_fb = META_DRM_BUFFER_DUMB (secondary_gpu_fb);
|
|
|
|
+ int i;
|
|
|
|
+ const int n = G_N_ELEMENTS (secondary_gpu_state->cpu.dumb_fbs);
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
+ for (i = 0; i < n; i++)
|
2021-11-12 08:43:54 +00:00
|
|
|
+ {
|
2022-04-02 05:32:56 +00:00
|
|
|
+ if (dumb_fb == secondary_gpu_state->cpu.dumb_fbs[i])
|
|
|
|
+ {
|
|
|
|
+ g_set_object (&secondary_gpu_state->cpu.source_fbs[i],
|
|
|
|
+ primary_gpu_fb);
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
+ }
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
+ g_warn_if_fail (i < n);
|
|
|
|
+ }
|
|
|
|
+}
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
static void
|
|
|
|
secondary_gpu_release_dumb (MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (secondary_gpu_state->cpu.dumb_fbs); i++)
|
|
|
|
- g_clear_object (&secondary_gpu_state->cpu.dumb_fbs[i]);
|
|
|
|
+ {
|
|
|
|
+ g_clear_object (&secondary_gpu_state->cpu.dumb_fbs[i]);
|
|
|
|
+ g_clear_object (&secondary_gpu_state->cpu.source_fbs[i]);
|
|
|
|
+ }
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -568,8 +570,6 @@ secondary_gpu_state_free (MetaOnscreenNativeSecondaryGpuState *secondary_gpu_sta
|
2021-11-12 08:43:54 +00:00
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
- g_clear_object (&secondary_gpu_state->gbm.current_fb);
|
2022-04-02 05:32:56 +00:00
|
|
|
- g_clear_object (&secondary_gpu_state->gbm.next_fb);
|
2021-11-12 08:43:54 +00:00
|
|
|
g_clear_pointer (&secondary_gpu_state->gbm.surface, gbm_surface_destroy);
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
secondary_gpu_release_dumb (secondary_gpu_state);
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -577,11 +577,11 @@ secondary_gpu_state_free (MetaOnscreenNativeSecondaryGpuState *secondary_gpu_sta
|
2022-04-02 05:32:56 +00:00
|
|
|
g_free (secondary_gpu_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
-static gboolean
|
|
|
|
+static MetaDrmBuffer *
|
|
|
|
import_shared_framebuffer (CoglOnscreen *onscreen,
|
|
|
|
- MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state)
|
|
|
|
+ MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state,
|
|
|
|
+ MetaDrmBuffer *primary_gpu_fb)
|
|
|
|
{
|
|
|
|
- MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
MetaRenderDevice *render_device;
|
|
|
|
g_autoptr (GError) error = NULL;
|
|
|
|
MetaDrmBuffer *imported_buffer;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -589,7 +589,7 @@ import_shared_framebuffer (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
render_device = secondary_gpu_state->renderer_gpu_data->render_device;
|
|
|
|
imported_buffer =
|
|
|
|
meta_render_device_import_dma_buf (render_device,
|
|
|
|
- onscreen_native->gbm.next_fb,
|
|
|
|
+ primary_gpu_fb,
|
|
|
|
&error);
|
|
|
|
if (!imported_buffer)
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -603,16 +603,9 @@ import_shared_framebuffer (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
META_SHARED_FRAMEBUFFER_IMPORT_STATUS_NONE);
|
|
|
|
secondary_gpu_state->import_status =
|
|
|
|
META_SHARED_FRAMEBUFFER_IMPORT_STATUS_FAILED;
|
|
|
|
- return FALSE;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
- /*
|
|
|
|
- * next_fb may already contain a fallback buffer, so clear it only
|
|
|
|
- * when we are sure to succeed.
|
|
|
|
- */
|
|
|
|
- g_clear_object (&secondary_gpu_state->gbm.next_fb);
|
|
|
|
- secondary_gpu_state->gbm.next_fb = imported_buffer;
|
|
|
|
-
|
|
|
|
if (secondary_gpu_state->import_status ==
|
|
|
|
META_SHARED_FRAMEBUFFER_IMPORT_STATUS_NONE)
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -629,16 +622,16 @@ import_shared_framebuffer (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
|
|
|
|
secondary_gpu_state->import_status =
|
|
|
|
META_SHARED_FRAMEBUFFER_IMPORT_STATUS_OK;
|
|
|
|
- return TRUE;
|
|
|
|
+ return imported_buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
-static void
|
|
|
|
+static MetaDrmBuffer *
|
|
|
|
copy_shared_framebuffer_gpu (CoglOnscreen *onscreen,
|
|
|
|
MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state,
|
|
|
|
MetaRendererNativeGpuData *renderer_gpu_data,
|
|
|
|
- gboolean *egl_context_changed)
|
|
|
|
+ gboolean *egl_context_changed,
|
|
|
|
+ MetaDrmBuffer *primary_gpu_fb)
|
|
|
|
{
|
|
|
|
- MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
MetaRendererNative *renderer_native = renderer_gpu_data->renderer_native;
|
|
|
|
MetaEgl *egl = meta_renderer_native_get_egl (renderer_native);
|
|
|
|
MetaGles3 *gles3 = meta_renderer_native_get_gles3 (renderer_native);
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -654,9 +647,6 @@ copy_shared_framebuffer_gpu (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
COGL_TRACE_BEGIN_SCOPED (CopySharedFramebufferSecondaryGpu,
|
|
|
|
"FB Copy (secondary GPU)");
|
|
|
|
|
|
|
|
- g_warn_if_fail (secondary_gpu_state->gbm.next_fb == NULL);
|
|
|
|
- g_clear_object (&secondary_gpu_state->gbm.next_fb);
|
|
|
|
-
|
|
|
|
render_device = renderer_gpu_data->render_device;
|
|
|
|
egl_display = meta_render_device_get_egl_display (render_device);
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -669,13 +659,13 @@ copy_shared_framebuffer_gpu (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
{
|
|
|
|
g_warning ("Failed to make current: %s", error->message);
|
|
|
|
g_error_free (error);
|
|
|
|
- return;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*egl_context_changed = TRUE;
|
|
|
|
|
|
|
|
|
|
|
|
- buffer_gbm = META_DRM_BUFFER_GBM (onscreen_native->gbm.next_fb);
|
|
|
|
+ buffer_gbm = META_DRM_BUFFER_GBM (primary_gpu_fb);
|
|
|
|
bo = meta_drm_buffer_gbm_get_bo (buffer_gbm);
|
|
|
|
if (!meta_renderer_native_gles3_blit_shared_bo (egl,
|
|
|
|
gles3,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -687,7 +677,7 @@ copy_shared_framebuffer_gpu (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
{
|
|
|
|
g_warning ("Failed to blit shared framebuffer: %s", error->message);
|
|
|
|
g_error_free (error);
|
|
|
|
- return;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!meta_egl_swap_buffers (egl,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -697,7 +687,7 @@ copy_shared_framebuffer_gpu (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
{
|
|
|
|
g_warning ("Failed to swap buffers: %s", error->message);
|
|
|
|
g_error_free (error);
|
|
|
|
- return;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
use_modifiers = meta_renderer_native_use_modifiers (renderer_native);
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -717,10 +707,10 @@ copy_shared_framebuffer_gpu (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
g_warning ("meta_drm_buffer_gbm_new_lock_front failed: %s",
|
|
|
|
error->message);
|
|
|
|
g_error_free (error);
|
|
|
|
- return;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
- secondary_gpu_state->gbm.next_fb = META_DRM_BUFFER (buffer_gbm);
|
|
|
|
+ return META_DRM_BUFFER (buffer_gbm);
|
|
|
|
}
|
|
|
|
|
|
|
|
static MetaDrmBufferDumb *
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -735,7 +725,7 @@ secondary_gpu_get_next_dumb_buffer (MetaOnscreenNativeSecondaryGpuState *seconda
|
2022-04-02 05:32:56 +00:00
|
|
|
return secondary_gpu_state->cpu.dumb_fbs[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
-static gboolean
|
|
|
|
+static MetaDrmBuffer *
|
|
|
|
copy_shared_framebuffer_primary_gpu (CoglOnscreen *onscreen,
|
|
|
|
MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state,
|
|
|
|
const int *rectangles,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -761,13 +751,13 @@ copy_shared_framebuffer_primary_gpu (CoglOnscreen *onscre
|
2022-04-13 08:38:52 +00:00
|
|
|
|
|
|
|
if (!secondary_gpu_state ||
|
|
|
|
secondary_gpu_state->egl_surface == EGL_NO_SURFACE)
|
|
|
|
- return FALSE;
|
|
|
|
+ return NULL;
|
|
|
|
|
|
|
|
primary_gpu = meta_renderer_native_get_primary_gpu (renderer_native);
|
2022-04-02 05:32:56 +00:00
|
|
|
primary_gpu_data =
|
|
|
|
meta_renderer_native_get_gpu_data (renderer_native, primary_gpu);
|
|
|
|
if (!primary_gpu_data->secondary.has_EGL_EXT_image_dma_buf_import_modifiers)
|
|
|
|
- return FALSE;
|
|
|
|
+ return NULL;
|
|
|
|
|
|
|
|
buffer_dumb = secondary_gpu_get_next_dumb_buffer (secondary_gpu_state);
|
|
|
|
buffer = META_DRM_BUFFER (buffer_dumb);
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -790,7 +780,7 @@ copy_shared_framebuffer_primary_gpu (CoglOnscreen *onscre
|
2022-04-02 05:32:56 +00:00
|
|
|
{
|
|
|
|
meta_topic (META_DEBUG_KMS,
|
|
|
|
"Failed to create DMA buffer: %s", error->message);
|
|
|
|
- return FALSE;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dmabuf_fb =
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -808,7 +798,7 @@ copy_shared_framebuffer_primary_gpu (CoglOnscreen *onscre
|
2022-04-02 05:32:56 +00:00
|
|
|
meta_topic (META_DEBUG_KMS,
|
|
|
|
"Failed to create DMA buffer for blitting: %s",
|
|
|
|
error->message);
|
|
|
|
- return FALSE;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
/* Limit the number of individual copies to 16 */
|
|
|
|
#define MAX_RECTS 16
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -821,7 +811,7 @@ copy_shared_framebuffer_primary_gpu (CoglOnscreen *onscre
|
2022-04-02 05:32:56 +00:00
|
|
|
&error))
|
|
|
|
{
|
|
|
|
g_object_unref (dmabuf_fb);
|
|
|
|
- return FALSE;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -838,20 +828,19 @@ copy_shared_framebuffer_primary_gpu (CoglOnscreen *onscre
|
2022-04-02 05:32:56 +00:00
|
|
|
&error))
|
|
|
|
{
|
|
|
|
g_object_unref (dmabuf_fb);
|
|
|
|
- return FALSE;
|
|
|
|
+ return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
g_object_unref (dmabuf_fb);
|
|
|
|
|
|
|
|
- g_set_object (&secondary_gpu_state->gbm.next_fb, buffer);
|
|
|
|
secondary_gpu_state->cpu.current_dumb_fb = buffer_dumb;
|
|
|
|
|
|
|
|
- return TRUE;
|
|
|
|
+ return g_object_ref (buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
-static void
|
|
|
|
+static MetaDrmBuffer *
|
|
|
|
copy_shared_framebuffer_cpu (CoglOnscreen *onscreen,
|
|
|
|
MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state,
|
|
|
|
MetaRendererNativeGpuData *renderer_gpu_data)
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -903,17 +892,19 @@ copy_shared_framebuffer_cpu (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
|
|
|
|
cogl_object_unref (dumb_bitmap);
|
|
|
|
|
|
|
|
- g_set_object (&secondary_gpu_state->gbm.next_fb, buffer);
|
|
|
|
secondary_gpu_state->cpu.current_dumb_fb = buffer_dumb;
|
|
|
|
+
|
|
|
|
+ return g_object_ref (buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
-static void
|
|
|
|
+static MetaDrmBuffer *
|
|
|
|
update_secondary_gpu_state_pre_swap_buffers (CoglOnscreen *onscreen,
|
|
|
|
const int *rectangles,
|
|
|
|
int n_rectangles)
|
|
|
|
{
|
|
|
|
MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state;
|
|
|
|
+ MetaDrmBuffer *copy = NULL;
|
|
|
|
|
|
|
|
COGL_TRACE_BEGIN_SCOPED (MetaRendererNativeGpuStatePreSwapBuffers,
|
|
|
|
"Onscreen (secondary gpu pre-swap-buffers)");
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -939,10 +930,11 @@ update_secondary_gpu_state_pre_swap_buffers (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
/* prepare fallback */
|
|
|
|
G_GNUC_FALLTHROUGH;
|
|
|
|
case META_SHARED_FRAMEBUFFER_COPY_MODE_PRIMARY:
|
|
|
|
- if (!copy_shared_framebuffer_primary_gpu (onscreen,
|
|
|
|
- secondary_gpu_state,
|
|
|
|
- rectangles,
|
|
|
|
- n_rectangles))
|
|
|
|
+ copy = copy_shared_framebuffer_primary_gpu (onscreen,
|
|
|
|
+ secondary_gpu_state,
|
|
|
|
+ rectangles,
|
|
|
|
+ n_rectangles);
|
|
|
|
+ if (!copy)
|
|
|
|
{
|
|
|
|
if (!secondary_gpu_state->noted_primary_gpu_copy_failed)
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -952,9 +944,9 @@ update_secondary_gpu_state_pre_swap_buffers (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
secondary_gpu_state->noted_primary_gpu_copy_failed = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
- copy_shared_framebuffer_cpu (onscreen,
|
|
|
|
- secondary_gpu_state,
|
|
|
|
- renderer_gpu_data);
|
|
|
|
+ copy = copy_shared_framebuffer_cpu (onscreen,
|
|
|
|
+ secondary_gpu_state,
|
|
|
|
+ renderer_gpu_data);
|
|
|
|
}
|
|
|
|
else if (!secondary_gpu_state->noted_primary_gpu_copy_ok)
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -966,11 +958,15 @@ update_secondary_gpu_state_pre_swap_buffers (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
+
|
|
|
|
+ return copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
-update_secondary_gpu_state_post_swap_buffers (CoglOnscreen *onscreen,
|
|
|
|
- gboolean *egl_context_changed)
|
|
|
|
+update_secondary_gpu_state_post_swap_buffers (CoglOnscreen *onscreen,
|
|
|
|
+ gboolean *egl_context_changed,
|
|
|
|
+ MetaDrmBuffer *primary_gpu_fb,
|
|
|
|
+ MetaDrmBuffer **secondary_gpu_fb)
|
|
|
|
{
|
|
|
|
MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
MetaRendererNative *renderer_native = onscreen_native->renderer_native;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -983,6 +979,7 @@ update_secondary_gpu_state_post_swap_buffers (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
if (secondary_gpu_state)
|
|
|
|
{
|
|
|
|
MetaRendererNativeGpuData *renderer_gpu_data;
|
|
|
|
+ g_autoptr (MetaDrmBuffer) next_fb = NULL;
|
|
|
|
|
|
|
|
renderer_gpu_data =
|
|
|
|
meta_renderer_native_get_gpu_data (renderer_native,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -990,23 +987,30 @@ update_secondary_gpu_state_post_swap_buffers (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
switch (renderer_gpu_data->secondary.copy_mode)
|
|
|
|
{
|
|
|
|
case META_SHARED_FRAMEBUFFER_COPY_MODE_ZERO:
|
|
|
|
- if (import_shared_framebuffer (onscreen, secondary_gpu_state))
|
|
|
|
+ next_fb = import_shared_framebuffer (onscreen,
|
|
|
|
+ secondary_gpu_state,
|
|
|
|
+ primary_gpu_fb);
|
|
|
|
+ if (next_fb)
|
|
|
|
break;
|
|
|
|
-
|
|
|
|
- /* The fallback was prepared in pre_swap_buffers */
|
|
|
|
+ /* The fallback was prepared in pre_swap_buffers and is currently
|
|
|
|
+ * in secondary_gpu_fb.
|
|
|
|
+ */
|
|
|
|
renderer_gpu_data->secondary.copy_mode =
|
|
|
|
META_SHARED_FRAMEBUFFER_COPY_MODE_PRIMARY;
|
|
|
|
G_GNUC_FALLTHROUGH;
|
|
|
|
case META_SHARED_FRAMEBUFFER_COPY_MODE_PRIMARY:
|
|
|
|
- /* Done before eglSwapBuffers. */
|
|
|
|
+ next_fb = g_object_ref (*secondary_gpu_fb);
|
|
|
|
break;
|
|
|
|
case META_SHARED_FRAMEBUFFER_COPY_MODE_SECONDARY_GPU:
|
|
|
|
- copy_shared_framebuffer_gpu (onscreen,
|
|
|
|
- secondary_gpu_state,
|
|
|
|
- renderer_gpu_data,
|
|
|
|
- egl_context_changed);
|
|
|
|
+ next_fb = copy_shared_framebuffer_gpu (onscreen,
|
|
|
|
+ secondary_gpu_state,
|
|
|
|
+ renderer_gpu_data,
|
|
|
|
+ egl_context_changed,
|
|
|
|
+ primary_gpu_fb);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
+
|
|
|
|
+ g_set_object (secondary_gpu_fb, next_fb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1040,34 +1044,39 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
CoglRendererEGL *cogl_renderer_egl = cogl_renderer->winsys;
|
|
|
|
MetaRendererNativeGpuData *renderer_gpu_data = cogl_renderer_egl->platform;
|
|
|
|
MetaRendererNative *renderer_native = renderer_gpu_data->renderer_native;
|
|
|
|
- MetaRenderer *renderer = META_RENDERER (renderer_native);
|
|
|
|
- MetaBackend *backend = meta_renderer_get_backend (renderer);
|
|
|
|
- MetaBackendNative *backend_native = META_BACKEND_NATIVE (backend);
|
|
|
|
- MetaMonitorManager *monitor_manager =
|
|
|
|
- meta_backend_get_monitor_manager (backend);
|
|
|
|
- MetaKms *kms = meta_backend_native_get_kms (backend_native);
|
|
|
|
MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
MetaGpuKms *render_gpu = onscreen_native->render_gpu;
|
|
|
|
MetaDeviceFile *render_device_file;
|
2022-04-02 05:32:56 +00:00
|
|
|
ClutterFrame *frame = user_data;
|
2021-11-12 08:43:54 +00:00
|
|
|
CoglOnscreenClass *parent_class;
|
|
|
|
gboolean egl_context_changed = FALSE;
|
|
|
|
- MetaPowerSave power_save_mode;
|
|
|
|
g_autoptr (GError) error = NULL;
|
2022-04-02 05:32:56 +00:00
|
|
|
MetaDrmBufferFlags buffer_flags;
|
2021-11-12 08:43:54 +00:00
|
|
|
MetaDrmBufferGbm *buffer_gbm;
|
|
|
|
- MetaKmsCrtc *kms_crtc;
|
|
|
|
- MetaKmsDevice *kms_device;
|
|
|
|
- MetaKmsUpdateFlag flags;
|
|
|
|
- g_autoptr (MetaKmsFeedback) kms_feedback = NULL;
|
|
|
|
- const GError *feedback_error;
|
2022-04-02 05:32:56 +00:00
|
|
|
+ g_autoptr (MetaDrmBuffer) primary_gpu_fb = NULL;
|
|
|
|
+ g_autoptr (MetaDrmBuffer) secondary_gpu_fb = NULL;
|
2021-11-12 08:43:54 +00:00
|
|
|
+ size_t rectangles_size;
|
|
|
|
|
|
|
|
COGL_TRACE_BEGIN_SCOPED (MetaRendererNativeSwapBuffers,
|
|
|
|
"Onscreen (swap-buffers)");
|
2022-04-02 05:32:56 +00:00
|
|
|
|
|
|
|
- update_secondary_gpu_state_pre_swap_buffers (onscreen,
|
|
|
|
- rectangles,
|
|
|
|
- n_rectangles);
|
|
|
|
+ if (meta_is_topic_enabled (META_DEBUG_KMS))
|
|
|
|
+ {
|
|
|
|
+ unsigned int frames_pending =
|
|
|
|
+ cogl_onscreen_count_pending_frames (onscreen);
|
|
|
|
+
|
|
|
|
+ meta_topic (META_DEBUG_KMS,
|
|
|
|
+ "Swap buffers: %u frames pending (%s-buffering)",
|
|
|
|
+ frames_pending,
|
|
|
|
+ frames_pending == 1 ? "double" :
|
|
|
|
+ frames_pending == 2 ? "triple" :
|
|
|
|
+ "?");
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ secondary_gpu_fb =
|
|
|
|
+ update_secondary_gpu_state_pre_swap_buffers (onscreen,
|
|
|
|
+ rectangles,
|
|
|
|
+ n_rectangles);
|
|
|
|
|
|
|
|
parent_class = COGL_ONSCREEN_CLASS (meta_onscreen_native_parent_class);
|
|
|
|
parent_class->swap_buffers_with_damage (onscreen,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1083,9 +1092,6 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2021-11-24 14:38:22 +00:00
|
|
|
switch (renderer_gpu_data->mode)
|
|
|
|
{
|
|
|
|
case META_RENDERER_NATIVE_MODE_GBM:
|
|
|
|
- g_warn_if_fail (onscreen_native->gbm.next_fb == NULL);
|
2022-04-02 05:32:56 +00:00
|
|
|
- g_clear_object (&onscreen_native->gbm.next_fb);
|
|
|
|
-
|
|
|
|
buffer_flags = META_DRM_BUFFER_FLAG_NONE;
|
|
|
|
if (!meta_renderer_native_use_modifiers (renderer_native))
|
|
|
|
buffer_flags |= META_DRM_BUFFER_FLAG_DISABLE_MODIFIERS;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1103,8 +1109,7 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
return;
|
|
|
|
}
|
2021-11-24 14:38:22 +00:00
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
- onscreen_native->gbm.next_fb = META_DRM_BUFFER (buffer_gbm);
|
2022-09-14 14:55:57 +00:00
|
|
|
-
|
2022-04-02 05:32:56 +00:00
|
|
|
+ primary_gpu_fb = META_DRM_BUFFER (g_steal_pointer (&buffer_gbm));
|
|
|
|
break;
|
|
|
|
case META_RENDERER_NATIVE_MODE_SURFACELESS:
|
2022-09-14 14:55:57 +00:00
|
|
|
g_assert_not_reached ();
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1115,7 +1120,46 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
- update_secondary_gpu_state_post_swap_buffers (onscreen, &egl_context_changed);
|
|
|
|
+ update_secondary_gpu_state_post_swap_buffers (onscreen,
|
|
|
|
+ &egl_context_changed,
|
|
|
|
+ primary_gpu_fb,
|
|
|
|
+ &secondary_gpu_fb);
|
|
|
|
+
|
|
|
|
+ switch (renderer_gpu_data->mode)
|
|
|
|
+ {
|
|
|
|
+ case META_RENDERER_NATIVE_MODE_GBM:
|
|
|
|
+ if (onscreen_native->gbm.next_fb != NULL)
|
|
|
|
+ {
|
|
|
|
+ g_warn_if_fail (onscreen_native->gbm.stalled_fb == NULL);
|
|
|
|
+ drop_stalled_swap (onscreen);
|
|
|
|
+ g_assert (onscreen_native->gbm.stalled_fb == NULL);
|
|
|
|
+ onscreen_native->gbm.stalled_fb =
|
|
|
|
+ g_steal_pointer (&onscreen_native->gbm.next_fb);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ if (onscreen_native->secondary_gpu_state)
|
|
|
|
+ {
|
|
|
|
+ g_set_object (&onscreen_native->gbm.next_fb, secondary_gpu_fb);
|
|
|
|
+ hold_primary_gpu_fb_for_secondary_gpu_scanout (
|
|
|
|
+ onscreen_native->secondary_gpu_state,
|
|
|
|
+ primary_gpu_fb,
|
|
|
|
+ secondary_gpu_fb);
|
|
|
|
+ }
|
|
|
|
+ else
|
|
|
|
+ {
|
|
|
|
+ g_set_object (&onscreen_native->gbm.next_fb, primary_gpu_fb);
|
|
|
|
+ }
|
|
|
|
+ break;
|
|
|
|
+ case META_RENDERER_NATIVE_MODE_SURFACELESS:
|
|
|
|
+ break;
|
|
|
|
+#ifdef HAVE_EGL_DEVICE
|
|
|
|
+ case META_RENDERER_NATIVE_MODE_EGL_DEVICE:
|
|
|
|
+ break;
|
|
|
|
+#endif
|
|
|
|
+ }
|
|
|
|
+
|
2021-11-12 08:43:54 +00:00
|
|
|
+ clutter_frame_set_result (frame,
|
|
|
|
+ CLUTTER_FRAME_RESULT_PENDING_PRESENTED);
|
|
|
|
|
|
|
|
/*
|
2022-04-02 05:32:56 +00:00
|
|
|
* If we changed EGL context, cogl will have the wrong idea about what is
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1126,23 +1170,77 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
if (egl_context_changed)
|
|
|
|
_cogl_winsys_egl_ensure_current (cogl_display);
|
|
|
|
|
|
|
|
+ rectangles_size = n_rectangles * 4 * sizeof (int);
|
|
|
|
+ onscreen_native->next_post.rectangles =
|
|
|
|
+ g_realloc (onscreen_native->next_post.rectangles, rectangles_size);
|
|
|
|
+ memcpy (onscreen_native->next_post.rectangles, rectangles, rectangles_size);
|
|
|
|
+ onscreen_native->next_post.n_rectangles = n_rectangles;
|
|
|
|
+
|
|
|
|
+ onscreen_native->swaps_pending++;
|
2022-04-02 05:32:56 +00:00
|
|
|
+ try_post_latest_swap (onscreen);
|
2021-11-12 08:43:54 +00:00
|
|
|
+}
|
|
|
|
+
|
|
|
|
+static void
|
2022-04-02 05:32:56 +00:00
|
|
|
+try_post_latest_swap (CoglOnscreen *onscreen)
|
2021-11-12 08:43:54 +00:00
|
|
|
+{
|
|
|
|
+ CoglFramebuffer *framebuffer = COGL_FRAMEBUFFER (onscreen);
|
|
|
|
+ CoglContext *cogl_context = cogl_framebuffer_get_context (framebuffer);
|
|
|
|
+ CoglRenderer *cogl_renderer = cogl_context->display->renderer;
|
|
|
|
+ CoglRendererEGL *cogl_renderer_egl = cogl_renderer->winsys;
|
|
|
|
+ MetaRendererNativeGpuData *renderer_gpu_data = cogl_renderer_egl->platform;
|
|
|
|
+ MetaRendererNative *renderer_native = renderer_gpu_data->renderer_native;
|
|
|
|
+ MetaRenderer *renderer = META_RENDERER (renderer_native);
|
|
|
|
+ MetaBackend *backend = meta_renderer_get_backend (renderer);
|
|
|
|
+ MetaBackendNative *backend_native = META_BACKEND_NATIVE (backend);
|
|
|
|
+ MetaMonitorManager *monitor_manager =
|
|
|
|
+ meta_backend_get_monitor_manager (backend);
|
|
|
|
+ MetaKms *kms = meta_backend_native_get_kms (backend_native);
|
|
|
|
+ MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
+ MetaPowerSave power_save_mode;
|
|
|
|
+ MetaCrtcKms *crtc_kms = META_CRTC_KMS (onscreen_native->crtc);
|
|
|
|
+ MetaKmsCrtc *kms_crtc = meta_crtc_kms_get_kms_crtc (crtc_kms);
|
|
|
|
+ MetaKmsDevice *kms_device = meta_kms_crtc_get_device (kms_crtc);
|
|
|
|
+ MetaKmsUpdateFlag flags;
|
|
|
|
+ g_autoptr (MetaKmsFeedback) kms_feedback = NULL;
|
|
|
|
+ const GError *feedback_error;
|
2022-04-02 05:32:56 +00:00
|
|
|
+ unsigned int frames_pending = cogl_onscreen_count_pending_frames (onscreen);
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
2022-10-27 14:41:22 +00:00
|
|
|
+ if (meta_kms_is_shutting_down (kms))
|
|
|
|
+ {
|
|
|
|
+ meta_onscreen_native_discard_pending_swaps (onscreen);
|
|
|
|
+ return;
|
|
|
|
+ }
|
|
|
|
+
|
2021-11-12 08:43:54 +00:00
|
|
|
+ if (onscreen_native->swaps_pending == 0)
|
|
|
|
+ return;
|
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
+ g_assert (frames_pending >= onscreen_native->swaps_pending);
|
2021-11-12 08:43:54 +00:00
|
|
|
+
|
|
|
|
power_save_mode = meta_monitor_manager_get_power_save_mode (monitor_manager);
|
|
|
|
if (power_save_mode == META_POWER_SAVE_ON)
|
|
|
|
{
|
2022-04-02 05:32:56 +00:00
|
|
|
+ unsigned int posts_pending;
|
|
|
|
+
|
|
|
|
+ posts_pending = frames_pending - onscreen_native->swaps_pending;
|
|
|
|
+ if (posts_pending > 0)
|
|
|
|
+ return; /* wait for the next frame notification and then try again */
|
|
|
|
+
|
|
|
|
+ drop_stalled_swap (onscreen);
|
|
|
|
+ g_return_if_fail (onscreen_native->swaps_pending > 0);
|
|
|
|
+ onscreen_native->swaps_pending--;
|
|
|
|
+
|
|
|
|
ensure_crtc_modes (onscreen);
|
|
|
|
meta_onscreen_native_flip_crtc (onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
onscreen_native->view,
|
|
|
|
onscreen_native->crtc,
|
|
|
|
META_KMS_PAGE_FLIP_LISTENER_FLAG_NONE,
|
|
|
|
- rectangles,
|
|
|
|
- n_rectangles);
|
|
|
|
+ onscreen_native->next_post.rectangles,
|
|
|
|
+ onscreen_native->next_post.n_rectangles);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
meta_renderer_native_queue_power_save_page_flip (renderer_native,
|
|
|
|
onscreen);
|
|
|
|
- clutter_frame_set_result (frame,
|
|
|
|
- CLUTTER_FRAME_RESULT_PENDING_PRESENTED);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1160,9 +1258,6 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
"Postponing primary plane composite update for CRTC %u (%s)",
|
|
|
|
meta_kms_crtc_get_id (kms_crtc),
|
|
|
|
meta_kms_device_get_path (kms_device));
|
|
|
|
-
|
|
|
|
- clutter_frame_set_result (frame,
|
|
|
|
- CLUTTER_FRAME_RESULT_PENDING_PRESENTED);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else if (meta_renderer_native_has_pending_mode_set (renderer_native))
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1172,8 +1267,6 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
meta_renderer_native_notify_mode_sets_reset (renderer_native);
|
|
|
|
meta_renderer_native_post_mode_set_updates (renderer_native);
|
|
|
|
- clutter_frame_set_result (frame,
|
|
|
|
- CLUTTER_FRAME_RESULT_PENDING_PRESENTED);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1186,8 +1279,6 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
{
|
|
|
|
meta_renderer_native_notify_mode_sets_reset (renderer_native);
|
|
|
|
meta_renderer_native_post_mode_set_updates (renderer_native);
|
|
|
|
- clutter_frame_set_result (frame,
|
|
|
|
- CLUTTER_FRAME_RESULT_PENDING_PRESENTED);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1200,18 +1291,16 @@ meta_onscreen_native_swap_buffers_with_damage (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
meta_kms_device_get_path (kms_device));
|
2021-11-12 08:43:54 +00:00
|
|
|
|
|
|
|
flags = META_KMS_UPDATE_FLAG_NONE;
|
2022-04-02 05:32:56 +00:00
|
|
|
- kms_feedback = meta_kms_post_pending_update_sync (kms, kms_device, flags);
|
|
|
|
+ kms_feedback = meta_kms_post_pending_update_for_crtc_sync (kms,
|
|
|
|
+ kms_crtc,
|
|
|
|
+ flags);
|
2021-11-12 08:43:54 +00:00
|
|
|
+ g_return_if_fail (kms_feedback != NULL);
|
|
|
|
|
|
|
|
switch (meta_kms_feedback_get_result (kms_feedback))
|
|
|
|
{
|
|
|
|
case META_KMS_FEEDBACK_PASSED:
|
|
|
|
- clutter_frame_set_result (frame,
|
|
|
|
- CLUTTER_FRAME_RESULT_PENDING_PRESENTED);
|
|
|
|
break;
|
|
|
|
case META_KMS_FEEDBACK_FAILED:
|
|
|
|
- clutter_frame_set_result (frame,
|
|
|
|
- CLUTTER_FRAME_RESULT_PENDING_PRESENTED);
|
|
|
|
-
|
|
|
|
feedback_error = meta_kms_feedback_get_error (kms_feedback);
|
|
|
|
if (!g_error_matches (feedback_error,
|
|
|
|
G_IO_ERROR,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1298,6 +1387,18 @@ meta_onscreen_native_direct_scanout (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
+ /* Our direct scanout frame counts as 1, so more than that means we would
|
|
|
|
+ * be jumping the queue (and post would fail).
|
|
|
|
+ */
|
|
|
|
+ if (cogl_onscreen_count_pending_frames (onscreen) > 1)
|
2021-11-12 08:43:54 +00:00
|
|
|
+ {
|
|
|
|
+ g_set_error_literal (error,
|
|
|
|
+ COGL_SCANOUT_ERROR,
|
|
|
|
+ COGL_SCANOUT_ERROR_INHIBITED,
|
|
|
|
+ "Direct scanout is inhibited during triple buffering");
|
|
|
|
+ return FALSE;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
renderer_gpu_data = meta_renderer_native_get_gpu_data (renderer_native,
|
|
|
|
render_gpu);
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1350,7 +1451,9 @@ meta_onscreen_native_direct_scanout (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
meta_kms_device_get_path (kms_device));
|
|
|
|
|
|
|
|
flags = META_KMS_UPDATE_FLAG_PRESERVE_ON_ERROR;
|
|
|
|
- kms_feedback = meta_kms_post_pending_update_sync (kms, kms_device, flags);
|
|
|
|
+ kms_feedback = meta_kms_post_pending_update_for_crtc_sync (kms,
|
|
|
|
+ kms_crtc,
|
|
|
|
+ flags);
|
|
|
|
switch (meta_kms_feedback_get_result (kms_feedback))
|
|
|
|
{
|
|
|
|
case META_KMS_FEEDBACK_PASSED:
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1364,7 +1467,6 @@ meta_onscreen_native_direct_scanout (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED))
|
|
|
|
break;
|
|
|
|
|
|
|
|
- g_clear_object (&onscreen_native->gbm.next_fb);
|
|
|
|
g_propagate_error (error, g_error_copy (feedback_error));
|
|
|
|
return FALSE;
|
|
|
|
}
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1400,7 +1502,10 @@ meta_onscreen_native_finish_frame (CoglOnscreen *onscreen,
|
2021-11-12 08:43:54 +00:00
|
|
|
g_autoptr (MetaKmsFeedback) kms_feedback = NULL;
|
|
|
|
const GError *error;
|
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
- kms_update = meta_kms_get_pending_update (kms, kms_device);
|
|
|
|
+ if (cogl_onscreen_count_pending_frames (onscreen) > 0)
|
2021-11-12 08:43:54 +00:00
|
|
|
+ return;
|
|
|
|
+
|
2022-04-02 05:32:56 +00:00
|
|
|
+ kms_update = meta_kms_get_pending_update_for_crtc (kms, kms_crtc);
|
2021-11-12 08:43:54 +00:00
|
|
|
if (!kms_update)
|
|
|
|
{
|
2022-04-02 05:32:56 +00:00
|
|
|
clutter_frame_set_result (frame, CLUTTER_FRAME_RESULT_IDLE);
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1415,9 +1520,9 @@ meta_onscreen_native_finish_frame (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
g_object_unref);
|
2021-11-24 14:38:22 +00:00
|
|
|
|
2022-04-02 05:32:56 +00:00
|
|
|
flags = META_KMS_UPDATE_FLAG_NONE;
|
|
|
|
- kms_feedback = meta_kms_post_pending_update_sync (kms,
|
|
|
|
- kms_device,
|
|
|
|
- flags);
|
|
|
|
+ kms_feedback = meta_kms_post_pending_update_for_crtc_sync (kms,
|
|
|
|
+ kms_crtc,
|
|
|
|
+ flags);
|
|
|
|
switch (meta_kms_feedback_get_result (kms_feedback))
|
|
|
|
{
|
|
|
|
case META_KMS_FEEDBACK_PASSED:
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1439,6 +1544,17 @@ meta_onscreen_native_finish_frame (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
+void
|
|
|
|
+meta_onscreen_native_discard_pending_swaps (CoglOnscreen *onscreen)
|
|
|
|
+{
|
|
|
|
+ MetaOnscreenNative *onscreen_native = META_ONSCREEN_NATIVE (onscreen);
|
|
|
|
+
|
|
|
|
+ onscreen_native->swaps_pending = 0;
|
|
|
|
+
|
|
|
|
+ g_clear_object (&onscreen_native->gbm.stalled_fb);
|
|
|
|
+ g_clear_object (&onscreen_native->gbm.next_fb);
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
static gboolean
|
|
|
|
should_surface_be_sharable (CoglOnscreen *onscreen)
|
|
|
|
{
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -1987,6 +2103,21 @@ pick_secondary_gpu_framebuffer_format_for_cpu (CoglOnscreen *onscreen)
|
2022-04-02 05:32:56 +00:00
|
|
|
return DRM_FORMAT_INVALID;
|
|
|
|
}
|
|
|
|
|
|
|
|
+static void
|
|
|
|
+dumb_toggle_notify (gpointer data,
|
|
|
|
+ GObject *object,
|
|
|
|
+ gboolean is_last_ref)
|
|
|
|
+{
|
|
|
|
+ MetaDrmBuffer **source_fb = data;
|
|
|
|
+
|
|
|
|
+ g_return_if_fail (source_fb != NULL);
|
|
|
|
+ if (is_last_ref && *source_fb)
|
|
|
|
+ {
|
|
|
|
+ g_return_if_fail (META_IS_DRM_BUFFER (*source_fb));
|
|
|
|
+ g_clear_object (source_fb);
|
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
static gboolean
|
|
|
|
init_secondary_gpu_state_cpu_copy_mode (MetaRendererNative *renderer_native,
|
|
|
|
CoglOnscreen *onscreen,
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -2043,6 +2174,12 @@ init_secondary_gpu_state_cpu_copy_mode (MetaRendererNative *renderer_nat
|
2022-04-02 05:32:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
secondary_gpu_state->cpu.dumb_fbs[i] = META_DRM_BUFFER_DUMB (dumb_buffer);
|
|
|
|
+ g_object_add_toggle_ref (G_OBJECT (dumb_buffer),
|
|
|
|
+ dumb_toggle_notify,
|
|
|
|
+ &secondary_gpu_state->cpu.source_fbs[i]);
|
|
|
|
+
|
|
|
|
+ /* It was incremented higher than we need by add_toggle_ref */
|
|
|
|
+ g_object_unref (dumb_buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -2132,7 +2269,7 @@ meta_onscreen_native_new (MetaRendererNative *renderer_native,
|
2022-04-02 05:32:56 +00:00
|
|
|
onscreen_native->renderer_native = renderer_native;
|
|
|
|
onscreen_native->render_gpu = render_gpu;
|
|
|
|
onscreen_native->output = output;
|
2021-11-24 14:38:22 +00:00
|
|
|
- onscreen_native->crtc = crtc;
|
|
|
|
+ onscreen_native->crtc = g_object_ref (crtc);
|
|
|
|
|
|
|
|
return onscreen_native;
|
|
|
|
}
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -2153,7 +2290,6 @@ meta_onscreen_native_dispose (GObject *object)
|
2022-01-14 06:01:58 +00:00
|
|
|
{
|
|
|
|
case META_RENDERER_NATIVE_MODE_GBM:
|
|
|
|
g_clear_object (&onscreen_native->gbm.next_fb);
|
2021-11-12 08:43:54 +00:00
|
|
|
- free_current_bo (onscreen);
|
|
|
|
break;
|
|
|
|
case META_RENDERER_NATIVE_MODE_SURFACELESS:
|
|
|
|
g_assert_not_reached ();
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -2181,9 +2317,12 @@ meta_onscreen_native_dispose (GObject *object)
|
2022-04-02 05:32:56 +00:00
|
|
|
|
|
|
|
G_OBJECT_CLASS (meta_onscreen_native_parent_class)->dispose (object);
|
|
|
|
|
|
|
|
+ g_clear_object (&onscreen_native->crtc);
|
2021-11-12 08:43:54 +00:00
|
|
|
g_clear_pointer (&onscreen_native->gbm.surface, gbm_surface_destroy);
|
|
|
|
g_clear_pointer (&onscreen_native->secondary_gpu_state,
|
|
|
|
secondary_gpu_state_free);
|
|
|
|
+ g_clear_pointer (&onscreen_native->next_post.rectangles, g_free);
|
|
|
|
+ onscreen_native->next_post.n_rectangles = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2022-04-02 05:32:56 +00:00
|
|
|
diff --git a/src/backends/native/meta-onscreen-native.h b/src/backends/native/meta-onscreen-native.h
|
2022-10-27 14:41:22 +00:00
|
|
|
index 8ea7ec2546fff96260c6696ea0efd643a21e7914..81b0eeaed5c6e79d2c0b14f9190a1490cf63b905 100644
|
2022-04-02 05:32:56 +00:00
|
|
|
--- a/src/backends/native/meta-onscreen-native.h
|
|
|
|
+++ b/src/backends/native/meta-onscreen-native.h
|
2022-10-27 14:41:22 +00:00
|
|
|
@@ -42,6 +42,8 @@ void meta_onscreen_native_finish_frame (CoglOnscreen *onscreen,
|
2022-04-02 05:32:56 +00:00
|
|
|
|
|
|
|
void meta_onscreen_native_dummy_power_save_page_flip (CoglOnscreen *onscreen);
|
|
|
|
|
|
|
|
+void meta_onscreen_native_discard_pending_swaps (CoglOnscreen *onscreen);
|
|
|
|
+
|
|
|
|
gboolean meta_onscreen_native_is_buffer_scanout_compatible (CoglOnscreen *onscreen,
|
|
|
|
MetaDrmBuffer *fb);
|
|
|
|
|
2021-11-24 14:38:22 +00:00
|
|
|
diff --git a/src/backends/native/meta-renderer-native.c b/src/backends/native/meta-renderer-native.c
|
2022-10-27 14:41:22 +00:00
|
|
|
index 99fbb2bb65f68f5ea0a8148b4c6ef3511775a3af..d86a5f4b4ec0b41915ec02ed3394fdb8038cc4d8 100644
|
2021-11-24 14:38:22 +00:00
|
|
|
--- a/src/backends/native/meta-renderer-native.c
|
|
|
|
+++ b/src/backends/native/meta-renderer-native.c
|
2022-08-03 09:36:52 +00:00
|
|
|
@@ -677,12 +677,18 @@ static gboolean
|
2021-11-24 14:38:22 +00:00
|
|
|
dummy_power_save_page_flip_cb (gpointer user_data)
|
|
|
|
{
|
|
|
|
MetaRendererNative *renderer_native = user_data;
|
|
|
|
+ GList *old_list =
|
|
|
|
+ g_steal_pointer (&renderer_native->power_save_page_flip_onscreens);
|
|
|
|
|
|
|
|
- g_list_foreach (renderer_native->power_save_page_flip_onscreens,
|
|
|
|
+ g_list_foreach (old_list,
|
|
|
|
(GFunc) meta_onscreen_native_dummy_power_save_page_flip,
|
|
|
|
NULL);
|
|
|
|
- g_clear_list (&renderer_native->power_save_page_flip_onscreens,
|
|
|
|
+ g_clear_list (&old_list,
|
|
|
|
g_object_unref);
|
|
|
|
+
|
|
|
|
+ if (renderer_native->power_save_page_flip_onscreens != NULL)
|
|
|
|
+ return G_SOURCE_CONTINUE;
|
|
|
|
+
|
|
|
|
renderer_native->power_save_page_flip_source_id = 0;
|
|
|
|
|
|
|
|
return G_SOURCE_REMOVE;
|
2022-08-03 09:36:52 +00:00
|
|
|
@@ -694,6 +700,9 @@ meta_renderer_native_queue_power_save_page_flip (MetaRendererNative *renderer_na
|
2022-04-02 05:32:56 +00:00
|
|
|
{
|
|
|
|
const unsigned int timeout_ms = 100;
|
|
|
|
|
|
|
|
+ if (g_list_find (renderer_native->power_save_page_flip_onscreens, onscreen))
|
|
|
|
+ return;
|
|
|
|
+
|
|
|
|
if (!renderer_native->power_save_page_flip_source_id)
|
|
|
|
{
|
|
|
|
renderer_native->power_save_page_flip_source_id =
|
2022-08-03 09:36:52 +00:00
|
|
|
@@ -1402,6 +1411,26 @@ meta_renderer_native_create_view (MetaRenderer *renderer,
|
2022-04-02 05:32:56 +00:00
|
|
|
return view;
|
|
|
|
}
|
|
|
|
|
|
|
|
+static void
|
|
|
|
+discard_pending_swaps (MetaRenderer *renderer)
|
|
|
|
+{
|
|
|
|
+ GList *views = meta_renderer_get_views (renderer);;
|
|
|
|
+ GList *l;
|
|
|
|
+
|
|
|
|
+ for (l = views; l; l = l->next)
|
|
|
|
+ {
|
|
|
|
+ ClutterStageView *stage_view = l->data;
|
|
|
|
+ CoglFramebuffer *fb = clutter_stage_view_get_onscreen (stage_view);
|
|
|
|
+ CoglOnscreen *onscreen;
|
|
|
|
+
|
|
|
|
+ if (!COGL_IS_ONSCREEN (fb))
|
|
|
|
+ continue;
|
|
|
|
+
|
|
|
|
+ onscreen = COGL_ONSCREEN (fb);
|
|
|
|
+ meta_onscreen_native_discard_pending_swaps (onscreen);
|
|
|
|
+ }
|
|
|
|
+}
|
|
|
|
+
|
|
|
|
static void
|
|
|
|
keep_current_onscreens_alive (MetaRenderer *renderer)
|
|
|
|
{
|
2022-08-03 09:36:52 +00:00
|
|
|
@@ -1430,6 +1459,7 @@ meta_renderer_native_rebuild_views (MetaRenderer *renderer)
|
2022-04-02 05:32:56 +00:00
|
|
|
MetaRendererClass *parent_renderer_class =
|
|
|
|
META_RENDERER_CLASS (meta_renderer_native_parent_class);
|
|
|
|
|
|
|
|
+ discard_pending_swaps (renderer);
|
|
|
|
meta_kms_discard_pending_page_flips (kms);
|
|
|
|
meta_kms_discard_pending_updates (kms);
|
|
|
|
|
2022-10-27 14:41:22 +00:00
|
|
|
diff --git a/src/tests/native-kms-render.c b/src/tests/native-kms-render.c
|
|
|
|
index 6595eb5a290e02f91c8968085f424bbd3afef816..42f7e62760416ded2c7c7bcb146f617fb7f2a714 100644
|
|
|
|
--- a/src/tests/native-kms-render.c
|
|
|
|
+++ b/src/tests/native-kms-render.c
|
|
|
|
@@ -36,6 +36,8 @@
|
|
|
|
#include "tests/meta-wayland-test-driver.h"
|
|
|
|
#include "tests/meta-wayland-test-utils.h"
|
|
|
|
|
|
|
|
+#define N_FRAMES_PER_TEST 10
|
|
|
|
+
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
int number_of_frames_left;
|
|
|
|
@@ -43,7 +45,9 @@ typedef struct
|
|
|
|
|
|
|
|
struct {
|
|
|
|
int n_paints;
|
|
|
|
- uint32_t fb_id;
|
|
|
|
+ int n_presentations;
|
|
|
|
+ int n_direct_scanouts;
|
|
|
|
+ GList *fb_ids;
|
|
|
|
} scanout;
|
|
|
|
|
|
|
|
gboolean wait_for_scanout;
|
|
|
|
@@ -72,7 +76,7 @@ meta_test_kms_render_basic (void)
|
|
|
|
gulong handler_id;
|
|
|
|
|
|
|
|
test = (KmsRenderingTest) {
|
|
|
|
- .number_of_frames_left = 10,
|
|
|
|
+ .number_of_frames_left = N_FRAMES_PER_TEST,
|
|
|
|
.loop = g_main_loop_new (NULL, FALSE),
|
|
|
|
};
|
|
|
|
handler_id = g_signal_connect (stage, "after-update",
|
|
|
|
@@ -93,7 +97,6 @@ on_scanout_before_update (ClutterStage *stage,
|
|
|
|
KmsRenderingTest *test)
|
|
|
|
{
|
|
|
|
test->scanout.n_paints = 0;
|
|
|
|
- test->scanout.fb_id = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
@@ -103,6 +106,7 @@ on_scanout_before_paint (ClutterStage *stage,
|
|
|
|
{
|
|
|
|
CoglScanout *scanout;
|
|
|
|
MetaDrmBuffer *buffer;
|
|
|
|
+ uint32_t fb_id;
|
|
|
|
|
|
|
|
scanout = clutter_stage_view_peek_scanout (stage_view);
|
|
|
|
if (!scanout)
|
|
|
|
@@ -110,8 +114,14 @@ on_scanout_before_paint (ClutterStage *stage,
|
|
|
|
|
|
|
|
g_assert_true (META_IS_DRM_BUFFER (scanout));
|
|
|
|
buffer = META_DRM_BUFFER (scanout);
|
|
|
|
- test->scanout.fb_id = meta_drm_buffer_get_fb_id (buffer);
|
|
|
|
- g_assert_cmpuint (test->scanout.fb_id, >, 0);
|
|
|
|
+
|
|
|
|
+ fb_id = meta_drm_buffer_get_fb_id (buffer);
|
|
|
|
+ g_assert_cmpuint (fb_id, >, 0);
|
|
|
|
+ test->scanout.fb_ids = g_list_append (test->scanout.fb_ids,
|
|
|
|
+ GUINT_TO_POINTER (fb_id));
|
|
|
|
+
|
|
|
|
+ /* Triple buffering, but no higher */
|
|
|
|
+ g_assert_cmpuint (g_list_length (test->scanout.fb_ids), <=, 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
@@ -138,12 +148,12 @@ on_scanout_presented (ClutterStage *stage,
|
|
|
|
MetaDeviceFile *device_file;
|
|
|
|
GError *error = NULL;
|
|
|
|
drmModeCrtc *drm_crtc;
|
|
|
|
+ uint32_t first_fb_id_expected;
|
|
|
|
|
|
|
|
- if (test->scanout.n_paints > 0)
|
|
|
|
+ if (test->wait_for_scanout && test->scanout.fb_ids == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
- if (test->wait_for_scanout && test->scanout.fb_id == 0)
|
|
|
|
- return;
|
|
|
|
+ test->scanout.n_presentations++;
|
|
|
|
|
|
|
|
device_pool = meta_backend_native_get_device_pool (backend_native);
|
|
|
|
|
|
|
|
@@ -162,15 +172,41 @@ on_scanout_presented (ClutterStage *stage,
|
|
|
|
drm_crtc = drmModeGetCrtc (meta_device_file_get_fd (device_file),
|
|
|
|
meta_kms_crtc_get_id (kms_crtc));
|
|
|
|
g_assert_nonnull (drm_crtc);
|
|
|
|
- if (test->scanout.fb_id == 0)
|
|
|
|
- g_assert_cmpuint (drm_crtc->buffer_id, !=, test->scanout.fb_id);
|
|
|
|
+
|
|
|
|
+ if (test->scanout.fb_ids)
|
|
|
|
+ {
|
|
|
|
+ test->scanout.n_direct_scanouts++;
|
|
|
|
+ first_fb_id_expected = GPOINTER_TO_UINT (test->scanout.fb_ids->data);
|
|
|
|
+ test->scanout.fb_ids = g_list_delete_link (test->scanout.fb_ids,
|
|
|
|
+ test->scanout.fb_ids);
|
|
|
|
+ }
|
|
|
|
else
|
|
|
|
- g_assert_cmpuint (drm_crtc->buffer_id, ==, test->scanout.fb_id);
|
|
|
|
+ {
|
|
|
|
+ first_fb_id_expected = 0;
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ /* The buffer ID won't match on the first frame because switching from
|
|
|
|
+ * triple buffered compositing to double buffered direct scanout takes
|
|
|
|
+ * an extra frame to drain the queue. Thereafter we are in direct scanout
|
|
|
|
+ * mode and expect the buffer IDs to match.
|
|
|
|
+ */
|
|
|
|
+ if (test->scanout.n_presentations > 1)
|
|
|
|
+ {
|
|
|
|
+ if (first_fb_id_expected == 0)
|
|
|
|
+ g_assert_cmpuint (drm_crtc->buffer_id, !=, first_fb_id_expected);
|
|
|
|
+ else
|
|
|
|
+ g_assert_cmpuint (drm_crtc->buffer_id, ==, first_fb_id_expected);
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
drmModeFreeCrtc (drm_crtc);
|
|
|
|
|
|
|
|
meta_device_file_release (device_file);
|
|
|
|
|
|
|
|
- g_main_loop_quit (test->loop);
|
|
|
|
+ test->number_of_frames_left--;
|
|
|
|
+ if (test->number_of_frames_left <= 0)
|
|
|
|
+ g_main_loop_quit (test->loop);
|
|
|
|
+ else
|
|
|
|
+ clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
|
|
|
}
|
|
|
|
|
|
|
|
typedef enum
|
|
|
|
@@ -209,7 +245,9 @@ meta_test_kms_render_client_scanout (void)
|
|
|
|
g_assert_nonnull (wayland_test_client);
|
|
|
|
|
|
|
|
test = (KmsRenderingTest) {
|
|
|
|
+ .number_of_frames_left = N_FRAMES_PER_TEST,
|
|
|
|
.loop = g_main_loop_new (NULL, FALSE),
|
|
|
|
+ .scanout = {0},
|
|
|
|
.wait_for_scanout = TRUE,
|
|
|
|
};
|
|
|
|
|
|
|
|
@@ -235,7 +273,8 @@ meta_test_kms_render_client_scanout (void)
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
|
|
|
g_main_loop_run (test.loop);
|
|
|
|
|
|
|
|
- g_assert_cmpuint (test.scanout.fb_id, >, 0);
|
|
|
|
+ g_assert_cmpint (test.scanout.n_presentations, ==, N_FRAMES_PER_TEST);
|
|
|
|
+ g_assert_cmpint (test.scanout.n_direct_scanouts, ==, N_FRAMES_PER_TEST);
|
|
|
|
|
|
|
|
g_debug ("Unmake fullscreen");
|
|
|
|
window = meta_find_window_from_title (test_context, "dma-buf-scanout-test");
|
|
|
|
@@ -257,10 +296,15 @@ meta_test_kms_render_client_scanout (void)
|
|
|
|
g_assert_cmpint (buffer_rect.y, ==, 10);
|
|
|
|
|
|
|
|
test.wait_for_scanout = FALSE;
|
|
|
|
+ test.number_of_frames_left = N_FRAMES_PER_TEST;
|
|
|
|
+ test.scanout.n_presentations = 0;
|
|
|
|
+ test.scanout.n_direct_scanouts = 0;
|
|
|
|
+
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
|
|
|
g_main_loop_run (test.loop);
|
|
|
|
|
|
|
|
- g_assert_cmpuint (test.scanout.fb_id, ==, 0);
|
|
|
|
+ g_assert_cmpint (test.scanout.n_presentations, ==, N_FRAMES_PER_TEST);
|
|
|
|
+ g_assert_cmpint (test.scanout.n_direct_scanouts, ==, 0);
|
|
|
|
|
|
|
|
g_debug ("Moving back to 0, 0");
|
|
|
|
meta_window_move_frame (window, TRUE, 0, 0);
|
|
|
|
@@ -272,10 +316,15 @@ meta_test_kms_render_client_scanout (void)
|
|
|
|
g_assert_cmpint (buffer_rect.y, ==, 0);
|
|
|
|
|
|
|
|
test.wait_for_scanout = TRUE;
|
|
|
|
+ test.number_of_frames_left = N_FRAMES_PER_TEST;
|
|
|
|
+ test.scanout.n_presentations = 0;
|
|
|
|
+ test.scanout.n_direct_scanouts = 0;
|
|
|
|
+
|
|
|
|
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
|
|
|
|
g_main_loop_run (test.loop);
|
|
|
|
|
|
|
|
- g_assert_cmpuint (test.scanout.fb_id, >, 0);
|
|
|
|
+ g_assert_cmpint (test.scanout.n_presentations, ==, N_FRAMES_PER_TEST);
|
|
|
|
+ g_assert_cmpint (test.scanout.n_direct_scanouts, ==, N_FRAMES_PER_TEST);
|
|
|
|
|
|
|
|
g_signal_handler_disconnect (stage, before_update_handler_id);
|
|
|
|
g_signal_handler_disconnect (stage, before_paint_handler_id);
|
2023-02-22 06:16:16 +00:00
|
|
|
|
|
|
|
diff --git a/src/backends/native/meta-onscreen-native.c b/src/backends/native/meta-onscreen-native.c
|
|
|
|
index 6c8245f8cb..79cf789634 100644
|
|
|
|
--- a/src/backends/native/meta-onscreen-native.c
|
|
|
|
+++ b/src/backends/native/meta-onscreen-native.c
|
|
|
|
@@ -71,8 +71,8 @@ typedef struct _MetaOnscreenNativeSecondaryGpuState
|
|
|
|
|
|
|
|
struct {
|
|
|
|
MetaDrmBufferDumb *current_dumb_fb;
|
|
|
|
- MetaDrmBufferDumb *dumb_fbs[2];
|
|
|
|
- MetaDrmBuffer *source_fbs[2];
|
|
|
|
+ MetaDrmBufferDumb *dumb_fbs[3];
|
|
|
|
+ MetaDrmBuffer *source_fbs[3];
|
|
|
|
} cpu;
|
|
|
|
|
|
|
|
gboolean noted_primary_gpu_copy_ok;
|
|
|
|
@@ -717,12 +717,17 @@ static MetaDrmBufferDumb *
|
|
|
|
secondary_gpu_get_next_dumb_buffer (MetaOnscreenNativeSecondaryGpuState *secondary_gpu_state)
|
|
|
|
{
|
|
|
|
MetaDrmBufferDumb *current_dumb_fb;
|
|
|
|
+ const int n_dumb_fbs = G_N_ELEMENTS (secondary_gpu_state->cpu.dumb_fbs);
|
|
|
|
+ int i;
|
|
|
|
|
|
|
|
current_dumb_fb = secondary_gpu_state->cpu.current_dumb_fb;
|
|
|
|
- if (current_dumb_fb == secondary_gpu_state->cpu.dumb_fbs[0])
|
|
|
|
- return secondary_gpu_state->cpu.dumb_fbs[1];
|
|
|
|
- else
|
|
|
|
- return secondary_gpu_state->cpu.dumb_fbs[0];
|
|
|
|
+ for (i = 0; i < n_dumb_fbs; i++)
|
|
|
|
+ {
|
|
|
|
+ if (current_dumb_fb == secondary_gpu_state->cpu.dumb_fbs[i])
|
|
|
|
+ return secondary_gpu_state->cpu.dumb_fbs[(i + 1) % n_dumb_fbs];
|
|
|
|
+ }
|
|
|
|
+
|
|
|
|
+ return secondary_gpu_state->cpu.dumb_fbs[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
static MetaDrmBuffer *
|
|
|
|
|
|
|
|
diff --git a/clutter/clutter/clutter-frame-clock.c b/clutter/clutter/clutter-frame-clock.c
|
|
|
|
index 1a16b048bf..78f8dde9b4 100644
|
|
|
|
--- a/clutter/clutter/clutter-frame-clock.c
|
|
|
|
+++ b/clutter/clutter/clutter-frame-clock.c
|
|
|
|
@@ -457,7 +457,7 @@ calculate_next_update_time_us (ClutterFrameClock *frame_clock,
|
|
|
|
int64_t refresh_interval_us;
|
|
|
|
int64_t min_render_time_allowed_us;
|
|
|
|
int64_t max_render_time_allowed_us;
|
|
|
|
- int64_t next_presentation_time_us;
|
|
|
|
+ int64_t next_presentation_time_us = 0;
|
|
|
|
int64_t next_update_time_us;
|
|
|
|
|
|
|
|
now_us = g_get_monotonic_time ();
|
|
|
|
@@ -501,7 +501,24 @@ calculate_next_update_time_us (ClutterFrameClock *frame_clock,
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
last_presentation_time_us = frame_clock->last_presentation_time_us;
|
|
|
|
- next_presentation_time_us = last_presentation_time_us + refresh_interval_us;
|
|
|
|
+ switch (frame_clock->state)
|
|
|
|
+ {
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_INIT:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_IDLE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_SCHEDULED:
|
|
|
|
+ next_presentation_time_us = last_presentation_time_us +
|
|
|
|
+ refresh_interval_us;
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE:
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_ONE_AND_SCHEDULED:
|
|
|
|
+ next_presentation_time_us = last_presentation_time_us +
|
|
|
|
+ 2 * refresh_interval_us;
|
|
|
|
+ break;
|
|
|
|
+ case CLUTTER_FRAME_CLOCK_STATE_DISPATCHED_TWO:
|
|
|
|
+ next_presentation_time_us = last_presentation_time_us +
|
|
|
|
+ 3 * refresh_interval_us;
|
|
|
|
+ break;
|
|
|
|
+ }
|
|
|
|
|
|
|
|
/*
|
|
|
|
* However, the last presentation could have happened more than a frame ago.
|
|
|
|
--
|