gpu accelerated
This commit is contained in:
645
src/renderer.c
Normal file
645
src/renderer.c
Normal file
@@ -0,0 +1,645 @@
|
||||
#include <gtk/gtk.h>
|
||||
#include <gdk/gdkx.h>
|
||||
#include <glib-unix.h>
|
||||
#include <webkit2/webkit2.h>
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/Xutil.h>
|
||||
#include <X11/extensions/XShm.h>
|
||||
#include <X11/extensions/Xcomposite.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <pthread.h>
|
||||
#include <poll.h>
|
||||
#include <signal.h>
|
||||
#include <stdatomic.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/ipc.h>
|
||||
#include <sys/shm.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "protocol.h"
|
||||
|
||||
struct config {
|
||||
uint32_t width;
|
||||
uint32_t height;
|
||||
uint32_t fps;
|
||||
bool transparent;
|
||||
char *url;
|
||||
char *css;
|
||||
};
|
||||
|
||||
struct renderer {
|
||||
struct config config;
|
||||
GtkWidget *window;
|
||||
WebKitWebView *web_view;
|
||||
GPid xvfb_pid;
|
||||
struct owb_shared_frames *shared;
|
||||
size_t shared_size;
|
||||
uint64_t next_sequence;
|
||||
atomic_bool stopping;
|
||||
pthread_t capture_thread;
|
||||
bool capture_thread_started;
|
||||
uint8_t command_buffer[sizeof(struct owb_command)];
|
||||
size_t command_used;
|
||||
Display *capture_display;
|
||||
Window capture_window;
|
||||
Pixmap capture_pixmap;
|
||||
XImage *capture_image;
|
||||
XShmSegmentInfo capture_shm;
|
||||
bool capture_redirected;
|
||||
bool capture_attached;
|
||||
};
|
||||
|
||||
static bool read_exact(int fd, void *data, size_t size)
|
||||
{
|
||||
uint8_t *cursor = data;
|
||||
while (size > 0) {
|
||||
ssize_t count = read(fd, cursor, size);
|
||||
if (count < 0 && errno == EINTR)
|
||||
continue;
|
||||
if (count <= 0)
|
||||
return false;
|
||||
cursor += (size_t)count;
|
||||
size -= (size_t)count;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool read_config(struct config *config)
|
||||
{
|
||||
struct owb_config_header header;
|
||||
if (!read_exact(STDIN_FILENO, &header, sizeof(header)) || header.magic != OWB_CONFIG_MAGIC ||
|
||||
header.version != OWB_PROTOCOL_VERSION || header.width < 2 || header.height < 2 ||
|
||||
header.width > 8192 || header.height > 8192 || header.fps < 1 || header.fps > 60 ||
|
||||
header.url_length > OWB_MAX_STRING || header.css_length > OWB_MAX_STRING)
|
||||
return false;
|
||||
config->width = header.width;
|
||||
config->height = header.height;
|
||||
config->fps = header.fps;
|
||||
config->transparent = header.transparent != 0;
|
||||
/* Protocol v2 used this flag for an experimental host-display mode. It is
|
||||
* intentionally ignored: an OBS source must never create an input window on
|
||||
* the user's desktop. */
|
||||
(void)header.hardware_acceleration;
|
||||
config->url = calloc((size_t)header.url_length + 1, 1);
|
||||
config->css = calloc((size_t)header.css_length + 1, 1);
|
||||
if (!config->url || !config->css)
|
||||
return false;
|
||||
return read_exact(STDIN_FILENO, config->url, header.url_length) &&
|
||||
read_exact(STDIN_FILENO, config->css, header.css_length);
|
||||
}
|
||||
|
||||
static char *normalize_uri(const char *value)
|
||||
{
|
||||
char *trimmed = g_strdup(value);
|
||||
g_strstrip(trimmed);
|
||||
if (strstr(trimmed, "://") || g_str_has_prefix(trimmed, "data:") ||
|
||||
g_str_has_prefix(trimmed, "about:"))
|
||||
return trimmed;
|
||||
if (g_file_test(trimmed, G_FILE_TEST_EXISTS)) {
|
||||
char *absolute = g_canonicalize_filename(trimmed, NULL);
|
||||
char *uri = g_filename_to_uri(absolute, NULL, NULL);
|
||||
g_free(absolute);
|
||||
g_free(trimmed);
|
||||
return uri;
|
||||
}
|
||||
char *uri = g_strdup_printf("https://%s", trimmed);
|
||||
g_free(trimmed);
|
||||
return uri;
|
||||
}
|
||||
|
||||
static bool prepare_display(struct renderer *renderer)
|
||||
{
|
||||
char screen[64];
|
||||
g_snprintf(screen, sizeof(screen), "%ux%ux24", renderer->config.width, renderer->config.height);
|
||||
char *argv[] = {"Xvfb", "-displayfd", "1", "-screen", "0", screen, "+extension", "Composite",
|
||||
"-nolisten", "tcp", "-noreset", "-dpi", "96", NULL};
|
||||
int stdout_fd = -1;
|
||||
GError *error = NULL;
|
||||
if (!g_spawn_async_with_pipes(NULL, argv, NULL,
|
||||
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL,
|
||||
&renderer->xvfb_pid, NULL, &stdout_fd, NULL, &error)) {
|
||||
fprintf(stderr, "Cannot start Xvfb: %s\n", error->message);
|
||||
g_error_free(error);
|
||||
return false;
|
||||
}
|
||||
char display_number[32] = {0};
|
||||
size_t display_used = 0;
|
||||
while (display_used + 1 < sizeof(display_number) &&
|
||||
!memchr(display_number, '\n', display_used)) {
|
||||
struct pollfd display_poll = {.fd = stdout_fd, .events = POLLIN};
|
||||
int ready;
|
||||
do {
|
||||
ready = poll(&display_poll, 1, 10000);
|
||||
} while (ready < 0 && errno == EINTR);
|
||||
if (ready <= 0)
|
||||
break;
|
||||
ssize_t count = read(stdout_fd, display_number + display_used,
|
||||
sizeof(display_number) - display_used - 1);
|
||||
if (count <= 0)
|
||||
break;
|
||||
display_used += (size_t)count;
|
||||
}
|
||||
close(stdout_fd);
|
||||
if (!display_used || !memchr(display_number, '\n', display_used)) {
|
||||
fprintf(stderr, "Xvfb did not publish a display number within 10 seconds\n");
|
||||
kill(renderer->xvfb_pid, SIGTERM);
|
||||
waitpid(renderer->xvfb_pid, NULL, 0);
|
||||
g_spawn_close_pid(renderer->xvfb_pid);
|
||||
renderer->xvfb_pid = 0;
|
||||
return false;
|
||||
}
|
||||
display_number[strcspn(display_number, "\r\n")] = '\0';
|
||||
char *display = g_strdup_printf(":%s", display_number);
|
||||
g_setenv("DISPLAY", display, TRUE);
|
||||
g_setenv("GDK_BACKEND", "x11", TRUE);
|
||||
g_free(display);
|
||||
/* WebKitGTK's accelerated backing store renders into a DRM DMA-BUF and maps
|
||||
* the completed buffer into this private X display. Xvfb remains useful for
|
||||
* keeping the Gtk window off the desktop; it must not force WebKit itself to
|
||||
* use llvmpipe. Override software-rendering flags inherited from OBS too. */
|
||||
g_unsetenv("LIBGL_ALWAYS_SOFTWARE");
|
||||
g_unsetenv("GALLIUM_DRIVER");
|
||||
g_unsetenv("MESA_LOADER_DRIVER_OVERRIDE");
|
||||
g_setenv("WEBKIT_DISABLE_COMPOSITING_MODE", "0", TRUE);
|
||||
g_setenv("WEBKIT_DISABLE_DMABUF_RENDERER", "0", TRUE);
|
||||
g_setenv("WEBKIT_FORCE_COMPOSITING_MODE", "1", TRUE);
|
||||
g_setenv("NO_AT_BRIDGE", "1", FALSE);
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool map_shared_frames(struct renderer *renderer)
|
||||
{
|
||||
struct stat info;
|
||||
renderer->shared_size = owb_shared_size(renderer->config.width, renderer->config.height);
|
||||
if (fstat(OWB_SHARED_FRAME_FD, &info) != 0 || (size_t)info.st_size < renderer->shared_size)
|
||||
return false;
|
||||
renderer->shared = mmap(NULL, renderer->shared_size, PROT_READ | PROT_WRITE, MAP_SHARED,
|
||||
OWB_SHARED_FRAME_FD, 0);
|
||||
if (renderer->shared == MAP_FAILED)
|
||||
return false;
|
||||
return renderer->shared->magic == OWB_SHARED_MAGIC &&
|
||||
renderer->shared->version == OWB_PROTOCOL_VERSION &&
|
||||
renderer->shared->width == renderer->config.width &&
|
||||
renderer->shared->height == renderer->config.height &&
|
||||
renderer->shared->stride == renderer->config.width * 4 &&
|
||||
renderer->shared->slots == OWB_SHARED_FRAME_SLOTS;
|
||||
}
|
||||
|
||||
static bool initialize_x11_capture(struct renderer *renderer)
|
||||
{
|
||||
renderer->capture_display = XOpenDisplay(NULL);
|
||||
if (!renderer->capture_display || !XShmQueryExtension(renderer->capture_display))
|
||||
return false;
|
||||
|
||||
/* An opaque WebKit view may render into child/compositor surfaces which are
|
||||
* absent from the top-level window's named backing pixmap. Xvfb's root
|
||||
* drawable contains the final assembled image, and the renderer window
|
||||
* covers that private screen exactly. */
|
||||
if (!renderer->config.transparent) {
|
||||
renderer->capture_window = DefaultRootWindow(renderer->capture_display);
|
||||
renderer->capture_pixmap = renderer->capture_window;
|
||||
} else {
|
||||
GdkWindow *gdk_window = gtk_widget_get_window(renderer->window);
|
||||
if (!gdk_window || !GDK_IS_X11_WINDOW(gdk_window))
|
||||
return false;
|
||||
renderer->capture_window = GDK_WINDOW_XID(gdk_window);
|
||||
int event_base = 0, error_base = 0;
|
||||
if (!XCompositeQueryExtension(renderer->capture_display, &event_base, &error_base))
|
||||
return false;
|
||||
XCompositeRedirectWindow(renderer->capture_display, renderer->capture_window,
|
||||
CompositeRedirectManual);
|
||||
renderer->capture_redirected = true;
|
||||
XSync(renderer->capture_display, False);
|
||||
renderer->capture_pixmap = XCompositeNameWindowPixmap(renderer->capture_display,
|
||||
renderer->capture_window);
|
||||
if (!renderer->capture_pixmap)
|
||||
return false;
|
||||
}
|
||||
XWindowAttributes attributes;
|
||||
if (!XGetWindowAttributes(renderer->capture_display, renderer->capture_window, &attributes))
|
||||
return false;
|
||||
memset(&renderer->capture_shm, 0, sizeof(renderer->capture_shm));
|
||||
renderer->capture_shm.shmid = -1;
|
||||
renderer->capture_image = XShmCreateImage(renderer->capture_display, attributes.visual,
|
||||
(unsigned)attributes.depth, ZPixmap, NULL,
|
||||
&renderer->capture_shm, renderer->config.width,
|
||||
renderer->config.height);
|
||||
if (!renderer->capture_image || renderer->capture_image->bits_per_pixel != 32)
|
||||
return false;
|
||||
size_t image_size = (size_t)renderer->capture_image->bytes_per_line *
|
||||
(size_t)renderer->capture_image->height;
|
||||
renderer->capture_shm.shmid = shmget(IPC_PRIVATE, image_size, IPC_CREAT | 0600);
|
||||
if (renderer->capture_shm.shmid < 0)
|
||||
return false;
|
||||
renderer->capture_shm.shmaddr = shmat(renderer->capture_shm.shmid, NULL, 0);
|
||||
if (renderer->capture_shm.shmaddr == (char *)-1) {
|
||||
renderer->capture_shm.shmaddr = NULL;
|
||||
return false;
|
||||
}
|
||||
renderer->capture_image->data = renderer->capture_shm.shmaddr;
|
||||
renderer->capture_shm.readOnly = False;
|
||||
if (!XShmAttach(renderer->capture_display, &renderer->capture_shm))
|
||||
return false;
|
||||
renderer->capture_attached = true;
|
||||
XSync(renderer->capture_display, False);
|
||||
shmctl(renderer->capture_shm.shmid, IPC_RMID, NULL);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void destroy_x11_capture(struct renderer *renderer)
|
||||
{
|
||||
if (renderer->capture_attached) {
|
||||
XShmDetach(renderer->capture_display, &renderer->capture_shm);
|
||||
XSync(renderer->capture_display, False);
|
||||
}
|
||||
if (renderer->capture_image) {
|
||||
renderer->capture_image->data = NULL;
|
||||
XDestroyImage(renderer->capture_image);
|
||||
}
|
||||
if (renderer->capture_shm.shmaddr)
|
||||
shmdt(renderer->capture_shm.shmaddr);
|
||||
if (renderer->capture_shm.shmid >= 0 && !renderer->capture_attached)
|
||||
shmctl(renderer->capture_shm.shmid, IPC_RMID, NULL);
|
||||
if (renderer->capture_pixmap && renderer->capture_redirected)
|
||||
XFreePixmap(renderer->capture_display, renderer->capture_pixmap);
|
||||
if (renderer->capture_redirected)
|
||||
XCompositeUnredirectWindow(renderer->capture_display, renderer->capture_window,
|
||||
CompositeRedirectManual);
|
||||
if (renderer->capture_display)
|
||||
XCloseDisplay(renderer->capture_display);
|
||||
}
|
||||
|
||||
static void publish_frame(struct renderer *renderer, const uint8_t *pixels, int stride,
|
||||
bool preserve_alpha)
|
||||
{
|
||||
uint32_t slot = (uint32_t)(renderer->next_sequence % OWB_SHARED_FRAME_SLOTS);
|
||||
uint64_t complete_sequence = (++renderer->next_sequence) << 1;
|
||||
__atomic_store_n(&renderer->shared->sequence[slot], complete_sequence | 1u, __ATOMIC_RELEASE);
|
||||
uint8_t *destination = owb_shared_slot(renderer->shared, slot);
|
||||
for (uint32_t y = 0; y < renderer->config.height; y++)
|
||||
memcpy(destination + (size_t)y * renderer->config.width * 4,
|
||||
pixels + (size_t)y * (size_t)stride, (size_t)renderer->config.width * 4);
|
||||
if (!preserve_alpha) {
|
||||
for (size_t offset = 3, size = owb_frame_size(renderer->config.width,
|
||||
renderer->config.height);
|
||||
offset < size; offset += 4)
|
||||
destination[offset] = 255;
|
||||
}
|
||||
__atomic_store_n(&renderer->shared->sequence[slot], complete_sequence, __ATOMIC_RELEASE);
|
||||
uint8_t notification = (uint8_t)slot;
|
||||
ssize_t ignored = write(STDOUT_FILENO, ¬ification, sizeof(notification));
|
||||
(void)ignored;
|
||||
}
|
||||
|
||||
static void publish_x11_frame(struct renderer *renderer)
|
||||
{
|
||||
if (!XShmGetImage(renderer->capture_display, renderer->capture_pixmap,
|
||||
renderer->capture_image, 0, 0, AllPlanes))
|
||||
return;
|
||||
publish_frame(renderer, (const uint8_t *)renderer->capture_image->data,
|
||||
renderer->capture_image->bytes_per_line,
|
||||
renderer->config.transparent && renderer->capture_image->depth == 32);
|
||||
}
|
||||
|
||||
static void advance_deadline(struct timespec *deadline, long interval_ns)
|
||||
{
|
||||
deadline->tv_nsec += interval_ns;
|
||||
while (deadline->tv_nsec >= 1000000000L) {
|
||||
deadline->tv_nsec -= 1000000000L;
|
||||
deadline->tv_sec++;
|
||||
}
|
||||
}
|
||||
|
||||
static void *capture_loop(void *opaque)
|
||||
{
|
||||
struct renderer *renderer = opaque;
|
||||
long interval_ns = 1000000000L / (long)renderer->config.fps;
|
||||
struct timespec deadline;
|
||||
clock_gettime(CLOCK_MONOTONIC, &deadline);
|
||||
while (!atomic_load_explicit(&renderer->stopping, memory_order_acquire)) {
|
||||
publish_x11_frame(renderer);
|
||||
advance_deadline(&deadline, interval_ns);
|
||||
while (clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &deadline, NULL) == EINTR) {
|
||||
}
|
||||
struct timespec now;
|
||||
clock_gettime(CLOCK_MONOTONIC, &now);
|
||||
if (now.tv_sec > deadline.tv_sec + 1)
|
||||
deadline = now;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static GdkModifierType modifiers_from_obs(uint32_t modifiers)
|
||||
{
|
||||
GdkModifierType state = 0;
|
||||
if (modifiers & (1u << 1))
|
||||
state |= GDK_SHIFT_MASK;
|
||||
if (modifiers & (1u << 2))
|
||||
state |= GDK_CONTROL_MASK;
|
||||
if (modifiers & (1u << 3))
|
||||
state |= GDK_MOD1_MASK;
|
||||
if (modifiers & (1u << 4))
|
||||
state |= GDK_BUTTON1_MASK;
|
||||
if (modifiers & (1u << 5))
|
||||
state |= GDK_BUTTON2_MASK;
|
||||
if (modifiers & (1u << 6))
|
||||
state |= GDK_BUTTON3_MASK;
|
||||
return state;
|
||||
}
|
||||
|
||||
static void dispatch_command(struct renderer *renderer, const struct owb_command *command)
|
||||
{
|
||||
if (command->magic != OWB_COMMAND_MAGIC)
|
||||
return;
|
||||
GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(renderer->web_view));
|
||||
if (!window)
|
||||
return;
|
||||
if (command->type == OWB_RELOAD) {
|
||||
webkit_web_view_reload(renderer->web_view);
|
||||
return;
|
||||
}
|
||||
if (command->type == OWB_FOCUS) {
|
||||
gtk_window_set_focus(GTK_WINDOW(renderer->window),
|
||||
command->value1 ? GTK_WIDGET(renderer->web_view) : NULL);
|
||||
return;
|
||||
}
|
||||
if (command->type == OWB_MOUSE_MOVE) {
|
||||
if (command->value1) {
|
||||
GdkEvent *event = gdk_event_new(GDK_LEAVE_NOTIFY);
|
||||
event->crossing.window = g_object_ref(window);
|
||||
event->crossing.send_event = TRUE;
|
||||
event->crossing.time = GDK_CURRENT_TIME;
|
||||
event->crossing.x = command->x;
|
||||
event->crossing.y = command->y;
|
||||
event->crossing.mode = GDK_CROSSING_NORMAL;
|
||||
event->crossing.detail = GDK_NOTIFY_NONLINEAR;
|
||||
event->crossing.state = modifiers_from_obs(command->modifiers);
|
||||
gtk_widget_event(GTK_WIDGET(renderer->web_view), event);
|
||||
gdk_event_free(event);
|
||||
return;
|
||||
}
|
||||
GdkEvent *event = gdk_event_new(GDK_MOTION_NOTIFY);
|
||||
event->motion.window = g_object_ref(window);
|
||||
event->motion.send_event = TRUE;
|
||||
event->motion.time = GDK_CURRENT_TIME;
|
||||
event->motion.x = command->x;
|
||||
event->motion.y = command->y;
|
||||
event->motion.state = modifiers_from_obs(command->modifiers);
|
||||
gtk_widget_event(GTK_WIDGET(renderer->web_view), event);
|
||||
gdk_event_free(event);
|
||||
return;
|
||||
}
|
||||
if (command->type == OWB_MOUSE_CLICK) {
|
||||
GdkEventType type = command->value2 ? GDK_BUTTON_RELEASE
|
||||
: command->text_length == 2 ? GDK_2BUTTON_PRESS
|
||||
: command->text_length >= 3 ? GDK_3BUTTON_PRESS
|
||||
: GDK_BUTTON_PRESS;
|
||||
GdkEvent *event = gdk_event_new(type);
|
||||
event->button.window = g_object_ref(window);
|
||||
event->button.send_event = TRUE;
|
||||
event->button.time = GDK_CURRENT_TIME;
|
||||
event->button.x = command->x;
|
||||
event->button.y = command->y;
|
||||
event->button.button = command->value1 == 1 ? 2 : command->value1 == 2 ? 3 : 1;
|
||||
event->button.state = modifiers_from_obs(command->modifiers);
|
||||
gtk_widget_event(GTK_WIDGET(renderer->web_view), event);
|
||||
gdk_event_free(event);
|
||||
return;
|
||||
}
|
||||
if (command->type == OWB_MOUSE_WHEEL) {
|
||||
GdkEvent *event = gdk_event_new(GDK_SCROLL);
|
||||
event->scroll.window = g_object_ref(window);
|
||||
event->scroll.send_event = TRUE;
|
||||
event->scroll.time = GDK_CURRENT_TIME;
|
||||
event->scroll.x = command->x;
|
||||
event->scroll.y = command->y;
|
||||
event->scroll.direction = GDK_SCROLL_SMOOTH;
|
||||
event->scroll.delta_x = -(double)command->value1 / 120.0;
|
||||
event->scroll.delta_y = -(double)command->value2 / 120.0;
|
||||
event->scroll.state = modifiers_from_obs(command->modifiers);
|
||||
gtk_widget_event(GTK_WIDGET(renderer->web_view), event);
|
||||
gdk_event_free(event);
|
||||
return;
|
||||
}
|
||||
if (command->type == OWB_KEY) {
|
||||
GdkEvent *event = gdk_event_new(command->value1 ? GDK_KEY_RELEASE : GDK_KEY_PRESS);
|
||||
event->key.window = g_object_ref(window);
|
||||
event->key.send_event = TRUE;
|
||||
event->key.time = GDK_CURRENT_TIME;
|
||||
event->key.state = modifiers_from_obs(command->modifiers);
|
||||
event->key.keyval = (guint)command->value2;
|
||||
if (command->text_length) {
|
||||
gunichar character = g_utf8_get_char_validated(command->text, command->text_length);
|
||||
if (character != (gunichar)-1 && character != (gunichar)-2)
|
||||
event->key.keyval = gdk_unicode_to_keyval(character);
|
||||
}
|
||||
event->key.length = (gint)command->text_length;
|
||||
event->key.string = g_strndup(command->text, command->text_length);
|
||||
gtk_widget_event(GTK_WIDGET(renderer->web_view), event);
|
||||
gdk_event_free(event);
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean control_ready(gint fd, GIOCondition condition, gpointer opaque)
|
||||
{
|
||||
struct renderer *renderer = opaque;
|
||||
if (condition & (G_IO_HUP | G_IO_ERR)) {
|
||||
gtk_main_quit();
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
for (;;) {
|
||||
ssize_t count = read(fd, renderer->command_buffer + renderer->command_used,
|
||||
sizeof(renderer->command_buffer) - renderer->command_used);
|
||||
if (count < 0 && errno == EINTR)
|
||||
continue;
|
||||
if (count < 0 && (errno == EAGAIN || errno == EWOULDBLOCK))
|
||||
return G_SOURCE_CONTINUE;
|
||||
if (count <= 0) {
|
||||
gtk_main_quit();
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
renderer->command_used += (size_t)count;
|
||||
if (renderer->command_used == sizeof(struct owb_command)) {
|
||||
dispatch_command(renderer, (const struct owb_command *)renderer->command_buffer);
|
||||
renderer->command_used = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean clear_window(GtkWidget *widget, cairo_t *context, gpointer unused)
|
||||
{
|
||||
(void)widget;
|
||||
(void)unused;
|
||||
cairo_set_operator(context, CAIRO_OPERATOR_SOURCE);
|
||||
cairo_set_source_rgba(context, 0, 0, 0, 0);
|
||||
cairo_paint(context);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
static gboolean terminate_renderer(gpointer opaque)
|
||||
{
|
||||
struct renderer *renderer = opaque;
|
||||
atomic_store_explicit(&renderer->stopping, true, memory_order_release);
|
||||
gtk_main_quit();
|
||||
return G_SOURCE_REMOVE;
|
||||
}
|
||||
|
||||
static void script_message_received(WebKitUserContentManager *manager,
|
||||
WebKitJavascriptResult *message, gpointer unused)
|
||||
{
|
||||
(void)manager;
|
||||
(void)unused;
|
||||
JSCValue *value = webkit_javascript_result_get_js_value(message);
|
||||
char *text = jsc_value_to_string(value);
|
||||
fprintf(stderr, "Page: %s\n", text ? text : "(empty message)");
|
||||
g_free(text);
|
||||
}
|
||||
|
||||
static gboolean load_failed(WebKitWebView *view, WebKitLoadEvent event, const char *uri,
|
||||
GError *error, gpointer unused)
|
||||
{
|
||||
(void)view;
|
||||
(void)event;
|
||||
(void)unused;
|
||||
fprintf(stderr, "Page load failed for %s: %s\n", uri, error->message);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
struct renderer renderer = {0};
|
||||
atomic_init(&renderer.stopping, false);
|
||||
if (!read_config(&renderer.config)) {
|
||||
fprintf(stderr, "Invalid renderer configuration\n");
|
||||
return 2;
|
||||
}
|
||||
if (!prepare_display(&renderer))
|
||||
return 3;
|
||||
if (!map_shared_frames(&renderer)) {
|
||||
fprintf(stderr, "Cannot map shared frame transport\n");
|
||||
return 4;
|
||||
}
|
||||
if (!gtk_init_check(NULL, NULL)) {
|
||||
fprintf(stderr, "GTK could not connect to private Xvfb display\n");
|
||||
return 5;
|
||||
}
|
||||
|
||||
WebKitUserContentManager *manager = webkit_user_content_manager_new();
|
||||
g_signal_connect(manager, "script-message-received::owbLog",
|
||||
G_CALLBACK(script_message_received), NULL);
|
||||
if (!webkit_user_content_manager_register_script_message_handler(manager, "owbLog"))
|
||||
fprintf(stderr, "Cannot register page diagnostic message handler\n");
|
||||
static const char error_reporter[] =
|
||||
"(()=>{const p=(k,v)=>{try{window.webkit.messageHandlers.owbLog.postMessage(k+': '+v)}catch{}};"
|
||||
"addEventListener('error',e=>p('error',e.message+' @ '+e.filename+':'+e.lineno));"
|
||||
"addEventListener('unhandledrejection',e=>p('rejection',e.reason?.stack||e.reason));"
|
||||
"const ce=console.error;console.error=(...a)=>{p('console',a.join(' '));ce(...a)}})();";
|
||||
WebKitUserScript *reporter = webkit_user_script_new(error_reporter,
|
||||
WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES, WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START,
|
||||
NULL, NULL);
|
||||
webkit_user_content_manager_add_script(manager, reporter);
|
||||
webkit_user_script_unref(reporter);
|
||||
if (*renderer.config.css) {
|
||||
WebKitUserStyleSheet *sheet = webkit_user_style_sheet_new(renderer.config.css,
|
||||
WEBKIT_USER_CONTENT_INJECT_ALL_FRAMES, WEBKIT_USER_STYLE_LEVEL_USER, NULL, NULL);
|
||||
webkit_user_content_manager_add_style_sheet(manager, sheet);
|
||||
webkit_user_style_sheet_unref(sheet);
|
||||
}
|
||||
renderer.web_view = WEBKIT_WEB_VIEW(webkit_web_view_new_with_user_content_manager(manager));
|
||||
g_signal_connect(renderer.web_view, "load-failed", G_CALLBACK(load_failed), NULL);
|
||||
g_object_unref(manager);
|
||||
WebKitSettings *settings = webkit_web_view_get_settings(renderer.web_view);
|
||||
webkit_settings_set_enable_webgl(settings, TRUE);
|
||||
webkit_settings_set_enable_page_cache(settings, TRUE);
|
||||
webkit_settings_set_enable_smooth_scrolling(settings, TRUE);
|
||||
webkit_settings_set_media_playback_requires_user_gesture(settings, FALSE);
|
||||
webkit_settings_set_hardware_acceleration_policy(settings,
|
||||
WEBKIT_HARDWARE_ACCELERATION_POLICY_ALWAYS);
|
||||
webkit_web_view_set_is_muted(renderer.web_view, TRUE);
|
||||
GdkRGBA background = renderer.config.transparent ? (GdkRGBA){0, 0, 0, 0} : (GdkRGBA){1, 1, 1, 1};
|
||||
webkit_web_view_set_background_color(renderer.web_view, &background);
|
||||
|
||||
renderer.window = gtk_window_new(GTK_WINDOW_POPUP);
|
||||
GdkScreen *screen = gdk_screen_get_default();
|
||||
GdkVisual *visual = renderer.config.transparent ? gdk_screen_get_rgba_visual(screen)
|
||||
: gdk_screen_get_system_visual(screen);
|
||||
if (visual)
|
||||
gtk_widget_set_visual(renderer.window, visual);
|
||||
gtk_widget_set_app_paintable(renderer.window, renderer.config.transparent);
|
||||
if (renderer.config.transparent)
|
||||
g_signal_connect(renderer.window, "draw", G_CALLBACK(clear_window), NULL);
|
||||
gtk_window_set_decorated(GTK_WINDOW(renderer.window), FALSE);
|
||||
gtk_window_set_resizable(GTK_WINDOW(renderer.window), FALSE);
|
||||
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(renderer.window), TRUE);
|
||||
gtk_window_set_skip_pager_hint(GTK_WINDOW(renderer.window), TRUE);
|
||||
gtk_window_set_accept_focus(GTK_WINDOW(renderer.window), FALSE);
|
||||
gtk_window_set_focus_on_map(GTK_WINDOW(renderer.window), FALSE);
|
||||
gtk_window_move(GTK_WINDOW(renderer.window), 0, 0);
|
||||
gtk_window_set_default_size(GTK_WINDOW(renderer.window), (int)renderer.config.width,
|
||||
(int)renderer.config.height);
|
||||
gtk_widget_set_size_request(GTK_WIDGET(renderer.web_view), (int)renderer.config.width,
|
||||
(int)renderer.config.height);
|
||||
gtk_container_add(GTK_CONTAINER(renderer.window), GTK_WIDGET(renderer.web_view));
|
||||
gtk_widget_realize(renderer.window);
|
||||
GdkWindow *renderer_window = gtk_widget_get_window(renderer.window);
|
||||
if (renderer_window) {
|
||||
cairo_region_t *empty_input = cairo_region_create();
|
||||
gdk_window_input_shape_combine_region(renderer_window, empty_input, 0, 0);
|
||||
cairo_region_destroy(empty_input);
|
||||
}
|
||||
gtk_widget_show_all(renderer.window);
|
||||
while (gtk_events_pending())
|
||||
gtk_main_iteration();
|
||||
if (!initialize_x11_capture(&renderer)) {
|
||||
fprintf(stderr, "Cannot initialize XComposite/XShm capture\n");
|
||||
return 6;
|
||||
}
|
||||
|
||||
int output_flags = fcntl(STDOUT_FILENO, F_GETFL, 0);
|
||||
if (output_flags >= 0)
|
||||
fcntl(STDOUT_FILENO, F_SETFL, output_flags | O_NONBLOCK);
|
||||
|
||||
int flags = fcntl(STDIN_FILENO, F_GETFL, 0);
|
||||
if (flags >= 0)
|
||||
fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);
|
||||
g_unix_fd_add(STDIN_FILENO, G_IO_IN | G_IO_HUP | G_IO_ERR, control_ready, &renderer);
|
||||
char *uri = normalize_uri(renderer.config.url);
|
||||
webkit_web_view_load_uri(renderer.web_view, uri);
|
||||
g_free(uri);
|
||||
if (pthread_create(&renderer.capture_thread, NULL, capture_loop, &renderer) != 0) {
|
||||
fprintf(stderr, "Cannot start X11 capture thread\n");
|
||||
return 7;
|
||||
}
|
||||
renderer.capture_thread_started = true;
|
||||
fprintf(stderr, "Ready: WebKitGTK %u.%u.%u, %ux%u@%u, GPU compositing, DMA-BUF, X11 capture\n",
|
||||
webkit_get_major_version(),
|
||||
webkit_get_minor_version(), webkit_get_micro_version(), renderer.config.width,
|
||||
renderer.config.height, renderer.config.fps);
|
||||
fflush(stderr);
|
||||
g_unix_signal_add(SIGTERM, terminate_renderer, &renderer);
|
||||
g_unix_signal_add(SIGINT, terminate_renderer, &renderer);
|
||||
gtk_main();
|
||||
|
||||
atomic_store_explicit(&renderer.stopping, true, memory_order_release);
|
||||
if (renderer.capture_thread_started)
|
||||
pthread_join(renderer.capture_thread, NULL);
|
||||
destroy_x11_capture(&renderer);
|
||||
if (renderer.xvfb_pid > 0) {
|
||||
kill(renderer.xvfb_pid, SIGTERM);
|
||||
waitpid(renderer.xvfb_pid, NULL, 0);
|
||||
g_spawn_close_pid(renderer.xvfb_pid);
|
||||
}
|
||||
munmap(renderer.shared, renderer.shared_size);
|
||||
free(renderer.config.url);
|
||||
free(renderer.config.css);
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user