Add support for multi-screen setups

This patch adds support for multi-screen setups by using xinerama
information if available to determine the screen size and position.

In case xinerama is not available or not active it uses the information
provided for the x screen.

To clean up the code some generic helper functions were moved to a
separate source file.

plugins/linux-xshm/CMakeLists.txt

@@ -7,10 +7,12 @@ include_directories(SYSTEM "${CMAKE_SOURCE_DIR}/libobs")
 set(linux-xshm_SOURCES
 	linux-xshm.c
 	xcursor.c
+	xhelpers.c
 	xshm-input.c
 )
 set(linux-xshm_HEADERS
 	xcursor.h
+	xhelpers.h
 )
 
 add_library(linux-xshm MODULE
@@ -22,6 +24,7 @@ target_link_libraries(linux-xshm
 	${X11_LIBRARIES}
 	${X11_XShm_LIB}
 	${X11_Xfixes_LIB}
+	${X11_Xinerama_LIB}
 )
 
 install_obs_plugin(linux-xshm)

plugins/linux-xshm/xcursor.c

@@ -66,8 +66,7 @@ static void xcursor_create(xcursor_t *data, XFixesCursorImage *xc) {
 }
 
 xcursor_t *xcursor_init(Display *dpy) {
-	xcursor_t *data = bmalloc(sizeof(xcursor_t));
-	memset(data, 0, sizeof(xcursor_t));
+	xcursor_t *data = bzalloc(sizeof(xcursor_t));
 
 	data->dpy = dpy;
 	xcursor_tick(data);

plugins/linux-xshm/xhelpers.c

@@ -0,0 +1,150 @@
+/*
+Copyright (C) 2014 by Leonhard Oelke <[email protected]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdint.h>
+#include <sys/shm.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xinerama.h>
+
+#include "xhelpers.h"
+
+int_fast32_t xinerama_is_active(Display *dpy)
+{
+	int minor, major;
+	if (!dpy)
+		return 0;
+	if (!XineramaQueryVersion(dpy, &minor, &major))
+		return 0;
+	if (!XineramaIsActive(dpy))
+		return 0;
+	return 1;
+}
+
+int_fast32_t xinerama_screen_count(Display *dpy)
+{
+	int screens;
+	if (!dpy)
+		return 0;
+	XFree(XineramaQueryScreens(dpy, &screens));
+	return screens;
+}
+
+int_fast32_t xinerama_screen_geo(Display *dpy, const int_fast32_t screen,
+	int_fast32_t *x, int_fast32_t *y, int_fast32_t *w, int_fast32_t *h)
+{
+	int screens;
+	XineramaScreenInfo *info;
+
+	if (!dpy)
+		goto fail;
+	info = XineramaQueryScreens(dpy, &screens);
+	if (screen < 0 || screen >= screens)
+		goto fail;
+
+	*x = info[screen].x_org;
+	*y = info[screen].y_org;
+	*w = info[screen].width;
+	*h = info[screen].height;
+
+	XFree(info);
+	return 0;
+fail:
+	if (info)
+		XFree(info);
+	
+	*x = *y = *w = *h = 0;
+	return -1;
+}
+
+int_fast32_t x11_screen_geo(Display *dpy, const int_fast32_t screen,
+	int_fast32_t *w, int_fast32_t *h)
+{
+	Screen *scr;
+
+	if (!dpy || screen < 0 || screen >= XScreenCount(dpy))
+		goto fail;
+
+	scr = XScreenOfDisplay(dpy, screen);
+	if (!scr)
+		goto fail;
+
+	*w = XWidthOfScreen(scr);
+	*h = XHeightOfScreen(scr);
+
+	return 0;
+fail:
+	*w = *h = 0;
+	return -1;
+}
+
+xshm_t *xshm_attach(Display *dpy, Screen *screen,
+	int_fast32_t w, int_fast32_t h)
+{
+	if (!dpy || !screen)
+		return NULL;
+
+	xshm_t *xshm = bzalloc(sizeof(xshm_t));
+
+	xshm->dpy = dpy;
+	xshm->image = XShmCreateImage(xshm->dpy, DefaultVisualOfScreen(screen),
+		DefaultDepthOfScreen(screen), ZPixmap, NULL, &xshm->info,
+		w, h);
+	if (!xshm->image)
+		goto fail;
+
+	xshm->info.shmid = shmget(IPC_PRIVATE,
+		xshm->image->bytes_per_line * xshm->image->height,
+		IPC_CREAT | 0700);
+	if (xshm->info.shmid < 0)
+		goto fail;
+
+	xshm->info.shmaddr
+		= xshm->image->data
+		= (char *) shmat(xshm->info.shmid, 0, 0);
+	if (xshm->info.shmaddr == (char *) -1)
+		goto fail;
+	xshm->info.readOnly = false;
+
+	if (!XShmAttach(xshm->dpy, &xshm->info))
+		goto fail;
+
+	xshm->attached = true;
+	return xshm;
+fail:
+	xshm_detach(xshm);
+	return NULL;
+}
+
+void xshm_detach(xshm_t *xshm)
+{
+	if (!xshm)
+		return;
+
+	if (xshm->attached)
+		XShmDetach(xshm->dpy, &xshm->info);
+
+	if (xshm->info.shmaddr != (char *) -1)
+		shmdt(xshm->info.shmaddr);
+
+	if (xshm->info.shmid != -1)
+		shmctl(xshm->info.shmid, IPC_RMID, NULL);
+
+	if (xshm->image)
+		XDestroyImage(xshm->image);
+
+	bfree(xshm);
+}

plugins/linux-xshm/xhelpers.h

@@ -0,0 +1,101 @@
+/*
+Copyright (C) 2014 by Leonhard Oelke <[email protected]>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <X11/Xlib.h>
+#include <X11/extensions/XShm.h>
+#include <obs.h>
+
+typedef struct {
+	XShmSegmentInfo info;
+	XImage *image;
+	Display *dpy;
+	bool attached;
+} xshm_t;
+
+/**
+ * Check for Xinerama extension
+ *
+ * @return > 0 if Xinerama is available and active
+ */
+int_fast32_t xinerama_is_active(Display *dpy);
+
+/**
+ * Get the number of Xinerama screens
+ *
+ * @return number of screens
+ */
+int_fast32_t xinerama_screen_count(Display *dpy);
+
+/**
+ * Get screen geometry for a Xinerama screen
+ *
+ * @note On error the passed coordinates/sizes will be set to 0.
+ *
+ * @param dpy X11 display
+ * @param screen screen number to get geometry for
+ * @param x x-coordinate of the screen
+ * @param y y-coordinate of the screen
+ * @param w width of the screen
+ * @param h height of the screen
+ *
+ * @return < 0 on error
+ */
+int_fast32_t xinerama_screen_geo(Display *dpy, const int_fast32_t screen,
+	int_fast32_t *x, int_fast32_t *y, int_fast32_t *w, int_fast32_t *h);
+
+/**
+ * Get screen geometry for a X11 screen
+ *
+ * @note On error the passed sizes will be set to 0.
+ *
+ * @param dpy X11 display
+ * @param screen screen number to get geometry for
+ * @param w width of the screen
+ * @param h height of the screen
+ *
+ * @return < 0 on error
+ */
+int_fast32_t x11_screen_geo(Display *dpy, const int_fast32_t screen,
+	int_fast32_t *w, int_fast32_t *h);
+
+/**
+ * Attach a shared memory segment to the X-Server
+ *
+ * @param dpy X11 Display
+ * @param screen X11 Screen
+ * @param w width for the shared memory segment
+ * @param h height for the shared memory segment
+ *
+ * @return NULL on error
+ */
+xshm_t *xshm_attach(Display *dpy, Screen *screen,
+	int_fast32_t w, int_fast32_t h);
+
+/**
+ * Detach a shared memory segment
+ */
+void xshm_detach(xshm_t *xshm);
+
+#ifdef __cplusplus
+}
+#endif

plugins/linux-xshm/xshm-input.c

@@ -14,193 +14,298 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-#include <stdlib.h>
-#include <stdio.h>
 
-#include <sys/shm.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
-#include <X11/extensions/XShm.h>
 
 #include <obs.h>
 #include "xcursor.h"
+#include "xhelpers.h"
 
 #define XSHM_DATA(voidptr) struct xshm_data *data = voidptr;
 
 struct xshm_data {
 	Display *dpy;
-	Window root_window;
-	uint32_t width, height;
-	int shm_attached;
-	XShmSegmentInfo shm_info;
-	XImage *image;
+	Screen *screen;
+
+	int_fast32_t x_org, y_org;
+	int_fast32_t width, height;
+
+	xshm_t *xshm;
 	texture_t texture;
+
+	bool show_cursor;
 	xcursor_t *cursor;
+
+	bool use_xinerama;
 };
 
+/**
+ * Resize the texture
+ *
+ * This will automatically create the texture if it does not exist
+ */
+static void xshm_resize_texture(struct xshm_data *data)
+{
+	gs_entercontext(obs_graphics());
+
+	if (data->texture)
+		texture_destroy(data->texture);
+	data->texture = gs_create_texture(data->width, data->height,
+		GS_BGRA, 1, NULL, GS_DYNAMIC);
+
+	gs_leavecontext();
+}
+
+/**
+ * Update the capture
+ *
+ * @return < 0 on error, 0 when size is unchanged, > 1 on size change
+ */
+static int_fast32_t xshm_update_geometry(struct xshm_data *data,
+	obs_data_t settings)
+{
+	int_fast32_t old_width = data->width;
+	int_fast32_t old_height = data->height;
+	int_fast32_t screen = obs_data_getint(settings, "screen");
+
+	if (data->use_xinerama) {
+		if (xinerama_screen_geo(data->dpy, screen,
+			&data->x_org, &data->y_org,
+			&data->width, &data->height) < 0) {
+			return -1;
+		}
+		data->screen = XDefaultScreenOfDisplay(data->dpy);
+	}
+	else {
+		data->x_org = 0;
+		data->y_org = 0;
+		if (x11_screen_geo(data->dpy, screen,
+			&data->width, &data->height) < 0) {
+			return -1;
+		}
+		data->screen = XScreenOfDisplay(data->dpy, screen);
+	}
+
+	if (!data->width || !data->height) {
+		blog(LOG_ERROR, "xshm-input: Failed to get geometry");
+		return -1;
+	}
+
+	blog(LOG_INFO, "xshm-input: Geometry %"PRIdFAST32"x%"PRIdFAST32
+		" @ %"PRIdFAST32",%"PRIdFAST32,
+		data->width, data->height, data->x_org, data->y_org);
+
+	if (old_width == data->width && old_height == data->height)
+		return 0;
+
+	return 1;
+}
+
+/**
+ * Returns the name of the plugin
+ */
 static const char* xshm_getname(const char* locale)
 {
 	UNUSED_PARAMETER(locale);
 	return "X11 Shared Memory Screen Input";
 }
 
-static void xshm_destroy(void *vptr)
+/**
+ * Update the capture with changed settings
+ */
+static void xshm_update(void *vptr, obs_data_t settings)
 {
 	XSHM_DATA(vptr);
 
-	if (!data)
-		return;
+	data->show_cursor = obs_data_getbool(settings, "show_cursor");
 
-	gs_entercontext(obs_graphics());
+	if (data->xshm)
+		xshm_detach(data->xshm);
 
-	texture_destroy(data->texture);
-	xcursor_destroy(data->cursor);
-
-	gs_leavecontext();
+	if (xshm_update_geometry(data, settings) < 0) {
+		blog(LOG_ERROR, "xshm-input: failed to update geometry !");
+		return;
+	}
 
-	if (data->shm_attached)
-		XShmDetach(data->dpy, &data->shm_info);
+	xshm_resize_texture(data);
+	xcursor_offset(data->cursor, data->x_org, data->y_org);
 
-	if (data->shm_info.shmaddr != (char *) -1) {
-		shmdt(data->shm_info.shmaddr);
-		data->shm_info.shmaddr = (char *) -1;
+	data->xshm = xshm_attach(data->dpy, data->screen,
+		data->width, data->height);
+	if (!data->xshm) {
+		blog(LOG_ERROR, "xshm-input: failed to attach shm !");
+		return;
 	}
+}
+
+/**
+ * Get the default settings for the capture
+ */
+static void xshm_defaults(obs_data_t defaults)
+{
+	obs_data_set_default_int(defaults, "screen", 0);
+	obs_data_setbool(defaults, "show_cursor", true);
+}
 
-	if (data->shm_info.shmid != -1)
-		shmctl(data->shm_info.shmid, IPC_RMID, NULL);
+/**
+ * Get the properties for the capture
+ */
+static obs_properties_t xshm_properties(const char *locale)
+{
+	obs_properties_t props = obs_properties_create(locale);
+	int_fast32_t screen_max;
 
-	if (data->image)
-		XDestroyImage(data->image);
+	Display *dpy = XOpenDisplay(NULL);
+	screen_max = xinerama_is_active(dpy)
+		? xinerama_screen_count(dpy)
+		: XScreenCount(dpy);
+	screen_max = (screen_max) ? screen_max - 1 : 0;
+	XCloseDisplay(dpy);
 
-	if (data->dpy)
-		XCloseDisplay(data->dpy);
+	obs_properties_add_int(props, "screen", "Screen", 0, screen_max, 1);
+	obs_properties_add_bool(props, "show_cursor", "Capture Cursor");
 
-	bfree(data);
+	return props;
 }
 
-static void *xshm_create(obs_data_t settings, obs_source_t source)
+/**
+ * Destroy the capture
+ */
+static void xshm_destroy(void *vptr)
 {
-	UNUSED_PARAMETER(settings);
-	UNUSED_PARAMETER(source);
-
+	XSHM_DATA(vptr);
 
-	struct xshm_data *data = bmalloc(sizeof(struct xshm_data));
-	memset(data, 0, sizeof(struct xshm_data));
+	if (!data)
+		return;
 
-	data->dpy = XOpenDisplay(NULL);
-	if (!data->dpy)
-		goto fail;
+	gs_entercontext(obs_graphics());
 
-	Screen *screen = XDefaultScreenOfDisplay(data->dpy);
-	data->width = WidthOfScreen(screen);
-	data->height = HeightOfScreen(screen);
-	data->root_window = XRootWindowOfScreen(screen);
-	Visual *visual = DefaultVisualOfScreen(screen);
-	int depth = DefaultDepthOfScreen(screen);
+	if (data->texture)
+		texture_destroy(data->texture);
+	if (data->cursor)
+		xcursor_destroy(data->cursor);
 
-	if (!XShmQueryExtension(data->dpy))
-		goto fail;
+	gs_leavecontext();
 
-	data->image = XShmCreateImage(data->dpy, visual, depth,
-		ZPixmap, NULL, &data->shm_info, data->width, data->height);
-	if (!data->image)
-		goto fail;
+	if (data->xshm)
+		xshm_detach(data->xshm);
+	if (data->dpy)
+		XCloseDisplay(data->dpy);
 
-	data->shm_info.shmid = shmget(IPC_PRIVATE,
-		data->image->bytes_per_line * data->image->height,
-		IPC_CREAT | 0700);
-	if (data->shm_info.shmid < 0)
-		goto fail;
+	bfree(data);
+}
 
-	data->shm_info.shmaddr
-		= data->image->data
-		= (char *) shmat(data->shm_info.shmid, 0, 0);
-	if (data->shm_info.shmaddr == (char *) -1)
-		goto fail;
-	data->shm_info.readOnly = False;
+/**
+ * Create the capture
+ */
+static void *xshm_create(obs_data_t settings, obs_source_t source)
+{
+	UNUSED_PARAMETER(source);
 
+	struct xshm_data *data = bzalloc(sizeof(struct xshm_data));
 
-	if (!XShmAttach(data->dpy, &data->shm_info))
+	data->dpy = XOpenDisplay(NULL);
+	if (!data->dpy) {
+		blog(LOG_ERROR, "xshm-input: Unable to open X display !");
 		goto fail;
-	data->shm_attached = 1;
+	}
 
-	if (!XShmGetImage(data->dpy, data->root_window, data->image,
-		0, 0, AllPlanes)) {
+	if (!XShmQueryExtension(data->dpy)) {
+		blog(LOG_ERROR, "xshm-input: XShm extension not found !");
 		goto fail;
 	}
 
+	data->use_xinerama = xinerama_is_active(data->dpy) ? true : false;
 
 	gs_entercontext(obs_graphics());
-	data->texture = gs_create_texture(data->width, data->height,
-		GS_BGRA, 1, (const void**) &data->image->data, GS_DYNAMIC);
 	data->cursor = xcursor_init(data->dpy);
 	gs_leavecontext();
 
-	if (!data->texture)
-		goto fail;
+	xshm_update(data, settings);
 
 	return data;
-
 fail:
 	xshm_destroy(data);
 	return NULL;
 }
 
+/**
+ * Prepare the capture data
+ */
 static void xshm_video_tick(void *vptr, float seconds)
 {
 	UNUSED_PARAMETER(seconds);
 	XSHM_DATA(vptr);
 
-	gs_entercontext(obs_graphics());
+	if (!data->xshm)
+		return;
 
+	gs_entercontext(obs_graphics());
 
-	XShmGetImage(data->dpy, data->root_window, data->image,
-		0, 0, AllPlanes);
-	texture_setimage(data->texture, (void *) data->image->data,
-		data->width * 4, False);
+	XShmGetImage(data->dpy, XRootWindowOfScreen(data->screen),
+		data->xshm->image, data->x_org, data->y_org, AllPlanes);
+	texture_setimage(data->texture, (void *) data->xshm->image->data,
+		data->width * 4, false);
 
 	xcursor_tick(data->cursor);
 
 	gs_leavecontext();
 }
 
+/**
+ * Render the capture data
+ */
 static void xshm_video_render(void *vptr, effect_t effect)
 {
 	XSHM_DATA(vptr);
 
+	if (!data->xshm)
+		return;
+
 	eparam_t image = effect_getparambyname(effect, "image");
 	effect_settexture(effect, image, data->texture);
 
-	gs_enable_blending(False);
-
+	gs_enable_blending(false);
 	gs_draw_sprite(data->texture, 0, 0, 0);
 
-	xcursor_render(data->cursor);
+	if (data->show_cursor)
+		xcursor_render(data->cursor);
 }
 
+/**
+ * Width of the captured data
+ */
 static uint32_t xshm_getwidth(void *vptr)
 {
 	XSHM_DATA(vptr);
-
-	return texture_getwidth(data->texture);
+	return data->width;
 }
 
+/**
+ * Height of the captured data
+ */
 static uint32_t xshm_getheight(void *vptr)
 {
 	XSHM_DATA(vptr);
-
-	return texture_getheight(data->texture);
+	return data->height;
 }
 
 struct obs_source_info xshm_input = {
-    .id           = "xshm_input",
-    .type         = OBS_SOURCE_TYPE_INPUT,
-    .output_flags = OBS_SOURCE_VIDEO,
-    .getname      = xshm_getname,
-    .create       = xshm_create,
-    .destroy      = xshm_destroy,
-    .video_tick   = xshm_video_tick,
-    .video_render = xshm_video_render,
-    .getwidth     = xshm_getwidth,
-    .getheight    = xshm_getheight
+	.id           = "xshm_input",
+	.type         = OBS_SOURCE_TYPE_INPUT,
+	.output_flags = OBS_SOURCE_VIDEO,
+	.getname      = xshm_getname,
+	.create       = xshm_create,
+	.destroy      = xshm_destroy,
+	.update       = xshm_update,
+	.defaults     = xshm_defaults,
+	.properties   = xshm_properties,
+	.video_tick   = xshm_video_tick,
+	.video_render = xshm_video_render,
+	.getwidth     = xshm_getwidth,
+	.getheight    = xshm_getheight
 };