diff options
Diffstat (limited to 'tools/guest-diag/gz_es.c')
| -rw-r--r-- | tools/guest-diag/gz_es.c | 250 |
1 files changed, 228 insertions, 22 deletions
diff --git a/tools/guest-diag/gz_es.c b/tools/guest-diag/gz_es.c index b371e4f..5a56fee 100644 --- a/tools/guest-diag/gz_es.c +++ b/tools/guest-diag/gz_es.c @@ -1,17 +1,165 @@ -// gz_es.c - give SDL2's offscreen driver a real NVIDIA EGL/GLES context. -// no X, no GLX, no llvmpipe. build: gcc -shared -fPIC -O2 -o gz_es.so gz_es.c -lEGL -lGLESv2 -ldl +// gz_es.c - give SDL2's offscreen driver a real NVIDIA EGL context and +// publish every presented frame to /dev/shm for a desktop viewer. +// +// The guest's vGPU 3D stream is replayed by vgsp; GZDoom renders through +// the real NVIDIA EGL/GL driver (GL_RENDERER = NVIDIA GeForce RTX 2080 +// SUPER, 4.6.0 NVIDIA 570.144). This shim creates the context on a +// pbuffer surface (so the default framebuffer is real), and on each +// SDL_GL_SwapWindow reads the frame back into /dev/shm/gzframes.bin. +// gz_view then displays those frames in an X11 window on the guest +// desktop - a capture surface, not a renderer. +// +// build: gcc -shared -fPIC -O2 -o gz_es.so gz_es.c -lEGL -lGLESv2 -ldl #define _GNU_SOURCE #include <dlfcn.h> #include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/mman.h> +#include <sys/stat.h> +#include <time.h> +#include <stdarg.h> #include <EGL/egl.h> #include <EGL/eglext.h> #include <GLES2/gl2.h> +#ifndef GL_BACK +#define GL_BACK 0x0405 +#endif +#ifndef GL_FRONT +#define GL_FRONT 0x0404 +#endif +#ifndef GL_RGBA8 +#define GL_RGBA8 0x8058 +#endif + +#define GZFRAME_MAGIC 0x31465a47u /* "GZF1" */ +struct gzframe_hdr { + unsigned int magic; + unsigned int w; + unsigned int h; + unsigned int seq; + unsigned int nonblack; + unsigned int pad[3]; +}; + static EGLDisplay dpy; static EGLContext ctx; +static EGLSurface surf; +static int fw = 640, fh = 480; static int (*real_make)(void *, void *); +static struct gzframe_hdr *shm; +static unsigned char *shm_px; +static size_t shm_len; +static unsigned int seq; +static int readbuf = GL_BACK; +static int tried_front; +static int logfd = -1; -void *SDL_GL_CreateContext(void *win) +static void gzlog(const char *fmt, ...) __attribute__((format(printf, 1, 2))); +static void gzlog(const char *fmt, ...) +{ + char buf[512]; + va_list ap; + int n; + + va_start(ap, fmt); + n = vsnprintf(buf, sizeof(buf), fmt, ap); + va_end(ap); + if (n < 0) + return; + if (n > (int)sizeof(buf) - 1) + n = sizeof(buf) - 1; + if (logfd >= 0) + (void)write(logfd, buf, n); + (void)write(2, buf, n); +} + +static int env_int(const char *name, int def) +{ + const char *v = getenv(name); + + return (v && *v) ? atoi(v) : def; +} + +static void shm_open_frame(void) +{ + const char *path = getenv("GZFRAME"); + int fd; + size_t need; + void *p; + + if (!path || !*path) + path = "/dev/shm/gzframes.bin"; + fw = env_int("GZFRAME_W", fw); + fh = env_int("GZFRAME_H", fh); + if (fw <= 0 || fw > 4096 || fh <= 0 || fh > 4096) { + fw = 640; + fh = 480; + } + need = sizeof(struct gzframe_hdr) + (size_t)fw * fh * 4; + fd = open(path, O_RDWR | O_CREAT | O_TRUNC, 0666); + if (fd < 0) + return; + if (ftruncate(fd, need) != 0) { + close(fd); + return; + } + p = mmap(NULL, need, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + close(fd); + if (p == MAP_FAILED) + return; + shm = p; + shm_px = (unsigned char *)(shm + 1); + shm_len = need; + memset(shm, 0, need); + shm->magic = GZFRAME_MAGIC; + shm->w = fw; + shm->h = fh; + gzlog("[gzes] frame shm %s w=%d h=%d len=%zu\n", path, fw, fh, need); +} + +static void publish_frame(void) +{ + unsigned int i, nb = 0; + + if (!shm || !shm_px) + return; + glFinish(); + glReadPixels(0, 0, fw, fh, GL_RGBA, GL_UNSIGNED_BYTE, shm_px); + for (i = 0; i < (unsigned int)fw * fh; i++) { + const unsigned char *p = shm_px + i * 4; + + if (p[0] || p[1] || p[2]) + nb++; + } + /* + * A pbuffer's default read buffer can be front (single buffered) or + * back. If the first frames are entirely black, retry the other + * buffer once; the nonblack count is published either way. + */ + if (!nb && !tried_front && readbuf == GL_BACK) { + tried_front = 1; + readbuf = GL_FRONT; + glReadPixels(0, 0, fw, fh, GL_RGBA, GL_UNSIGNED_BYTE, shm_px); + for (i = 0; i < (unsigned int)fw * fh; i++) { + const unsigned char *p = shm_px + i * 4; + + if (p[0] || p[1] || p[2]) + nb++; + } + gzlog("[gzes] first frame black on GL_BACK; GL_FRONT nonblack=%u\n", nb); + } + seq += 2; + shm->seq = seq; + shm->nonblack = nb; + __sync_synchronize(); + shm->seq = seq + 1; +} + +static int create_context(void) { PFNEGLGETPLATFORMDISPLAYEXTPROC gp = (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress( @@ -21,18 +169,29 @@ void *SDL_GL_CreateContext(void *win) "eglQueryDevicesEXT"); EGLint maj, min, nc = 0; EGLConfig cfg; - EGLint ca[] = { EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGLint ca_gl[] = { EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, + EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, + EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, + EGL_DEPTH_SIZE, 24, EGL_NONE }; + EGLint ca_es[] = { EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, EGL_NONE }; - EGLint at[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; + EGLint at_gl[] = { EGL_CONTEXT_MAJOR_VERSION, 3, + EGL_CONTEXT_MINOR_VERSION, 3, + EGL_CONTEXT_OPENGL_PROFILE_MASK, + EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT, EGL_NONE }; + EGLint at_es[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; + EGLint pb[] = { EGL_WIDTH, fw, EGL_HEIGHT, fh, EGL_NONE }; void (*load)(const char *) = dlsym(RTLD_NEXT, "SDL_GL_LoadLibrary"); + int desktop = 0; if (load) load(NULL); if (!gp || !qd) { - fprintf(stderr, "[gzes] no EGL platform ext\n"); - return NULL; + gzlog("[gzes] no EGL platform ext\n"); + return -1; } { EGLDeviceEXT devs[8]; @@ -44,24 +203,68 @@ void *SDL_GL_CreateContext(void *win) if (dpy == EGL_NO_DISPLAY) dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); if (!eglInitialize(dpy, &maj, &min)) { - fprintf(stderr, "[gzes] eglInitialize 0x%x\n", eglGetError()); - return NULL; + gzlog("[gzes] eglInitialize 0x%x\n", eglGetError()); + return -1; } - if (!eglChooseConfig(dpy, ca, &cfg, 1, &nc) || nc < 1) { - fprintf(stderr, "[gzes] choose 0x%x\n", eglGetError()); - return NULL; + if (eglBindAPI(EGL_OPENGL_API) && + eglChooseConfig(dpy, ca_gl, &cfg, 1, &nc) && nc >= 1) { + ctx = eglCreateContext(dpy, cfg, EGL_NO_CONTEXT, at_gl); + if (ctx != EGL_NO_CONTEXT) { + desktop = 1; + surf = eglCreatePbufferSurface(dpy, cfg, pb); + if (surf == EGL_NO_SURFACE) { + gzlog("[gzes] pbuffer 0x%x (desktop)\n", + eglGetError()); + eglDestroyContext(dpy, ctx); + ctx = EGL_NO_CONTEXT; + } + } } - ctx = eglCreateContext(dpy, cfg, EGL_NO_CONTEXT, at); if (ctx == EGL_NO_CONTEXT) { - fprintf(stderr, "[gzes] ctx 0x%x\n", eglGetError()); - return NULL; + EGLint sa = EGL_NONE; + + eglBindAPI(EGL_OPENGL_ES_API); + if (!eglChooseConfig(dpy, ca_es, &cfg, 1, &nc) || nc < 1) { + gzlog("[gzes] choose 0x%x\n", eglGetError()); + return -1; + } + ctx = eglCreateContext(dpy, cfg, EGL_NO_CONTEXT, at_es); + if (ctx == EGL_NO_CONTEXT) { + gzlog("[gzes] ctx 0x%x\n", eglGetError()); + return -1; + } + /* ES2 allows a pbuffer too; keep a surface so readback works. */ + surf = eglCreatePbufferSurface(dpy, cfg, pb); + (void)sa; + } else { + eglBindAPI(EGL_OPENGL_API); } - if (!eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx)) { - fprintf(stderr, "[gzes] current 0x%x\n", eglGetError()); - return NULL; + if (surf == EGL_NO_SURFACE) { + if (!eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx)) { + gzlog("[gzes] current 0x%x\n", eglGetError()); + return -1; + } + } else if (!eglMakeCurrent(dpy, surf, surf, ctx)) { + gzlog("[gzes] current(surf) 0x%x\n", eglGetError()); + return -1; } - fprintf(stderr, "[gzes] OK %s | %s ctx=%p\n", - glGetString(GL_RENDERER), glGetString(GL_VERSION), (void *)ctx); + shm_open_frame(); + gzlog("[gzes] OK api=%s renderer=%s version=%s surf=%d desktop=%d\n", + eglQueryString(dpy, EGL_CLIENT_APIS) ?: "?", + glGetString(GL_RENDERER) ? (const char *)glGetString(GL_RENDERER) : "?", + glGetString(GL_VERSION) ? (const char *)glGetString(GL_VERSION) : "?", + surf != EGL_NO_SURFACE, desktop); + return 0; +} + +void *SDL_GL_CreateContext(void *win) +{ + (void)win; + if (!logfd) + logfd = open("/dev/shm/gzes.log", + O_WRONLY | O_CREAT | O_APPEND, 0666); + if (create_context()) + return NULL; return (void *)ctx; } @@ -71,6 +274,8 @@ int SDL_GL_MakeCurrent(void *win, void *c) real_make = dlsym(RTLD_NEXT, "SDL_GL_MakeCurrent"); if (!dpy || !c) return real_make ? real_make(win, c) : -1; + if (surf != EGL_NO_SURFACE) + return eglMakeCurrent(dpy, surf, surf, (EGLContext)c) ? 0 : -1; return eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, (EGLContext)c) ? 0 : -1; } @@ -78,6 +283,7 @@ int SDL_GL_MakeCurrent(void *win, void *c) void SDL_GL_SwapWindow(void *win) { (void)win; + publish_frame(); glFlush(); } @@ -85,9 +291,9 @@ void SDL_GL_GetDrawableSize(void *win, int *w, int *h) { (void)win; if (w) - *w = 640; + *w = fw; if (h) - *h = 480; + *h = fh; } void SDL_GL_GetWindowSize(void *win, int *w, int *h) |
