freerdp/server/proxy/pf_rdpgfx.c

/**
 * FreeRDP: A Remote Desktop Protocol Implementation
 * FreeRDP Proxy Server
 *
 * Copyright 2019 Mati Shabtay <matishabtay@gmail.com>
 * Copyright 2019 Kobi Mizrachi <kmizrachi18@gmail.com>
 * Copyright 2019 Idan Freiberg <speidy@gmail.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 <freerdp/client/rdpgfx.h>
#include <freerdp/server/rdpgfx.h>

#include <winpr/synch.h>

#include "pf_rdpgfx.h"
#include "pf_context.h"
#include "pf_log.h"

#define TAG PROXY_TAG("gfx")

BOOL pf_server_rdpgfx_init(pServerContext* ps)
{
	RdpgfxServerContext* gfx;
	gfx = ps->gfx = rdpgfx_server_context_new(ps->vcm);

	if (!gfx)
	{
		return FALSE;
	}

	gfx->rdpcontext = (rdpContext*)ps;
	return TRUE;
}

static UINT pf_rdpgfx_reset_graphics(RdpgfxClientContext* context,
                                     const RDPGFX_RESET_GRAPHICS_PDU* resetGraphics)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->ResetGraphics(server, resetGraphics)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->ResetGraphics(gfx_decoder, resetGraphics);
}

static UINT pf_rdpgfx_start_frame(RdpgfxClientContext* context,
                                  const RDPGFX_START_FRAME_PDU* startFrame)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->StartFrame(server, startFrame)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->StartFrame(gfx_decoder, startFrame);
}

static UINT pf_rdpgfx_end_frame(RdpgfxClientContext* context, const RDPGFX_END_FRAME_PDU* endFrame)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->EndFrame(server, endFrame)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->EndFrame(gfx_decoder, endFrame);
}

static UINT pf_rdpgfx_surface_command(RdpgfxClientContext* context,
                                      const RDPGFX_SURFACE_COMMAND* cmd)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->SurfaceCommand(server, cmd)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->SurfaceCommand(gfx_decoder, cmd);
}

static UINT
pf_rdpgfx_delete_encoding_context(RdpgfxClientContext* context,
                                  const RDPGFX_DELETE_ENCODING_CONTEXT_PDU* deleteEncodingContext)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->DeleteEncodingContext(server, deleteEncodingContext)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->DeleteEncodingContext(gfx_decoder, deleteEncodingContext);
}

static UINT pf_rdpgfx_create_surface(RdpgfxClientContext* context,
                                     const RDPGFX_CREATE_SURFACE_PDU* createSurface)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->CreateSurface(server, createSurface)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->CreateSurface(gfx_decoder, createSurface);
}

static UINT pf_rdpgfx_delete_surface(RdpgfxClientContext* context,
                                     const RDPGFX_DELETE_SURFACE_PDU* deleteSurface)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->DeleteSurface(server, deleteSurface)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->DeleteSurface(gfx_decoder, deleteSurface);
}

static UINT pf_rdpgfx_solid_fill(RdpgfxClientContext* context,
                                 const RDPGFX_SOLID_FILL_PDU* solidFill)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->SolidFill(server, solidFill)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->SolidFill(gfx_decoder, solidFill);
}

static UINT pf_rdpgfx_surface_to_surface(RdpgfxClientContext* context,
                                         const RDPGFX_SURFACE_TO_SURFACE_PDU* surfaceToSurface)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->SurfaceToSurface(server, surfaceToSurface)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->SurfaceToSurface(gfx_decoder, surfaceToSurface);
}

static UINT pf_rdpgfx_surface_to_cache(RdpgfxClientContext* context,
                                       const RDPGFX_SURFACE_TO_CACHE_PDU* surfaceToCache)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->SurfaceToCache(server, surfaceToCache)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->SurfaceToCache(gfx_decoder, surfaceToCache);
}

static UINT pf_rdpgfx_cache_to_surface(RdpgfxClientContext* context,
                                       const RDPGFX_CACHE_TO_SURFACE_PDU* cacheToSurface)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->CacheToSurface(server, cacheToSurface)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->CacheToSurface(gfx_decoder, cacheToSurface);
}

static UINT pf_rdpgfx_cache_import_reply(RdpgfxClientContext* context,
                                         const RDPGFX_CACHE_IMPORT_REPLY_PDU* cacheImportReply)
{
	proxyData* pdata = (proxyData*)context->custom;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	WLog_VRB(TAG, __FUNCTION__);
	return server->CacheImportReply(server, cacheImportReply);
}

static UINT pf_rdpgfx_evict_cache_entry(RdpgfxClientContext* context,
                                        const RDPGFX_EVICT_CACHE_ENTRY_PDU* evictCacheEntry)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->EvictCacheEntry(server, evictCacheEntry)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->EvictCacheEntry(gfx_decoder, evictCacheEntry);
}

static UINT pf_rdpgfx_map_surface_to_output(RdpgfxClientContext* context,
                                            const RDPGFX_MAP_SURFACE_TO_OUTPUT_PDU* surfaceToOutput)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->MapSurfaceToOutput(server, surfaceToOutput)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->MapSurfaceToOutput(gfx_decoder, surfaceToOutput);
}

static UINT pf_rdpgfx_map_surface_to_window(RdpgfxClientContext* context,
                                            const RDPGFX_MAP_SURFACE_TO_WINDOW_PDU* surfaceToWindow)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->MapSurfaceToWindow(server, surfaceToWindow)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->MapSurfaceToWindow(gfx_decoder, surfaceToWindow);
}

static UINT pf_rdpgfx_map_surface_to_scaled_window(
    RdpgfxClientContext* context,
    const RDPGFX_MAP_SURFACE_TO_SCALED_WINDOW_PDU* surfaceToScaledWindow)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->MapSurfaceToScaledWindow(server, surfaceToScaledWindow)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->MapSurfaceToScaledWindow(gfx_decoder, surfaceToScaledWindow);
}

static UINT pf_rdpgfx_map_surface_to_scaled_output(
    RdpgfxClientContext* context,
    const RDPGFX_MAP_SURFACE_TO_SCALED_OUTPUT_PDU* surfaceToScaledOutput)
{
	UINT error;
	proxyData* pdata = (proxyData*)context->custom;
	proxyConfig* config = pdata->config;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	RdpgfxClientContext* gfx_decoder = pdata->pc->gfx_decoder;
	WLog_VRB(TAG, __FUNCTION__);

	if ((error = server->MapSurfaceToScaledOutput(server, surfaceToScaledOutput)))
		return error;

	if (!config->SessionCapture)
		return CHANNEL_RC_OK;

	return gfx_decoder->MapSurfaceToScaledOutput(gfx_decoder, surfaceToScaledOutput);
}

static UINT pf_rdpgfx_on_open(RdpgfxClientContext* context, BOOL* do_caps_advertise,
                              BOOL* send_frame_acks)
{
	proxyData* pdata = (proxyData*)context->custom;
	WLog_VRB(TAG, __FUNCTION__);

	if (NULL != do_caps_advertise)
		*do_caps_advertise = FALSE;

	if (NULL != send_frame_acks)
		*send_frame_acks = FALSE;

	/* do not open the channel before gfx server side is in ready state */
	WaitForSingleObject(pdata->gfx_server_ready, INFINITE);
	return CHANNEL_RC_OK;
}

