obs-studio/plugins/linux-capture/xcompcap-helper.cpp

#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/extensions/Xcomposite.h>

#include <unordered_set>
#include <pthread.h>

#include <obs-module.h>
#include <util/platform.h>

#include "xcompcap-helper.hpp"

namespace XCompcap {
static Display *xdisplay = 0;

Display *disp()
{
	if (!xdisplay)
		xdisplay = XOpenDisplay(NULL);

	return xdisplay;
}

void cleanupDisplay()
{
	if (!xdisplay)
		return;

	XCloseDisplay(xdisplay);
	xdisplay = 0;
}

static void getAllWindows(Window parent, std::list<Window> &windows)
{
	UNUSED_PARAMETER(parent);
	UNUSED_PARAMETER(windows);
}

std::list<Window> getAllWindows()
{
	std::list<Window> res;

	for (int i = 0; i < ScreenCount(disp()); ++i)
		getAllWindows(RootWindow(disp(), i), res);

	return res;
}

// Specification for checking for ewmh support at
// http://standards.freedesktop.org/wm-spec/wm-spec-latest.html#idm140200472693600

bool ewmhIsSupported()
{
	Display *display = disp();
	Atom netSupportingWmCheck =
		XInternAtom(display, "_NET_SUPPORTING_WM_CHECK", true);
	Atom actualType;
	int format = 0;
	unsigned long num = 0, bytes = 0;
	unsigned char *data = NULL;
	Window ewmh_window = 0;

	int status = XGetWindowProperty(display, DefaultRootWindow(display),
					netSupportingWmCheck, 0L, 1L, false,
					XA_WINDOW, &actualType, &format, &num,
					&bytes, &data);

	if (status == Success) {
		if (num > 0) {
			ewmh_window = ((Window *)data)[0];
		}
		if (data) {
			XFree(data);
			data = NULL;
		}
	}

	if (ewmh_window) {
		status = XGetWindowProperty(display, ewmh_window,
					    netSupportingWmCheck, 0L, 1L, false,
					    XA_WINDOW, &actualType, &format,
					    &num, &bytes, &data);
		if (status != Success || num == 0 ||
		    ewmh_window != ((Window *)data)[0]) {
			ewmh_window = 0;
		}
		if (status == Success && data) {
			XFree(data);
		}
	}

	return ewmh_window != 0;
}

std::list<Window> getTopLevelWindows()
{
	std::list<Window> res;

	if (!ewmhIsSupported()) {
		blog(LOG_WARNING, "Unable to query window list "
				  "because window manager "
				  "does not support extended "
				  "window manager Hints");
		return res;
	}

	Atom netClList = XInternAtom(disp(), "_NET_CLIENT_LIST", true);
	Atom actualType;
	int format;
	unsigned long num, bytes;
	Window *data = 0;

	for (int i = 0; i < ScreenCount(disp()); ++i) {
		Window rootWin = RootWindow(disp(), i);

		int status = XGetWindowProperty(disp(), rootWin, netClList, 0L,
						~0L, false, AnyPropertyType,
						&actualType, &format, &num,
						&bytes, (uint8_t **)&data);

		if (status != Success) {
			blog(LOG_WARNING, "Failed getting root "
					  "window properties");
			continue;
		}

		for (unsigned long i = 0; i < num; ++i)
			res.push_back(data[i]);

		XFree(data);
	}

	return res;
}

int getRootWindowScreen(Window root)
{
	XWindowAttributes attr;

	if (!XGetWindowAttributes(disp(), root, &attr))
		return DefaultScreen(disp());

	return XScreenNumberOfScreen(attr.screen);
}

std::string getWindowAtom(Window win, const char *atom)
{
	Atom netWmName = XInternAtom(disp(), atom, false);
	int n;
	char **list = 0;
	XTextProperty tp;
	std::string res = "unknown";

	XGetTextProperty(disp(), win, &tp, netWmName);

	if (!tp.nitems)
		XGetWMName(disp(), win, &tp);

	if (!tp.nitems)
		return "error";

	if (tp.encoding == XA_STRING) {
		res = (char *)tp.value;
	} else {
		int ret = XmbTextPropertyToTextList(disp(), &tp, &list, &n);

		if (ret >= Success && n > 0 && *list) {
			res = *list;
			XFreeStringList(list);
		}
	}

	char *conv = nullptr;
	if (os_mbs_to_utf8_ptr(res.c_str(), 0, &conv))
		res = conv;
	bfree(conv);

	XFree(tp.value);

	return res;
}

std::string getWindowCommand(Window win)
{
	Atom xi = XInternAtom(disp(), "WM_COMMAND", false);
	int n;
	char **list = 0;
	XTextProperty tp;
	std::string res = "error";

	XGetTextProperty(disp(), win, &tp, xi);

	if (!tp.nitems)
		return std::string();

	if (tp.encoding == XA_STRING) {
		res = (char *)tp.value;
	} else {
		int ret = XmbTextPropertyToTextList(disp(), &tp, &list, &n);
		if (ret >= Success && n > 0 && *list) {
			res = *list;
			XFreeStringList(list);
		}
	}

	XFree(tp.value);

	return res;
}

int getWindowPid(Window win)
{
	UNUSED_PARAMETER(win);
	return 1234; //TODO
}

static std::unordered_set<Window> changedWindows;
static pthread_mutex_t changeLock = PTHREAD_MUTEX_INITIALIZER;
void processEvents()
{
	PLock lock(&changeLock);

	XLockDisplay(disp());

	while (XEventsQueued(disp(), QueuedAfterReading) > 0) {
		XEvent ev;

		XNextEvent(disp(), &ev);

		if (ev.type == ConfigureNotify)
			changedWindows.insert(ev.xconfigure.event);

		if (ev.type == MapNotify)
			changedWindows.insert(ev.xmap.event);

		if (ev.type == Expose)
			changedWindows.insert(ev.xexpose.window);

		if (ev.type == VisibilityNotify)
			changedWindows.insert(ev.xvisibility.window);

		if (ev.type == DestroyNotify)
			changedWindows.insert(ev.xdestroywindow.event);
	}

	XUnlockDisplay(disp());
}

bool windowWasReconfigured(Window win)
{
	PLock lock(&changeLock);

	auto it = changedWindows.find(win);

	if (it != changedWindows.end()) {
		changedWindows.erase(it);
		return true;
	}

	return false;
}

}

