Flutter Linux Embedder
fl_view_renderer_software.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 
10 
11 // Maximum time to wait for a frame to be ready before giving up and rendering.
12 static constexpr gint64 kRenderTimeoutMicroseconds = 100000; // 100ms
13 
15  FlViewRenderer parent_instance;
16 
17  // Engine this widget is rendering.
18  FlEngine* engine;
19 
20  // TRUE if the view size should be controlled by Flutter.
21  gboolean sized_to_content;
22 
23  // Combines and stores frames.
24  FlCompositorSoftware* compositor;
25 
26  // Surface the current frame is composited into.
27  cairo_surface_t* surface;
28 
29  // Task runner to wait for frames on.
30  FlTaskRunner* task_runner;
31 
32  // Ensure Flutter and GTK can access the frame stored in the compositor.
33  GMutex frame_mutex;
34 };
35 
36 G_DEFINE_TYPE(FlViewRendererSoftware,
37  fl_view_renderer_software,
38  fl_view_renderer_get_type())
39 
40 // Get the size of the current frame in pixels. The size is zero if there is no
41 // frame yet. Must be called with the frame mutex held.
42 static void get_frame_size(FlViewRendererSoftware* self,
43  size_t* width,
44  size_t* height) {
45  if (self->surface != nullptr) {
46  *width = cairo_image_surface_get_width(self->surface);
47  *height = cairo_image_surface_get_height(self->surface);
48  } else {
49  *width = 0;
50  *height = 0;
51  }
52 }
53 
54 // Redraw the view from the GTK thread.
55 static gboolean redraw_cb(gpointer user_data) {
56  g_autoptr(FlViewRendererSoftware) self = FL_VIEW_RENDERER_SOFTWARE(user_data);
57 
58  if (self->compositor == nullptr) {
59  return G_SOURCE_REMOVE;
60  }
61 
62  fl_view_renderer_notify_frame(FL_VIEW_RENDERER(self));
63 
64  // If Flutter is controlling the window size, then resize the view if
65  // necessary. The redraw happens once the resized frame arrives.
66  if (self->sized_to_content) {
67  size_t frame_width, frame_height;
68  g_mutex_lock(&self->frame_mutex);
69  get_frame_size(self, &frame_width, &frame_height);
70  g_mutex_unlock(&self->frame_mutex);
71  if (fl_view_renderer_resize_to_frame(FL_VIEW_RENDERER(self), frame_width,
72  frame_height)) {
73  return G_SOURCE_REMOVE;
74  }
75  }
76 
77  gtk_widget_queue_draw(GTK_WIDGET(self));
78 
79  return G_SOURCE_REMOVE;
80 }
81 
82 // Wait for a frame matching the window size to be ready, or until the timeout
83 // expires. Must be called with the frame mutex held; the mutex is still held
84 // when this function returns.
85 static void wait_for_frame(FlViewRendererSoftware* self,
86  GdkWindow* window,
87  gint scale_factor) {
88  gint64 expiry_time = g_get_monotonic_time() + kRenderTimeoutMicroseconds;
89  while (true) {
90  size_t width = gdk_window_get_width(window) * scale_factor;
91  size_t height = gdk_window_get_height(window) * scale_factor;
92  size_t frame_width, frame_height;
93  get_frame_size(self, &frame_width, &frame_height);
94  if (frame_width == width && frame_height == height) {
95  break;
96  }
97 
98  if (g_get_monotonic_time() > expiry_time) {
99  g_warning(
100  "Timed out waiting for software frame of size %zdx%zd (have "
101  "%zdx%zd)",
102  width, height, frame_width, frame_height);
103  break;
104  }
105 
106  g_mutex_unlock(&self->frame_mutex);
107  fl_task_runner_wait(self->task_runner, expiry_time);
108  g_mutex_lock(&self->frame_mutex);
109  }
110 }
111 
112 // Implements GtkWidget::realize.
113 static void fl_view_renderer_software_realize(GtkWidget* widget) {
114  FlViewRendererSoftware* self = FL_VIEW_RENDERER_SOFTWARE(widget);
115 
116  GTK_WIDGET_CLASS(fl_view_renderer_software_parent_class)->realize(widget);
117 
118  self->task_runner =
119  FL_TASK_RUNNER(g_object_ref(fl_engine_get_task_runner(self->engine)));
120  self->compositor = fl_compositor_software_new();
121 
122  // Any frames rendered before this point were dropped, as there was nothing
123  // to present them to. Ask for another one so the view isn't left empty until
124  // something else causes Flutter to render.
125  fl_engine_schedule_frame(self->engine);
126 }
127 
128 // Implements GtkWidget::draw.
129 static gboolean fl_view_renderer_software_draw(GtkWidget* widget, cairo_t* cr) {
130  FlViewRendererSoftware* self = FL_VIEW_RENDERER_SOFTWARE(widget);
131 
132  fl_view_renderer_paint_background(FL_VIEW_RENDERER(self), cr);
133 
134  // The compositor is created when the widget is realized; if it is not yet
135  // available there is nothing to render beyond the background.
136  if (self->compositor == nullptr) {
137  return TRUE;
138  }
139 
140  GdkWindow* window = gtk_widget_get_window(widget);
141  gint scale_factor = gdk_window_get_scale_factor(window);
142 
143  g_mutex_lock(&self->frame_mutex);
144 
145  // If frame not ready, then wait for it.
146  if (!self->sized_to_content) {
147  wait_for_frame(self, window, scale_factor);
148  }
149 
150  gboolean result = FALSE;
151  if (self->surface != nullptr) {
152  cairo_save(cr);
153  cairo_scale(cr, 1.0 / scale_factor, 1.0 / scale_factor);
154  cairo_set_source_surface(cr, self->surface, 0.0, 0.0);
155  cairo_paint(cr);
156  cairo_restore(cr);
157  result = TRUE;
158  }
159 
160  g_mutex_unlock(&self->frame_mutex);
161 
162  return result;
163 }
164 
165 // Implements FlViewRenderer::present_layers.
166 static void fl_view_renderer_software_present_layers(
167  FlViewRenderer* renderer,
168  const FlutterLayer** layers,
169  size_t layers_count) {
170  FlViewRendererSoftware* self = FL_VIEW_RENDERER_SOFTWARE(renderer);
171 
172  // Frames may be presented before the widget is realized and the compositor
173  // is set up; ignore them.
174  if (self->compositor == nullptr) {
175  return;
176  }
177 
178  g_mutex_lock(&self->frame_mutex);
179  size_t width = 0;
180  size_t height = 0;
181  gboolean have_frame = TRUE;
182  if (layers_count > 0) {
183  width = layers[0]->size.width;
184  height = layers[0]->size.height;
185  } else if (self->surface != nullptr) {
186  // Keep current size if no layers - just clearing.
187  width = cairo_image_surface_get_width(self->surface);
188  height = cairo_image_surface_get_height(self->surface);
189  } else {
190  // Nothing has been rendered yet, so there is nothing to clear.
191  have_frame = FALSE;
192  }
193 
194  if (have_frame) {
195  if (width == 0 || height == 0) {
196  // A zero-sized layer has no content to show. Drop any existing frame so
197  // the renderer reports no frame rather than an empty surface (a 0x0
198  // surface would otherwise be treated as a valid frame while matching the
199  // "no frame" size of 0x0).
200  g_clear_pointer(&self->surface, cairo_surface_destroy);
201  } else {
202  // Recreate the surface if the frame size has changed.
203  if (self->surface == nullptr ||
204  static_cast<size_t>(cairo_image_surface_get_width(self->surface)) !=
205  width ||
206  static_cast<size_t>(cairo_image_surface_get_height(self->surface)) !=
207  height) {
208  g_clear_pointer(&self->surface, cairo_surface_destroy);
209  self->surface =
210  cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
211  }
212 
213  cairo_t* cr = cairo_create(self->surface);
214  fl_compositor_software_composite_layers(self->compositor, cr, layers,
215  layers_count);
216  cairo_destroy(cr);
217  cairo_surface_flush(self->surface);
218  }
219  }
220  g_mutex_unlock(&self->frame_mutex);
221 
222  // Wake up the GTK thread if it is waiting for this frame.
223  fl_task_runner_stop_wait(self->task_runner);
224 
225  // Perform the redraw in the GTK thread.
226  g_idle_add(redraw_cb, g_object_ref(self));
227 }
228 
229 static void fl_view_renderer_software_dispose(GObject* object) {
230  FlViewRendererSoftware* self = FL_VIEW_RENDERER_SOFTWARE(object);
231 
232  g_clear_object(&self->engine);
233  g_clear_object(&self->task_runner);
234  g_mutex_clear(&self->frame_mutex);
235 
236  G_OBJECT_CLASS(fl_view_renderer_software_parent_class)->dispose(object);
237 }
238 
239 static void fl_view_renderer_software_finalize(GObject* object) {
240  FlViewRendererSoftware* self = FL_VIEW_RENDERER_SOFTWARE(object);
241 
242  // The compositor is released here rather than in dispose() so it outlives a
243  // forced dispose (e.g. gtk_widget_destroy()) and is only freed once the last
244  // reference is dropped. This keeps it alive for the raster thread, which
245  // holds a strong reference on the view (and thus this renderer) while
246  // presenting.
247  g_clear_object(&self->compositor);
248  g_clear_pointer(&self->surface, cairo_surface_destroy);
249 
250  G_OBJECT_CLASS(fl_view_renderer_software_parent_class)->finalize(object);
251 }
252 
253 static void fl_view_renderer_software_class_init(
254  FlViewRendererSoftwareClass* klass) {
255  GObjectClass* object_class = G_OBJECT_CLASS(klass);
256  object_class->dispose = fl_view_renderer_software_dispose;
257  object_class->finalize = fl_view_renderer_software_finalize;
258 
259  GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
260  widget_class->realize = fl_view_renderer_software_realize;
261  widget_class->draw = fl_view_renderer_software_draw;
262 
263  FlViewRendererClass* renderer_class = FL_VIEW_RENDERER_CLASS(klass);
264  renderer_class->present_layers = fl_view_renderer_software_present_layers;
265 }
266 
267 static void fl_view_renderer_software_init(FlViewRendererSoftware* self) {
268  g_mutex_init(&self->frame_mutex);
269 }
270 
271 FlViewRendererSoftware* fl_view_renderer_software_new(
272  FlEngine* engine,
273  gboolean sized_to_content) {
274  g_return_val_if_fail(FL_IS_ENGINE(engine), nullptr);
275 
276  FlViewRendererSoftware* self = FL_VIEW_RENDERER_SOFTWARE(
277  g_object_new(fl_view_renderer_software_get_type(), nullptr));
278  self->engine = FL_ENGINE(g_object_ref(engine));
279  self->sized_to_content = sized_to_content;
280  return self;
281 }
g_autoptr(FlEngine) engine
const char FlTextDirection FlAssertiveness gpointer user_data
FlCompositorSoftware * fl_compositor_software_new()
gboolean fl_compositor_software_composite_layers(FlCompositorSoftware *self, cairo_t *cr, const FlutterLayer **layers, size_t layers_count)
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
const uint8_t uint32_t uint32_t * height
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)
G_BEGIN_DECLS gboolean sized_to_content
static constexpr gint64 kRenderTimeoutMicroseconds
size_t * width
G_DEFINE_TYPE(FlViewRendererSoftware, fl_view_renderer_software, fl_view_renderer_get_type()) static void get_frame_size(FlViewRendererSoftware *self
FlCompositorSoftware * compositor