1 /*
2 * GTK UI -- egl opengl code.
3 *
4 * Note that gtk 3.16+ (released 2015-03-23) has a GtkGLArea widget,
5 * which is GtkDrawingArea like widget with opengl rendering support.
6 *
7 * This code handles opengl support on older gtk versions, using egl
8 * to get a opengl context for the X11 window.
9 *
10 * This work is licensed under the terms of the GNU GPL, version 2 or later.
11 * See the COPYING file in the top-level directory.
12 */
13
14 #include "qemu/osdep.h"
15 #include "qemu/main-loop.h"
16 #include "qemu/error-report.h"
17
18 #include "trace.h"
19
20 #include "ui/console.h"
21 #include "ui/gtk.h"
22 #include "ui/egl-helpers.h"
23 #include "ui/shader.h"
24
25 #include "system/system.h"
26
gtk_egl_set_scanout_mode(VirtualConsole * vc,bool scanout)27 static void gtk_egl_set_scanout_mode(VirtualConsole *vc, bool scanout)
28 {
29 if (vc->gfx.scanout_mode == scanout) {
30 return;
31 }
32
33 vc->gfx.scanout_mode = scanout;
34 if (!vc->gfx.scanout_mode) {
35 eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
36 vc->gfx.esurface, vc->gfx.ectx);
37 egl_fb_destroy(&vc->gfx.guest_fb);
38 if (vc->gfx.surface) {
39 surface_gl_destroy_texture(vc->gfx.gls, vc->gfx.ds);
40 surface_gl_create_texture(vc->gfx.gls, vc->gfx.ds);
41 }
42 }
43 }
44
45 /** DisplayState Callbacks (opengl version) **/
46
gd_egl_init(VirtualConsole * vc)47 void gd_egl_init(VirtualConsole *vc)
48 {
49 GdkWindow *gdk_window = gtk_widget_get_window(vc->gfx.drawing_area);
50 if (!gdk_window) {
51 return;
52 }
53
54 Window x11_window = gdk_x11_window_get_xid(gdk_window);
55 if (!x11_window) {
56 return;
57 }
58
59 vc->gfx.ectx = qemu_egl_init_ctx();
60 vc->gfx.esurface = qemu_egl_init_surface_x11
61 (vc->gfx.ectx, (EGLNativeWindowType)x11_window);
62
63 assert(vc->gfx.esurface);
64 }
65
gd_egl_draw(VirtualConsole * vc)66 void gd_egl_draw(VirtualConsole *vc)
67 {
68 GdkWindow *window;
69 #ifdef CONFIG_GBM
70 QemuDmaBuf *dmabuf = vc->gfx.guest_fb.dmabuf;
71 int fence_fd;
72 #endif
73 int ww, wh, pw, ph, gs;
74
75 if (!vc->gfx.gls) {
76 return;
77 }
78
79 window = gtk_widget_get_window(vc->gfx.drawing_area);
80 gs = gdk_window_get_scale_factor(window);
81 ww = gdk_window_get_width(window);
82 wh = gdk_window_get_height(window);
83 pw = ww * gs;
84 ph = wh * gs;
85
86 if (vc->gfx.scanout_mode) {
87 #ifdef CONFIG_GBM
88 if (dmabuf) {
89 if (!qemu_dmabuf_get_draw_submitted(dmabuf)) {
90 return;
91 } else {
92 qemu_dmabuf_set_draw_submitted(dmabuf, false);
93 }
94 }
95 #endif
96 gd_egl_scanout_flush(&vc->gfx.dcl, 0, 0, vc->gfx.w, vc->gfx.h);
97
98 vc->gfx.scale_x = (double)ww / surface_width(vc->gfx.ds);
99 vc->gfx.scale_y = (double)wh / surface_height(vc->gfx.ds);
100
101 glFlush();
102 #ifdef CONFIG_GBM
103 if (dmabuf) {
104 egl_dmabuf_create_fence(dmabuf);
105 fence_fd = qemu_dmabuf_get_fence_fd(dmabuf);
106 if (fence_fd >= 0) {
107 qemu_set_fd_handler(fence_fd, gd_hw_gl_flushed, NULL, vc);
108 return;
109 }
110 graphic_hw_gl_block(vc->gfx.dcl.con, false);
111 }
112 #endif
113 } else {
114 if (!vc->gfx.ds) {
115 return;
116 }
117 eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
118 vc->gfx.esurface, vc->gfx.ectx);
119
120 surface_gl_setup_viewport(vc->gfx.gls, vc->gfx.ds, pw, ph);
121 surface_gl_render_texture(vc->gfx.gls, vc->gfx.ds);
122
123 eglSwapBuffers(qemu_egl_display, vc->gfx.esurface);
124
125 vc->gfx.scale_x = (double)ww / surface_width(vc->gfx.ds);
126 vc->gfx.scale_y = (double)wh / surface_height(vc->gfx.ds);
127
128 glFlush();
129 }
130 }
131
gd_egl_update(DisplayChangeListener * dcl,int x,int y,int w,int h)132 void gd_egl_update(DisplayChangeListener *dcl,
133 int x, int y, int w, int h)
134 {
135 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
136
137 if (!vc->gfx.gls || !vc->gfx.ds) {
138 return;
139 }
140
141 eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
142 vc->gfx.esurface, vc->gfx.ectx);
143 surface_gl_update_texture(vc->gfx.gls, vc->gfx.ds, x, y, w, h);
144 vc->gfx.glupdates++;
145 eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE,
146 EGL_NO_SURFACE, EGL_NO_CONTEXT);
147 }
148
gd_egl_refresh(DisplayChangeListener * dcl)149 void gd_egl_refresh(DisplayChangeListener *dcl)
150 {
151 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
152
153 gd_update_monitor_refresh_rate(
154 vc, vc->window ? vc->window : vc->gfx.drawing_area);
155
156 if (vc->gfx.guest_fb.dmabuf &&
157 qemu_dmabuf_get_draw_submitted(vc->gfx.guest_fb.dmabuf)) {
158 gd_egl_draw(vc);
159 return;
160 }
161
162 if (!vc->gfx.esurface) {
163 gd_egl_init(vc);
164 if (!vc->gfx.esurface) {
165 return;
166 }
167 vc->gfx.gls = qemu_gl_init_shader();
168 if (vc->gfx.ds) {
169 surface_gl_destroy_texture(vc->gfx.gls, vc->gfx.ds);
170 surface_gl_create_texture(vc->gfx.gls, vc->gfx.ds);
171 }
172 #ifdef CONFIG_GBM
173 if (vc->gfx.guest_fb.dmabuf) {
174 egl_dmabuf_release_texture(vc->gfx.guest_fb.dmabuf);
175 gd_egl_scanout_dmabuf(dcl, vc->gfx.guest_fb.dmabuf);
176 }
177 #endif
178 }
179
180 graphic_hw_update(dcl->con);
181
182 if (vc->gfx.glupdates) {
183 vc->gfx.glupdates = 0;
184 gtk_egl_set_scanout_mode(vc, false);
185 gd_egl_draw(vc);
186 }
187 }
188
gd_egl_switch(DisplayChangeListener * dcl,DisplaySurface * surface)189 void gd_egl_switch(DisplayChangeListener *dcl,
190 DisplaySurface *surface)
191 {
192 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
193 bool resized = true;
194
195 trace_gd_switch(vc->label, surface_width(surface), surface_height(surface));
196
197 if (vc->gfx.ds &&
198 surface_width(vc->gfx.ds) == surface_width(surface) &&
199 surface_height(vc->gfx.ds) == surface_height(surface)) {
200 resized = false;
201 }
202 eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
203 vc->gfx.esurface, vc->gfx.ectx);
204
205 surface_gl_destroy_texture(vc->gfx.gls, vc->gfx.ds);
206 vc->gfx.ds = surface;
207 if (vc->gfx.gls) {
208 surface_gl_create_texture(vc->gfx.gls, vc->gfx.ds);
209 }
210
211 if (resized) {
212 gd_update_windowsize(vc);
213 }
214
215 eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
216 EGL_NO_CONTEXT);
217 }
218
gd_egl_create_context(DisplayGLCtx * dgc,QEMUGLParams * params)219 QEMUGLContext gd_egl_create_context(DisplayGLCtx *dgc,
220 QEMUGLParams *params)
221 {
222 VirtualConsole *vc = container_of(dgc, VirtualConsole, gfx.dgc);
223
224 eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
225 vc->gfx.esurface, vc->gfx.ectx);
226 return qemu_egl_create_context(dgc, params);
227 }
228
gd_egl_scanout_disable(DisplayChangeListener * dcl)229 void gd_egl_scanout_disable(DisplayChangeListener *dcl)
230 {
231 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
232
233 vc->gfx.w = 0;
234 vc->gfx.h = 0;
235 gtk_egl_set_scanout_mode(vc, false);
236 }
237
gd_egl_scanout_texture(DisplayChangeListener * dcl,uint32_t backing_id,bool backing_y_0_top,uint32_t backing_width,uint32_t backing_height,uint32_t x,uint32_t y,uint32_t w,uint32_t h,void * d3d_tex2d)238 void gd_egl_scanout_texture(DisplayChangeListener *dcl,
239 uint32_t backing_id, bool backing_y_0_top,
240 uint32_t backing_width, uint32_t backing_height,
241 uint32_t x, uint32_t y,
242 uint32_t w, uint32_t h,
243 void *d3d_tex2d)
244 {
245 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
246
247 vc->gfx.x = x;
248 vc->gfx.y = y;
249 vc->gfx.w = w;
250 vc->gfx.h = h;
251 vc->gfx.y0_top = backing_y_0_top;
252
253 if (!vc->gfx.esurface) {
254 gd_egl_init(vc);
255 if (!vc->gfx.esurface) {
256 return;
257 }
258 }
259
260 eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
261 vc->gfx.esurface, vc->gfx.ectx);
262
263 gtk_egl_set_scanout_mode(vc, true);
264 egl_fb_setup_for_tex(&vc->gfx.guest_fb, backing_width, backing_height,
265 backing_id, false);
266 }
267
gd_egl_scanout_dmabuf(DisplayChangeListener * dcl,QemuDmaBuf * dmabuf)268 void gd_egl_scanout_dmabuf(DisplayChangeListener *dcl,
269 QemuDmaBuf *dmabuf)
270 {
271 #ifdef CONFIG_GBM
272 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
273 uint32_t x, y, width, height, backing_width, backing_height, texture;
274 bool y0_top;
275
276 eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
277 vc->gfx.esurface, vc->gfx.ectx);
278
279 egl_dmabuf_import_texture(dmabuf);
280 texture = qemu_dmabuf_get_texture(dmabuf);
281 if (!texture) {
282 return;
283 }
284
285 x = qemu_dmabuf_get_x(dmabuf);
286 y = qemu_dmabuf_get_y(dmabuf);
287 width = qemu_dmabuf_get_width(dmabuf);
288 height = qemu_dmabuf_get_height(dmabuf);
289 backing_width = qemu_dmabuf_get_backing_width(dmabuf);
290 backing_height = qemu_dmabuf_get_backing_height(dmabuf);
291 y0_top = qemu_dmabuf_get_y0_top(dmabuf);
292
293 gd_egl_scanout_texture(dcl, texture, y0_top, backing_width, backing_height,
294 x, y, width, height, NULL);
295
296 if (qemu_dmabuf_get_allow_fences(dmabuf)) {
297 vc->gfx.guest_fb.dmabuf = dmabuf;
298 }
299 #endif
300 }
301
gd_egl_cursor_dmabuf(DisplayChangeListener * dcl,QemuDmaBuf * dmabuf,bool have_hot,uint32_t hot_x,uint32_t hot_y)302 void gd_egl_cursor_dmabuf(DisplayChangeListener *dcl,
303 QemuDmaBuf *dmabuf, bool have_hot,
304 uint32_t hot_x, uint32_t hot_y)
305 {
306 #ifdef CONFIG_GBM
307 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
308 uint32_t backing_width, backing_height, texture;
309
310 if (dmabuf) {
311 egl_dmabuf_import_texture(dmabuf);
312 texture = qemu_dmabuf_get_texture(dmabuf);
313 if (!texture) {
314 return;
315 }
316
317 backing_width = qemu_dmabuf_get_backing_width(dmabuf);
318 backing_height = qemu_dmabuf_get_backing_height(dmabuf);
319 egl_fb_setup_for_tex(&vc->gfx.cursor_fb, backing_width, backing_height,
320 texture, false);
321 } else {
322 egl_fb_destroy(&vc->gfx.cursor_fb);
323 }
324 #endif
325 }
326
gd_egl_cursor_position(DisplayChangeListener * dcl,uint32_t pos_x,uint32_t pos_y)327 void gd_egl_cursor_position(DisplayChangeListener *dcl,
328 uint32_t pos_x, uint32_t pos_y)
329 {
330 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
331
332 vc->gfx.cursor_x = pos_x * vc->gfx.scale_x;
333 vc->gfx.cursor_y = pos_y * vc->gfx.scale_y;
334 }
335
gd_egl_scanout_flush(DisplayChangeListener * dcl,uint32_t x,uint32_t y,uint32_t w,uint32_t h)336 void gd_egl_scanout_flush(DisplayChangeListener *dcl,
337 uint32_t x, uint32_t y, uint32_t w, uint32_t h)
338 {
339 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
340 GdkWindow *window;
341 int ww, wh, ws;
342
343 if (!vc->gfx.scanout_mode) {
344 return;
345 }
346 if (!vc->gfx.guest_fb.framebuffer) {
347 return;
348 }
349
350 eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
351 vc->gfx.esurface, vc->gfx.ectx);
352
353 window = gtk_widget_get_window(vc->gfx.drawing_area);
354 ws = gdk_window_get_scale_factor(window);
355 ww = gdk_window_get_width(window) * ws;
356 wh = gdk_window_get_height(window) * ws;
357 egl_fb_setup_default(&vc->gfx.win_fb, ww, wh);
358 if (vc->gfx.cursor_fb.texture) {
359 egl_texture_blit(vc->gfx.gls, &vc->gfx.win_fb, &vc->gfx.guest_fb,
360 vc->gfx.y0_top);
361 egl_texture_blend(vc->gfx.gls, &vc->gfx.win_fb, &vc->gfx.cursor_fb,
362 vc->gfx.y0_top,
363 vc->gfx.cursor_x, vc->gfx.cursor_y,
364 vc->gfx.scale_x, vc->gfx.scale_y);
365 } else {
366 egl_fb_blit(&vc->gfx.win_fb, &vc->gfx.guest_fb, !vc->gfx.y0_top);
367 }
368
369 #ifdef CONFIG_GBM
370 if (vc->gfx.guest_fb.dmabuf) {
371 egl_dmabuf_create_sync(vc->gfx.guest_fb.dmabuf);
372 }
373 #endif
374
375 eglSwapBuffers(qemu_egl_display, vc->gfx.esurface);
376 }
377
gd_egl_flush(DisplayChangeListener * dcl,uint32_t x,uint32_t y,uint32_t w,uint32_t h)378 void gd_egl_flush(DisplayChangeListener *dcl,
379 uint32_t x, uint32_t y, uint32_t w, uint32_t h)
380 {
381 VirtualConsole *vc = container_of(dcl, VirtualConsole, gfx.dcl);
382 GtkWidget *area = vc->gfx.drawing_area;
383
384 if (vc->gfx.guest_fb.dmabuf &&
385 !qemu_dmabuf_get_draw_submitted(vc->gfx.guest_fb.dmabuf)) {
386 graphic_hw_gl_block(vc->gfx.dcl.con, true);
387 qemu_dmabuf_set_draw_submitted(vc->gfx.guest_fb.dmabuf, true);
388 gtk_egl_set_scanout_mode(vc, true);
389 gtk_widget_queue_draw_area(area, x, y, w, h);
390 return;
391 }
392
393 gd_egl_scanout_flush(&vc->gfx.dcl, x, y, w, h);
394 }
395
gtk_egl_init(DisplayGLMode mode)396 void gtk_egl_init(DisplayGLMode mode)
397 {
398 GdkDisplay *gdk_display = gdk_display_get_default();
399 Display *x11_display = gdk_x11_display_get_xdisplay(gdk_display);
400
401 if (qemu_egl_init_dpy_x11(x11_display, mode) < 0) {
402 return;
403 }
404
405 display_opengl = 1;
406 }
407
gd_egl_make_current(DisplayGLCtx * dgc,QEMUGLContext ctx)408 int gd_egl_make_current(DisplayGLCtx *dgc,
409 QEMUGLContext ctx)
410 {
411 VirtualConsole *vc = container_of(dgc, VirtualConsole, gfx.dgc);
412
413 if (!eglMakeCurrent(qemu_egl_display, vc->gfx.esurface,
414 vc->gfx.esurface, ctx)) {
415 error_report("egl: eglMakeCurrent failed: %s", qemu_egl_get_error_string());
416 return -1;
417 }
418
419 return 0;
420 }
421