AuroraMiddleware/gtk
1
0
Fork 1
mirror of https://gitlab.gnome.org/GNOME/gtk.git synced 2024-11-10 02:40:11 +00:00
Code Issues Projects Releases Wiki Activity
3cd25516ab
gtk/gdk/gdkframeclockprivate.h

130 lines
4.2 KiB
C
Raw Normal View History

Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Changed obsolete FSF portal addresses to web address Fixed https://bugzilla.gnome.org/show_bug.cgi?id=721530
2014-01-12 12:56:49 +00:00
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
*/
/*
* Modified by the GTK+ Team and others 1997-2010. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
/* Uninstalled header, internal to GDK */
Convert headers to #pragma once The conversion was done by guard2one.
2023-03-31 19:11:10 +00:00
#pragma once
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
#include <gdk/gdkframeclock.h>
Redo frame profiling We were adding incomplete frame timings to the profile, which lead to occasional nonsense numbers. Instead, only add timings to the profile once we marked them as complete. This also gives us an opportunity to add the presentation time as a marker.
2019-05-16 19:08:34 +00:00
#include <gdk/gdkprofilerprivate.h>
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
G_BEGIN_DECLS
docs: add docs for GtkFrameClock
2014-01-20 20:59:04 +00:00
/**
* GdkFrameClock:
* @parent_instance: The parent instance.
*/
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
struct _GdkFrameClock
{
GObject parent_instance;
/*< private >*/
GdkFrameClockPrivate *priv;
};
docs: add docs for GtkFrameClock
2014-01-20 20:59:04 +00:00
/**
* GdkFrameClockClass:
* @parent_class: The parent class.
* @get_frame_time: Gets the time that should currently be used for
* animations.
* @request_phase: Asks the frame clock to run a particular phase.
* @begin_updating: Starts updates for an animation.
* @end_updating: Stops updates for an animation.
* @freeze:
* @thaw:
*/
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
struct _GdkFrameClockClass
{
GObjectClass parent_class;
docs: add docs for GtkFrameClock
2014-01-20 20:59:04 +00:00
/*< public >*/
gdk_frame_clock_get_frame_time(): use gint64 for time
2013-02-13 13:35:05 +00:00
gint64 (* get_frame_time) (GdkFrameClock *clock);
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
GdkFrameClock: Clean up the public API * remove gdk_frame_clock_get_frame_time_val(); a convenience function that would rarely be used. * remove gdk_frame_clock_get_requested() and ::frame-requested signal; while we might want to eventually be able to track the requested phases for a clock, we don't have a current use case. * Make gdk_frame_clock_freeze/thaw() private: they are only used within GTK+ and have complex semantics. * Remove gdk_frame_clock_get_last_complete(). Another convenience function that I don't have a current use case for. * Rename: gdk_frame_clock_get_start() => gdk_frame_clock_get_history_start() gdk_frame_clocK_get_current_frame_timings() => gdk_frame_clock_get_timings()
2013-02-12 20:03:21 +00:00
void (* request_phase) (GdkFrameClock *clock,
GdkFrameClockPhase phase);
Add gdk_frame_clock_begin/end_updating() Add an API to start or stop continually updating the frame clock. This is a slight convenience for applcations and avoids the problem of getting one more frame run after an animation stops, but the primary motivation for this is because it looks like we might have to use timeBeginPeriod()/timeEndPeriod() on Windows to get reasonably accurate timing, and for that we'll need to know if there is an animation running. https://bugzilla.gnome.org/show_bug.cgi?id=693934
2013-02-15 22:04:39 +00:00
void (* begin_updating) (GdkFrameClock *clock);
void (* end_updating) (GdkFrameClock *clock);
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
GdkFrameClock: Clean up the public API * remove gdk_frame_clock_get_frame_time_val(); a convenience function that would rarely be used. * remove gdk_frame_clock_get_requested() and ::frame-requested signal; while we might want to eventually be able to track the requested phases for a clock, we don't have a current use case. * Make gdk_frame_clock_freeze/thaw() private: they are only used within GTK+ and have complex semantics. * Remove gdk_frame_clock_get_last_complete(). Another convenience function that I don't have a current use case for. * Rename: gdk_frame_clock_get_start() => gdk_frame_clock_get_history_start() gdk_frame_clocK_get_current_frame_timings() => gdk_frame_clock_get_timings()
2013-02-12 20:03:21 +00:00
void (* freeze) (GdkFrameClock *clock);
void (* thaw) (GdkFrameClock *clock);
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
/* signals */
/* void (* flush_events) (GdkFrameClock *clock); */
/* void (* before_paint) (GdkFrameClock *clock); */
/* void (* update) (GdkFrameClock *clock); */
/* void (* layout) (GdkFrameClock *clock); */
/* void (* paint) (GdkFrameClock *clock); */
/* void (* after_paint) (GdkFrameClock *clock); */
/* void (* resume_events) (GdkFrameClock *clock); */
};
GdkFrameTimings: strip down to a minimal public API Since we're not exporting the ability to create your own frame clock for now, remove the setters for GdkFrameTimings fields. Also remove all setters and getters for fields that are more about implementation than about quantities that are meaningful to the applcation and just access the fields directly within GDK.
2013-02-12 21:14:24 +00:00
struct _GdkFrameTimings
{
docs: add docs for GtkFrameClock
2014-01-20 20:59:04 +00:00
/*< private >*/
GdkFrameTimings: strip down to a minimal public API Since we're not exporting the ability to create your own frame clock for now, remove the setters for GdkFrameTimings fields. Also remove all setters and getters for fields that are more about implementation than about quantities that are meaningful to the applcation and just access the fields directly within GDK.
2013-02-12 21:14:24 +00:00
guint ref_count;
gint64 frame_counter;
guint64 cookie;
gint64 frame_time;
frame-clock: New approach in smoothing frame clock In commit c6901a8b, the frame clock reported time was changed from simply reporting the time we ran the frame clock cycle to reporting a smoothed value that increased by the frame interval each time it was called. However, this change caused some problems, such as: https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/1415 https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/1416 https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/1482 I think a lot of this is caused by the fact that we just overwrote the old frame time with the smoothed, monotonous timestamp, breaking some things that relied on knowing the actual time something happened. This is a new approach to doing the smoothing that is more explicit. The "frame_time" we store is the actual time we ran the update cycle, and then we separately compute and store the derived smoothed time and its period, allowing us to easily return a smoothed time at any time by rounding the time difference to an integer number of frames. The initial frame_time can be somewhat arbitrary, as it depends on the first cycle which is not driven by the frame clock. But follow-up cycles are typically tied to the the compositor sending the drawn signal. It may happen that the initial frame is exactly in the middle between two frames where jitter causes us to randomly round in different directions when rounding to nearest frame. To fix this we additionally do a quadratic convergence towards the "real" time, during presentation driven clock cycles (i.e. when the frame times are small).
2020-05-18 13:48:03 +00:00
gint64 smoothed_frame_time;
GdkFrameTimings: strip down to a minimal public API Since we're not exporting the ability to create your own frame clock for now, remove the setters for GdkFrameTimings fields. Also remove all setters and getters for fields that are more about implementation than about quantities that are meaningful to the applcation and just access the fields directly within GDK.
2013-02-12 21:14:24 +00:00
gint64 drawn_time;
gint64 presentation_time;
gint64 refresh_interval;
gint64 predicted_presentation_time;
gint64 layout_start_time;
gint64 paint_start_time;
gint64 frame_end_time;
guint complete : 1;
guint slept_before : 1;
};
gdk/frameclock: Make surfaces inhibit freeze To make a frame clock tick as long as any of the associated surfaces expect to receive ticks, make the surfaces inhibit freezing the clock, instead of directly tell the frame clock to freeze itself. This makes it so that as long as any surface using a certain frame clock is not frozen (e.g. just received a frame event from the display server), the frame clock will not be frozen. With this, the frame clock is initiated as frozen, and won't be thawed until any surface inhibits freeze. It will be frozen again, when every surface has that previously inhibited freeze uninhibited freeze.
2019-06-28 16:45:44 +00:00
void _gdk_frame_clock_inhibit_freeze (GdkFrameClock *clock);
void _gdk_frame_clock_uninhibit_freeze (GdkFrameClock *clock);
GdkFrameClock: Clean up the public API * remove gdk_frame_clock_get_frame_time_val(); a convenience function that would rarely be used. * remove gdk_frame_clock_get_requested() and ::frame-requested signal; while we might want to eventually be able to track the requested phases for a clock, we don't have a current use case. * Make gdk_frame_clock_freeze/thaw() private: they are only used within GTK+ and have complex semantics. * Remove gdk_frame_clock_get_last_complete(). Another convenience function that I don't have a current use case for. * Rename: gdk_frame_clock_get_start() => gdk_frame_clock_get_history_start() gdk_frame_clocK_get_current_frame_timings() => gdk_frame_clock_get_timings()
2013-02-12 20:03:21 +00:00
frameclock: Make timings history dynamic Keep at least 1 second of frame timings. This is necessary for 2 reasons - a real one and a fun one. First, with the difference in monitor refresh rates, we can have 48Hz latops as well as 240Hz high refresh rate monitors. That's a factor of 4, and tracking frame rates in both situations reliably is kind of hard - either we track over too many frames and the fps take a lot of time to adjust, or we track too little time and the fps fluctuate wildly. Second, when benchmarking with GDK_DEBUG=no-vsync with a somewhat fast renderer (*cough*Vulkan*cough*) frame rates can go into insane dimensions and only very few frames are actually getting presentation times reported. So to report accurate frame rates in those cases, we need a *very* large history that can be 1000s of times larger than the usual history. And that's just a waste for normal usage.
2024-03-10 09:18:57 +00:00
void _gdk_frame_clock_begin_frame (GdkFrameClock *clock,
gint64 monotonic_time);
Merge GdkFrameHistory into GdkFrameClock Now that GdkFrameClock is a class, not interface, there's no real advantage to splitting the frame history into an aggregate object, so directly merge it into GdkFrameClock.
2013-02-12 20:47:38 +00:00
void _gdk_frame_clock_debug_print_timings (GdkFrameClock *clock,
GdkFrameTimings *timings);
Redo frame profiling We were adding incomplete frame timings to the profile, which lead to occasional nonsense numbers. Instead, only add timings to the profile once we marked them as complete. This also gives us an opportunity to add the presentation time as a marker.
2019-05-16 19:08:34 +00:00
void _gdk_frame_clock_add_timings_to_profiler (GdkFrameClock *frame_clock,
GdkFrameTimings *timings);
Merge GdkFrameHistory into GdkFrameClock Now that GdkFrameClock is a class, not interface, there's no real advantage to splitting the frame history into an aggregate object, so directly merge it into GdkFrameClock.
2013-02-12 20:47:38 +00:00
frametimings: reuse previous frame timing in common case Typically, there won't be any references on old frame timings except for the most recent timing. So instead of discarding these and re-entering gslice twice, just steal the old frame timing and reuse it. https://bugzilla.gnome.org/show_bug.cgi?id=765592
2016-04-26 10:08:11 +00:00
GdkFrameTimings *_gdk_frame_timings_new (gint64 frame_counter);
gboolean _gdk_frame_timings_steal (GdkFrameTimings *timings,
gint64 frame_counter);
GdkFrameTimings: strip down to a minimal public API Since we're not exporting the ability to create your own frame clock for now, remove the setters for GdkFrameTimings fields. Also remove all setters and getters for fields that are more about implementation than about quantities that are meaningful to the applcation and just access the fields directly within GDK.
2013-02-12 21:14:24 +00:00
frame-clock: avoid g_signal_emit_by_name() These were showing up higher in Sysprof profiles. The simple fix is to avoid the emit_by_name() and let the interface emit the signals directly. No function preconditions are provided since these are internal API.
2016-04-18 21:16:20 +00:00
void _gdk_frame_clock_emit_flush_events (GdkFrameClock *frame_clock);
void _gdk_frame_clock_emit_before_paint (GdkFrameClock *frame_clock);
void _gdk_frame_clock_emit_update (GdkFrameClock *frame_clock);
void _gdk_frame_clock_emit_layout (GdkFrameClock *frame_clock);
void _gdk_frame_clock_emit_paint (GdkFrameClock *frame_clock);
void _gdk_frame_clock_emit_after_paint (GdkFrameClock *frame_clock);
void _gdk_frame_clock_emit_resume_events (GdkFrameClock *frame_clock);
Change GdkFrameClock from an interface to a class It's unlikely that anyone will want to have, say, a GtkWidget that also acts as a GdkFrameClock, so an abstract base class is as flexible as making GdkFrameClock an interface, but has advantages: - If we decide to never make implementing your own frame clock possible, we can remove the virtualization. - We can put functionality like history into the base class. - Avoids the oddity of a interface without a public interface VTable, which may cause problems for language bindings.
2013-02-12 20:02:21 +00:00
G_END_DECLS
Reference in New Issue Copy Permalink