static UINT pf_rdpgfx_caps_confirm(RdpgfxClientContext* context,
                                   const RDPGFX_CAPS_CONFIRM_PDU* capsConfirm)
{
	proxyData* pdata = (proxyData*)context->custom;
	RdpgfxServerContext* server = (RdpgfxServerContext*)pdata->ps->gfx;
	WLog_VRB(TAG, __FUNCTION__);
	return server->CapsConfirm(server, capsConfirm);
}

/* Proxy server side callbacks */
static UINT pf_rdpgfx_caps_advertise(RdpgfxServerContext* context,
                                     const RDPGFX_CAPS_ADVERTISE_PDU* capsAdvertise)
{
	proxyData* pdata = (proxyData*)context->custom;
	RdpgfxClientContext* client = (RdpgfxClientContext*)pdata->pc->gfx_proxy;
	UINT16 index;
	UINT16 proxySupportedCapsSetCount = 0;
	RDPGFX_CAPS_ADVERTISE_PDU supportedCapsAdvertise;
	RDPGFX_CAPSET* proxySupportedCapsSet;
	RDPGFX_CAPSET proxySupportedCapsSets[RDPGFX_NUMBER_CAPSETS] = { 0 };

	for (index = 0; index < capsAdvertise->capsSetCount; index++)
	{
		const RDPGFX_CAPSET* currentCaps = &capsAdvertise->capsSets[index];

		/* Add cap to supported caps list if supported by FreeRDP.
		 * TODO: Have a better way of expressing max supported GFX caps version
		 * by FreeRDP.
		 */
		if (currentCaps->version <= RDPGFX_CAPVERSION_106)
		{
			proxySupportedCapsSet = &proxySupportedCapsSets[proxySupportedCapsSetCount++];
			proxySupportedCapsSet->version = currentCaps->version;
			proxySupportedCapsSet->length = currentCaps->length;
			proxySupportedCapsSet->flags = currentCaps->flags;
		}
	}

	supportedCapsAdvertise.capsSetCount = proxySupportedCapsSetCount;
	supportedCapsAdvertise.capsSets = proxySupportedCapsSets;
	WLog_VRB(TAG, __FUNCTION__);
	return client->CapsAdvertise(client, &supportedCapsAdvertise);
}

