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(DisplayGLCtx *dgc, 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(dgc, 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_scanout_disable = egl_scanout_disable, 161 .dpy_gl_scanout_texture = egl_scanout_texture, 162 .dpy_gl_scanout_dmabuf = egl_scanout_dmabuf, 163 .dpy_gl_cursor_dmabuf = egl_cursor_dmabuf, 164 .dpy_gl_cursor_position = egl_cursor_position, 165 .dpy_gl_release_dmabuf = egl_release_dmabuf, 166 .dpy_gl_update = egl_scanout_flush, 167 }; 168 169 static bool 170 egl_is_compatible_dcl(DisplayGLCtx *dgc, 171 DisplayChangeListener *dcl) 172 { 173 if (!dcl->ops->dpy_gl_update) { 174 /* 175 * egl-headless is compatible with all 2d listeners, as it blits the GL 176 * updates on the 2d console surface. 177 */ 178 return true; 179 } 180 181 return dcl->ops == &egl_ops; 182 } 183 184 static const DisplayGLCtxOps eglctx_ops = { 185 .dpy_gl_ctx_is_compatible_dcl = egl_is_compatible_dcl, 186 .dpy_gl_ctx_create = egl_create_context, 187 .dpy_gl_ctx_destroy = qemu_egl_destroy_context, 188 .dpy_gl_ctx_make_current = qemu_egl_make_context_current, 189 }; 190 191 static void early_egl_headless_init(DisplayOptions *opts) 192 { 193 display_opengl = 1; 194 } 195 196 static void egl_headless_init(DisplayState *ds, DisplayOptions *opts) 197 { 198 DisplayGLMode mode = opts->has_gl ? opts->gl : DISPLAYGL_MODE_ON; 199 QemuConsole *con; 200 egl_dpy *edpy; 201 int idx; 202 203 if (egl_rendernode_init(opts->u.egl_headless.rendernode, mode) < 0) { 204 error_report("egl: render node init failed"); 205 exit(1); 206 } 207 208 for (idx = 0;; idx++) { 209 DisplayGLCtx *ctx; 210 211 con = qemu_console_lookup_by_index(idx); 212 if (!con || !qemu_console_is_graphic(con)) { 213 break; 214 } 215 216 edpy = g_new0(egl_dpy, 1); 217 edpy->dcl.con = con; 218 edpy->dcl.ops = &egl_ops; 219 edpy->gls = qemu_gl_init_shader(); 220 ctx = g_new0(DisplayGLCtx, 1); 221 ctx->ops = &eglctx_ops; 222 qemu_console_set_display_gl_ctx(con, ctx); 223 register_displaychangelistener(&edpy->dcl); 224 } 225 } 226 227 static QemuDisplay qemu_display_egl = { 228 .type = DISPLAY_TYPE_EGL_HEADLESS, 229 .early_init = early_egl_headless_init, 230 .init = egl_headless_init, 231 }; 232 233 static void register_egl(void) 234 { 235 qemu_display_register(&qemu_display_egl); 236 } 237 238 type_init(register_egl); 239 240 module_dep("ui-opengl"); 241