PLock::PLock(pthread_mutex_t *mtx, bool trylock) : m(mtx)
{
	if (trylock)
		islock = mtx && pthread_mutex_trylock(mtx) == 0;
	else
		islock = mtx && pthread_mutex_lock(mtx) == 0;
}

PLock::~PLock()
{
	if (islock) {
		pthread_mutex_unlock(m);
	}
}

bool PLock::isLocked()
{
	return islock;
}

void PLock::unlock()
{
	if (islock) {
		pthread_mutex_unlock(m);
		islock = false;
	}
}

void PLock::lock()
{
	if (!islock) {
		pthread_mutex_lock(m);
		islock = true;
	}
}

static bool *curErrorTarget = 0;
static char curErrorText[200];
static int xerrorlock_handler(Display *disp, XErrorEvent *err)
{

	if (curErrorTarget)
		*curErrorTarget = true;

	XGetErrorText(disp, err->error_code, curErrorText, 200);

	return 0;
}

XErrorLock::XErrorLock()
{
	goterr = false;
	islock = false;
	prevhandler = 0;

	lock();
}

XErrorLock::~XErrorLock()
{
	unlock();
}

bool XErrorLock::isLocked()
{
	return islock;
}

void XErrorLock::lock()
{
	if (!islock) {
		XLockDisplay(XCompcap::disp());
		XSync(XCompcap::disp(), 0);

		curErrorTarget = &goterr;
		curErrorText[0] = 0;
		prevhandler = XSetErrorHandler(xerrorlock_handler);

		islock = true;
	}
}

void XErrorLock::unlock()
{
	if (islock) {
		XSync(XCompcap::disp(), 0);

		curErrorTarget = 0;
		XSetErrorHandler(prevhandler);
		prevhandler = 0;
		XUnlockDisplay(XCompcap::disp());
		islock = false;
	}
}

bool XErrorLock::gotError()
{
	if (!islock)
		return false;

	XSync(XCompcap::disp(), 0);

	bool res = goterr;
	goterr = false;
	return res;
}

std::string XErrorLock::getErrorText()
{
	return curErrorText;
}

void XErrorLock::resetError()
{
	if (islock)
		XSync(XCompcap::disp(), 0);

	goterr = false;
	curErrorText[0] = 0;
}

XDisplayLock::XDisplayLock()
{
	islock = false;
	lock();
}

XDisplayLock::~XDisplayLock()
{
	unlock();
}

bool XDisplayLock::isLocked()
{
	return islock;
}

void XDisplayLock::lock()
{
	if (!islock) {
		XLockDisplay(XCompcap::disp());
		islock = true;
	}
}

void XDisplayLock::unlock()
{
	if (islock) {
		XSync(XCompcap::disp(), 0);
		XUnlockDisplay(XCompcap::disp());
		islock = false;
	}
}

ObsGsContextHolder::ObsGsContextHolder()
{
	obs_enter_graphics();
}

ObsGsContextHolder::~ObsGsContextHolder()
{
	obs_leave_graphics();
}