static UINT pf_rdpgfx_frame_acknowledge(RdpgfxServerContext* context,
                                        const RDPGFX_FRAME_ACKNOWLEDGE_PDU* frameAcknowledge)
{
	proxyData* pdata = (proxyData*)context->custom;
	RdpgfxClientContext* client = (RdpgfxClientContext*)pdata->pc->gfx_proxy;
	WLog_VRB(TAG, __FUNCTION__);
	return client->FrameAcknowledge(client, frameAcknowledge);
}

static UINT
pf_rdpgfx_qoe_frame_acknowledge(RdpgfxServerContext* context,
                                const RDPGFX_QOE_FRAME_ACKNOWLEDGE_PDU* qoeFrameAcknowledge)
{
	proxyData* pdata = (proxyData*)context->custom;
	RdpgfxClientContext* client = (RdpgfxClientContext*)pdata->pc->gfx_proxy;
	WLog_VRB(TAG, __FUNCTION__);
	return client->QoeFrameAcknowledge(client, qoeFrameAcknowledge);
}

static UINT pf_rdpgfx_cache_import_offer(RdpgfxServerContext* context,
                                         const RDPGFX_CACHE_IMPORT_OFFER_PDU* cacheImportOffer)
{
	proxyData* pdata = (proxyData*)context->custom;
	RdpgfxClientContext* client = (RdpgfxClientContext*)pdata->pc->gfx_proxy;
	WLog_VRB(TAG, __FUNCTION__);

	if (pdata->config->SessionCapture)
	{
		/* do not proxy CacheImportOffer, as is it currently not supported by FREERDP. */
		return CHANNEL_RC_OK;
	}

	return client->CacheImportOffer(client, cacheImportOffer);
}

void pf_rdpgfx_pipeline_init(RdpgfxClientContext* gfx, RdpgfxServerContext* server,
                             proxyData* pdata)
{
	pClientContext* pc = pdata->pc;

	/* create another gfx client and register it to the gdi graphics pipeline */
	pc->gfx_decoder = rdpgfx_client_context_new(pc->context.settings);
	if (!pc->gfx_decoder)
	{
		WLog_ERR(TAG, "failed to initialize gfx capture client!");
		return;
	}

	/* start GFX pipeline for fake client */
	gdi_graphics_pipeline_init(pc->context.gdi, pc->gfx_decoder);

	/* Set server and client side references to proxy data */
	gfx->custom = (void*)pdata;
	server->custom = (void*)pdata;
	/* Set client callbacks */
	gfx->ResetGraphics = pf_rdpgfx_reset_graphics;
	gfx->StartFrame = pf_rdpgfx_start_frame;
	gfx->EndFrame = pf_rdpgfx_end_frame;
	gfx->SurfaceCommand = pf_rdpgfx_surface_command;
	gfx->DeleteEncodingContext = pf_rdpgfx_delete_encoding_context;
	gfx->CreateSurface = pf_rdpgfx_create_surface;
	gfx->DeleteSurface = pf_rdpgfx_delete_surface;
	gfx->SolidFill = pf_rdpgfx_solid_fill;
	gfx->SurfaceToSurface = pf_rdpgfx_surface_to_surface;
	gfx->SurfaceToCache = pf_rdpgfx_surface_to_cache;
	gfx->CacheToSurface = pf_rdpgfx_cache_to_surface;
	gfx->CacheImportReply = pf_rdpgfx_cache_import_reply;
	gfx->EvictCacheEntry = pf_rdpgfx_evict_cache_entry;
	gfx->MapSurfaceToOutput = pf_rdpgfx_map_surface_to_output;
	gfx->MapSurfaceToWindow = pf_rdpgfx_map_surface_to_window;
	gfx->MapSurfaceToScaledOutput = pf_rdpgfx_map_surface_to_scaled_output;
	gfx->MapSurfaceToScaledWindow = pf_rdpgfx_map_surface_to_scaled_window;
	/* No need to register to OnClose callback. GFX termination is handled in pf_server */
	gfx->OnOpen = pf_rdpgfx_on_open;
	gfx->CapsConfirm = pf_rdpgfx_caps_confirm;
	/* Set server callbacks */
	server->CapsAdvertise = pf_rdpgfx_caps_advertise;
	server->FrameAcknowledge = pf_rdpgfx_frame_acknowledge;
	server->CacheImportOffer = pf_rdpgfx_cache_import_offer;
	server->QoeFrameAcknowledge = pf_rdpgfx_qoe_frame_acknowledge;
}