freerdp/channels/tsmf/client/gstreamer/tsmf_X11.c

/*
 * FreeRDP: A Remote Desktop Protocol Implementation
 * Video Redirection Virtual Channel - GStreamer Decoder X11 specifics
 *
 * (C) Copyright 2014 Thincast Technologies GmbH
 * (C) Copyright 2014 Armin Novak <armin.novak@thincast.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#ifndef __CYGWIN__
#include <sys/syscall.h>
#endif

#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <err.h>
#include <errno.h>
#include <winpr/thread.h>
#include <winpr/string.h>

#if __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wparentheses-equality"
#endif /* __clang__ */
#include <gst/gst.h>
#if __clang__
#pragma clang diagnostic pop
#endif /* __clang__ */

#if GST_VERSION_MAJOR > 0
#include <gst/video/videooverlay.h>
#else
#include <gst/interfaces/xoverlay.h>
#endif

#include <X11/Xlib.h>
#include <X11/extensions/Xrandr.h>
#include <X11/extensions/shape.h>

#include <freerdp/channels/tsmf.h>

#include "tsmf_platform.h"
#include "tsmf_constants.h"
#include "tsmf_decoder.h"

#if !defined(WITH_XEXT)
#warning "Building TSMF without shape extension support"
#endif

struct X11Handle
{
	int shmid;
	int* xfwin;
#if defined(WITH_XEXT)
	BOOL has_shape;
#endif
	Display* disp;
	Window subwin;
	BOOL subwinMapped;
#if GST_VERSION_MAJOR > 0
	GstVideoOverlay* overlay;
#else
	GstXOverlay* overlay;
#endif
	int subwinWidth;
	int subwinHeight;
	int subwinX;
	int subwinY;
};

static const char* get_shm_id()
{
	static char shm_id[128];
	sprintf_s(shm_id, sizeof(shm_id), "/com.freerdp.xfreerdp.tsmf_%016X", GetCurrentProcessId());
	return shm_id;
}

static GstBusSyncReply tsmf_platform_bus_sync_handler(GstBus* bus, GstMessage* message,
                                                      gpointer user_data)
{
	struct X11Handle* hdl;

	TSMFGstreamerDecoder* decoder = user_data;

	if (GST_MESSAGE_TYPE(message) != GST_MESSAGE_ELEMENT)
		return GST_BUS_PASS;

#if GST_VERSION_MAJOR > 0
	if (!gst_is_video_overlay_prepare_window_handle_message(message))
		return GST_BUS_PASS;
#else
	if (!gst_structure_has_name(message->structure, "prepare-xwindow-id"))
		return GST_BUS_PASS;
#endif

	hdl = (struct X11Handle*)decoder->platform;

	if (hdl->subwin)
	{
#if GST_VERSION_MAJOR > 0
		hdl->overlay = GST_VIDEO_OVERLAY(GST_MESSAGE_SRC(message));
		gst_video_overlay_set_window_handle(hdl->overlay, hdl->subwin);
		gst_video_overlay_handle_events(hdl->overlay, FALSE);
#else
		hdl->overlay = GST_X_OVERLAY(GST_MESSAGE_SRC(message));
#if GST_CHECK_VERSION(0, 10, 31)
		gst_x_overlay_set_window_handle(hdl->overlay, hdl->subwin);
#else
		gst_x_overlay_set_xwindow_id(hdl->overlay, hdl->subwin);
#endif
		gst_x_overlay_handle_events(hdl->overlay, TRUE);
#endif

		if (hdl->subwinWidth != -1 && hdl->subwinHeight != -1 && hdl->subwinX != -1 &&
		    hdl->subwinY != -1)
		{
#if GST_VERSION_MAJOR > 0
			if (!gst_video_overlay_set_render_rectangle(hdl->overlay, 0, 0, hdl->subwinWidth,
			                                            hdl->subwinHeight))
			{
				WLog_ERR(TAG, "Could not resize overlay!");
			}

			gst_video_overlay_expose(hdl->overlay);
#else
			if (!gst_x_overlay_set_render_rectangle(hdl->overlay, 0, 0, hdl->subwinWidth,
			                                        hdl->subwinHeight))
			{
				WLog_ERR(TAG, "Could not resize overlay!");
			}

			gst_x_overlay_expose(hdl->overlay);
#endif
			XLockDisplay(hdl->disp);
			XMoveResizeWindow(hdl->disp, hdl->subwin, hdl->subwinX, hdl->subwinY, hdl->subwinWidth,
			                  hdl->subwinHeight);
			XSync(hdl->disp, FALSE);
			XUnlockDisplay(hdl->disp);
		}
	}
	else
	{
		g_warning("Window was not available before retrieving the overlay!");
	}

	gst_message_unref(message);

	return GST_BUS_DROP;
}

