1 #include "qemu/osdep.h" 2 #include "qemu/error-report.h" 3 #include "qemu/module.h" 4 #include "qapi/error.h" 5 #include "ui/console.h" 6 #include "ui/egl-helpers.h" 7 #include "ui/egl-context.h" 8 #include "ui/shader.h" 9 10 typedef struct egl_dpy { 11 DisplayChangeListener dcl; 12 DisplaySurface *ds; 13 QemuGLShader *gls; 14 egl_fb guest_fb; 15 egl_fb cursor_fb; 16 egl_fb blit_fb; 17 bool y_0_top; 18 uint32_t pos_x; 19 uint32_t pos_y; 20 } egl_dpy; 21 22 /* ------------------------------------------------------------------ */ 23 24 static void egl_refresh(DisplayChangeListener *dcl) 25 { 26 graphic_hw_update(dcl->con); 27 } 28 29 static void egl_gfx_update(DisplayChangeListener *dcl, 30 int x, int y, int w, int h) 31 { 32 } 33 34 static void egl_gfx_switch(DisplayChangeListener *dcl, 35 struct DisplaySurface *new_surface) 36 { 37 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl); 38 39 edpy->ds = new_surface; 40 } 41 42 static QEMUGLContext egl_create_context(DisplayGLCtx *dgc, 43 QEMUGLParams *params) 44 { 45 eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE, 46 qemu_egl_rn_ctx); 47 return qemu_egl_create_context(dgc, params); 48 } 49 50 static void egl_scanout_disable(DisplayChangeListener *dcl) 51 { 52 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl); 53 54 egl_fb_destroy(&edpy->guest_fb); 55 egl_fb_destroy(&edpy->blit_fb); 56 } 57 58 static void egl_scanout_texture(DisplayChangeListener *dcl, 59 uint32_t backing_id, 60 bool backing_y_0_top, 61 uint32_t backing_width, 62 uint32_t backing_height, 63 uint32_t x, uint32_t y, 64 uint32_t w, uint32_t h, 65 void *d3d_tex2d) 66 { 67 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl); 68 69 edpy->y_0_top = backing_y_0_top; 70 71 /* source framebuffer */ 72 egl_fb_setup_for_tex(&edpy->guest_fb, 73 backing_width, backing_height, backing_id, false); 74 75 /* dest framebuffer */ 76 if (edpy->blit_fb.width != backing_width || 77 edpy->blit_fb.height != backing_height) { 78 egl_fb_destroy(&edpy->blit_fb); 79 egl_fb_setup_new_tex(&edpy->blit_fb, backing_width, backing_height); 80 } 81 } 82 83 #ifdef CONFIG_GBM 84 85 static void egl_scanout_dmabuf(DisplayChangeListener *dcl, 86 QemuDmaBuf *dmabuf) 87 { 88 uint32_t width, height, texture; 89 90 egl_dmabuf_import_texture(dmabuf); 91 texture = qemu_dmabuf_get_texture(dmabuf); 92 if (!texture) { 93 return; 94 } 95 96 width = qemu_dmabuf_get_width(dmabuf); 97 height = qemu_dmabuf_get_height(dmabuf); 98 99 egl_scanout_texture(dcl, texture, false, width, height, 0, 0, 100 width, height, NULL); 101 } 102 103 static void egl_cursor_dmabuf(DisplayChangeListener *dcl, 104 QemuDmaBuf *dmabuf, bool have_hot, 105 uint32_t hot_x, uint32_t hot_y) 106 { 107 uint32_t width, height, texture; 108 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl); 109 110 if (dmabuf) { 111 egl_dmabuf_import_texture(dmabuf); 112 texture = qemu_dmabuf_get_texture(dmabuf); 113 if (!texture) { 114 return; 115 } 116 117 width = qemu_dmabuf_get_width(dmabuf); 118 height = qemu_dmabuf_get_height(dmabuf); 119 egl_fb_setup_for_tex(&edpy->cursor_fb, width, height, texture, false); 120 } else { 121 egl_fb_destroy(&edpy->cursor_fb); 122 } 123 } 124 125 static void egl_release_dmabuf(DisplayChangeListener *dcl, 126 QemuDmaBuf *dmabuf) 127 { 128 egl_dmabuf_release_texture(dmabuf); 129 } 130 131 #endif 132 133 static void egl_cursor_position(DisplayChangeListener *dcl, 134 uint32_t pos_x, uint32_t pos_y) 135 { 136 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl); 137 138 edpy->pos_x = pos_x; 139 edpy->pos_y = pos_y; 140 } 141 142 static void egl_scanout_flush(DisplayChangeListener *dcl, 143 uint32_t x, uint32_t y, 144 uint32_t w, uint32_t h) 145 { 146 egl_dpy *edpy = container_of(dcl, egl_dpy, dcl); 147 148 if (!edpy->guest_fb.texture || !edpy->ds) { 149 return; 150 } 151 assert(surface_format(edpy->ds) == PIXMAN_x8r8g8b8); 152 153 if (edpy->cursor_fb.texture) { 154 /* have cursor -> render using textures */ 155 egl_texture_blit(edpy->gls, &edpy->blit_fb, &edpy->guest_fb, 156 !edpy->y_0_top); 157 egl_texture_blend(edpy->gls, &edpy->blit_fb, &edpy->cursor_fb, 158 !edpy->y_0_top, edpy->pos_x, edpy->pos_y, 159 1.0, 1.0); 160 } else { 161 /* no cursor -> use simple framebuffer blit */ 162 egl_fb_blit(&edpy->blit_fb, &edpy->guest_fb, edpy->y_0_top); 163 } 164 165 egl_fb_read(edpy->ds, &edpy->blit_fb); 166 dpy_gfx_update(edpy->dcl.con, x, y, w, h); 167 } 168 169 static const DisplayChangeListenerOps egl_ops = { 170 .dpy_name = "egl-headless", 171 .dpy_refresh = egl_refresh, 172 .dpy_gfx_update = egl_gfx_update, 173 .dpy_gfx_switch = egl_gfx_switch, 174 175 .dpy_gl_scanout_disable = egl_scanout_disable, 176 .dpy_gl_scanout_texture = egl_scanout_texture, 177 #ifdef CONFIG_GBM 178 .dpy_gl_scanout_dmabuf = egl_scanout_dmabuf, 179 .dpy_gl_cursor_dmabuf = egl_cursor_dmabuf, 180 .dpy_gl_release_dmabuf = egl_release_dmabuf, 181 #endif 182 .dpy_gl_cursor_position = egl_cursor_position, 183 .dpy_gl_update = egl_scanout_flush, 184 }; 185 186 static bool 187 egl_is_compatible_dcl(DisplayGLCtx *dgc, 188 DisplayChangeListener *dcl) 189 { 190 if (!dcl->ops->dpy_gl_update) { 191 /* 192 * egl-headless is compatible with all 2d listeners, as it blits the GL 193 * updates on the 2d console surface. 194 */ 195 return true; 196 } 197 198 return dcl->ops == &egl_ops; 199 } 200 201 static const DisplayGLCtxOps eglctx_ops = { 202 .dpy_gl_ctx_is_compatible_dcl = egl_is_compatible_dcl, 203 .dpy_gl_ctx_create = egl_create_context, 204 .dpy_gl_ctx_destroy = qemu_egl_destroy_context, 205 .dpy_gl_ctx_make_current = qemu_egl_make_context_current, 206 }; 207 208 static void early_egl_headless_init(DisplayOptions *opts) 209 { 210 DisplayGLMode mode = DISPLAYGL_MODE_ON; 211 212 if (opts->has_gl) { 213 mode = opts->gl; 214 } 215 216 egl_init(opts->u.egl_headless.rendernode, mode, &error_fatal); 217 } 218 219 static void egl_headless_init(DisplayState *ds, DisplayOptions *opts) 220 { 221 QemuConsole *con; 222 egl_dpy *edpy; 223 int idx; 224 225 for (idx = 0;; idx++) { 226 DisplayGLCtx *ctx; 227 228 con = qemu_console_lookup_by_index(idx); 229 if (!con || !qemu_console_is_graphic(con)) { 230 break; 231 } 232 233 edpy = g_new0(egl_dpy, 1); 234 edpy->dcl.con = con; 235 edpy->dcl.ops = &egl_ops; 236 edpy->gls = qemu_gl_init_shader(); 237 ctx = g_new0(DisplayGLCtx, 1); 238 ctx->ops = &eglctx_ops; 239 qemu_console_set_display_gl_ctx(con, ctx); 240 register_displaychangelistener(&edpy->dcl); 241 } 242 } 243 244 static QemuDisplay qemu_display_egl = { 245 .type = DISPLAY_TYPE_EGL_HEADLESS, 246 .early_init = early_egl_headless_init, 247 .init = egl_headless_init, 248 }; 249 250 static void register_egl(void) 251 { 252 qemu_display_register(&qemu_display_egl); 253 } 254 255 type_init(register_egl); 256 257 module_dep("ui-opengl"); 258