qemu/ui/egl-headless.c
<<
>>
Prefs
   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
   9typedef 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
  23static void egl_refresh(DisplayChangeListener *dcl)
  24{
  25    graphic_hw_update(dcl->con);
  26}
  27
  28static void egl_gfx_update(DisplayChangeListener *dcl,
  29                           int x, int y, int w, int h)
  30{
  31}
  32
  33static 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
  41static 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
  49static 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
  57static 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
  81static 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
  94static 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
 112static 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
 121static void egl_release_dmabuf(DisplayChangeListener *dcl,
 122                               QemuDmaBuf *dmabuf)
 123{
 124    egl_dmabuf_release_texture(dmabuf);
 125}
 126
 127static 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
 154static 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
 174static void early_egl_headless_init(DisplayOptions *opts)
 175{
 176    display_opengl = 1;
 177}
 178
 179static 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
 205static QemuDisplay qemu_display_egl = {
 206    .type       = DISPLAY_TYPE_EGL_HEADLESS,
 207    .early_init = early_egl_headless_init,
 208    .init       = egl_headless_init,
 209};
 210
 211static void register_egl(void)
 212{
 213    qemu_display_register(&qemu_display_egl);
 214}
 215
 216type_init(register_egl);
 217