const char* tsmf_platform_get_video_sink(void)
{
	return "autovideosink";
}

const char* tsmf_platform_get_audio_sink(void)
{
	return "autoaudiosink";
}

int tsmf_platform_create(TSMFGstreamerDecoder* decoder)
{
	struct X11Handle* hdl;

	if (!decoder)
		return -1;

	if (decoder->platform)
		return -1;

	hdl = calloc(1, sizeof(struct X11Handle));
	if (!hdl)
	{
		WLog_ERR(TAG, "Could not allocate handle.");
		return -1;
	}

	decoder->platform = hdl;
	hdl->shmid = shm_open(get_shm_id(), (O_RDWR | O_CREAT), (PROT_READ | PROT_WRITE));
	if (hdl->shmid == -1)
	{
		WLog_ERR(TAG, "failed to get access to shared memory - shmget(%s): %i - %s", get_shm_id(),
		         errno, strerror(errno));
		return -2;
	}

	hdl->xfwin = mmap(0, sizeof(void*), PROT_READ | PROT_WRITE, MAP_SHARED, hdl->shmid, 0);
	if (hdl->xfwin == MAP_FAILED)
	{
		WLog_ERR(TAG, "shmat failed!");
		return -3;
	}

	hdl->disp = XOpenDisplay(NULL);
	if (!hdl->disp)
	{
		WLog_ERR(TAG, "Failed to open display");
		return -4;
	}

	hdl->subwinMapped = FALSE;
	hdl->subwinX = -1;
	hdl->subwinY = -1;
	hdl->subwinWidth = -1;
	hdl->subwinHeight = -1;

	return 0;
}

int tsmf_platform_set_format(TSMFGstreamerDecoder* decoder)
{
	if (!decoder)
		return -1;

	if (decoder->media_type == TSMF_MAJOR_TYPE_VIDEO)
	{
	}

	return 0;
}

int tsmf_platform_register_handler(TSMFGstreamerDecoder* decoder)
{
	GstBus* bus;

	if (!decoder)
		return -1;

	if (!decoder->pipe)
		return -1;

	bus = gst_pipeline_get_bus(GST_PIPELINE(decoder->pipe));

#if GST_VERSION_MAJOR > 0
	gst_bus_set_sync_handler(bus, (GstBusSyncHandler)tsmf_platform_bus_sync_handler, decoder, NULL);
#else
	gst_bus_set_sync_handler(bus, (GstBusSyncHandler)tsmf_platform_bus_sync_handler, decoder);
#endif

	if (!bus)
	{
		WLog_ERR(TAG, "gst_pipeline_get_bus failed!");
		return 1;
	}

	gst_object_unref(bus);

	return 0;
}

int tsmf_platform_free(TSMFGstreamerDecoder* decoder)
{
	struct X11Handle* hdl = decoder->platform;

	if (!hdl)
		return -1;

	if (hdl->disp)
		XCloseDisplay(hdl->disp);

	if (hdl->xfwin)
		munmap(0, sizeof(void*));

	if (hdl->shmid >= 0)
		close(hdl->shmid);

	free(hdl);
	decoder->platform = NULL;

	return 0;
}

int tsmf_window_create(TSMFGstreamerDecoder* decoder)
{
	struct X11Handle* hdl;

	if (decoder->media_type != TSMF_MAJOR_TYPE_VIDEO)
	{
		decoder->ready = TRUE;
		return -3;
	}
	else
	{
		if (!decoder)
			return -1;

		if (!decoder->platform)
			return -1;

		hdl = (struct X11Handle*)decoder->platform;

		if (!hdl->subwin)
		{
			XLockDisplay(hdl->disp);
			hdl->subwin = XCreateSimpleWindow(hdl->disp, *(int*)hdl->xfwin, 0, 0, 1, 1, 0, 0, 0);
			XUnlockDisplay(hdl->disp);

			if (!hdl->subwin)
			{
				WLog_ERR(TAG, "Could not create subwindow!");
			}
		}

		tsmf_window_map(decoder);

		decoder->ready = TRUE;
#if defined(WITH_XEXT)
		int event, error;
		XLockDisplay(hdl->disp);
		hdl->has_shape = XShapeQueryExtension(hdl->disp, &event, &error);
		XUnlockDisplay(hdl->disp);
#endif
	}

	return 0;
}

