target/mips: Move MUL opcode check from decode_mxu() to decode_legacy()
[qemu/ar7.git] / ui / egl-headless.c
blobda377a74af69b3e7c91a833e671a6b43a480691a
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"
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;
21 /* ------------------------------------------------------------------ */
23 static void egl_refresh(DisplayChangeListener *dcl)
25     graphic_hw_update(dcl->con);
28 static void egl_gfx_update(DisplayChangeListener *dcl,
29                            int x, int y, int w, int h)
33 static void egl_gfx_switch(DisplayChangeListener *dcl,
34                            struct DisplaySurface *new_surface)
36     egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
38     edpy->ds = new_surface;
41 static QEMUGLContext egl_create_context(DisplayChangeListener *dcl,
42                                         QEMUGLParams *params)
44     eglMakeCurrent(qemu_egl_display, EGL_NO_SURFACE, EGL_NO_SURFACE,
45                    qemu_egl_rn_ctx);
46     return qemu_egl_create_context(dcl, params);
49 static void egl_scanout_disable(DisplayChangeListener *dcl)
51     egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
53     egl_fb_destroy(&edpy->guest_fb);
54     egl_fb_destroy(&edpy->blit_fb);
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)
65     egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
67     edpy->y_0_top = backing_y_0_top;
69     /* source framebuffer */
70     egl_fb_setup_for_tex(&edpy->guest_fb,
71                          backing_width, backing_height, backing_id, false);
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     }
81 static void egl_scanout_dmabuf(DisplayChangeListener *dcl,
82                                QemuDmaBuf *dmabuf)
84     egl_dmabuf_import_texture(dmabuf);
85     if (!dmabuf->texture) {
86         return;
87     }
89     egl_scanout_texture(dcl, dmabuf->texture,
90                         false, dmabuf->width, dmabuf->height,
91                         0, 0, dmabuf->width, dmabuf->height);
94 static void egl_cursor_dmabuf(DisplayChangeListener *dcl,
95                               QemuDmaBuf *dmabuf, bool have_hot,
96                               uint32_t hot_x, uint32_t hot_y)
98     egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
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     }
112 static void egl_cursor_position(DisplayChangeListener *dcl,
113                                 uint32_t pos_x, uint32_t pos_y)
115     egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
117     edpy->pos_x = pos_x;
118     edpy->pos_y = pos_y;
121 static void egl_release_dmabuf(DisplayChangeListener *dcl,
122                                QemuDmaBuf *dmabuf)
124     egl_dmabuf_release_texture(dmabuf);
127 static void egl_scanout_flush(DisplayChangeListener *dcl,
128                               uint32_t x, uint32_t y,
129                               uint32_t w, uint32_t h)
131     egl_dpy *edpy = container_of(dcl, egl_dpy, dcl);
133     if (!edpy->guest_fb.texture || !edpy->ds) {
134         return;
135     }
136     assert(surface_format(edpy->ds) == PIXMAN_x8r8g8b8);
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     }
150     egl_fb_read(edpy->ds, &edpy->blit_fb);
151     dpy_gfx_update(edpy->dcl.con, x, y, w, h);
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,
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,
164     .dpy_gl_scanout_disable  = egl_scanout_disable,
165     .dpy_gl_scanout_texture  = egl_scanout_texture,
166     .dpy_gl_scanout_dmabuf   = egl_scanout_dmabuf,
167     .dpy_gl_cursor_dmabuf    = egl_cursor_dmabuf,
168     .dpy_gl_cursor_position  = egl_cursor_position,
169     .dpy_gl_release_dmabuf   = egl_release_dmabuf,
170     .dpy_gl_update           = egl_scanout_flush,
173 static void early_egl_headless_init(DisplayOptions *opts)
175     display_opengl = 1;
178 static void egl_headless_init(DisplayState *ds, DisplayOptions *opts)
180     DisplayGLMode mode = opts->has_gl ? opts->gl : DISPLAYGL_MODE_ON;
181     QemuConsole *con;
182     egl_dpy *edpy;
183     int idx;
185     if (egl_rendernode_init(opts->u.egl_headless.rendernode, mode) < 0) {
186         error_report("egl: render node init failed");
187         exit(1);
188     }
190     for (idx = 0;; idx++) {
191         con = qemu_console_lookup_by_index(idx);
192         if (!con || !qemu_console_is_graphic(con)) {
193             break;
194         }
196         edpy = g_new0(egl_dpy, 1);
197         edpy->dcl.con = con;
198         edpy->dcl.ops = &egl_ops;
199         edpy->gls = qemu_gl_init_shader();
200         register_displaychangelistener(&edpy->dcl);
201     }
204 static QemuDisplay qemu_display_egl = {
205     .type       = DISPLAY_TYPE_EGL_HEADLESS,
206     .early_init = early_egl_headless_init,
207     .init       = egl_headless_init,
210 static void register_egl(void)
212     qemu_display_register(&qemu_display_egl);
215 type_init(register_egl);