obs-studio/plugins/linux-xshm/xshm-input.c

/*
Copyright (C) 2014 by Leonhard Oelke <leonhard@in-verted.de>

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 <stdlib.h>
#include <stdio.h>

#include <sys/shm.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/extensions/XShm.h>

#include <obs.h>
#include "xcursor.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;
	texture_t texture;
	xcursor_t *cursor;
};

static const char* xshm_getname(const char* locale)
{
	UNUSED_PARAMETER(locale);
	return "X11 Shared Memory Screen Input";
}

static void xshm_destroy(void *vptr)
{
	XSHM_DATA(vptr);
	
	if (!data)
		return;
	
	gs_entercontext(obs_graphics());
	
	texture_destroy(data->texture);
	xcursor_destroy(data->cursor);
	
	gs_leavecontext();
	
	if (data->shm_attached)
		XShmDetach(data->dpy, &data->shm_info);
	
	if (data->shm_info.shmaddr != (char *) -1) {
		shmdt(data->shm_info.shmaddr);
		data->shm_info.shmaddr = (char *) -1;
	}
	
	if (data->shm_info.shmid != -1)
		shmctl(data->shm_info.shmid, IPC_RMID, NULL);
	
	if (data->image)
		XDestroyImage(data->image);
	
	if (data->dpy)
		XCloseDisplay(data->dpy);
	
	bfree(data);
}

static void *xshm_create(obs_data_t settings, obs_source_t source)
{
	UNUSED_PARAMETER(settings);
	UNUSED_PARAMETER(source);
	
	
	struct xshm_data *data = bmalloc(sizeof(struct xshm_data));
	memset(data, 0, sizeof(struct xshm_data));
	
	data->dpy = XOpenDisplay(NULL);
	if (!data->dpy)
		goto fail;
	
	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 (!XShmQueryExtension(data->dpy))
		goto fail;
	
	data->image = XShmCreateImage(data->dpy, visual, depth,
		ZPixmap, NULL, &data->shm_info, data->width, data->height);
	if (!data->image)
		goto fail;
	
	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;
	
	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;
	
	
	if (!XShmAttach(data->dpy, &data->shm_info))
		goto fail;
	data->shm_attached = 1;
	
	if (!XShmGetImage(data->dpy, data->root_window, data->image,
		0, 0, AllPlanes)) {
		goto fail;
	}
	
	
	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;
	
	return data;
	
fail:
	xshm_destroy(data);
	return NULL;
}

static void xshm_video_tick(void *vptr, float seconds)
{
	UNUSED_PARAMETER(seconds);
	XSHM_DATA(vptr);
	
	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);
	
	xcursor_tick(data->cursor);
	
	gs_leavecontext();
}

static void xshm_video_render(void *vptr, effect_t effect)
{
	XSHM_DATA(vptr);
	
	eparam_t image = effect_getparambyname(effect, "image");
	effect_settexture(effect, image, data->texture);
	
	gs_enable_blending(False);
	
	gs_draw_sprite(data->texture, 0, 0, 0);
	
	xcursor_render(data->cursor);
}

static uint32_t xshm_getwidth(void *vptr)
{
	XSHM_DATA(vptr);
	
	return texture_getwidth(data->texture);
}

static uint32_t xshm_getheight(void *vptr)
{
	XSHM_DATA(vptr);
	
	return texture_getheight(data->texture);
}

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
};