int tsmf_window_resize(TSMFGstreamerDecoder* decoder, int x, int y, int width, int height,
                       int nr_rects, RDP_RECT* rects)
{
	struct X11Handle* hdl;

	if (!decoder)
		return -1;

	if (decoder->media_type != TSMF_MAJOR_TYPE_VIDEO)
	{
		return -3;
	}

	if (!decoder->platform)
		return -1;

	hdl = (struct X11Handle*)decoder->platform;
	DEBUG_TSMF("resize: x=%d, y=%d, w=%d, h=%d", x, y, width, height);

	if (hdl->overlay)
	{
#if GST_VERSION_MAJOR > 0

		if (!gst_video_overlay_set_render_rectangle(hdl->overlay, 0, 0, width, height))
		{
			WLog_ERR(TAG, "Could not resize overlay!");
		}

		gst_video_overlay_expose(hdl->overlay);
#else
		if (!gst_x_overlay_set_render_rectangle(hdl->overlay, 0, 0, width, height))
		{
			WLog_ERR(TAG, "Could not resize overlay!");
		}

		gst_x_overlay_expose(hdl->overlay);
#endif
	}

	if (hdl->subwin)
	{
		hdl->subwinX = x;
		hdl->subwinY = y;
		hdl->subwinWidth = width;
		hdl->subwinHeight = height;

		XLockDisplay(hdl->disp);
		XMoveResizeWindow(hdl->disp, hdl->subwin, hdl->subwinX, hdl->subwinY, hdl->subwinWidth,
		                  hdl->subwinHeight);

		/* Unmap the window if there are no visibility rects */
		if (nr_rects == 0)
			tsmf_window_unmap(decoder);
		else
			tsmf_window_map(decoder);

#if defined(WITH_XEXT)
		if (hdl->has_shape)
		{
			int i;
			XRectangle* xrects = NULL;

			if (nr_rects == 0)
			{
				xrects = calloc(1, sizeof(XRectangle));
				xrects->x = x;
				xrects->y = y;
				xrects->width = width;
				xrects->height = height;
			}
			else
			{
				xrects = calloc(nr_rects, sizeof(XRectangle));
			}

			if (xrects)
			{
				for (i = 0; i < nr_rects; i++)
				{
					xrects[i].x = rects[i].x - x;
					xrects[i].y = rects[i].y - y;
					xrects[i].width = rects[i].width;
					xrects[i].height = rects[i].height;
				}

				XShapeCombineRectangles(hdl->disp, hdl->subwin, ShapeBounding, x, y, xrects,
				                        nr_rects, ShapeSet, 0);
				free(xrects);
			}
		}
#endif
		XSync(hdl->disp, FALSE);
		XUnlockDisplay(hdl->disp);
	}

	return 0;
}

int tsmf_window_map(TSMFGstreamerDecoder* decoder)
{
	struct X11Handle* hdl;
	if (!decoder)
		return -1;

	hdl = (struct X11Handle*)decoder->platform;

	/* Only need to map the window if it is not currently mapped */
	if ((hdl->subwin) && (!hdl->subwinMapped))
	{
		XLockDisplay(hdl->disp);
		XMapWindow(hdl->disp, hdl->subwin);
		hdl->subwinMapped = TRUE;
		XSync(hdl->disp, FALSE);
		XUnlockDisplay(hdl->disp);
	}

	return 0;
}

int tsmf_window_unmap(TSMFGstreamerDecoder* decoder)
{
	struct X11Handle* hdl;
	if (!decoder)
		return -1;

	hdl = (struct X11Handle*)decoder->platform;

	/* only need to unmap window if it is currently mapped */
	if ((hdl->subwin) && (hdl->subwinMapped))
	{
		XLockDisplay(hdl->disp);
		XUnmapWindow(hdl->disp, hdl->subwin);
		hdl->subwinMapped = FALSE;
		XSync(hdl->disp, FALSE);
		XUnlockDisplay(hdl->disp);
	}

	return 0;
}

int tsmf_window_destroy(TSMFGstreamerDecoder* decoder)
{
	struct X11Handle* hdl;

	if (!decoder)
		return -1;

	decoder->ready = FALSE;

	if (decoder->media_type != TSMF_MAJOR_TYPE_VIDEO)
		return -3;

	if (!decoder->platform)
		return -1;

	hdl = (struct X11Handle*)decoder->platform;

	if (hdl->subwin)
	{
		XLockDisplay(hdl->disp);
		XDestroyWindow(hdl->disp, hdl->subwin);
		XSync(hdl->disp, FALSE);
		XUnlockDisplay(hdl->disp);
	}

	hdl->overlay = NULL;
	hdl->subwin = 0;
	hdl->subwinMapped = FALSE;
	hdl->subwinX = -1;
	hdl->subwinY = -1;
	hdl->subwinWidth = -1;
	hdl->subwinHeight = -1;
	return 0;
}