Flutter Linux Embedder
fl_view_renderer_opengl.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
6 
12 
13 // Maximum time to wait for a frame to be ready before giving up and rendering.
14 static constexpr gint64 kRenderTimeoutMicroseconds = 100000; // 100ms
15 
17  FlViewRenderer parent_instance;
18 
19  // Engine this widget is rendering.
20  FlEngine* engine;
21 
22  // TRUE if the view size should be controlled by Flutter.
23  gboolean sized_to_content;
24 
25  // Rendering context for OpenGL.
26  GdkGLContext* render_context;
27 
28  // Combines layers into frame.
29  FlCompositorOpenGL* compositor;
30 
31  // Manages the framebuffer the current frame is composited into.
32  FlOpenGLFrame* frame;
33 
34  // Task runner to wait for frames on.
35  FlTaskRunner* task_runner;
36 
37  // Ensure Flutter and GTK can access the frame stored in the compositor.
38  GMutex frame_mutex;
39 };
40 
41 G_DEFINE_TYPE(FlViewRendererOpenGL,
42  fl_view_renderer_opengl,
43  fl_view_renderer_get_type())
44 
45 // Get the size of the current frame in pixels. The size is zero if there is no
46 // frame yet. Must be called with the frame mutex held.
47 static void get_frame_size(FlViewRendererOpenGL* self,
48  size_t* width,
49  size_t* height) {
50  if (self->frame != nullptr) {
51  fl_opengl_frame_get_size(self->frame, width, height);
52  } else {
53  *width = 0;
54  *height = 0;
55  }
56 }
57 
58 // Redraw the view from the GTK thread.
59 static gboolean redraw_cb(gpointer user_data) {
60  g_autoptr(FlViewRendererOpenGL) self = FL_VIEW_RENDERER_OPENGL(user_data);
61 
62  if (self->compositor == nullptr) {
63  return G_SOURCE_REMOVE;
64  }
65 
66  fl_view_renderer_notify_frame(FL_VIEW_RENDERER(self));
67 
68  // If Flutter is controlling the window size, then resize the view if
69  // necessary. The redraw happens once the resized frame arrives.
70  if (self->sized_to_content) {
71  size_t frame_width, frame_height;
72  g_mutex_lock(&self->frame_mutex);
73  get_frame_size(self, &frame_width, &frame_height);
74  g_mutex_unlock(&self->frame_mutex);
75  if (fl_view_renderer_resize_to_frame(FL_VIEW_RENDERER(self), frame_width,
76  frame_height)) {
77  return G_SOURCE_REMOVE;
78  }
79  }
80 
81  gtk_widget_queue_draw(GTK_WIDGET(self));
82 
83  return G_SOURCE_REMOVE;
84 }
85 
86 // Wait for a frame matching the window size to be ready, or until the timeout
87 // expires. Must be called with the frame mutex held; the mutex is still held
88 // when this function returns.
89 static void wait_for_frame(FlViewRendererOpenGL* self,
90  GdkWindow* window,
91  gint scale_factor) {
92  gint64 expiry_time = g_get_monotonic_time() + kRenderTimeoutMicroseconds;
93  while (true) {
94  size_t width = gdk_window_get_width(window) * scale_factor;
95  size_t height = gdk_window_get_height(window) * scale_factor;
96  size_t frame_width, frame_height;
97  get_frame_size(self, &frame_width, &frame_height);
98  if (frame_width == width && frame_height == height) {
99  break;
100  }
101 
102  if (g_get_monotonic_time() > expiry_time) {
103  g_warning(
104  "Timed out waiting for OpenGL frame of size %zdx%zd (have "
105  "%zdx%zd)",
106  width, height, frame_width, frame_height);
107  break;
108  }
109 
110  g_mutex_unlock(&self->frame_mutex);
111  fl_task_runner_wait(self->task_runner, expiry_time);
112  g_mutex_lock(&self->frame_mutex);
113  }
114 }
115 
116 // Implements GtkWidget::realize.
117 static void fl_view_renderer_opengl_realize(GtkWidget* widget) {
118  FlViewRendererOpenGL* self = FL_VIEW_RENDERER_OPENGL(widget);
119 
120  GTK_WIDGET_CLASS(fl_view_renderer_opengl_parent_class)->realize(widget);
121 
122  g_autoptr(GError) error = nullptr;
123  self->render_context = gdk_window_create_gl_context(
124  gtk_widget_get_window(GTK_WIDGET(self)), &error);
125  if (self->render_context == nullptr) {
126  g_warning("Failed to create OpenGL context: %s", error->message);
127  return;
128  }
129 
130  if (!gdk_gl_context_realize(self->render_context, &error)) {
131  g_warning("Failed to realize OpenGL context: %s", error->message);
132  g_clear_object(&self->render_context);
133  return;
134  }
135 
136  self->frame = fl_opengl_frame_new();
137  self->task_runner =
138  FL_TASK_RUNNER(g_object_ref(fl_engine_get_task_runner(self->engine)));
139  self->compositor =
141 
142  // Any frames rendered before this point were dropped, as there was nothing
143  // to present them to. Ask for another one so the view isn't left empty until
144  // something else causes Flutter to render.
145  fl_engine_schedule_frame(self->engine);
146 }
147 
148 // Implements GtkWidget::draw.
149 static gboolean fl_view_renderer_opengl_draw(GtkWidget* widget, cairo_t* cr) {
150  FlViewRendererOpenGL* self = FL_VIEW_RENDERER_OPENGL(widget);
151 
152  fl_view_renderer_paint_background(FL_VIEW_RENDERER(self), cr);
153 
154  // The compositor is created when the widget is realized; if it is not yet
155  // available there is nothing to render beyond the background.
156  if (self->compositor == nullptr) {
157  return TRUE;
158  }
159 
160  GdkWindow* window = gtk_widget_get_window(widget);
161  gint scale_factor = gdk_window_get_scale_factor(window);
162 
163  g_mutex_lock(&self->frame_mutex);
164 
165  // If frame not ready, then wait for it.
166  if (!self->sized_to_content) {
167  wait_for_frame(self, window, scale_factor);
168  }
169 
170  // The frame is drawn from an OpenGL texture, so make a context current that
171  // can access it. This is deliberately not cleared once the frame is drawn -
172  // GTK makes the context it needs current before using OpenGL but doesn't
173  // check that this succeeded, and then uses whatever context is current. If
174  // that is nothing it dereferences NULL and crashes.
175  //
176  // Leaving this context current gives GTK one to fall back on. It is created
177  // on the same window and shares with the context GTK would have used itself,
178  // so GTK can safely draw with it.
179  if (self->render_context != nullptr) {
180  gdk_gl_context_make_current(self->render_context);
181  }
182 
183  gboolean result = FALSE;
184  if (self->frame != nullptr) {
185  size_t width = gdk_window_get_width(window) * scale_factor;
186  size_t height = gdk_window_get_height(window) * scale_factor;
187  result = fl_opengl_frame_draw(self->frame, cr, window, scale_factor, width,
188  height);
189  }
190 
191  g_mutex_unlock(&self->frame_mutex);
192 
193  return result;
194 }
195 
196 // Implements FlViewRenderer::present_layers.
197 static void fl_view_renderer_opengl_present_layers(FlViewRenderer* renderer,
198  const FlutterLayer** layers,
199  size_t layers_count) {
200  FlViewRendererOpenGL* self = FL_VIEW_RENDERER_OPENGL(renderer);
201 
202  // Frames may be presented before the widget is realized and the compositor
203  // is set up; ignore them.
204  if (self->compositor == nullptr) {
205  return;
206  }
207 
208  g_mutex_lock(&self->frame_mutex);
209  fl_opengl_frame_composite(self->frame, self->compositor, layers,
210  layers_count);
211  g_mutex_unlock(&self->frame_mutex);
212 
213  // Wake up the GTK thread if it is waiting for this frame.
214  fl_task_runner_stop_wait(self->task_runner);
215 
216  // Perform the redraw in the GTK thread.
217  g_idle_add(redraw_cb, g_object_ref(self));
218 }
219 
220 static void fl_view_renderer_opengl_dispose(GObject* object) {
221  FlViewRendererOpenGL* self = FL_VIEW_RENDERER_OPENGL(object);
222 
223  g_clear_object(&self->engine);
224  g_clear_object(&self->render_context);
225  g_clear_object(&self->task_runner);
226  g_mutex_clear(&self->frame_mutex);
227 
228  G_OBJECT_CLASS(fl_view_renderer_opengl_parent_class)->dispose(object);
229 }
230 
231 static void fl_view_renderer_opengl_finalize(GObject* object) {
232  FlViewRendererOpenGL* self = FL_VIEW_RENDERER_OPENGL(object);
233 
234  // The compositor is released here rather than in dispose() so it outlives a
235  // forced dispose (e.g. gtk_widget_destroy()) and is only freed once the last
236  // reference is dropped. This keeps it alive for the raster thread, which
237  // holds a strong reference on the view (and thus this renderer) while
238  // presenting.
239  g_clear_object(&self->compositor);
240  g_clear_object(&self->frame);
241 
242  G_OBJECT_CLASS(fl_view_renderer_opengl_parent_class)->finalize(object);
243 }
244 
245 static void fl_view_renderer_opengl_class_init(
246  FlViewRendererOpenGLClass* klass) {
247  GObjectClass* object_class = G_OBJECT_CLASS(klass);
248  object_class->dispose = fl_view_renderer_opengl_dispose;
249  object_class->finalize = fl_view_renderer_opengl_finalize;
250 
251  GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
252  widget_class->realize = fl_view_renderer_opengl_realize;
253  widget_class->draw = fl_view_renderer_opengl_draw;
254 
255  FlViewRendererClass* renderer_class = FL_VIEW_RENDERER_CLASS(klass);
256  renderer_class->present_layers = fl_view_renderer_opengl_present_layers;
257 }
258 
259 static void fl_view_renderer_opengl_init(FlViewRendererOpenGL* self) {
260  g_mutex_init(&self->frame_mutex);
261 }
262 
263 FlViewRendererOpenGL* fl_view_renderer_opengl_new(FlEngine* engine,
264  gboolean sized_to_content) {
265  g_return_val_if_fail(FL_IS_ENGINE(engine), nullptr);
266 
267  FlViewRendererOpenGL* self = FL_VIEW_RENDERER_OPENGL(
268  g_object_new(fl_view_renderer_opengl_get_type(), nullptr));
269  self->engine = FL_ENGINE(g_object_ref(engine));
270  self->sized_to_content = sized_to_content;
271  return self;
272 }
g_autoptr(FlEngine) engine
const char FlTextDirection FlAssertiveness gpointer user_data
FlCompositorOpenGL * fl_compositor_opengl_new(FlOpenGLManager *opengl_manager)
FlOpenGLManager * fl_engine_get_opengl_manager(FlEngine *self)
Definition: fl_engine.cc:751
FlTaskRunner * fl_engine_get_task_runner(FlEngine *self)
Definition: fl_engine.cc:1591
void fl_engine_schedule_frame(FlEngine *self)
Definition: fl_engine.cc:1185
gboolean fl_opengl_frame_draw(FlOpenGLFrame *self, cairo_t *cr, GdkWindow *window, gint scale_factor, size_t width, size_t height)
void fl_opengl_frame_get_size(FlOpenGLFrame *self, size_t *width, size_t *height)
void fl_opengl_frame_composite(FlOpenGLFrame *self, FlCompositorOpenGL *compositor, const FlutterLayer **layers, size_t layers_count)
FlOpenGLFrame * fl_opengl_frame_new()
const uint8_t uint32_t uint32_t * height
const uint8_t uint32_t uint32_t GError ** error
void fl_task_runner_stop_wait(FlTaskRunner *self)
void fl_task_runner_wait(FlTaskRunner *self, gint64 expiry_time)
const FlutterLayer size_t layers_count
const FlutterLayer ** layers
gboolean fl_view_renderer_resize_to_frame(FlViewRenderer *self, size_t frame_width, size_t frame_height)
void fl_view_renderer_notify_frame(FlViewRenderer *self)
void fl_view_renderer_paint_background(FlViewRenderer *self, cairo_t *cr)
static constexpr gint64 kRenderTimeoutMicroseconds
size_t * width
G_DEFINE_TYPE(FlViewRendererOpenGL, fl_view_renderer_opengl, fl_view_renderer_get_type()) static void get_frame_size(FlViewRendererOpenGL *self
G_BEGIN_DECLS gboolean sized_to_content
FlCompositorOpenGL * compositor