Merge remote-tracking branch 'remotes/palmer/tags/riscv-for-master-5.0-sf1' into...
[qemu.git] / ui / egl-headless.c
1 #include "qemu/osdep.h"
2 #include "qemu/module.h"
3 #include "sysemu/sysemu.h"
4 #include "ui/console.h"
5 #include "ui/egl-helpers.h"
6 #include "ui/egl-context.h"
7 #include "ui/shader.h"
8
9 typedef struct egl_dpy {
10 DisplayChangeListener dcl;
11 DisplaySurface *ds;
12 QemuGLShader *gls;
13 egl_fb guest_fb;
14 egl_fb cursor_fb;
15 egl_fb blit_fb;
16 bool y_0_top;
17 uint32_t pos_x;
18 uint32_t pos_y;
19 } egl_dpy;
20
21 /* ------------------------------------------------------------------ */
22
23 static void egl_refresh(DisplayChangeListener *dcl)
24 {
25 graphic_hw_update(dcl->con);
26 }
27
28 static void egl_gfx_update(DisplayChangeListener *dcl,
29 int x, int y, int w, int h)
30 {
31 }
32
33 static void egl_gfx_switch(DisplayChangeListener *dcl,
34 struct DisplaySurface *new_surface)
35 {
36 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
37
38 edpy->ds = new_surface;
39 }
40
41 static QEMUGLContext egl_create_context(DisplayChangeListener *dcl,
42 QEMUGLParams *params)
43 {
44 eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
45 qemu_egl_rn_ctx);
46 return qemu_egl_create_context(dcl, params);
47 }
48
49 static void egl_scanout_disable(DisplayChangeListener *dcl)
50 {
51 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
52
53 egl_fb_destroy(&edpy->guest_fb);
54 egl_fb_destroy(&edpy->blit_fb);
55 }
56
57 static void egl_scanout_texture(DisplayChangeListener *dcl,
58 uint32_t backing_id,
59 bool backing_y_0_top,
60 uint32_t backing_width,
61 uint32_t backing_height,
62 uint32_t x, uint32_t y,
63 uint32_t w, uint32_t h)
64 {
65 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
66
67 edpy->y_0_top = backing_y_0_top;
68
69 /* source framebuffer */
70 egl_fb_setup_for_tex(&edpy->guest_fb,
71 backing_width, backing_height, backing_id, false);
72
73 /* dest framebuffer */
74 if (edpy->blit_fb.width != backing_width ||
75 edpy->blit_fb.height != backing_height) {
76 egl_fb_destroy(&edpy->blit_fb);
77 egl_fb_setup_new_tex(&edpy->blit_fb, backing_width, backing_height);
78 }
79 }
80
81 static void egl_scanout_dmabuf(DisplayChangeListener *dcl,
82 QemuDmaBuf *dmabuf)
83 {
84 egl_dmabuf_import_texture(dmabuf);
85 if (!dmabuf->texture) {
86 return;
87 }
88
89 egl_scanout_texture(dcl, dmabuf->texture,
90 false, dmabuf->width, dmabuf->height,
91 0, 0, dmabuf->width, dmabuf->height);
92 }
93
94 static void egl_cursor_dmabuf(DisplayChangeListener *dcl,
95 QemuDmaBuf *dmabuf, bool have_hot,
96 uint32_t hot_x, uint32_t hot_y)
97 {
98 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
99
100 if (dmabuf) {
101 egl_dmabuf_import_texture(dmabuf);
102 if (!dmabuf->texture) {
103 return;
104 }
105 egl_fb_setup_for_tex(&edpy->cursor_fb, dmabuf->width, dmabuf->height,
106 dmabuf->texture, false);
107 } else {
108 egl_fb_destroy(&edpy->cursor_fb);
109 }
110 }
111
112 static void egl_cursor_position(DisplayChangeListener *dcl,
113 uint32_t pos_x, uint32_t pos_y)
114 {
115 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
116
117 edpy->pos_x = pos_x;
118 edpy->pos_y = pos_y;
119 }
120
121 static void egl_release_dmabuf(DisplayChangeListener *dcl,
122 QemuDmaBuf *dmabuf)
123 {
124 egl_dmabuf_release_texture(dmabuf);
125 }
126
127 static void egl_scanout_flush(DisplayChangeListener *dcl,
128 uint32_t x, uint32_t y,
129 uint32_t w, uint32_t h)
130 {
131 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
132
133 if (!edpy->guest_fb.texture || !edpy->ds) {
134 return;
135 }
136 assert(surface_format(edpy->ds) == PIXMAN_x8r8g8b8);
137
138 if (edpy->cursor_fb.texture) {
139 /* have cursor -> render using textures */
140 egl_texture_blit(edpy->gls, &edpy->blit_fb, &edpy->guest_fb,
141 !edpy->y_0_top);
142 egl_texture_blend(edpy->gls, &edpy->blit_fb, &edpy->cursor_fb,
143 !edpy->y_0_top, edpy->pos_x, edpy->pos_y,
144 1.0, 1.0);
145 } else {
146 /* no cursor -> use simple framebuffer blit */
147 egl_fb_blit(&edpy->blit_fb, &edpy->guest_fb, edpy->y_0_top);
148 }
149
150 egl_fb_read(edpy->ds, &edpy->blit_fb);
151 dpy_gfx_update(edpy->dcl.con, x, y, w, h);
152 }
153
154 static const DisplayChangeListenerOps egl_ops = {
155 .dpy_name = "egl-headless",
156 .dpy_refresh = egl_refresh,
157 .dpy_gfx_update = egl_gfx_update,
158 .dpy_gfx_switch = egl_gfx_switch,
159
160 .dpy_gl_ctx_create = egl_create_context,
161 .dpy_gl_ctx_destroy = qemu_egl_destroy_context,
162 .dpy_gl_ctx_make_current = qemu_egl_make_context_current,
163 .dpy_gl_ctx_get_current = qemu_egl_get_current_context,
164
165 .dpy_gl_scanout_disable = egl_scanout_disable,
166 .dpy_gl_scanout_texture = egl_scanout_texture,
167 .dpy_gl_scanout_dmabuf = egl_scanout_dmabuf,
168 .dpy_gl_cursor_dmabuf = egl_cursor_dmabuf,
169 .dpy_gl_cursor_position = egl_cursor_position,
170 .dpy_gl_release_dmabuf = egl_release_dmabuf,
171 .dpy_gl_update = egl_scanout_flush,
172 };
173
174 static void early_egl_headless_init(DisplayOptions *opts)
175 {
176 display_opengl = 1;
177 }
178
179 static void egl_headless_init(DisplayState *ds, DisplayOptions *opts)
180 {
181 DisplayGLMode mode = opts->has_gl ? opts->gl : DISPLAYGL_MODE_ON;
182 QemuConsole *con;
183 egl_dpy *edpy;
184 int idx;
185
186 if (egl_rendernode_init(opts->u.egl_headless.rendernode, mode) < 0) {
187 error_report("egl: render node init failed");
188 exit(1);
189 }
190
191 for (idx = 0;; idx++) {
192 con = qemu_console_lookup_by_index(idx);
193 if (!con || !qemu_console_is_graphic(con)) {
194 break;
195 }
196
197 edpy = g_new0(egl_dpy, 1);
198 edpy->dcl.con = con;
199 edpy->dcl.ops = &egl_ops;
200 edpy->gls = qemu_gl_init_shader();
201 register_displaychangelistener(&edpy->dcl);
202 }
203 }
204
205 static QemuDisplay qemu_display_egl = {
206 .type = DISPLAY_TYPE_EGL_HEADLESS,
207 .early_init = early_egl_headless_init,
208 .init = egl_headless_init,
209 };
210
211 static void register_egl(void)
212 {
213 qemu_display_register(&qemu_display_egl);
214 }
215
216 type_init(register_egl);